Process Development Kit © 2026 iQnite Foundry Services · Home

Straight CPW segment with guaranteed ports.

Builds a straight CPW segment using a CPW cross-section contract:
sections[0] is signal and sections[1] (optional) is keepout. Ports are
guaranteed and are synthesized on the signal section only when needed.

length_um : float

Segment length (µm).

cross_section : CrossSectionSpec

CPW cross-section spec or factory. Signal is sections[0]; keepout is sections[1] when present.

o1 : West port at x=0 (orientation=180).
o2 : East port at x=length (orientation=0).

• Signal + keepout : derived from cross_section sections ordering

• “CPW” in this PDK means signal + keepout envelope only.
• No explicit ground rails are drawn.

length_um

Circular CPW bend.

Builds a circular bend using the provided CPW cross-section. Signal and
keepout are emitted by the cross-section itself (section ordering contract).
Ports are exported from the underlying bend component.

radius_um : float

Bend radius to the centerline (µm).

angle_deg : float

Bend angle (degrees).

cross_section : CrossSectionSpec

CPW cross-section spec or factory used by gdsfactory.

o1 : Input port.
o2 : Output port.

• Signal + keepout : derived from cross_section

• No explicit overlay polygons are drawn here. This keeps geometry purely
  cross-section–driven.

radius_um, angle_deg

Rectangular keepout stud with one port.

Draws a rectangle on the provided cross-section's signal section layer
(sections[0]) and exports a single west-facing port sized to the section
width. Intended for keepout markers, open-stud placeholders, or density/
DRC envelopes.

length : float

Stud length along +x (µm).

cross_section : CrossSectionSpec

Nofill/keepout cross-section spec or factory. Rectangle width and layer are taken from sections[0].

o1 : West port at x=0 (orientation=180), width = section width.

• Stud polygon : derived from cross_section (sections[0].layer)

length_um

Josephson junction cross in Manhattan convention (patch + shadow ready).

This PCell builds a JJ cross rotated into the 45° Manhattan orientation and adds
symmetric patch pads plus patch-shadow layers. Patch layers default to the JJ
layers unless overridden by non-empty layer names.

variant : Literal["rounded", "rectangle", "bar"]

Patch style selector ("rounded", "rectangle", "bar").

jj_wid : float

JJ arm width (µm).

jj_len : float

JJ arm length (µm).

jj_arm_ext : float

Geometric extension used for shifting before the final -45° rotation (µm).

jj_shadow_len : float

Shadow geometry length (µm).

jj_arm_shadow_overlap : float

Shadow geometry overlap (µm).

merge_jj_and_patches : bool

If True, boolean-union JJ metal + patch pads into the JJ metal layer.

layer_jj_name : str

PDK layer name (resolved via resolve_layer). JJ metal layer.

layer_jj_shadow_name : str

PDK layer name (resolved via resolve_layer). JJ shadow layer.

layer_patch_name : str

PDK layer name (resolved via resolve_layer). Patch layer. If empty, uses layer_jj_name.

layer_patch_shadow_name : str

PDK layer name (resolved via resolve_layer). Patch-shadow layer. If empty, uses layer_jj_shadow_name.

• JJ metal : layer_jj_name
• JJ shadow : layer_jj_shadow_name
• Patch : layer_patch_name
• Patch shadow : layer_patch_shadow_name

• Layer resolution occurs at runtime via resolve_layer.
• Tier B builders operate strictly on resolved layer tuples.

cell
layer_jj_name
layer_jj_shadow_name
layer_patch_name
layer_patch_shadow_name

Generic qubit capacitor pocket with antennas and local ground cutout.

Builds a reusable pocket primitive for lumped-element qubits, including two
capacitor pads (signal/ground), JJ landing arms with fillet cutouts, a resonator
antenna and a charge/drive antenna (each with a straight CPW), and a local ground
region where cpwgnd = gengnd - nofill is created via a boolean operation.

res_antenna_width_um : float

