API¶

The component to add the route into.

the start ports

the end ports

the straight-spec to create straights with

the bend-spec to create bends with

the layers to avoid.

the discretization unit for the a-star algorithm.

the spacing between the waveguides in the bundle

extra space (um) between the bundle body and any obstacle on layers. Each obstacle polygon is grown by clearance (via kdb.Region.sized) before A* discretization, so the bundle stays clearance away from every obstacle edge. 0.0 (default) preserves the prior behaviour of letting the bundle share an edge with obstacles.

how the start (ports1) bundle is formed. A string ("manhattan", "sbend", "lbend") or a :class:FanStrategySpec dict with a "type" key and optional per-strategy parameters.

how the end (ports2) bundle is formed. Same options as fan_in. None (default) inherits fan_in so existing call sites keep working; pass an explicit value to mix strategies.

class:BundleResult with per-trace corner polylines,

path lengths, and the bundle centerline.

the component to add the fan-in to

the list of ports to start from

the straight-spec to create straights from

the bend-spec to create bends from

the x-location (µm) where to form the confluence of the bundle. Will be two bend radii from the inputs if not given.

the y-location (µm) where to form the confluence of the bundle. Will be somewhere in the middle if not given.

the spacing (µm) between waveguides in the bundle

the start direction of the bundle (derived from ports if not given)

fan-in strategy. A string ("manhattan", "sbend", or "lbend") or a :class:FanStrategySpec dict with a "type" key and optional per-strategy parameters. "manhattan" uses the existing 90°-comb fan-in. "sbend" compresses each wire to the bundle line with a single S-bend per port (useful when the bend radius is tight relative to the port pitch). "lbend" forms an L-shaped per-port fan-in (variable straight + 90° bend + variable straight) so virtual ports land on a common line at spacing pitch with the bundle direction rotated 90° from the input ports. "lbend" requires an explicit lbend_side ("left" or "right") in the strategy dict; "auto" resolution is only available via add_bundle_astar (which sees both port sets). Strategy-specific options (e.g. start_straight, lbend_side, sbend_length) are passed inside the dict, e.g. strategy={"type": "manhattan", "start_straight": 5.0}.

(stops, legs) where stops is the (N, 2) int64 array of

bundle-side stop positions and legs is a list of

class:FanLeg with per-wire corner polylines and exact lengths.

legs[j] corresponds to stops[j]; legs[j].input_index

maps back to the caller's inputs list (wires are reordered by

lateral position). Each leg carries its placed instances

(legs[j].instances) in start→end order.

the component to add the route to

the start port

the stop port

the straight-spec to create straights from

the bend-spec to create bends from

the layers to avoid

the discretization unit for the a-star algorithm

extra space (µm) between the route body and any obstacle on layers. Each obstacle polygon is grown by clearance before A* discretization, so the route stays clearance away from every obstacle edge. 0.0 (default) preserves the prior behaviour of letting the route share an edge with obstacles.

class:Route whose backbone spans the full polyline

(start port, intermediate corners, stop port) and whose

length is the sum of the placed cells' info["length"]

in µm (corners / path_length remain as aliases).

the component to find the route in

the start port

the stop port

the straight-spec to create straights from

the bend-spec to create bends from

the layers to avoid

the discretization unit for the a-star algorithm

extra space (µm) between the route body and any obstacle on layers. Implemented by polygon-growing the obstacles via kdb.Region.sized before A* discretization (the same mechanism the multilayer engines use).

The corners of the route as a list of points in dbu.

component/KCell to place instances in.

list of instance names or specs.

placement netlist — either PlacementNetSpec dicts (pins refer to instance names or PlacementPinSpec dicts) or RouteNetSpec objects. When RouteNetSpec objects are given they are auto-converted via derive_placement_nets() with real pin offsets.

"openroad", "tiling", or "auto".

objective weights.

placement constraints (min_spacing, bbox, fences, ...).

reserved for future routing-in-loop strategies.

apply placement in-place when True.

also apply the optimizer's chosen orientation to the geometry. Only meaningful when the optimizer is allowed to choose one at all — see objective["auto_orientation"], which is "none" by default. Positions are exact either way — instances are re-centered after the orientation op.

optimizer iteration budget.

Structured placement report with final locations and metrics.