Lumped port: partial overlap with conductor metal allowed?

[VolkerMuehlhaus]

Hello forum,

In a recent discussion here I claimed that the lumped port must not overlap the metal wire, because that would partially short the port. However in the same thread I was told that my assumption is wrong.

To find out if lumped ports in openEMS may partially overlap with metal or not, I created the testcase shown below.

UPDATE: This initial testcase seems to show that openEMS tolerates this situation, but this testcase is incomplete and results are misleading. Don't miss the amendment with more dense mesh here.

Why did I believe that lumped ports must not overlap with metal?

The simple reason is my experience with the commercial FDTD solver that I use at work. In the testcase shown below, the 50 Ohm lumped ports extend through the 1.5mm substrate and also through the 1.0mm bottom metal. Using this commercial FDTD solver, this shorts the lower part of the port that is embedded inside metal.

We can see that by looking at the input impedance into port 1 at low frequency: we get 30 Ohm instead of the expected 50 Ohm from port 2. That 30 Ohm is exactly the fraction of the port 2 termination resistor that is not shorted by the bottom metral: 1.5mm/2.5mm*50 Ohm = 30 Ohm

(The solver supports priority concept just like openEMS, but something is obviously different in the implemention of ports)

How does openEMS handle this partial overlap between lumped port and metal?

To verify the behaviour of openEMS, I created the exact same scenario. The overlap in the bottom metal is not seen in AppCSXCAD screenshot, but we can see it when disabling bottom metal display. Excitation and termination resistor of both ports extends to the bottom of the lower metal layer.

    port_zmin = BottomMetal_zmin
    port_zmax = TopMetal_zmin 

Different from the commercial solver results documented above, openEMS seems to tolerate this partial short, and gives the desired 50 Ohm input impedance into the structure.

UPDATE: Not quite true, this test is incomplete! Don't miss the amendment with more dense mesh here.

The openEMS testcase is attached below.

Best regards
Volker

import os
from pylab import *

from CSXCAD  import ContinuousStructure
from openEMS import openEMS
from openEMS.physical_constants import *

# preview model/mesh only?
# postprocess existing data without re-running simulation?
preview_only = False
postprocess_only = False

# Simulate reverse path (S22 and S12) also?
full_2port = False

# get *.py model path and put simulation files in data directory below
model_path = os.path.normcase(os.path.dirname(__file__))
model_basename = os.path.basename(__file__).replace('.py','')
common_data_path = os.path.join(model_path, 'data')
sim_path = os.path.join(common_data_path,  model_basename)

print('Model path:', model_path)
print('Model basename:', model_basename)
print('Simulation data path:', sim_path, '\n')

# create data directory if it does not exist
if not os.path.exists(sim_path):
    os.makedirs(sim_path)

# change to data directory
os.chdir(sim_path)

############ simulation settings ############
 
unit = 1e-3 # specify everything in mm
Z0=50 # reference impedance for ports

fstart = 0
fstop  = 2e9
numfreq = 501  # number of frequency points (has no effect on simulation time!)

energy_limit = -40    # end criteria for residual energy
Boundaries   = ['PEC', 'PEC', 'PEC', 'PEC', 'PEC', 'PEC']  # xmin xmax ymin ymax zmin zmax

eps_max = 1 # maximum permittivity in model, used for calculating max cellsize

lim = exp(energy_limit/10 * log(10))
FDTD = openEMS(EndCriteria=lim)
FDTD.SetGaussExcite( (fstart+fstop)/2, (fstop-fstart)/2 )
FDTD.SetBoundaryCond( Boundaries )

wavelength_air = (3e8/unit)/fstop
# max_cellsize = wavelength_air/(sqrt(eps_max)*20) # max cellsize is lambda/20 in medium
max_cellsize = 2 # using lambda/20 would be too large here, creating abrupt steps in cell size -> use smaller value for nicely graded mesh

