Prepare IHP SG13G2 GDSII layout for EM simulation

Version 1.2: all-new, geometry-based algorithms across every tool, replacing the earlier hardcoded heuristics — for significantly cleaner and more general simplification output.

This is a collection of tools to simplify GDSII layout for EM simulation.

Layouts are usually simple and clean in the initial design phase, but simulating a „final“ layout that was already prepared for tape-out with density rules etc. can be a challenge. The picture below shows some typical challenges:

1. To fulfill metal density rules, larger areas have been created as an array of squares with hole inside. This hole does not really matter for EM results, but it will lead to additional mesh cells and slow down mesh generation and simulation. For openEMS, the value of refined_cellsize can efficiently be used to skip small detail, but still those edges will slow down the meshing processing. For Palace, such small detail will all be included in mesh and it is absolutely required to remove this.
2. On layer TopMetal2 shown as orange boxes on the top right side, and many other layers hidden here, the layout includes unconnected (floating) metal boxes that are used to fulfill density rules. Unlike auto-generated dummy metal fill, this man-made dummy metal fill is on purpose „drawing“ and can’t be skipped by the purpose (data type).
3. Especially for pads, there is a massive amount of vias located in via arrays at rather large spacing. A large distance for via array merging could merge adjacent via stacks that connect different metal shapes, and short them. gds_prepare_for_EM, gds2palace (0.8.1 and newer) and gds2openEMS only merge vias that connect the same metal shapes above and below.
4. In the case shown here, the pads for copper pillar are round, which is represented in GDSII as a polygon with many vertices, resulting in over-meshing at these polygons, wasting simulation time.

To solve these issues and create a more simulation-friendly layout, a collection of tools is provided here.

gds_removefill

Removes unconnected (floating) man-made dummy metal fill. A shape only counts as removable fill once that same size repeats often enough on a layer, so genuinely isolated design content is left alone.

Optional commandline parameters, and their default value if not given:

