📘 EMStudio – User Guide & Developer Documentation

EMStudio

Qt-based GUI for electromagnetic and thermal simulations Developed at IHP Microelectronics

---

Overview

EMStudio is a Qt-based desktop application for preparing, visualizing, and managing electromagnetic and thermal simulations.

It provides an integrated workflow for:

• Loading GDS layout data

• Choosing substrate stacks (dielectrics, metals, layers, thermal tables)

• Visualizing a 2.5D stack cross-section and GDS layout top-view (2D / Iso3D / Field)

• Configuring simulation parameters

• Generating configuration files for solvers (OpenEMS, Palace, Elmer EM, Elmer Thermal)

• Editing Python driver scripts with syntax highlighting

• Running simulations, streaming logs, and viewing results (S-parameters / Layout Field for thermal)

---

Features

• Cross-platform Qt GUI (Linux & Windows)

• GDS reader (gdsreader.cpp)

• Substrate & material model (including thermal conductivity / tables)

• 2.5D stack visualization with GDS layout preview (2D / Iso3D / Field) and click cross-reference (substrateview / layoutview)

• Python script editor with syntax highlighting & autocompletion

• Python/Palace parser with JSON configuration

• QtPropertyBrowser-based parameter editor

• Preferences dialog (paths, solver settings, Python interpreter, Layout Field Python)

• Simulation tools: OpenEMS, Palace, Elmer EM, Elmer Thermal

• Results viewer for S-parameters; Layout Field Z-clip for thermal VTU fields

• Command-line interface for automation

---

Installation

You can download a ready-to-run build if you are logged into your GitHub account. Without login, downloading is not possible!

• Go to Actions (In the Bar next to Code, Issues, Pull requests, etc.)
• Click on the latest run with a green checkmark
• Scroll to the bottom of the page ("Artifacts")
• Download the build for your platform (see below)

Pre-built Installer (Windows)

Download the artifact named emstudio-windows-installer and run the installer it contains.

---

Pre-built Bundle (Linux)

Download a portable artifact with bundled Qt:

Artifact	Built on	Needs host glibc	Typical host
emstudio-linux-ubuntu22	Ubuntu 22.04	≥ 2.35	Ubuntu 22.04
emstudio-linux-ubuntu24	Ubuntu 24.04	≥ 2.38	Ubuntu 24.04+

If you see version 'GLIBC_2.38' not found, the host is older than Ubuntu 24 — use ubuntu22.

1. Unzip the downloaded artifact.
2. Run it with:

./EMStudio

EMStudio is a small launcher that sets up the bundled Qt libraries; the real binary is EMStudio.bin. Do not start EMStudio.bin directly unless you set LD_LIBRARY_PATH yourself.

This works on a normal Ubuntu desktop session (X11 or Wayland, with the usual graphics drivers). If it doesn't start on a minimal/server system, you may be missing one of these common packages: libxkbcommon-x11-0 libxcb-cursor0 libgl1 libegl1 libdbus-1-3 fontconfig.

---

Building from source (developers only)

Most users should use the pre-built downloads above. If you want to build EMStudio yourself:

Linux:

cd /path/to/EMStudio
qmake EMStudio.pro
make -j$(nproc)
./EMStudio

Windows (MinGW, matching our CI build):

cd \path\to\EMStudio
qmake EMStudio.pro
mingw32-make
.\release\EMStudio.exe

---

External solvers (required for full functionality)

EMStudio integrates with external electromagnetic and thermal solvers.
For full functionality, these tools must be installed separately by the user.

Please ensure the solvers are available in your PATH, or configure their locations explicitly in the EMStudio settings.

openEMS

EC-FDTD electromagnetic solver.

• Project page: https://www.openems.de/
• Documentation: https://docs.openems.de/
• Source code & build instructions: https://github.com/thliebig/openEMS-Project

Palace

Parallel finite-element electromagnetic solver.

• Project page & documentation: https://awslabs.github.io/palace/
• Source code: https://github.com/awslabs/palace

Elmer (EM and Thermal)

Finite-element solver used by EMStudio for Elmer EM (S-parameters via gds2palace) and Elmer Thermal (steady-state heat conduction).