def createSimulation (exciteport):
# Define function for model creation because we need to create and run separate CSX
# for each excitation. For S11,S21 we only need to excite port 1, but for S22,S12
# we need to excite port 2. This requires separate CSX with different port settings.


    ############ Geometry setup ############
    CSX = ContinuousStructure()
    FDTD.SetCSX(CSX)
    mesh = CSX.GetGrid()
    mesh.SetDeltaUnit(unit)

    # air above and below
    air_thick = 5

    # substrate
    Sub = CSX.AddMaterial('Sub', epsilon=4.4)
    Sub_thick = 1.5
    Sub_zmin = 0
    Sub_zmax = Sub_zmin + Sub_thick

    # TopMetal
    TopMetal_thick = 0.5
    TopMetal_zmin  = Sub_zmax 
    TopMetal_zmax  = Sub_zmax + TopMetal_thick
    TopMetal = CSX.AddMetal('TopMetal')

    # BottomMetal
    BottomMetal_thick = 1
    BottomMetal_zmax  = Sub_zmin
    BottomMetal_zmin  = Sub_zmin - BottomMetal_thick
    BottomMetal = CSX.AddMetal('BottomMetal')

    
    ############# begin layout geometries ###########

    # TopMetal line over BottomMetal ground
    wline = 2
    lline = 10
    wgnd  = 5
    lgnd  = 12

    # signal line
    TopMetal.AddBox(priority=200, start=[-lline/2, -wline/2, TopMetal_zmin], stop=[lline/2, wline/2, TopMetal_zmax])
    # ground plane
    BottomMetal.AddBox(priority=200, start=[-lgnd/2, -wgnd/2, BottomMetal_zmin], stop=[lgnd/2, wgnd/2, BottomMetal_zmax])
    # substrate
    Sub.AddBox(priority=200, start=[-lgnd/2, -wgnd/2, Sub_zmin], stop=[lgnd/2, wgnd/2, Sub_zmax])

    ############# end layout geometries ##########

    ############ ports created manually ##########

    port_zmin = BottomMetal_zmin
    port_zmax = TopMetal_zmin 
   
    if exciteport==1:
        port1 = FDTD.AddLumpedPort(1, Z0, [-lline/2, -wline/2, port_zmin], [-lline/2, wline/2, port_zmax], 'z', excite=1.0, priority=150)
        port2 = FDTD.AddLumpedPort(2, Z0, [ lline/2, -wline/2, port_zmin], [ lline/2, wline/2, port_zmax], 'z', excite=0,   priority=150)        
    else:    
        port1 = FDTD.AddLumpedPort(1, Z0, [-lline/2, -wline/2, port_zmin], [-lline/2, wline/2, port_zmax], 'z', excite=0,   priority=150)
        port2 = FDTD.AddLumpedPort(2, Z0, [ lline/2, -wline/2, port_zmin], [ lline/2, wline/2, port_zmax], 'z', excite=1.0, priority=150)        
    


    #################  end ports  ################

    # Simulation box with some margin to line
    box_xmin = -(lgnd/2 + 5)
    box_xmax =  (lgnd/2 + 5)
    box_ymin = -(wgnd/2 + 5)
    box_ymax =  (wgnd/2 + 5)

    ############# create  mesh  #############

    # Detect metal edges and place mesh lines
    FDTD.AddEdges2Grid(dirs='all', properties=TopMetal)
    FDTD.AddEdges2Grid(dirs='all', properties=BottomMetal)
    
    # manual mesh line in substrate
    mesh.AddLine('z',linspace(Sub_zmin, Sub_zmax, 5))

    # fine mesh near port 1
    mesh.AddLine('x', linspace(-lline/2-wline/2, -lline/2+wline/2, 5))    

    #finer mesh near port 2
    mesh.AddLine('x', linspace(+lline/2-wline/2, +lline/2+wline/2, 5))   

    # fine mesh across line width
    mesh.AddLine('y', linspace(-wline/2, wline/2,5))


    # mesh lines at simulation boundaries

    mesh.AddLine('x', box_xmin)
    mesh.AddLine('x', box_xmax)

    mesh.AddLine('y', box_ymin)
    mesh.AddLine('y', box_ymax)

    mesh.AddLine('z', TopMetal_zmax + air_thick)
    mesh.AddLine('z', BottomMetal_zmin - air_thick)


    mesh.SmoothMeshLines('x', max_cellsize, 1.3)
    mesh.SmoothMeshLines('y', max_cellsize, 1.3)
    mesh.SmoothMeshLines('z', max_cellsize, 1.3)
    

    #################### write model file and view in AppCSXCAD ################


    # create subdirectory to hold data for this excitation
    excitation_path = os.path.join(sim_path, 'sub-' + str(exciteport))
    if not os.path.exists(excitation_path):
        os.makedirs(excitation_path)

    # write CSX file 
    CSX_file = os.path.join(excitation_path, model_basename + '.xml')
    CSX.Write2XML(CSX_file)

    if not postprocess_only: # preview model, but only for first port excitation
        if (exciteport==1): 
            from CSXCAD import AppCSXCAD_BIN
            os.system(AppCSXCAD_BIN + ' "{}"'.format(CSX_file))

    if not preview_only:  # start simulation 
        if not postprocess_only:
            print("Running FDTD simulation, excitation port " + str(exciteport))
            FDTD.Run(excitation_path, verbose=1)
            
    # return ports, so that we can postprocess them
    return port1, port2, excitation_path
  
