Stackup¶

A Stackup describes how the 2D layers in your layout extend into 3D — what material lives at what height, how its xy footprint morphs with z, and which entries override which. From the same Stackup you can currently produce either of two outputs:

• 3D: stack.resolve(cell) returns a ResolvedStackup describing how each layer polygon should be extruded and cut against the others using a CAD tool.

• 2D: stack.resolve_cutline(cell, cutline) or stack.resolve_cross_section(cs) returns a ResolvedStackup2D containing the (already processed) 2D polygons of the cross-sectional view.

Both outputs share the same minimalistic painter’s-algorithm metadata: mesh_order, keep, and cut_by. This page works through both outputs on a small but realistic silicon-photonic stack: a rib waveguide with a TiN heater wired out to a metal pad.

A silicon-photonic PDK¶

A handful of layers is enough to express a complete rib-waveguide device. For the bulk media (Si substrate, buried oxide, oxide cladding) we use the smart AllLayers().bbox() recipe as the xy footprint: it expands at resolve time to the bounding box of every shape in the cell, so the bulk bodies automatically grow to enclose whatever the device draws — no dedicated “device extent” layer required.

Building entries¶

A StackupEntry is one logical 3D body. Currently this is a name plus a z_to_layer dict mapping absolute z values (µm) to LayerBase recipes (with room to expand to more intricate geometries).

• The convenience constructor StackupEntry.uniform(name, layer, zmin, zmax) builds a 2-key entry with vertical sidewalls

• Passing the dict directly lets you vary the xy recipe with z to produce slanted sidewalls or a topology that morphs between the keys.

Composing StackupEntries into a Stackup with + and -¶

Stackup composition is strict painter’s order (left-to-right). + appends an entry with keep=True. - appends it with keep=False: this is used as a optional shortcut to indicate that an entity should participate in later cut_by computations, while not being emitted as an output volume. Use parentheses for explicit grouping when mixing the two.

Pretty-printing¶

print(stack) renders the stackup as a table in painter’s order. Uniform entries collapse to a single zmin → zmax row; z-varying entries get one row per z-key so slanted sidewalls and topology morphs stay visible (look at Si_rib).

Stack perturbations¶

Both StackupEntry and Stackup are immutable: every perturbation returns a new object and leaves the original untouched. Perturbations come in two flavours — one acts on each entry’s xy layer recipes, the other on its z-keys — and both compose cleanly through + / -, so you can perturb a sub-stackup and drop it straight into a larger composition.

Transforming layers (xy)¶

The map_layers(fn) family rewrites the recipe side of every z_to_layer entry while leaving the z-keys fixed. size, transformed, round_corners, bbox, and the boolean selectors (interacting, inside, outside, overlapping) are exactly the Smart Layer API operations from notebook 12, lifted onto a stackup: each one applies the corresponding LayerBase recipe transform to every entry. Calling one on a Stackup applies it to every entry in the stack.

Here we grow both silicon layers by 100 nm per side — the recipes become LayerSize(...) wrappers while the z-keys stay put:

Transforming z-keys¶

shift_z(dz) translates every z-key; scale_z(factor, origin=0.0) scales them about a single shared absolute origin (new_z = origin + (z - origin) * factor). A negative factor mirrors the stack in z. On a Stackup both apply uniformly to all entries, so a sub-stackup moves or stretches as one rigid body.

The motivating use is floating one sub-stackup in z relative to another. Here the silicon device is lifted 200 nm above the lower cladding — the Si_slab / Si_rib z-rows shift up while the bulk media stay put:

scale_z stretches thickness about the origin. Doubling the device about z = 0 sends the slab top from 70 nm to 140 nm and the rib top from 220 nm to 440 nm:

Drawing the device¶

Th stackup itself is only a recipe. To resolve it, we need a cell. Here, we make a device with a 20 µm-long rib waveguide with a TiN heater strip running along it; both ends of the heater fan out to a metal-1 pad south of the waveguide, contacted by a small via column.

Resolving in 3D¶

Stackup.resolve(cell) materialises each entry’s xy regions at its own z-keys (no resampling) and emits one ResolvedPrism per slot. The downstream 3D backend is expected to consume the output and apply cuts in real 3D space, so .resolve itself does no 2D booleans — disjoint slots simply omit each other from cut_by.

cut_by is a forward-only list of slot indices whose 3D bbox overlaps this prism’s; a 3D backend subtracts those entries’ raw solids to obtain each kept prism’s final volume.

Rendering the 3D stack with PyVista¶

gw.plot_stackup_3d(resolved) builds one pv.PolyData per kept prism and returns a configured pv.Plotter. The viewer renders raw prism bodies — it does not apply cut_by subtractions, because robust 3D booleans on coplanar slab faces require exact-arithmetic CSG that VTK does not provide. Painter’s-algorithm cuts are the downstream backend’s job (e.g. meshwell); use this viewer for sanity-checking painter’s order, layer footprints, and z-extents. The default opacity=0.3 keeps bulk media (substrate, BOX, claddings) see-through so the rib, slab, heater, via, and metal-1 pad stay visible through them. opacity_map is the escape hatch for making specific prisms opaque.

For interactive exploration during dev work, switch to pv.set_jupyter_backend("trame") (and install trame-pyvista); the viewer code is unchanged.

Cutting in 2D — resolve_cutline¶

To get a 2D cross-section, pass a cutline (two xy points in microns) through the cell. The output ResolvedStackup2D carries per-entry kdb.Regions in the (s, z) → (x, y) convention: the region’s x-axis is arclength s along the cutline; its y-axis is the stackup height z.

The bulk media (substrate, BOX, oxide claddings) fill the frame; on top of them you can see the heater strip, the heater contact pad with a via climbing up through the upper cladding, and the metal-1 pad capping the via. The zoom on the right reveals the 220 nm slanted-sidewall rib sitting on the 70 nm slab — both vanish in the full-stack view because they are honestly to scale next to micron-thick claddings.

Painter’s algorithm and cut_by¶

Later entries cut earlier ones where their 3D (or 2D) bboxes overlap. plot_cross_section applies these cuts by default (apply_cuts=True) so you see each prism’s final, carved patch. Compare with apply_cuts=False, which renders the raw per-entry regions before any subtraction. This is useful to debug painter’s order.

Cutting in 2D — resolve_cross_section¶

In many layouts, you usually already work with a CrossSection. The convenience Stackup.resolve_cross_section(xs, s=0.0) evaluates the CrossSection at s, builds a synthetic straight whose xy layout matches the evaluated profile, and slices it with a perpendicular midspan cutline. No manual cutline needed.

Improvements¶

This framework is extremely modular. We can add subclasses or keywords to StackupEntries to log information about more intricate geometries (e.g. filleted corners). We could also generate sets of StackupEntries from Stackup, for instance to emulate conformal claddings that calculate their effective footprints and levels from sets of StackupEntries in a Stackup. Alternatively, we could output “process” recipes for process simulation instead of already-rendered prisms.