• Project page: https://www.elmerfem.org/
• Source / downloads: https://github.com/ElmerCSC/elmerfem

Field results have their own Fields page in the Run Control list (after Results): the layout with the 2D Z-clip heatmap and the Layers panel. After a successful Elmer Thermal run EMStudio opens it automatically; if FIELD_VIEWER_PYTHON is set, it also opens the interactive PyVista Field 3D window (no ParaView). You can open 3D later with the 3D viewer ↗ button on the Fields page.

Layout Field (2D Z-clip on the Fields page):

Field → 3D (separate PyVista volume window):

---

Running EMStudio (Standalone)

You can launch EMStudio.exe directly or via terminal:

EMStudio.exe [options] [run_file.json]

Command-line options

• -gdsfile <path>
  Path to GDS file

• -topcell <name>
  Top-level GDS cell

Example

EMStudio.exe -gdsfile "C:/Work/design.gds" -topcell "top"

---

KLayout Integration (method 1)

EMStudio can be launched directly from KLayout through the helper script:

scripts/klEmsDriver.py

Usage on Linux

1. Save klEmsDriver.py inside your EMStudio installation directory.
2. (Optional) Add EMStudio directory to your system PATH.
3. Launch KLayout with:

"<path>/klayout -e -rm <path>/EMStudio/scripts/klEmsDriver.py"

Desktop Shortcut (Windows)

1. Right-click → New → Shortcut
2. Set target:

"<Path to KLayout>\klayout_app.exe" -e -rm "<Path to EMStudio>\scripts\klEmsDriver.py"

3. Name it e.g. EMStudio via KLayout
4. (Optional) Change the icon: installer/emstudio.ico

KLayout Integration (method 2)

EMStudio can be launched directly from KLayout if you start KLayout using one of the scripts provided in the EMStudio scripts directory:

• KLayout.bat for Windows
• KLayout.sh for Linux

This will find your KLayout installation by searching the PATH, and then start KLayout with EMStudio integration.

What happens when executed?

• EMStudio receives the currently opened GDS layout
• The top cell name is passed automatically
• If you had already created a simulation model for this layout, you can load it from the history list in File menu

---

Workflow overview

EMStudio is a Qt-based desktop application for preparing, visualizing, and managing electromagnetic and thermal simulations.

EMStudio can be started stand-alone, or from the klayout layout editor.

After simulation settings and port (or thermal object) configuration are configured, EMStudio can save a simulation model to disk, and also start simulation. The simulation model requires the solver workflow folder ('modules' for openEMS, 'gds2palace' for Palace / Elmer) and the stackup file (*.XML) to be present in your target directory. This means you usually want to have one folder for each solver type (openEMS, Palace, or Elmer) where simulation model scripts are located together with the solver modules folder and the substrate files.

Note that the solver workflow folders are only the "bridge" to openEMS, Palace, and Elmer, and you need to have these solvers installed, as described in the solver documentation. This is no different from using the normal Python script based IHP EM workflows.

Note for advanced users: If you want to create simulation models in different directories, and don't want to copy & paste the "modules" or "gds2palace" to each of these folders, you can also include these folders in your PYTHONPATH environment variable. Prefer installing from PyPI and keeping it current:

python -m pip install -U -r requirements-python.txt
# or at least:
python -m pip install -U "gds2palace>=0.5.2"

That pulls gds2palace 0.5.2+ (schema 3.x stackup Variables / Reference / DerivedLayers; needs Python ≥ 3.12) together with gdspy and gmsh. For Touchstone post-processing (scripts/combine_extend_snp.py) you also need numpy and scikit-rf. Model Fit on the Results tab launches snp2le (pip install snp2le, Python ≥ 3.10). See requirements-python.txt for the full recommended set (aligned with Volker’s setupEM / gds2palace PyPI packages).

User Interface

When you start EMStudio, you first need to configure some path settings using Setup > Preferences from the main menu.

Configuration

The screenshot shows the configuration of EMStudio on a Windows machine, with openEMS installed on Windows and Palace installed in Windows Subsystem for Linux (WSL).