######### end of function createSimulation (exciteport) ##########



########### create model, run and post-process ###########

f = np.linspace(fstart,fstop,numfreq)

# call createSimulation function defined above 
sub1_port1, sub1_port2, sub1_excitation_path = createSimulation (1)  # excite port 1 
if full_2port:
    sub2_port1, sub2_port2, sub2_excitation_path = createSimulation (2)  # excite port 2

if not preview_only:
    # evaluate port 1 excitation
    sub1_port1.CalcPort( sub1_excitation_path, f, ref_impedance = Z0)
    sub1_port2.CalcPort( sub1_excitation_path, f, ref_impedance = Z0)

    s11 = sub1_port1.uf_ref / sub1_port1.uf_inc
    s21 = sub1_port2.uf_ref / sub1_port1.uf_inc

    if full_2port:
        # evaluate port 2 excitation
        sub2_port1.CalcPort( sub2_excitation_path, f, ref_impedance = Z0)
        sub2_port2.CalcPort( sub2_excitation_path, f, ref_impedance = Z0)

        s22 = sub2_port2.uf_ref / sub2_port2.uf_inc
        s12 = sub2_port1.uf_ref / sub2_port2.uf_inc

    Zin_port1 = sub1_port1.uf_tot / sub1_port1.if_tot

    ### Plot results

    s11_dB = 20.0*np.log10(np.abs(s11))
    s11_phase = angle(s11, deg=True) 

    s21_dB = 20.0*np.log10(np.abs(s21))
    s21_phase = angle(s21, deg=True) 

    if full_2port:
        s22_dB = 20.0*np.log10(np.abs(s22))
        s22_phase = angle(s22, deg=True) 

        s12_dB = 20.0*np.log10(np.abs(s12))
        s12_phase = angle(s12, deg=True) 

    
    
    ## Plot reflection coefficient S11
    figure()
    plot( f/1e6, s11_dB, 'k-', linewidth=2 )
    grid()
    title( 'reflection coefficient S11' )
    xlabel( 'frequency (MHz)' )
    ylabel( 'reflection coefficient S11' )

    ## Plot DUT input impedance at  port 1
    figure()
    plot( f/1e6, real(Zin_port1), 'k-', linewidth=2 )
    grid()
    title( 'DUT input impedance at port 1' )
    xlabel( 'frequency (MHz)' )
    ylabel( 'real(Z) (Ohm)' )
    

    # show plots
    show()

[LubomirJagos]

I don't understand this example or how this should show nesting port is allowed. I looked on your example and simulate it using openEMS and got your graph but your meshing is too coarse like is visible on first image. So I changed line:

#max_cellsize = 2 # using lambda/20 would be too large here, creating abrupt steps in cell size -> use smaller value for nicely graded mesh
max_cellsize = 0.1

and got fine mesh, it has simulate for 20min and got almost same result like from commercial solver, Zin=32Ohm
there is other problem what I already got when simulated dipole, that coarse mesh is giving wrong impedance, I think that correct model is one that when you make mesh finer it will not significantly change ports impedance

[VolkerMuehlhaus]

Hi Lubomir,