Width of the resonator antenna pad (um).

res_antenna_height_um : float

Height of the resonator antenna pad (um).

res_antenna_offset_x_um : float

X offset applied after connecting the resonator antenna to the top pad (um).

res_antenna_offset_y_um : float

Y offset applied after connecting the resonator antenna to the top pad (um).

res_straight_len_um : float

Length of the CPW straight attached to the resonator antenna (um).

res_antenna_radius_um : float

Corner radius used for the resonator antenna pad (um).

charge_antenna_width_um : float

Width of the charge antenna pad (um).

charge_antenna_height_um : float

Height of the charge antenna pad (um).

charge_antenna_offset_x_um : float

X offset applied after connecting the charge antenna to the bottom pad (um).

charge_antenna_offset_y_um : float

Y offset applied after connecting the charge antenna to the bottom pad (um).

charge_straight_len_um : float

Length of the CPW straight attached to the charge antenna (um).

charge_antenna_radius_um : float

Corner radius used for the charge antenna pad (um).

qb_cap_spacing_um : float

Vertical spacing between the two capacitor pads (um).

qb_cap_width_um : float

Width of each capacitor pad (um).

qb_cap_height_um : float

Height of each capacitor pad (um).

jj_gap_um : float

Vertical opening reserved between pads for a JJ device (um).

jj_arm_width_um : float

Width of the JJ landing arms (um).

qb_nofill_extent_um : float

Margin added around the pocket for the global nofill keepout (um).

qb_ground_extent_um : float

Margin between global nofill and chip-outline ground region (um).

cap_radius_um : float

Corner radius used for capacitor pad rounding (um).

cap_arc_pts : int

Number of arc discretization points used for rounded corners.

fillet_radius_um : float

Radius of 90deg fillet cutouts at JJ arm corners (um).

nofill_pad_um : float

Local antenna nofill padding size (um).

nofill_radius_small_um : float

Radius used for small local nofill rounding (um).

nofill_radius_big_um : float

Radius used for the global nofill pocket rounding (um).

chip_outline_extra_y_um : float

Additional Y margin applied to the ground outline for routing clearance (um).

layer_qbtsig_name : str

PDK layer name for qubit signal metal. Resolved via resolve_layer (PDK-first, YAML-fallback).

layer_qbtgnd_name : str

PDK layer name for qubit ground metal. Resolved via resolve_layer (PDK-first, YAML-fallback).

layer_cpwsig_name : str

PDK layer name for CPW signal. Resolved via resolve_layer (PDK-first, YAML-fallback).

layer_nofill_name : str

PDK layer name for nofill/keepout. Resolved via resolve_layer (PDK-first, YAML-fallback).

layer_gengnd_name : str

PDK layer name for global ground. Resolved via resolve_layer (PDK-first, YAML-fallback).

layer_cpwgnd_name : str

PDK layer name for CPW ground (post-boolean). Resolved via resolve_layer (PDK-first, YAML-fallback).

qb_sig_jj : JJ-facing port on the top (signal) arm.
qb_gnd_jj : JJ-facing port on the bottom (ground) arm.
res_o2 : Output port of the resonator antenna straight (o2).
charge_o2 : Output port of the charge antenna straight (o2).
cap_u_N, cap_u_S, cap_d_N, cap_d_S : Debug ports on capacitor pad edges.

• Signal metal : layer_qbtsig_name
• Ground metal : layer_qbtgnd_name
• CPW signal : layer_cpwsig_name
• Nofill : layer_nofill_name
• Global ground : layer_gengnd_name
• CPW ground (post-boolean) : layer_cpwgnd_name

• This cell does not place a Josephson junction device; it only defines the pocket
  and JJ landing geometry.
• The boolean ground cutout requires an active PDK.