• output filename (second positional argument) - <input>_cleaned.gds
• --cell - the top-level cell with the largest bounding box (KLayout's $$$CONTEXT_INFO$$$ never counts); the log names the cell and the other top-level cells. Before, the first top-level cell was taken, which in a file with several of them could be another cell than the design
• --minsize - 1 (micron)
• --maxsize - no upper limit
• --mincount - 20 (how many repeats of the same size count as fill)

python gds_removefill.py layout.gds cleaned_layout.gds --minsize 1 --maxsize 40 --mincount 20

gds_simplify

Replaces density-fill cutouts (squares/shapes with a hole punched in them) with solid outlines, replaces circle-like pads with octagons for faster meshing, and detects and removes thin ring/frame structures on the layout periphery such as seal rings. Always processes the full built-in default set of layers.

Optional commandline parameters, and their default value if not given:

• --exclude-layers - none (the full built-in default layer set is processed)
• --cell - as for gds_removefill; used for the seal ring detection, all cells are simplified

python gds_simplify.py layout.gds --exclude-layers 126,134

gds_prepare_for_EM

The all-in-one tool: runs all of the above plus via-array simplification (replacing dense via arrays with a handful of clean shapes) and round-pad-to-octagon conversion, producing a single simulation-ready output file in one pass.

It also fills holes that only appear once neighbouring polygons are merged, e.g. a meshed ground plane drawn as several polygons whose seams cut through rows of openings. Such a hole is filled only if holes of the same size repeat at least --fill-mincount times on a layer, so a one-off opening enclosed by merged metal (e.g. the aperture around an antenna) stays open.

Optional commandline parameters, and their default value if not given:

• output filename (second positional argument) - <input>_cleaned.gds
• --cell - the top-level cell with the largest bounding box (KLayout's $$$CONTEXT_INFO$$$ never counts); the log names the cell and the other top-level cells. Before, the first top-level cell was taken, which in a file with several of them could be another cell than the design
• --fill-minsize - 1 (micron)
• --fill-maxsize - no upper limit
• --fill-mincount - 20 (how many repeats of the same size count as fill, or as a hole pattern to fill)
• --max-hole-area - no upper limit (every real cutout found is filled); set this to leave larger cutouts untouched
• --via-merge-size - 2 (micron): vias closer than this are merged into one shape, but only if they connect the same metal shapes above and below, so via merging never shorts different metal shapes. The merged shape is clipped to the overlap of these metal shapes. 0 = no via merging.

python gds_prepare_for_EM.py layout.gds cleaned_layout.gds --fill-minsize 1 --fill-maxsize 40 --fill-mincount 20 --max-hole-area 1

Starting from the example above, the resulting cleaned and simplified GDSII then looks like this:

Installation

There are two ways to use these tools - pick whichever fits your workflow.

Requires Python 3.9+ and these libraries: gdspy, rtree, numpy, shapely (>=2.0).

Run the Python files directly, no installation needed beyond the dependencies:

pip install -r requirements.txt
python gds_prepare_for_EM.py layout.gds

Install as a package, which adds gds_prepare_for_EM, gds_simplify, and gds_removefill as commands on your PATH while the virtual environment is active:

pip install gds_prepare_for_EM
gds_prepare_for_EM layout.gds

(For a local/development install from a clone of this repository, use pip install -e . instead.)

Usage

To run a tool, specify the *.gds filename as commandline parameter; the cleaned file is saved with an appropriate file suffix (or pass a second argument to choose the output filename). Every tool always prints its full list of options and the values used for that particular run, so you can see exactly what a run did after the fact - run with --help to see the options without processing a file, or --version to print the version.

example, either as a direct script or as an installed command:

python gds_prepare_for_EM.py layout.gds
python gds_prepare_for_EM.py layout.gds cleaned_layout.gds

gds_prepare_for_EM layout.gds
gds_prepare_for_EM layout.gds cleaned_layout.gds

Use from Python (stackup-driven simplification)

gds_simplify_for_em runs the same steps from Python, with the layers taken from a gds2palace XML stackup instead of the IHP SG13G2 layer names. setupEM's Tools > Simplify GDS and the gds2palace MCP server use it.

from gds2palace import stackup_reader, utilities
from gds_simplify_for_em import layers_from_stackup, run_simplify, estimate_polygon_count_by_layer

_, _, metals_list = stackup_reader.read_substrate(utilities.get_stackup_path("SG13G2_FEM_200um.xml"))
metal_layers, via_layers = layers_from_stackup(metals_list)    # port layers 201-299 are left out

print(estimate_polygon_count_by_layer("layout.gds", "", purposelist=[0]))   # {layer: count}, no flattening
run_simplify("layout.gds", metal_layers, "layout_simplified.gds",
             do_floating=True, do_cutouts=True, via_layers=via_layers, via_merge_size=1.0)

• run_simplify(): fills small cutouts, removes floating fill, merges each layer and merges via arrays (vias closer than via_merge_size that connect the same metal shapes above and below), in this order, then checks and repairs polygon validity.
• estimate_polygon_count() / estimate_polygon_count_by_layer(): the polygon count of a cell, from the cell hierarchy without flattening it, so it is fast even for dense fill and via arrays.
• ground_plane_holes() / run_simplify(..., fill_ground_holes=True): openings in ground planes, measured in the layout. Each metal layer is merged first, so holes drawn inside tiles and gaps left between side-by-side tiles are the same kind of opening. A merged shape is a ground plane if, with its holes filled, it is large (at least 10 % of the layout's bounding box) and solid (at least 60 % of its own bounding box). Openings of one size that occur at least 20 times on a layer (cheesing, a tiled mesh) are filled; other openings, which belong to the circuit, and holes in shapes that are not ground planes stay. There is no size threshold: only the repeated sizes found in the layout are filled.

License

This project is licensed under the Apache License, Version 2.0 - see LICENSE for the full text.

Technology-specific (IHP SG13G2) hardcoded values

These tools are written against the IHP SG13G2 GDSII layer/purpose numbering. To adapt them to a different PDK, edit the tables below - there is no config file, everything else in each script derives from these tables.

Each of the three tools keeps its own independent copy of the layer/purpose tables - they are not shared or synced. Editing one script's table has no effect on the others; if a layer/purpose number needs to change, it must be changed in each script that defines it.

gds_prepare_for_EM.py

gds_simplify.py

gds_removefill.py

gds_geometry_utils.py / tools/gds_diff.py

Neither file contains any PDK-specific values - both work purely on generic polygon geometry (hole/cutout decomposition, circle detection, periphery ring detection, design cell selection, structural diffing) and apply to any GDSII layout.

python tools/gds_diff.py [--flat] a.gds b.gds compares the polygons and paths per cell and (layer, datatype): count, area and vertex counts, and ends with a summary line (also "no differences"). Cells are compared by name; --flat compares the two design cells flattened instead, whatever their names, e.g. a layout against gds_prepare_for_EM's output, whose cell is flattened and renamed.

Tests

python -m pytest from the repo root (pip install pytest, or .[test]). Small layouts generated by the tests check that layers above 200 are kept, the choice of the design cell, fill removal and tools/gds_diff.py, in a few seconds. The golden checks (marker golden, about 30 s) run gds_prepare_for_EM and gds_removefill on the layouts in testcases/ and compare the per-layer polygon count and area with tests/golden/; testcases/ is not in git, so they are skipped without it (or set GDS_TESTCASES to its folder). A change that alters a result on purpose updates the golden files with UPDATE_GOLDEN=1 python -m pytest tests/test_golden.py; python -m pytest -m "not golden" skips them.