All-Angle Routing

All-angle routing lets you connect ports along an arbitrary backbone — segments do not have to be axis-aligned. Unlike manhattan routing (which forces horizontal/vertical segments), all-angle routes follow any sequence of kdb.DPoint waypoints and insert euler bends at each corner.

Feature	API
Single route	`kf.routing.aa.optical.route(c, width, backbone, ...)`
Bundle of routes	`kf.routing.aa.optical.route_bundle(c, start_ports, end_ports, backbone, ...)`
Result object	`OpticalAllAngleRoute` — `.length`, `.backbone`, `.instances`

When to use all-angle routing

Diagonal bus sections in large photonic chips
Routing around non-rectilinear obstacles
Compact fan-outs at arbitrary angles

Setup

All-angle routing uses virtual factories from kf.factories.virtual.*. Virtual components live in memory only and are materialised into a real cell when VInstance.insert_into(c) is called (or when routing directly into a KCell).

from functools import partial

import numpy as np

import kfactory as kf


class LAYER(kf.LayerInfos):
    WG: kf.kdb.LayerInfo = kf.kdb.LayerInfo(1, 0)
    WGCLAD: kf.kdb.LayerInfo = kf.kdb.LayerInfo(2, 0)


L = LAYER()
kf.kcl.infos = L

wg_enc = kf.LayerEnclosure(name="WGSTD_AA", sections=[(L.WGCLAD, 0, 2_000)])

# Virtual straight: width and length in µm
straight_factory = partial(
    kf.factories.virtual.straight.virtual_straight_factory(kcl=kf.kcl),
    layer=L.WG,
    enclosure=wg_enc,
)

# Virtual euler bend: width and radius in µm
bend_factory = partial(
    kf.factories.virtual.euler.virtual_bend_euler_factory(kcl=kf.kcl),
    width=0.5,
    radius=10,
    layer=L.WG,
    enclosure=wg_enc,
)

1 · Single all-angle route

kf.routing.aa.optical.route places a single route along a backbone — an ordered list of kdb.DPoint values in µm. The router inserts euler bends wherever the backbone changes direction and fills the straight segments automatically.

Rules for a valid backbone:

At least 3 points (the first and last define the port orientations)
Each interior segment must be long enough to fit the bend: roughly 2 × effective_radius clearance on either side of a corner

The returned OpticalAllAngleRoute exposes:

.length — total path length in µm
.length_straights — straight-only contribution in µm
.backbone — the original backbone points
.instances — list of placed VInstance objects

backbone_single = [
    kf.kdb.DPoint(0, 0),
    kf.kdb.DPoint(120, 0),  # horizontal run
    kf.kdb.DPoint(120, 80),  # 90° turn upward
    kf.kdb.DPoint(240, 80),  # horizontal run to exit
]

c_single = kf.kcl.kcell("aa_single_route")
route = kf.routing.aa.optical.route(
    c_single,
    width=0.5,
    backbone=backbone_single,
    straight_factory=straight_factory,
    bend_factory=bend_factory,
)

print(f"Total length : {route.length:.2f} µm")
print(f"Straight length: {route.length_straights:.2f} µm")
print(f"Bend count     : {route.length - route.length_straights:.2f} µm in bends")

c_single.plot()

Total length : 320.00 µm
Straight length: 245.20 µm
Bend count     : 74.80 µm in bends

2 · Diagonal backbone

The backbone is not restricted to axis-aligned segments. Diagonal segments route through tight corridors where a manhattan route would require many detours.

backbone_diag = [
    kf.kdb.DPoint(0, 0),
    kf.kdb.DPoint(80, 60),  # diagonal up-right
    kf.kdb.DPoint(200, 60),  # horizontal
    kf.kdb.DPoint(280, 0),  # diagonal back down
]

c_diag = kf.kcl.kcell("aa_diagonal_route")
route_diag = kf.routing.aa.optical.route(
    c_diag,
    width=0.5,
    backbone=backbone_diag,
    straight_factory=straight_factory,
    bend_factory=bend_factory,
)

print(f"Total length: {route_diag.length:.2f} µm")
c_diag.plot()

Total length: 320.00 µm

3 · Bundle routing

kf.routing.aa.optical.route_bundle routes multiple ports in parallel along a shared backbone. Each route in the bundle is offset from the backbone by separation (or a per-route list).

Port orientation convention

start_ports — sorted anti-clockwise around the start cluster
end_ports — sorted clockwise around the end cluster