cell
res_antenna_width_um
res_antenna_height_um
res_antenna_offset_x_um
res_antenna_offset_y_um
res_straight_len_um
charge_antenna_width_um
charge_antenna_height_um
charge_antenna_offset_x_um
charge_antenna_offset_y_um
charge_straight_len_um
qb_cap_spacing_um
qb_cap_width_um
qb_cap_height_um
jj_gap_um
jj_arm_width_um
jj_arm_len_um
qb_nofill_extent_um
qb_ground_extent_um
chip_outline_extra_y_um
pocket_nofill_w_um
pocket_nofill_h_um
chip_outline_w_um
chip_outline_h_um
cap_u_center_y_um
cap_d_center_y_um
layer_qbtsig_name
layer_qbtgnd_name
layer_cpwsig_name
layer_nofill_name
layer_gengnd_name
layer_cpwgnd_name

Finger-cap clip structure formed by boolean operations.

Builds a local capacitor-like clip geometry by (A) carving a meander nofill
pattern out of a smaller ground island (result emitted onto
layer_cpwsig_name), and (B) carving an outer nofill window out of a full
cell ground (result emitted onto layer_cpwgnd_name). A full-cell nofill
rectangle is also emitted for density/keepout visibility.

cell_size_xy_um : tuple[float, float]

Cell boundary size (x, y) in um.

finger_overlap_um : float

Meander run length target (um). Effective straight run is (finger_overlap_um - finger_width_um).

finger_gap_um : float

Gap between adjacent fingers (um). Also used as the meander trace width on the nofill layer.

finger_width_um : float

Finger bar thickness used in derived pitch and box sizing (um).

periods : int

Number of meander periods (unitless). Controls overall vertical extent.

carve_out_gap_um : float

Additional padding (um) that defines the carve-box larger than the cap box.

carve_ext_width_um : float

Width (um) of the carve-box side extension rectangles.

cap_corner_r_um : float | None

Corner radius (um) for the cap box and carve box. If None, defaults to finger_width_um.

ext_corner_r_um : float

Corner radius (um) for side extension rectangles.

fillet_r_um : float

Radius (um) for 90deg fillet cutouts used on extension corners.

layer_gengnd_name : str

PDK layer name for source ground. Resolved via resolve_layer (PDK-first, YAML-fallback).

layer_nofill_name : str

PDK layer name for keepout/nofill. Resolved via resolve_layer (PDK-first, YAML-fallback).

layer_cpwsig_name : str

PDK layer name receiving (cap_gengnd - meander_nofill). Resolved via resolve_layer (PDK-first, YAML-fallback).

layer_cpwgnd_name : str

PDK layer name receiving (cell_gengnd - carvebox_nofill). Resolved via resolve_layer (PDK-first, YAML-fallback).

precision : float

Boolean geometry precision (um units assumed; typical 1e-3).

W : West boundary port, orientation 180deg.
E : East boundary port, orientation 0deg.
S : South boundary port, orientation 270deg.
N : North boundary port, orientation 90deg.

• Ground source : layer_gengnd_name
• Nofill mask : layer_nofill_name
• Cap result : layer_cpwsig_name
• Cell result : layer_cpwgnd_name

• Requires an active PDK because boolean_between_layers(...) depends on it.
• The meander geometry is drawn on layer_nofill_name using a strip
  cross-section whose width equals finger_gap_um.

cell_size_xy_um
finger_overlap_um
finger_gap_um
finger_width_um
carve_out_gap_um
carve_ext_width_um
periods
cap_corner_r_um
ext_corner_r_um
fillet_r_um
finger_pitch_um
cap_box_size_xy_um
carve_box_size_xy_um
cap_ext_size_xy_um
carve_ext_size_xy_um
precision

Bump unit cell with a circular bump and a polygon marker.

Builds a centered circular bump on the bump layer, plus a same-center
regular polygon marker sized by radius_KOZ_um (default octagon).

radius_um : float

Bump circle radius (um).

radius_KOZ_um : float

Marker KOZ radius (um), defined as the polygon apothem (center to flat side). Flat-to-flat width is 2 * radius_KOZ_um.

layer_bump_name : str