• MODEL_TEMPLATES_DIR EMStudio provides templates for openEMS and Palace workflows, so that you can start from scratch with no existing Python model code. The path configured here points to the template directory where openems_model.py and palace_model.pyare located.

• FIELD_VIEWER_PYTHON
  Optional host Python for Layout Field: 2D slices (scripts/field_slice_export.py) and the Field→3D viewer (scripts/field_viewer.py), both reading results through scripts/field_io.py.
  Prefer a native Windows python.exe with pyvista, pillow, pyvistaqt and PySide6 installed (the 3D viewer needs the last two).
  If empty, EMStudio falls back to the active tool Python / PATH.

• STACKUP_DIR_OPENEMS, STACKUP_DIR_FEM (EMStudio)
  Folders where the XML stackup file dialog on the Substrate tab starts: the first for OpenEMS (FDTD stackups), the second for Palace, Elmer EM and Elmer Thermal (FEM stackups). If empty or not an existing folder, the dialog starts in the folder of the last stackup file used, else in your home folder.

• LAYOUT_MAX_VIA_POLYGONS (Layout Preview, default 100)
  Most polygons a via layer may have, after via array merging with the model's merge_polygon_size, before the 2D / 3D layout preview shows a message instead of the layout. Thousands of single vias make the preview slow; set merge_polygon_size in the model or raise this limit.

• OpenEMS Python Path
  Path to the Python interpreter used for the openEMS workflow. If you installed openEMS and the IHP workflow files into a venv named "openEMS" located in your home directory "home/venv/openEMS", the python interpreter would be "home/venv/openEMS/bin/python"

• PALACE_PYTHON
  Path to the Python interpreter used for the Palace workflow. If you installed the gds2palace workflow files into a venv named "palace" located in "home/venv/palace", the python interpreter would be "home/venv/palace/bin/python". If you don't want to use Palace, you can leave this empty.

  IMPORTANT: There is no native Palace version for Windows. When running Palace from EMStudio on Windows, you need to have gds2palace installed in a WSL virtual machine, and PALACE_PYTHON points to the venv for gds2palace in your WSL subsystem! In that case, gds2palace and the Palace solver will all run in the WSL subsystem.

• PALACE_RUN_MODE
  This setting is used to define how Palace is started after creating the model files (config.json and *.msh). "Executable" is used if Palace is installed into the "normal" file system, e.g. using spack installation. "Script" is used if you want/need more control over starting Palace, e.g. because you installed it in an apptainer container, or if you want to send jobs to remote machines. An example run script is shown in the gds2palace repository here.

• PALACE_INSTALL_PATH
  This is where you have installed Palace when using the "Executable" run mode. When using EMStudio on Windows, this points to Palace in your WSL virtual machine.

  If you don't want to use Palace, or start Palace using script, you can leave this empty.

  

  In this case, Palace will be started with the maximum number of cores available on your system.

• PALACE_RUN_SCRIPT
  This is the script used to start Palace when using the "Script" run mode. When using EMStudio on Windows, this points to Palace in your WSL virtual machine. If you don't want to use Palace, or start Palace using the "Executable" run mode, you can leave this empty.

Main

The main tab is where you configure the layout input file (*.gds) and the main simulation settings.

When you start from scratch, the settings grid is almost empty. Use File > New and pick the simulator (OpenEMS, Palace, Elmer EM or Elmer Thermal): EMStudio selects it, clears the previous model's GDS file, stackup and ports, creates the default model from its template and opens the Main tab; the first Save asks where to store the new model. Opened and saved models (also with Save As) are listed under File > Recent. You can also load an existing model using File > Load Python Model ..., or go to the Python tab, choose the simulator and press Generate Default. Before leaving the tab, save your changes using File > Save or Ctrl+S

When a valid model is loaded or created from the template, the main tab will look as shown below. Scripts parameters defined using the settings[]=value syntax will be shown in the settings grid and can be modified, with bi-directional synchronization to the built-in Python script editor. Moving the mouse over a setting shows its "flyout help": the description from the keyword files (see below), marked "Required." where the workflow needs the setting and followed by the workflow's default value. A comment of the form # @brief your text on the script line replaces the description with your own text for that model; plain comments are not used.

