Simulating Basic microstrip structures on a PCB

[hv2220]

Im new to openEMS and have the following questions pertaining to its usage:

1. I would like to use my own PCB stackup(GND plane on copper, 17um thick), 200um ROGERS substrate(relative permitivity 3.5), and conductor on top (17um thick). In the examples, I see PEC (perfect conductor being used). How can I change the material properties in the python code.
2. Secondly, the geometry of the structure is defined in the python code. Is there a tool to visualize it while its drawn(not after meshing).
   Thanks,
   -HV

[VolkerMuehlhaus]

Hi @hv2220

You did not mention if you use openEMS with Python code or Matlab/Octave code. I will asume Python here.

In most cases, you should simulate your PCB metal as an infinitely thin sheet, with metal thickness not meshed in the EM model. The reason is that meshing a very small dimension will results in a small timestep for FDTD simulation, which then requires many timesteps total until your simulation is finished. Slow!

If your model does NOT require including the actual height in field simulation, you can use function

sheetmetal = CSX.AddConductingSheet("Coppersheet")
sheetmetal.SetConductivity (5.8e7)
sheetmetal.SetThickness(35e-6)

which models the thickness for loss calculation, but otherwise simulates a flat 2D sheet for field simulation. I hope the syntax is ok, the auto-generated online help is somewhat difficult to interpret: link

Only if the physical height really matters, e.g. for side wall coupling of conductors with a narrow gap, you would model the conductor as a material with conductivity

Thickmetal= CSX.AddMaterial('Copper', kappa=conductivity))

and then need to mesh that conductor height. Not sure why, but conductivity sigma is named kappa in openEMS parameters. As discussed, this will be numerically expensive with much longer total simulation time. And even worse, to get skin effect loss you would need to mesh into skin depth.

Just in general because you are new to openEMS: There is some excellent documentation (work in progress) by @biergaizi:
https://openems.readthedocs.io/en/latest/index.html#

[biergaizi]

Wrong link, none of the draft documentation has been formally published on the project's ReadTheDocs website. The current draft is available on the following draft-only domains.

• For a step-by-step guide of a simulation setup, see

  • https://fasterems.github.io/openEMS-Project/python/openEMS/Tutorials/First_Lessons.html

• For basic concepts of openEMS simulations, see

  • https://openems--417.org.readthedocs.build/en/417/concepts/index.html