PDK layer name for the bump circle. Resolved via resolve_layer (PDK-first, YAML-fallback).

layer_marker_name : str

PDK layer name for the marker polygon. Resolved via resolve_layer (PDK-first, YAML-fallback).

marker_sides : int

Number of polygon sides for the marker (>= 3). Default is 8.

• bump circle : layer_bump_name
• marker polygon : layer_marker_name

• For even-sided polygons, radius_KOZ_um is the apothem. The polygon is
  rotated by pi/n so a flat side aligns with the x/y axes.
• The circumradius used is: radius_KOZ_um / cos(pi/n).

• cell
• radius_um
• radius_KOZ_um
• marker_sides
• layer_bump_name
• layer_marker_name

5 mm × 5 mm routing demo chip with perimeter pads and a chained CPW route.

Builds a 5 mm × 5 mm chip outline, places pad arrays on all four sides, places multiple
resonator devices, and routes a chain across the devices using gdsfactory.routing.get_route.
Applies a final ground-vs-nofill subtraction post-process before returning the component.

None

None
This example cell does not export top-level ports.

• Pad/device geometry : inherited from my_pdk.components (PDK-driven)
• Final ground post-process : "QM1F_gengnd" minus "QM1F_nofill"

(resolved via resolve_layer, PDK-first, YAML-fallback)

• Activates the current PDK via my_pdk.get_pdk().activate() at runtime.
• Routing uses get_route(...) with cross_section=comp.xs_cpw and a chain of port pairs.
• Final boolean uses subtract_nofill_from_gengnd(..., precision=1e-3).

None

Side-coupled meander demo chip with unitcell decorations, pads, and routed connections.

Builds a decorated meander resonator by periodically placing unitcells along the path, recenters
the resonator by bbox, sizes a chip outline from the resonator bbox, places two pad cells near
opposite corners, and routes from pads to the resonator ends using a taper and orthogonalization
adaptors. Optionally applies a chip-level ground boolean post-process before returning.

run_length_um : float

Meander run length (um).

n_turns : int

Number of meander turns.

pitch_um : float

Meander pitch (um).

radius_um : float

Meander bend radius (um).

turn_angle_deg : float

Effective turn angle used for the meander (degrees).

linewidth_um : float

Main CPW signal width for device wiring (um).

gap_factor : float

Main CPW gap factor so that gap = gap_factor * linewidth_um.

io_width_um : float

IO CPW signal width for pad-side wiring (um).

io_gap_um : float

IO CPW gap for pad-side wiring (um).

unitcell_pitch_um : float

Arc-length spacing for unitcell placement (um).

unitcell_start_s_um : float

Arc-length offset for the first unitcell (um).

unitcell_radius_um : float

Unitcell placement radius parameter (um).

unitcell_offset_um : float

Unitcell offset parameter (um).

pad_shift_top_xy_um : tuple[float, float]

(dx, dy) offset applied after anchoring the top pad near a chip corner (um).

pad_shift_bot_xy_um : tuple[float, float]

(dx, dy) offset applied after anchoring the bottom pad near a chip corner (um).

pad_straight_len_um : float

Straight segment from pad port before taper (um).

taper_len_um : float

Length of the CPW taper from IO cross-section to main cross-section (um).

resonator_end_straight_um : float

Straight added at each resonator end before orthogonalization (um).

orth_L_straight_um : float

Straight length inside the orthogonalize adaptor (um).

orth_radius_correction_um : float

Radius correction inside the orthogonalize adaptor (um).

orth_target_dir_top : str

Target Manhattan direction ("N"/"E"/"S"/"W") for the top-side adaptor output port.

orth_target_dir_bot : str

Target Manhattan direction ("N"/"E"/"S"/"W") for the bottom-side adaptor output port.

bend90_radius_um : float

Radius for the 90-degree bend used by orthogonalization (um).

route_bend_radius_um : float

Radius for the bend used by get_route (um).

chip_margin : float

Multiplier applied to resonator bbox to size the chip outline.