I don't understand why you always have trouble with mesh not aligned to the geometries???? In the code there is function AddEdges2Grid() and this works just fine on my openEMS installation for Windows, see screenshot below. The AppCSXDAD view is in 2D mode, to avoid perspective distortion.

Everything nicely aligned with the mesh!

This is a coarse mesh only, and was meant to work good enough at low frequency. No fancy RF effects required for this test, just a very basic conductor loop with two ports, where we expect to see port2 impedance at the input. So the coarse mesh is "good enough" to model the simple conductor loop - at least I though that's the case.

But you now point me to a weakness in my test: the bottom metal is meshed by only one cell in my test, and this doesn't proof that everything works if the port fraction embedded into the bottom metal is meshed by multiple cells! Your result seems to show that something might go wrong then.

You wrote "and got fine mesh, it has simulate for 20min and got almost same result like from commercial solver, Zin=32Ohm" and that would mean we get wrong results using that model. For the short metal loop we need to see 50 Ohm, which is the input impedance into port 2.

To avoid misunderstanding: The commercial solver result shown above is an example for WRONG results from incorrect modelling where the port is extending into the metal.

BR, Volker

PS: You might wonder why I used this strange configuration. My main requirement/application for openEMS is simulation of RFIC structures, where the conductor thickness is on the order of dielectrics, and users are tempted to place ports on via layers that penetrate into the planar metals. This is exactly the "port partially embedded into a metal" case that I thought would be critical. That's the motivation why I look at this specific topic. The related project is this and some openEMS examples are here.

[LubomirJagos]

now I finished simulation with fine mesh and not overlapping port and is still 50Ohm, that means that you are true, port shouldn't overlapped metal structure
seems like I was using it wrong from beginning, must repair my examples, so this example is showing that you are true, port should not overlap metals because than it's impedance is changed
still I think that in CalcPort() there is some mechanism which doesn't matter on it's input impedance so S11 should be without change

about misaligned mesh, I haven't changed anything, I thought you done it these lines:

    mesh.AddLine('z', TopMetal_zmax + air_thick)
    mesh.AddLine('z', BottomMetal_zmin - air_thick)

seems like I have old version of openEMS and should reinstall it, we are getting different mesh for same code, I think I have something wrong on my side, thanks for notice

Here is fine plot for not touching port

[VolkerMuehlhaus]

Yes, I just noticed the same thing: the test with port overlapping the metal by 1 mesh cell was incomplete and misleading, thanks for double checking!

I also tested this, by just placing some more mesh lines into the bottom metal layer, and then results no longer show the correct port 2 impedance of 50 Ohm. So it seems the same rule applies that I know from the commercial FDTD solver: place ports between metal edges, and don't let them penetrate into the metal. Overlap will partially short the internals of the port, such as the termination resistor.

Great to have this community which double checks things :-)

[LubomirJagos]

ok, you should write here some answer that lumped port MUST NOT OVERLAP metal structure and mark that as answer to have conclusion from this
I have to check what is wrong with my python interface since what I tried on your code these lines are not running on my side:

    # Detect metal edges and place mesh lines
    FDTD.AddEdges2Grid(dirs='all', properties=TopMetal)
    FDTD.AddEdges2Grid(dirs='all', properties=BottomMetal)

I must reinstall python package, I used on Windows standard one from repository but seems this function is not running at all, I will try later since now I'm on VPN and cannot reach python repositories.

Write here conclusion and mark that as answer for people, I was thinking about this problem but haven't seen this documented nowhere and this is basic question which everybody is asking when start to modelling anything. Luckily till now I was mostly using S params and haven't been looking on impedance, it's picky after 2 years to find error in fundamentals :D :D :D better than never

[VolkerMuehlhaus]

Luckily till now I was mostly using S params and haven't been looking on impedance

The effect is not limited to calculated impedance, you should see similar error in S-parameters also, because the port that claims to be 50 Ohm is really changing its impedance (depending how much of it is shorted by overlapping metal), and that changes S11 etc.

I guess you haven't seen much issues because the "normal" use case for PCB has port dimensions that are much larger than metal thickness. For this testcase I used rather extreme case (as found in RFIC technology) where a significant fraction of port length is shorted, making the error in results very visible.