This ensures that routes do not cross between the start cluster and the backbone.

Backbone requirements for bundles

The backbone must have at least 2 points (it defines the shared bundle axis). Segments must be long enough to accommodate the widest route in the bundle plus its separation.

# Place start ports fanned out at various angles on the left, end ports on the right
r = 50  # radius of port fan-out cluster (µm)
n = 1  # angle step centre
_l = 5  # number of routes

c_bundle = kf.kcl.kcell("aa_bundle_route")

start_ports: list[kf.Port] = []
end_ports: list[kf.Port] = []

for i in range(_l):
    a_start = (n - i) * 15  # angles spread around centre
    a_rad = np.deg2rad(a_start)
    a_end = 270 - n + i * 15
    ae_rad = np.deg2rad(a_end)

    start_ports.append(
        c_bundle.create_port(
            name=f"s{i}",
            dcplx_trans=kf.kdb.DCplxTrans(
                1,
                a_start,
                False,
                -500 + r * np.cos(a_rad),
                -100 + r * np.sin(a_rad),
            ),
            layer=c_bundle.kcl.find_layer(L.WG),
            width=c_bundle.kcl.to_dbu(0.5),
        )
    )
    end_ports.append(
        c_bundle.create_port(
            name=f"e{i}",
            dcplx_trans=kf.kdb.DCplxTrans(
                1,
                a_end,
                False,
                1510 + r * np.cos(ae_rad),
                1410 + r * np.sin(ae_rad),
            ),
            layer=c_bundle.kcl.find_layer(L.WG),
            width=c_bundle.kcl.to_dbu(0.5),
        )
    )

# Shared backbone — each segment long enough for 10 µm-radius euler bends
backbone_bundle = [
    kf.kdb.DPoint(200, -200),
    kf.kdb.DPoint(500, 300),
    kf.kdb.DPoint(600, 700),
    kf.kdb.DPoint(1300, 950),
]

routes = kf.routing.aa.optical.route_bundle(
    c_bundle,
    start_ports=start_ports,
    end_ports=end_ports,
    backbone=backbone_bundle,
    separation=2.0,  # µm between adjacent routes
    straight_factory=straight_factory,
    bend_factory=bend_factory,
)

print(f"Bundle contains {len(routes)} routes")
for i, rt in enumerate(routes):
    print(f"  route {i}: length = {rt.length:.2f} µm")

c_bundle.plot()

Bundle contains 5 routes
  route 0: length = 2965.36 µm
  route 1: length = 3040.05 µm
  route 2: length = 3182.96 µm
  route 3: length = 3471.07 µm
  route 4: length = 3876.84 µm

4 · Using VKCell for preview before committing

All-angle routing can also target a VKCell (virtual cell) so you can inspect or transform the result before materialising it into a real cell with VInstance.insert_into.

vc = kf.kcl.vkcell(name="aa_virtual")
kf.routing.aa.optical.route(
    vc,
    width=0.5,
    backbone=[
        kf.kdb.DPoint(0, 0),
        kf.kdb.DPoint(100, 0),
        kf.kdb.DPoint(100, 80),
        kf.kdb.DPoint(200, 80),
    ],
    straight_factory=straight_factory,
    bend_factory=bend_factory,
)

# Materialise: place the virtual route into a real KCell
c_real = kf.kcl.kcell("aa_from_virtual")
vi = kf.VInstance(vc)
vi.insert_into(c_real)
c_real.plot()

Summary

Parameter	Type	Unit	Notes
`backbone`	`list[kdb.DPoint]`	µm	≥3 points for single route, ≥2 for bundle
`width`	`float`	µm	route width (single route only)
`separation`	`float` or `list[float]`	µm	spacing between bundle routes
`straight_factory`	callable	—	`virtual_straight_factory` partial
`bend_factory`	callable	—	`virtual_bend_euler_factory` partial

Key constraints

Each backbone segment must be long enough to fit the euler bends on both ends (~2 × effective radius per corner).
For bundles, segments must also accommodate the full bundle width (N × (wire_width + separation)).
start_ports must be sorted anti-clockwise; end_ports clockwise.

Topic	Where
Manhattan (90°/180° bend) routing	Routing: Optical
Virtual cells used as intermediate routing containers	Components: Virtual Cells
Euler bend cells and `virtual_bend_euler_factory`	Components: Euler Bends
Routing overview and choosing an approach	Routing: Overview
Port construction and `DCplxTrans`	Core Concepts: Ports