apply_ground_boolean : bool

If True, applies a chip-level boolean postprocess (gengnd - nofill) before returning.

boolean_precision : float

Precision passed to the boolean postprocess.

None
This example cell does not export top-level ports.

• Device geometry : inherited from my_pdk.components (PDK-driven)
• Optional boolean : "QM1F_gengnd" minus "QM1F_nofill" -> "QM1F_gengnd"

(resolved via resolve_layer, PDK-first, YAML-fallback)

• Activates the current PDK via my_pdk.get_pdk().activate() at runtime.
• Unitcells are selected cyclically by arc-length using the local unitcell_factory_by_s.
• When apply_ground_boolean is True, the chip outline is added before the post-process.

• cell_type
• run_length_um
• n_turns
• pitch_um
• radius_um
• turn_angle_deg
• linewidth_um
• gap_um
• chip_w_um
• chip_h_um
• unitcell_pitch_um
• unitcell_start_s_um
• apply_ground_boolean

Side-coupled meander demo chip with unitcell decorations, pads, and routed connections.

Builds a decorated meander resonator by periodically placing unitcells along the path, recenters
the resonator by bbox, sizes a chip outline from the resonator bbox, places two pad cells near
opposite corners, and routes from pads to the resonator ends using a taper and orthogonalization
adaptors. Optionally applies a chip-level ground boolean post-process before returning.

run_length_um : float

Meander run length (um).

n_turns : int

Number of meander turns.

pitch_um : float

Meander pitch (um).

radius_um : float

Meander bend radius (um).

turn_angle_deg : float

Effective turn angle used for the meander (degrees).

linewidth_um : float

Main CPW signal width for device wiring (um).

gap_factor : float

Main CPW gap factor so that gap = gap_factor * linewidth_um.

io_width_um : float

IO CPW signal width for pad-side wiring (um).

io_gap_um : float

IO CPW gap for pad-side wiring (um).

unitcell_pitch_um : float

Arc-length spacing for unitcell placement (um).

unitcell_start_s_um : float

Arc-length offset for the first unitcell (um).

unitcell_radius_um : float

Unitcell placement radius parameter (um).

unitcell_offset_um : float

Unitcell offset parameter (um).

pad_shift_top_xy_um : tuple[float, float]

(dx, dy) offset applied after anchoring the top pad near a chip corner (um).

pad_shift_bot_xy_um : tuple[float, float]

(dx, dy) offset applied after anchoring the bottom pad near a chip corner (um).

pad_straight_len_um : float

Straight segment from pad port before taper (um).

taper_len_um : float

Length of the CPW taper from IO cross-section to main cross-section (um).

resonator_end_straight_um : float

Straight added at each resonator end before orthogonalization (um).

orth_L_straight_um : float

Straight length inside the orthogonalize adaptor (um).

orth_radius_correction_um : float

Radius correction inside the orthogonalize adaptor (um).

orth_target_dir_top : str

Target Manhattan direction ("N"/"E"/"S"/"W") for the top-side adaptor output port.

orth_target_dir_bot : str

Target Manhattan direction ("N"/"E"/"S"/"W") for the bottom-side adaptor output port.

bend90_radius_um : float

Radius for the 90-degree bend used by orthogonalization (um).

route_bend_radius_um : float

Radius for the bend used by get_route (um).

chip_margin : float

Multiplier applied to resonator bbox to size the chip outline.

apply_ground_boolean : bool

If True, applies a chip-level boolean postprocess (gengnd - nofill) before returning.

boolean_precision : float

Precision passed to the boolean postprocess.

None
This example cell does not export top-level ports.

• Device geometry : inherited from my_pdk.components (PDK-driven)
• Optional boolean : "QM1F_gengnd" minus "QM1F_nofill" -> "QM1F_gengnd"

(resolved via resolve_layer, PDK-first, YAML-fallback)