[LubomirJagos]

hmmm, I have feeling in Octave after CalcPort() there was literally its impedance calculated and stored in variable in port structure and it used to be different from what I put 50Ohm, must recheck that, so I have to rerecreate octave simulation for this.
In this case in python this returns both 50Ohm as you are writing:

sub1_port.Z_ref    #returns 50
sub1_port.R         #returns 50

[LubomirJagos]

Hey, sorry this is not joke, but I am taking back that rule about ports not overlapping metals, I tried to do that port impedance calculation in octave and have to remodel your model in FreeCAD to use my generator and since I was playing with that I figure out that ports MUST OVERLAP METAL STRUCTURE, let's reopen this discussion :D

My fault that I haven't asked before what your model has to do and here is what I think is wrong with it and this model is misleading:
- port is nested into bottom metal not touching top metal
- if you display S11, S21 you can see there is no wave propagates through structure

My conclusion is that depends what effect do you want to model, if this is microstrip line then PORT MUST OVERLAPPED both top and bottom
If this is something else and port doesn't overlap top or bottom you can clearly see from S11, S21 there is no energy transfer between ports and it's something else

Last picture is case why I always nesting ports into metal, if you are modelling microstrip line you have to overlapped metal by excitation otherwise S11,S21 are nonsense.

Sorry for this, but now I'm really confused by your model, just saying let's talk more about this.

here original case when port nested into bottom S11, S21, no energy transfer ports are disconnected

here is case when port not touching anything it's in middle S11, S21, no energy transfer ports are disconnected

here is overlapping both top and bottom, S11,S22 its microstrip, energy transfer

[LubomirJagos]

ok, so we both agree it must at least touch metal, so to reformulate the question is this:
How much can be port overlapped into metal to his impedance change <10% ?

until now what call overlapping port or nesting I did it like 5um or so, therefore I was confused by this example where it's 1mm, it's due I'm generating gridlines little inside material so my gridlines used to be like 0.001um from the material boundaries but that's due I'm using FreeCAD for modelling to be sure that gridline is inside generated STL and therefore I call it nesting.

[LubomirJagos]

hmmm, so port impedance is calculated as let's say for 50Ohm as:
50 = sum(portStart, portStop)
in other way in region of resistive box in each node there is Ohm/m and it's summarize together over according ax, if part of it is shorted then it's less

[VolkerMuehlhaus]

How much can be port overlapped into metal to his impedance change <10% ?

That would be 10% of the port length.

If you remember the yagi antenna case, we had a gap between the dipole arms of 5mm and KJ7LNW added an overlap of 1mm on both ends of the port. That means we have 7mm port length, and 2mm of that is shorted by overlapping metal. That would be a noticeable error in termination resistor, but it is possible that we don't have an effect because this is a 1-port simulation where the internal resistor doesn't matter. Not sure about that.

[LubomirJagos]

ok, now it's crystal clear for me, it's same way how E and H fields are discretized, so everything in FDTD is discretized in scalar units over length like V/m, A/m, Ohm/m and there are 2 matrices for each of them one for scalar value of field strength and then there is second with nodes coordinates and all scalar values are volume integral over defined regions

for resistivity it means that if let's say in extreme case port would be 99% nested in metal it would have just 1% of it defined scalar value

yeah this was last missing piece what I had to realize that same thing how fields also resistivity is calculated, I was thinking about this question but was busy by other things so have no time to really play with field values and read them from .h5 files and perform integral to get real values, tried just once but for short. Ok, thanks.

[LubomirJagos]

next thread could be "How to calculate scalar values U, I from E, H fields and mesh stored in .h5 files" since it's quite easy and most explanatory how FDTD is running

[LubomirJagos42]

Thank you very much one more time, sorry for my misunderstanding, now I realized that I have one model of discone antenna in cylindrical coordinates and couldn't make it running due I have small gap there and too much nested port and always I got numerical instabilities there and the reason is for sure wrong port, this is exact reason why it's not running, this seems trivial but the way how I am using openEMS in conjunction with modelling SW this is crucible, I will resimulate it and will post here there are nice animations from these antennas