The grid groups the settings by topic (Script control and output files, Input files, Frequencies, Mesh size and accuracy, …), in the order of the workflow's user guide; settings EMStudio doesn't know are listed under Other. Settings the workflow requires are shown in bold. + Add setting... above the grid (or right-click a topic: Add setting to ...) lists the keywords of that topic with their description and default; the new line goes into the script next to the settings of the same topic. Right-click a setting to Reset to default or Remove from model (not for required settings). The filter field next to the button narrows the grid. Older openEMS models that pass plain variables to the workflow functions can't add settings this way. File → Convert to Settings Dictionary... converts such a model to the settings[...] form of current models.

• It shows each variable that becomes a setting, and what proves its meaning: the workflow function it is passed to, or the openEMS call it is used in. Variables it can't prove stay as they are.
• It shows the original and the converted model side by side before anything is changed. Equal lines are aligned, changes are coloured (red: before, green: after) and scrolling is synchronized; Previous / Next change jump between the edits and select the variables changed there in the list above; clicking a variable in the list shows its line.
• A backup copy (<model>_backup_<date>_<time>.py) is saved next to the model first.
• Models with an old local modules folder can only be converted together with switching the imports to the installed gds2openEMS package. The dialog asks for this, because results can differ with the newer workflow version.
• The converted model re-simulates once on its next run. Topics can be collapsed and stay collapsed when you save. The flyout help comes from the keyword files in keywords/ (one per simulation tool) and also shows the workflow's default value. Setup → Keywords edits them: keyword, description, topic, default and required. In older openEMS models with freely named variables, a variable gets the topic of the workflow parameter it is passed to (e.g. the 9th argument of setupSimulation() is refined_cellsize).

Stackup Variable overrides (variable_overrides) are edited in the Substrate tab's override table, not in the grid. EMStudio reads and writes the dict that read_substrate(..., variable_overrides=...) actually passes, whether it is a variable or a settings['variable_overrides'] entry.

Not all possible settings are included in the template. Adding an additional setting is possible using the script editor on the Python tab. For a full list of available settings[] and their meaning, please refer to the documentation of the IHP openEMS workflow: https://github.com/VolkerMuehlhaus/gds2openEMS/blob/main/doc/Using_OpenEMS_Python_with_IHP_SG13G2_v3.pdf and IHP Palace workflow gds2palace: https://github.com/VolkerMuehlhaus/gds2palace_ihp_sg13g2/blob/main/doc/gds2palace_workflow_userguide.pdf

Before leaving any tab, save your changes using File > Save or Ctrl+S

Substrate

The substrate tab is where you select the XML stackup file to be used for simulation. EMStudio shows a 2.5D stack cross-section next to a GDS layout top-view. Click a metal, via, or dielectric in either pane to highlight the matching layer in the other (cross-reference). Unmapped GDS layers such as port markers are still shown. The same stackup also prepares the Ports configuration tab using layer names from the XML.

Layout preview: 2D / 3D / Field

Floating controls on the layout preview (top-right):

Control	Role
[2D | 3D]	Substrate page: a two-part switch between top view and isometric layout extrusion; the active side is highlighted (keys 2 / 3).
3D viewer ↗	Fields page: the layout stays 2D with the field heatmap; this button (or key 3) opens the separate Field 3D viewer window.