• Activates the current PDK via my_pdk.get_pdk().activate() at runtime.
• Unitcells are selected cyclically by arc-length using the local unitcell_factory_by_s.
• When apply_ground_boolean is True, the chip outline is added before the post-process.

• cell_type
• run_length_um
• n_turns
• pitch_um
• radius_um
• turn_angle_deg
• linewidth_um
• gap_um
• chip_w_um
• chip_h_um
• unitcell_pitch_um
• unitcell_start_s_um
• apply_ground_boolean

Quarter-wave CPW resonator implemented as a single straight section.

Builds a minimal λ/4 transmission-line resonator whose physical length is
computed from a target frequency and a reference effective index. This cell
is intended as a compact, analytically defined resonator primitive.

f_target_GHz : float

Target resonant frequency (GHz).

cross_section : CrossSectionSpec

CPW cross-section specification for the resonator trace.

v_ph_over_c : float | None

Phase velocity normalized to the speed of light. If None, derived from the reference effective index in tech.

input : Feed port at the grounded end of the resonator.
open_end : Open-circuit port at the voltage antinode.

• Signal conductor : defined by the supplied cross_section.

• Electrical length is computed as λ/4 = v_ph / (4 f).
• The default phase velocity is derived from tech.N_EFF_REF.
• No coupling structures or bends are included.

• kind
• mode
• f_target_GHz
• length_total_um_est
• eps_eff_ref
• n_eff_ref
• cpw_source

Generate an explicit-turn meander using Path + extrude.

Builds a centerline Path consisting of alternating straight runs and (optionally) arc turns,
then extrudes that Path using the provided cross-section. This is the canonical explicit-turn
meander builder in this PDK.

run_length_um : float

Length of each horizontal run (um). Must be > 0.

n_turns : int

Number of U-turns in the meander. Must be >= 0.

pitch_um : float

Vertical spacing between adjacent runs (um). Must be > 0.

radius_um : float

Arc radius for each turn (um). Must be >= 0.

turn_angle_deg : float

Signed magnitude of each arc turn (deg). Typically 90deg for quarter-circle corners.

npoints : int

Number of points used to discretize each arc. Higher gives smoother arcs.

cross_section : CrossSectionSpec

Cross-section used for extrusion.

o1 : Input port on the signal trace (points out of the component at the start).
o2 : Output port on the signal trace (points out of the component at the end).

• Signal : derived from cross_section.sections[0].layer
• Keepout (optional) : derived from cross_section.sections[1].layer

• Constraint: pitch_um >= 2 * radius_um. The vertical straight length is
  vlen_um = pitch_um - 2 * radius_um.
• When radius_um == 0, arc segments are skipped and the path uses only straight segments.
• Cross-section ports are sanitized via xs_signal_ports_only(...) before extrusion to
  ensure only signal ports (o1/o2) are created at the top level.

kind
builder
run_length_um
n_turns
pitch_um
radius_um
turn_angle_deg
npoints
end_direction
cpw_source

Quarter-wave CPW resonator using a circular meander geometry.

Builds a λ/4 resonator composed of straight CPW segments connected by
circular bends, with a defined coupler section at the input and an
open-circuit termination at the end. The final straight segment is
automatically adjusted to match the target electrical length.

f_target_GHz : float

Target resonant frequency (GHz).

cross_section : CrossSectionSpec

CPW cross-section specification for the resonator trace.

v_ph_over_c : float | None

Phase velocity normalized to the speed of light. If None, derived from the reference effective index in tech.

radius_um : float

Radius of each circular bend (um).

num_bends : int

Number of 180-degree bends in the meander.

seg_length_um : float

Length of each straight segment between bends (um).

L_s0_um : float

Length of the initial straight section after the coupler (um).

L_coupler_um : float

Length of the input coupling straight section (um).

input : Feed port at the coupler end of the resonator.
open_end : Open-circuit port at the voltage antinode.

• Signal conductor : defined by the supplied cross_section.

• Total electrical length is maintained at λ/4 by trimming the final straight.
• Bend lengths are computed from circular arc geometry.
• num_bends must be greater than or equal to 1.

