Skip to content
BranchesTags

Repository files navigation

📘 EMStudio – User Guide & Developer Documentation

EMStudio Logo

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 cross-section
  • 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 / ParaView for thermal)

Features

  • Cross-platform Qt GUI (Linux & Windows)
  • GDS reader (gdsreader.cpp)
  • Substrate & material model (including thermal conductivity / tables)
  • 2.5D stack visualization (substrateview)
  • Python script editor with syntax highlighting & autocompletion
  • Python/Palace parser with JSON configuration
  • QtPropertyBrowser-based parameter editor
  • Preferences dialog (paths, solver settings, Python interpreter, ParaView)
  • Simulation tools: OpenEMS, Palace, Elmer EM, Elmer Thermal
  • Results viewer for S-parameters; ParaView launch 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.

installer

Pre-built Bundle (Linux)

Download the artifact named emstudio-linux-ubuntu24. It's a self-contained bundle — no need to install Qt or any development tools.

  1. Unzip the downloaded artifact.
  2. Run it with:
./EMStudio.sh

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.

Palace

Parallel finite-element electromagnetic solver.

Elmer (EM and Thermal)

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

For thermal field visualization after a successful run, install ParaView and set PARAVIEW_EXE in Preferences (or leave it empty to auto-detect a common install path).

The screenshot below shows an Elmer Thermal stackup in EMStudio together with the resulting temperature field opened in ParaView:

Elmer Thermal workflow with ParaView

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"
  1. Name it e.g. EMStudio via KLayout
  2. (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.

klayout

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.4.1"

That pulls gds2palace 0.4.1+ (schema 3.x stackup Variables / Reference / DerivedLayers) 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).

preferences

  • 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.

  • 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.

    exepath

    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.

main

When you start from scratch, the settings grid is almost empty. You can now load a project template using File > Load Python Model ... or you can go to the Python tab, choose the simulator that you want to use and then press Generate Default. Before leaving the tab, save your changes using File > Save or Ctrl+S

generate

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. If the script line provides additional information in a comment, this will be shown as "flyout help" when moving the mouse over that item in the settings grid.

main

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/openems_ihp_sg13g2/blob/main/doc/Using_OpenEMS_Python_with_IHP_SG13G2_v2.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 cross section of the substrate file, and in the background, it prepares the Ports configuration tab using the layer names found in the stackup.

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

substrate

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

python

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

ports

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. After a successful solve, EMStudio opens the temperature field (thermal_results*.vtu) in ParaView (see the screenshot under Elmer (EM and Thermal) above).

Simulate

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

simulate

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).

simulate

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 between dB + Phase, Smith chart, and a zoomed Smith view, and launch Model Fit… (snp2le) when available.

Results viewer S-parameters

For Elmer Thermal, the Results tab is hidden — temperature fields are viewed in ParaView instead (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.

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/openems_ihp_sg13g2

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 (open in ParaView) 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 optionally PARAVIEW_EXE
  3. Open or generate a thermal Python model, set GDS + XML, define Thermal objects
  4. Run from the Simulate tab — on success, ParaView opens the temperature field

(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 ParaView field 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.

This project also includes third-party components:

  • QtPropertyBrowser – from the Qt Solutions package, licensed under BSD-like terms

About

EMStudio

Resources

Readme
GPL-3.0 license
Activity
Custom properties

Stars

15 stars

Watchers

1 watching

Forks

2 forks
Report repository

Releases

Packages

Contributors

Languages