Note that the step-by-step tutorial is exclusive to the first link, while the concept documentation is exclusive to the second link (the first link also contains the "concept" section, but it's outdated). Before these documents are merged, please use both of them.

A microstrip simulation is trivial to construct, by adjusting the size of the upper waveguide plate and the separation distance in the parallel-plate waveguide tutorial. This works okay (though not optimal) for a simple simulation.

The existing tutorial doesn't cover de-embedding/calibration, optimal signal launching, or transmission line ports, which are difficult topics and it will take some time to document. If you have any question, ask in the forum,
@VolkerMuehlhaus seems to have an infinite amount of patience to answer them.

[VolkerMuehlhaus]

@biergaizi Ok, I was searching for your documents for 15 minutes, and still found the wrong thing. Maybe there is a way to make the correct version more visible as a permanent link somewhere?

[biergaizi]

I believe the draft documentation on all ReadTheDocs domains are excluded from search engines on purpose (not sure if they did it explicitly with robots.txt, or implicitly just by using a special subdomain) to prevent people from accidentally landing on a draft page.

Maybe there is a way to make the correct version more visible as a permanent link somewhere?

I don't have the forum privilege to do so. Perhaps we can periodically bump the tutorial thread once a week instead: #310 I did it just now.

[biergaizi]

In the examples, I see PEC (perfect conductor being used). How can I change the material properties in the python code.

The current examples are incomplete and almost unusable for introductory purposes. I'm working on creating new documentation to solve this problem, it's still a work-in-progress. For documentation, see my reply to VolkerMuehlhaus above. The legacy project Wiki also contained some old examples in Matlab/Octave, which are still of some use before the new documentation is ready.

Is there a tool to visualize it while its drawn(not after meshing).

Yes. AppCSXCAD. There's no real-time preview, but you can just dump your structure to a .xml file and manually open it after each change to debug your code. For documentation, see my reply to VolkerMuehlhaus above.

[hv2220]

@biergaizi and @VolkerMuehlhaus. Thank you for your response. I have a couple of quesitons:

1. How can I define a microstrip(MSL) port if along with a ground plane? The bottom of my PCB is a GND plane. The MSL port uses start and stop. e,g.

portstart = [MSL_length, -MSL_width/2, substrate_thickness]
portstop = [-MSL_length/2 , MSL_width/2, 0]
port[1] = FDTD.AddMSLPort( 2, pec, portstart, portstop, 'x', 'z', excite=1, MeasPlaneShift=MSL_length/3, priority=10 )
I presume portstart and portstop refer to the port edge on the excitation and the gnd planes respectively. Is this correct? (Im trying to use an equivalent of an edgeport in Keysight Momemtum or HFSS) . Im using Python. It is not very clear from the open EMS doccument.

2. How can ports for a grounded CPW structure be defined?

[biergaizi]

The MSLPort is one of the most complicated objects in openEMS, it does a bunch of things at the same time, and it's currently undocumented because I haven't find time to do so. Its behavior differs greatly from the straightforward lumped port, which behaves like an excitation source at a given location with a lumped impedance.

To repeat the answer again: MSLPort is a beast, it basically does three things at the same time: creating a microstrip from location a to b according to its start and stop coordinates, placing an excitation at location c, and placing a probe at location d. The following diagram is a typical setup.

                         |                            |
          a              |                            |           b
          v  [In PML]    |                            | [IN PML]  v
          ---------------|----------------------------|------------
                         |     ^                ^     |
                         |     c                d     |

The microstrip goes from a to b according to the start and stop coordinates. Lumped termination resistance is not supported, so it must be terminated implicitly using the boundary condition, by allow a small section of the microstrip to enter inside PML on each end. The PML must be defined by the user prior to using the MSL Port, implicitly using the boundary condition of the simulation box. The excitation c and probe d have no lumped impedance at all, instead, the PML before excitation c and after probe d acts like Port 1 and Port 2's termination. This allows one to excite a microstrip without knowing its characteristic impedance. But note that c is not at the same location as d - by moving the Measurement Plane d far away from the Excitation Plane c at a location where the field has already stabilized (TEM mode), the impedance discontinuity becomes invisible.

The ground plane itself is not defined by the port, you need to manually create a metal sheet or implicitly use the boundary condition. If I recall correctly, when the microstrip port is excited, the stop coordinate implicitly tells the port the location of its ground plane, so it sets up an excitation between the microstrip and the plane.

In a MSL Port, the excitation c is actually the same kind of excitation as the Lumped Ports, there's no special field pattern optimization (yet). So there's actually little reason to use the MSLPort unless you want to use the auto-impedance extraction feature (which is also undocumented), or if you want to create a microstrip and a port at the same time.

In a MSL Port, the excitation c is actually the same kind of excitation as the Lumped Ports, there's no special field pattern optimization (yet). Edit: Note that the Coax port does have a radial field. So just switching to a microstrip port does not improve simulation in itself. Instead, it involves tuning the beginning-of-line (PML) to excitation spacing (called FeedShift), and tuning the excitation-to-measurement spacing (MeasPlaneShift). Both parameters are defined with respect to the beginning of the microstrip port, a. Tuning a microstrip port is a trial-and-error process and requires some experience. This is a rather topic that deserves an entire documentation chapter, but we do not have enough manpower to write it.

If one really wants to use MSLPort, the simulation should look like this. Two separate microstrip ports that defines the input and output traces, with the DUT at the middle.

                         |                                   |
          a              |              b      b'            |          a'
          v  [In PML]    |              v       v            | [IN PML]  v
          ---------------|---------------  DUT  -------------|------------
                         |     ^    ^               ^    ^   |
                         |     c    d               d    c   |

The microstrip tutorial is not doing a good job explaining how the MSLPort works, because it exploits the microstrip port's features to define the Device-Under-Test implicitly just by creating the microstrip port itself. Ideally, in a better tutorial, the port and DUT should be created as three separate objects, not as a single port.

How can ports for a grounded CPW structure be defined?

In the ideal world, openEMS should provide a function (all "ports" in openEMS are actually just helper functions to create raw structures, raw field excitation sources, and lumped resistance automatically) to do so. But it's not implemented.

In the second-best world, you want to use custom raw electric field source with its locations and weighting functions to launch a signal that matches the field pattern of a GCPW, implementing the GCPW port from scratch. But I don't think anyone took their time and effort to implement that either.

In the real world, you just excite it as if it's a microstrip, and define the beginning of the port to be a distance away from the actual excitation by tuning the MeasPlaneShift parameter, with the hope that the high-order modes have died down and the signals are now propagating in GCPW in its intended mode.

If you want to do it even better, you can run three calibration simulations and use external TRL software (not provided by openEMS) to de-embed the ports and the imperfect port launching effects. Again this is also on the TODO list of the documentation.

[thliebig]

A MSL port does not need to terminate in a PML, it can be terminated with a lumped R by setting the argument "Feed_R", but the termination into a PML is of course much more accurate.
Yes a MSL port is mush more complex than a lumped port, but again also much more accurate, for example you can use it to calculate and extract the line impedance. A lumped port cannot do that.
Does it need to be this complex, yes, because otherwise you would not have all the capabilities.
The python interface currently does not have a CPW port, only the Matlab interface does. This is one more of the ports that need to be "ported" (haha) to python...

[thliebig]

In the ideal world, openEMS should provide a function (all "ports" in openEMS are actually just helper functions to create raw structures, raw field excitation sources, and lumped resistance automatically) to do so. But it's not implemented.

This separation between the C++ part doing only all the raw low level stuff and the python (or Matlab) code is doing all the high level operations is not a missing implementation, it is by design. And in my opinion this is the only design that makes sense as implementing stuff like ports and all its complex calculations and dynamic behaviors would be a nightmare in C++.
Thus this is by design and I have no plans to change that. In the long run we will have to decide if we will continue to support both Matlab and python or if some day this will be C++ for the core FDTD and python only for all the higher level stuff.
And both part together are whats called openEMS 😏

[biergaizi]

But it's not implemented.

You misunderstood me, I'm not saying openEMS should implement this feature in C++, I think the high-level port is a great design decision, and there's nothing mysterious about the "port." I was just saying that there's no high-level Python wrapper for creating a Ground Coplanar Waveguide (high-level) port.

[hv2220]

Thank you for the quick response. Im trying to simulate a 50 ohm microstrip line(with backside ground plane) on Rogers substrate(thickness 203um and Er of 3.6).

1. From my understanding (and the Notch filter example), the MSL port definition itself will create the microstrip line structure. Is this correct?

2. In the first figure you had illustrated, is "v" in the GND plane? So port 1 is an edge port with "a" as the feed and "v" being the ground plane.

                     |                            |
      a              |                            |           b
      v  [In PML]    |                            | [IN PML]  v
      ---------------|----------------------------|------------
                     |     ^                ^     |
                     |     c                d     |
   

3. Given the complexity of the MSL port, can I use some other port to EM simulate a microstrip line with backside ground? I just created python script to EM simulate an MSL using MSL ports. Linecalc gives me a 50 ohm characteristic impedance. But this is is simulating a much lower characteristic impedance.

MSL_WithGNDPlane_MSLPort.py

[VolkerMuehlhaus]

Have a look at the lumped port, it will do the job. But note there is no port calibration, so port size shows up as parasitic length in results.

[thliebig]

1.) yes the port will create the metal parts of the MSL too
2) I think the "v" are just "arrows" ? a points to the beginning of the MSL inside the PML
3) MSL ports are complex, but if you work a lot with MSL's you should learn to use them?