The layout preview shows only the GDS datatypes the model reads (purposelist of read_gds, e.g. settings['purpose'] = [0]; datatype 0 if the model doesn't say), just like the simulation. The Layers panel lists the stackup layers from top to bottom, ports and thermal objects last. Port marker layers are listed by their GDS number (e.g. L201) until a row in the Ports table uses them as source layer; then they are named by that port's number (P1, P2, …). In the Layers panel, the check box of the All layers row shows or hides all listed layers at once (partly checked when only some are shown; also in the right-click menu, which also has Hide Unmapped for port / thermal marker layers without stackup layers). EM only (next to Used only) removes every unmapped layer from the list and hides it in the layout: GDS layers without a stackup layer and port / thermal markers not used in the Ports / Thermal table. A layer comes back as soon as it is mapped, and unchecking the box shows again the layers it hid. The Substrate and Fields pages share one layout view (same layer visibility); each page keeps its own zoom and layout opacity. With All layers selected, the opacity slider sets the fill opacity of the whole layout, 59 % by default (the fill of an untouched layer). Below that it fades the layout as one image, so the fills look the same however many layers overlap; above it the fills get more opaque, up to solid at 100 %, keeping the relative look (in 3D, walls lighter than tops, vias darker than metals). Outlines, ports and thermal markers stay visible, and 0 % shows outlines only. With a single layer selected, the slider changes only that layer's fill and shows it as you see it, with the All layers value applied (an untouched layer shows the same value as All layers). While All layers is below 59 %, a single layer can't be made more opaque than that fade allows. On the Fields page the layout starts at 0 % (outlines in the layer colors), so the field map stays readable.

Navigation and key bindings. Setup → Key Bindings… picks one mouse navigation style for the layout preview and the Field 3D viewer, and lists every binding:

	EMStudio (default)	setupEM (VTK trackball)
Wheel / trackpad scroll	3D: orbit · 2D: pan (a mouse wheel zooms in 2D)	zoom
Ctrl+wheel, pinch	zoom	zoom
Left drag	3D: orbit · 2D: pan	3D: orbit · 2D: pan
Right drag	3D: orbit	zoom (drag up = in)
Middle, Shift+left or Alt+left drag	pan	pan

Keys (click the view first): F fit, Home everything, + / − zoom, arrows pan, 2 / 3 top view / 3D, R reset, I isometric, X / Y / Z axis views (Shift: negative side; Shift+Z looks from below), M measure ruler (or Ctrl+Shift+click), Esc clears, Ctrl+C copies the view. Shift+F switches between Substrate and Fields. On Fields: PgUp / PgDn Z slice, L log, P probe, 3 opens Field 3D. Window-wide: Ctrl+O load, Ctrl+S / Ctrl+Shift+S save, F5 run, Ctrl+1…7 pages, Ctrl+, preferences, F1 about.

Field view (requires a host Python with PyVista + Pillow):

1. Run a simulation that writes field dumps: Palace fdump (.pvd), Elmer EM field dump (fields_t*.vtu/.pvtu), openEMS frequency-domain dump boxes (*_abs.vtr + *_arg.vtr), or Elmer Thermal (thermal_results*.vtu).
2. Open the Fields page (after a successful Elmer Thermal run this happens automatically at max-T Z).
3. On first open, EMStudio auto-picks a “hot” Z (strongest field / max temperature), then exports a PNG via scripts/field_slice_export.py. The default field is |E| for EM runs and temperature for thermal runs.
4. If the run has several result files or frequencies, pick one in the combo box at the top of the Field panel (e.g. driven.pvd, 6 GHz (cycle 1), fields_t0002.vtu - 7.5 GHz, Ef - 10 GHz).
5. Drag the Z slider, use Max, optional Log / Arrows.

Field → 3D (separate OS window):

1. On the Fields page, click 3D viewer ↗ (or press 3). EMStudio shows a short splash, then starts scripts/field_viewer.py for the whole run, with the file / frequency chosen in the Field panel preselected. Clicking it again while the window is open brings it to the front (and switches to the current choice).
2. The viewer offers every result file of the run (volume / boundary dumps, excitations, frequencies; AMR iterations on request), a Cycle picker for multi-frequency .pvd files, and a grouped Field list with physical names and units (|E|, |B|, |H|, |J_s| magnitudes, real / imaginary parts, S, U_e, temperature, …).
3. Clip Plane: X / Y / Z plane with a fine slider, Find max. jumps to the field maximum, 2D plane only shows just the section. Clipping runs in the background, so large dumps do not freeze the window.
4. Display / Field: opacity, mesh overlay, legend, log scale (Min is then a dropdown, -10 … -70 dB below Max, default -70 dB), Min / Max with Reset range to data, and direction arrows for vector fields. View: ±X/±Y/±Z buttons (parallel projection) with the cut face turned toward the camera. Ctrl+C or the right-click menu copies the 3D view. Mouse navigation follows Setup → Key Bindings; keys: R / F / Home reset camera, I isometric, X / Y / Z axis views (Shift: negative side), + / − zoom, arrows pan, O parallel projection, M find max., A arrows, P probe, PgUp / PgDn clip plane.
5. Value markers: check Probe (View box, key P) and click the model to place a numbered marker with the value at that point, from any angle, on the clipped solid, its cut face or the 2D plane. Dragging still rotates. The Markers list beside the view shows the marker number, the value and x / y / z in µm; for temperatures a dropdown switches the list and the labels between K, °C and ΔT (rise above the lowest temperature of the model, in K). Remove, Clear and Copy (tab-separated, for spreadsheets). Right-click the model for Jump to Maximum in Cut Plane (with the clip plane on) and Jump to Maximum on Surface of Body N (the body you clicked, e.g. the chip; the whole shown surface for results without body IDs), Add Marker Here, Remove Marker N and Clear Markers. Markers update when you change the field, file or cycle.
6. Positions are shown in µm for every solver (Elmer Thermal and openEMS dumps are in meters and are scaled).
7. Same FIELD_VIEWER_PYTHON as the 2D exporter; it needs pyvistaqt and PySide6.
8. The viewer also runs on its own and headless, e.g. python scripts/field_viewer.py --run-path <..._data> --source palace --clip-axis Z --clip-max --screenshot out.png; see --help.

Set Preferences → Layout Field → FIELD_VIEWER_PYTHON to a Windows python.exe that has:

python -m pip install pyvista pillow pyvistaqt PySide6
# optional, smoother 2D sampling:
python -m pip install scipy

The Windows installer bundles field_viewer_python\ (embeddable CPython + those packages) next to EMStudio.exe. EMStudio prefers that path when Preferences is empty, so Field 2D/3D works after a normal install with no extra pip step. Set FIELD_VIEWER_PYTHON only to override. If PyVista is missing, the Field panel shows a short hint and the Log window prints the install command. If the 3D viewer fails to start, check the Log window ([Field 3D]). The colormap is autoscaled per Z-slice (2–98% percentiles), so a nearly flat field far from the DUT can look like a strong rainbow — prefer the auto-Z hotspot or enable Log. Nested metal rectangles that look “shifted” are usually different GDS layers, not a broken transform.

See screenshots under Elmer (EM and Thermal) (field.png / field3d.png).

Before leaving any tab, save your changes using File > Save or Ctrl+S

Python

On the Python tab, you can see the Python model code that is used to run openEMS or Palace workflows. When you start EMStudio, you will see an empty editor window. You can now generate a default model code (Button "Generate Default") or you can load an existing model code (Menu: File > Load Python Model ...).

Python model templates are read from the scripts folder in EMStudio, with one template each for openEMS and Palace. You could modify these files if required.

The model code will be synchronized automatically with settings on the "Main" tab, where you can edit your simulation settings. Synchronization works both ways, you can apply changes in the editor on the "Python" tab or in the Settings grid on the "Main" tab.

Before leaving any tab, save your changes using File > Save or Ctrl+S

Ports / Thermal

On the Ports tab (OpenEMS / Palace / Elmer EM), you need to configure simulation ports. It is expected that ports are included in the GDSII file on special layers, one layer per port, as described in the documentation of the IHP EM workflows. The EM workflows support in-plane ports (in xy plane) and vertical via ports (z direction). The direction of current flow in the port must be set by the user: x,y,z or -x,-y,-z for reverse polarity. Port polarity matters when multiple ports are connected to the same return path.

For in-plane ports, specify only the "To Layer" field, and leave the "From Layer" field empty. This will create the correct port configuration in the Python model script.

Before leaving any tab, save your changes using File > Save or Ctrl+S

When creating ports entries from scratch, there is a checkbox "Use Substrate Layer Names" of the left bottom side of the Window. This will tell EMStudio to use layer names from the XML stackup file for the layer dropdown boxes. Of course, you need to set the XML stackup file before, so that layer mappings are available.

In the GDSII file, in-plane ports (X or Y direction) must be drawn as a rectangle for openEMS and Palace workflow. Vertical ports (Z direction) can be drawn as a zero area box (line) for Palace and openEMS. In addition, openEMS also allows via ports to have an area.

When Elmer Thermal is selected as the simulation tool, the Ports tab becomes Thermal. Instead of EM ports you define thermal objects (heat sources in Watts and constant-temperature boundaries in Kelvin), each with a GDS marker layer and a target stackup layer. The layout preview draws them at their target layer; in 3D they are stacked between the layers by height, so a constant temperature at the bottom of the substrate stays below the metals. After a successful solve, EMStudio opens the Fields page (2D) at max temperature Z; if FIELD_VIEWER_PYTHON is set it also launches Field 3D (see Elmer (EM and Thermal) and Layout Field above).

Simulate

On the Simulate tab, you can run the model script to generate the solver input files and start the simulation.

When you press the run button, the simulation model script will be executed, using the Python interpreter that you defined using Setup > Preferences. For openEMS, simulation only starts when setting preview_only=True in the simulation model. For Elmer Thermal, use the Windows native Elmer Python / ElmerSolver paths from Preferences (ELMER_PYTHON, ELMER_SOLVER_PATH).

Results

After a successful OpenEMS, Palace, or Elmer EM run, open the Results tab to inspect S-parameters. EMStudio scans the simulation data directory for Touchstone files (.sNp). For Palace / Elmer EM, CSV outputs can be converted automatically via scripts/combine_extend_snp.py.

You can overlay parameters (S11, S21, …), switch display mode (dB, Phase, Smith chart, zoomed Smith), use Compare… to overlay another .sNp or run folder, and launch Model Fit… (snp2le) when available. On dB/Phase charts: click a curve to select for the calculator; Ctrl+drag a rectangle, or use the mouse wheel / trackpad pinch (zoom toward the cursor); use arrow keys to pan; Esc clears curve selection; F resets the view. The Smith chart has a white chart area with labelled resistance / reactance circles; click near a trace for a marker that shows frequency, |Γ| with angle and the impedance Z (using the file's reference impedance), ←/→ step through the frequencies (Shift: 10 points), Esc clears it. Selected S-parameters and calculator panel visibility are remembered (QSettings); if a saved parameter is missing in the current run, the viewer falls back to S11 without overwriting that preference.

Calculator

Toggle the calculator icon (bottom-right of the Results pane) to open a resizable side panel.

1. Check Touchstone file(s) in the tree (and optionally Compare… overlays).
2. Click a curve on the plot to select it — selected traces become $1, $2, … (click again to deselect).
3. Pick a function from the combo (inserts into the expression line), edit if needed, set Default f, then Evaluate.

Examples:

cser($1)                 # series C from Y at default f (fF)
lser($1) / rser($1) / q($1)  # series L (nH), R (Ω), Q from −1/Y12
delay($1)                # −arg(S21)/ω phase delay (ps; wraps with phase)
cser($1)-cser($2)        # raw C difference of two curves
ydiff_cser($1,$2)        # C from Ya−Yb (open-fixture de-embed)
ydiff_lser($1,$2)        # L from Ya−Yb
csh1($1) / csh2($1)      # shunt capacitances
db(S21,$1)               # |S21| in dB
ph(S21,$1)               # phase in degrees
cser($1,1)               # optional explicit frequency in GHz
cser($1)+csh1($1)        # arithmetic OK

ydiff_cser($1,$2) matches the CMIM open-de-embed flow (scripts/y_open_deembed.py): select meas as $1 and open as $2 (or evaluate an already written *_yopen.s2p with cser($1)).

For Elmer Thermal, the Results tab is hidden — temperature fields are viewed on the Fields page (see the Thermal section above).

--

Switching simulation tools

Choose the solver with the Simulation Tool combo on the Main tab: OpenEMS | Palace | Elmer EM | Elmer Thermal. Generate a matching default model (or open an existing Python model) for that tool. Switching tools for an already customized script is not automatic — start from the matching template or open a model written for that solver. If you change the tool while a model is open, EMStudio warns you:

• Between Palace, Elmer EM and Elmer Thermal (all gds2palace): on Save, the script's workflow calls are adapted to the new solver, but its settings are not. Check them before running. For example, fdump is a list of frequencies for Palace but an on/off checkbox for Elmer EM; the grid switches its editor, and EMStudio never writes fdump = True/False (the Run check reports such a script).
• To or from OpenEMS: the script is not converted and won't run with the other solver. Use File > New or open a model written for it.

---

Example Workflows & Reference Projects

EMStudio is compatible with most publicly available example projects that demonstrate complete EM simulation flows based on IHP SG13G2 technology.

These repositories provide real-world examples for OpenEMS, Palace, and Elmer (including thermal), with GDS layouts, stackup files, simulation scripts, and post-processing.

---

1. OpenEMS Example (IHP SG13G2)

Repository:
https://github.com/VolkerMuehlhaus/gds2openEMS

This project contains:

• SG13G2 example GDS files
• SG13G2 technology XML
• Python simulation scripts
• OpenEMS mesh and solver setup
• Post-processing utilities (S-parameters)

Using with EMStudio

Load the Python script via:

File → Open Python Model…

EMStudio will:

• Parse openEMS simulation settings
• Import GDS + XML files
• Load ports and boundaries
• Provide full editing of simulation parameters
• Export updated openEMS Python script

---

2. GDS‑to‑Palace Example (IHP SG13G2)

Repository:
https://github.com/VolkerMuehlhaus/gds2palace_ihp_sg13g2

This repository shows a complete Palace EM simulation flow including:

• SG13G2 example GDS files
• SG13G2 technology XML
• Palace Python model scripts
• S‑parameter generation

Using with EMStudio

Load the Palace Python script via:

File → Open Python Model…

EMStudio will:

• Parse all Palace simulation settings
• Import GDS + XML files
• Load ports and boundaries
• Provide full editing of simulation parameters
• Export updated Palace-ready Python script

---

3. Elmer Thermal Example (gds2palace / Elmer)

Elmer Thermal models follow the same gds2palace stackup + GDS flow as Palace/Elmer EM, with heat sources and constant-temperature boundaries instead of RF ports.

Typical ingredients:

• Stackup XML with thermal conductivity (and optional temperature tables)
• GDS marker layers for heatsource / consttemp objects
• Python model using create_elmer_thermal
• Results: thermal_results*.vtu (Fields page) and thermal_results.dat (min/max T)

Using with EMStudio

1. Set Simulation Tool to Elmer Thermal
2. Configure ELMER_SOLVER_PATH, ELMER_PYTHON (Python ≥ 3.12 recommended), and FIELD_VIEWER_PYTHON (PyVista)
3. Open or generate a thermal Python model, set GDS + XML, define Thermal objects
4. Run from the Simulate tab — on success, the Fields page opens (2D); Field 3D opens too if FIELD_VIEWER_PYTHON is set

(See the Elmer Thermal screenshot under Elmer (EM and Thermal).)

---

Summary

These example repositories are ideal for learning EMStudio workflows and validating correct operation.

EMStudio can be used directly with OpenEMS, Palace, and Elmer models for:

• Full‑wave EM simulation
• Steady-state thermal (heat) simulation with Elmer Thermal
• SG13G2 / interposer stack evaluation
• Port setup & S‑parameter extraction
• Thermal object setup and Layout Field temperature viewing
• Automated script generation
• KLayout‑based design environment integration

License

EMStudio 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 3 of the License, or (at your option) any later version.

See the LICENSE file for details.

Third-party components

Full inventory (source tree and shipped binaries): THIRD_PARTY_NOTICES.md.

In the source tree

• QtPropertyBrowser (QtPropertyBrowser/) — Nokia Qt Solutions; LGPL-2.1 + Nokia Qt LGPL Exception 1.1, or GPL-3.0 (see QtPropertyBrowser/LICENSE.*). Not “BSD-like”.
• Property editors (extension/) — maintained with EMStudio under GPL-3.0-or-later (historically based on a Qt Quarterly sample; see the notices file).
• Icons — KLayout / Doxygen artwork where noted in the notices file.

Shipped with CI / installer binaries (not exhaustive): Qt 5.15 (LGPL) and Qt Charts (GPL), ICU on Linux portable builds, Windows ANGLE/Mesa/D3Dcompiler/MinGW runtime, and on Windows the bundled Field viewer Python (PySide6-Essentials, VTK, PyVista, NumPy, SciPy, …). Solver tools (openEMS, Palace, Elmer, …) are not shipped.