quantcore_circuits.layouts.wafers.wafer

Wafer assembly: pack square dies on a round wafer, name them, and place real chip layouts on them.

Wafer level layers (PDK): the wafer outline is on 500/0 (wafer_boundary) and everything else drawn at wafer level (die labels, die outlines, alignment / orientation marks) is on 501/0 (wafer_markers). Chips keep their own layers; each is a sub-cell of the wafer cell.

Units: the user-facing parameters and tables are in mm (a wafer is “100 mm”, a die “7.5 mm”); the layout is written in µm like every other Quantcore layout. The wafer centre is the origin, x to the right, y up.

>>> w = Wafer(diameter_mm=100, die_mm=7.5)             # dense packing, notch on the bottom edge
>>> w.die_count, w.dies[0].name
>>> w.write("build/wafer/wafer_100.oas", chips="examples/designs/legacy/chip_06_test_cyro_tlq.json")

Naming: rows are letters from the top (A, B … Z, AA …), columns are numbers from the left (1, 2 …), a die is <row><column> (C4). On a uniform wafer columns are counted from the leftmost occupied column of the whole wafer, so a short top row starts at a higher number, as on a wafer map; on a mixed wafer (bands) the rows do not share a grid and each row is counted from its leftmost die.

Packing:

  • packing="dense": every die that fits completely inside the usable disc (wafer radius minus the edge exclusion, and clear of the notch / flat).

  • packing="centred": only dies completely inside a circle of radius_mm around the packing centre (offset_mm away from the wafer centre), and still inside the usable disc. The grid is laid out around that centre.

  • bands=[(die_mm, n_rows), ...] (mixed die sizes): rows of one size stacked top to bottom, the stack centred on the packing centre; each row is filled with as many dies as fit.

Attributes

Classes

Die

One die position: name = row letter + column number, centre (x, y) in mm, side size_mm.

Wafer

A wafer layout plan: the die positions and names, and write() / build() to draw it.

Functions

row_letters(index) → str

0 → A, 25 → Z, 26 → AA (spreadsheet style).

Module Contents

class quantcore_circuits.layouts.wafers.wafer.Die

One die position: name = row letter + column number, centre (x, y) in mm, side size_mm.

band: int = 0
property box_um: tuple[float, float, float, float]
chip: str | None = None
col: int
name: str
row: str
size_mm: float
x_mm: float
y_mm: float
class quantcore_circuits.layouts.wafers.wafer.Wafer

A wafer layout plan: the die positions and names, and write() / build() to draw it.

diameter_mm 100 (4 in) or 150 (6 in) are the presets; any diameter works. orientation is "notch" (default), "flat" or "none" at orientation_side (bottom default). edge_mm is the edge exclusion (no die closer than this to the rim, the notch or the flat); street_mm the dicing street between dies. align: where the die grid sits relative to the packing centre: "centre" (a die centred there), "corner" (a street crossing there), "row" / "column" (one of each) or "auto" (the one that fits most dies).

assign(chips) → None

Set the chip id of every die from chips (see build()) without loading any layout.

build(chips=None, layout: kqcircuits.pya_resolver.pya.Layout | None = None) → tuple[kqcircuits.pya_resolver.pya.Layout, kqcircuits.pya_resolver.pya.Cell]

Draw the wafer: outline 500/0, labels / outlines / marks 501/0, the chips as sub-cells. Returns (layout, top cell).

chips places layouts on the dies: None (empty dies), one source for every die, {"B3": src} by die name, {7.5: src} by die size in mm ("*" is the default) or a function die -> source | None. A source is a .json design (built headless), an .oas / .gds file, or a BuildResult. A chip is centred on its die; it must fit inside the die (its 100/0 chip boundary, or its bounding box).

counts_by_size() → dict[float, int]
die(name: str) → Die
outline_polygon_um(points: int = 2000) → kqcircuits.pya_resolver.pya.DPolygon

The wafer outline (a circle with the notch or flat cut in), in µm.

plot_map(path: str | pathlib.Path | None = None, ax=None, size_in: float = 7.0)

Die map (matplotlib): the outline with the notch, every die with its name. Saves to path when given.

table() → list[dict]

One row per die: name, row, column, size, centre (mm) and the chip placed on it.

table_markdown(limit: int | None = None) → str
write(path: str | pathlib.Path, chips=None, table: bool = True) → pathlib.Path

Build and write the wafer OAS / GDS; with table=True also <path>.csv (the die table).

write_table(path: str | pathlib.Path) → pathlib.Path
align: str = 'auto'
bands: list[tuple[float, int]] | None = None
diameter_mm: float = 100.0
property die_count: int
die_mm: float = 7.5
die_outline: bool = True
dies: list[Die] = []
edge_mm: float = 3.0
label_mm: float | None = None
labels: bool = True
name: str = ''
offset_mm: tuple[float, float] = (0.0, 0.0)
orientation: str = 'notch'
orientation_side: str = 'bottom'
packing: str = 'dense'
radius_mm: float | None = None
property radius_wafer_mm: float
street_mm: float = 0.1
quantcore_circuits.layouts.wafers.wafer.row_letters(index: int) → str

0 → A, 25 → Z, 26 → AA (spreadsheet style).

quantcore_circuits.layouts.wafers.wafer.DBU = 0.001
quantcore_circuits.layouts.wafers.wafer.MARKER_LAYER = (501, 0)
quantcore_circuits.layouts.wafers.wafer.NOTCH_DEPTH_MM = 1.0
quantcore_circuits.layouts.wafers.wafer.PRESETS
quantcore_circuits.layouts.wafers.wafer.WAFER_LAYER = (500, 0)