[thliebig]

There is no problem to create a MSL (with MSL ports) and a backside ground. Just create a PEC plane or body where in the simple cases was the PEC boundary condition...

I looked at your example. The MSL-port itself calculates the impedance to ~50 Ohms, I'm not sure what you are calculating...

for p in port:
    p.CalcPort( Sim_Path, f)  # not giving any ref-impedance to allow the port to calculate it itself...

print(port[0].Z_ref)

[biergaizi]

The MSL-port itself calculates the impedance to ~50 Ohms, I'm not sure what you are calculating...

I think it was copied from my Lumped Port example, which takes a manual reference impedance, but the poster didn't know that the MSLPort extracts the line's Z0 by itself. The reference impedance and reference plane are currently a minefield in openEMS because there can be many kinds of impedance and termination:

1. A lumped output/input impedance of the lumped ports, Feed_R. This is only used for terminating the lumped port.

2. A reference impedance for post-processing, in p.CalcPort(). It can be different from Feed_R to renormalize the impedance for S-parameter calculation.

3. When using a transmission line port instead of a microstrip port, without an explicit reference impedance, p.CalcPort() tries to extract the line's true impedance by numerical differentiation.

   • But this is only supported if the Port itself implements this feature, for waveguide ports there's no numerical extraction, it uses standard analytical formulas.

4. Transmission line ports can be terminated by a lumped resistance, a boundary condition, or an artificial lossy material.

5. One can shift the measurement reference plane of a transmission line port by adjusting the MeasPlaneShift parameter. But p.CalcPort() can also shift the reference plane by adding or removing a phase shift by multiplying it with exp(Γl). The first method is a true measurement shift, while the second method is a port extension in post-processing.

So we have three kinds of impedances, two kinds of reference planes, and three kinds of termination. I personally didn't know the differences before I read the source code.

And this is in addition to the already confusing nature of RF measurements, where the impedance can either be referenced to the lumped port, or to the line, and it can be real or complex corresponding to lossless or lossy lines.

Any beginners would be confused and documenting it is a monumental task.

[biergaizi]

@hv2220: In the first figure you had illustrated, is "v" in the GND plane? So port 1 is an edge port with "a" as the feed and "v" being the ground plane.

It's an arrow. The graph is an XY plot, viewing the PCB substrate from the top (the signal layer), it's not a cross section diagram (like you'd see in 2D impedance calculators).

As I said, the ground plane itself is not defined by the MSLPort. The MSLPort only creates a metal trace on the signal layer. the ground plane is created manually by the user, either by explicitly creating a 2D/3D metal sheet as metal objects, which is straightforward, by setting the boundary condition of z_min as PEC to explicitly do it.

But how does MSLPort without knowing the ground plane? Internally, MSLPort creates and measures the electric field between two locations in space, starting from the ground plane and stopping at the signal trace. So MSLPort uses the start and stop Z coordinates to know the endpoints. So the ground plane can exist at any location, as long as the 3D coordinates of the MSLPort is correct.