• kind
• mode
• f_target_GHz
• L_target_um
• leftover_um
• radius_um
• num_bends
• seg_length_um
• L_coupler_um
• bend_len_um
• bend90_len_um
• eps_eff_ref
• n_eff_ref
• cpw_source

Build a routed path from dict-only steps by composing CPW primitives.

Parses a dict-based steps DSL into validated Step objects, then builds a route by
chaining CPW primitives (straight segments and circular bends). This is intended as an
advanced route builder compatible with Pydantic-friendly schemas.

steps : Sequence[Mapping[str, Any]]

Step dictionaries defining the route intent (um for lengths, deg for angles).

radius_um : float

Default bend radius (um) used for L/R turns when a per-step radius is not provided.

cross_section : CrossSectionSpec

Cross-section used for CPW primitives.

allow_non_90 : bool

If False, L/R turns must be exactly ?90deg. If True, arbitrary angles are allowed.

strict_extra : bool

If True, unknown keys in step dicts raise an error during parsing.

npoints : int

Number of points used to discretize each bend arc (if supported by the bend primitive).

coerce_numeric_strings : bool

If True, numeric-like strings in step dicts are coerced to numbers during parsing.

o1 : Input signal port inherited from the first segment.
o2 : Output signal port inherited from the last segment.

• Signal / keepout : derived from cross_section used by the CPW primitives.

• When radius_um == 0, L/R turn operations are not allowed (bends require nonzero radius).
• If allow_non_90=False, only ?90deg L/R turns are accepted; arcs ("A") may still specify angles.
• Arc discretization uses npoints only when the bend primitive supports that argument.

kind
builder
mode
radius_default_um
n_steps
allow_non_90
strict_extra
coerce_numeric_strings
cpw_source
step_source

Generate an explicit-turn meander with unit cells placed along the path.

Builds an explicit-turn meander (via meander_path_extrude) and computes a matching
polyline for placement. Then places repeated unit cell components along the path
at a fixed pitch and offset, optionally mirrored on one or both sides.

run_length_um : float

Length of each horizontal run (um). Must be > 0.

n_turns : int

Number of U-turns in the meander. Must be >= 0.

pitch_um : float

Vertical spacing between adjacent runs (um). Must be > 0.

radius_um : float

Arc radius for each turn (um). Must be >= 0.

turn_angle : float

Signed magnitude of each arc turn (deg). Defaults to 90deg.

cross_section : CrossSectionSpec

Cross-section used for meander extrusion.

unitcell_radius_um : float

Default unit-cell radius parameter used by the default factory (um).

unitcell_offset_um : float

Lateral offset of placed unit cells from the path centerline (um).

unitcell_pitch_um : float

Spacing between consecutive unit cells along the path arclength (um).

unitcell_side : Side

Placement side relative to the path: "left", "right", or "both".

unitcell_start_s : float

Starting arclength coordinate for the first placement (um).

npoints : int

Number of points used to discretize each meander arc for extrusion.

snap_next : bool

If True, placement may snap the next unit cell to avoid corner collisions.

unitcell_factory : Optional[UnitCellFactory]

Factory returning a unit-cell component to place. If None, a default bump unit is used.

o1 : Input port on the signal trace (from the underlying meander).
o2 : Output port on the signal trace (from the underlying meander).

• Signal / keepout : derived from cross_section (meander geometry)
• Unit cells : determined by the unitcell_factory output cells

• Unit cell placement uses port_name=None to support unit cells that export no ports.
• A fixed corner guard distance is applied during placement to reduce corner overlap risk.

kind
mode
run_length_um
n_turns
pitch_um
radius_um
turn_angle_deg
end_direction
unitcell_radius_um
unitcell_offset_um
unitcell_pitch_um
unitcell_side
unitcell_snap_next
unitcell_start_s_um
unitcell_corner_guard_um
cpw_source
unitcell_placement_source