@tscircuit/fanout-solver 0.0.64 → 0.0.65

package/lib/route-shallow-split-perimeter-bus.ts

@@ -0,0 +1,268 @@
+import {
+  distance,
+  distancePointToObstacle,
+  distancePointToSegment,
+  distanceSegmentToObstacle,
+  segmentsAreClear,
+} from "./geometry"
+import { matchComponentDogboneViaSites } from "./match-component-dogbone-via-sites"
+import type { PeripheralSourceEscape } from "./route-peripheral-source-escapes"
+import {
+  routeSplitPerimeterBusSteps,
+  type SplitBusParams,
+} from "./route-split-perimeter-bus"
+import type { SplitPerimeterSources } from "./route-split-perimeter-source-escapes"
+import type { RouteViaMinimalWindingProgress } from "./route-via-minimal-winding"
+import type { FanoutRoutePlan, PreparedBus } from "./types"
+
+const EPSILON = 1e-7
+export type ShallowSplitBusParams = SplitBusParams & {
+  buses: readonly PreparedBus[]
+}
+export type ShallowSplitBusResult = SplitPerimeterSources & {
+  plans: FanoutRoutePlan[]
+}
+
+function sourcesAreClear(
+  params: ShallowSplitBusParams,
+  sources: readonly PeripheralSourceEscape[],
+): boolean {
+  const connections = new Map(
+    params.buses
+      .flatMap((bus) => bus.connections)
+      .map((connection) => [connection.connectionIndex, connection]),
+  )
+  const boundary = params.bus.sharedBoundary
+  for (const source of sources) {
+    const own = connections.get(source.connectionIndex)!
+    const radius = source.via.diameter / 2
+    for (const obstacle of params.srj.obstacles) {
+      if (
+        obstacle.layers.some((layer) =>
+          source.via.spanLayers.includes(layer),
+        ) &&
+        distancePointToObstacle(source.via.center, obstacle) <
+          radius + params.clearance - EPSILON
+      )
+        return false
+      if (
+        obstacle !== own.sourceObstacle &&
+        source.segments.some(
+          (segment) =>
+            obstacle.layers.includes(segment.layer) &&
+            distanceSegmentToObstacle(segment, obstacle) <
+              segment.width / 2 + params.clearance - EPSILON,
+        )
+      )
+        return false
+    }
+    for (const segment of source.segments) {
+      if (
+        [segment.start, segment.end].some(
+          (point) =>
+            point.x < boundary.minX - EPSILON ||
+            point.x > boundary.maxX + EPSILON ||
+            point.y < boundary.minY - EPSILON ||
+            point.y > boundary.maxY + EPSILON,
+        )
+      )
+        return false
+    }
+    for (const other of sources) {
+      if (source.connectionIndex === other.connectionIndex) continue
+      if (
+        distance(source.via.center, other.via.center) <
+        radius + other.via.diameter / 2 + params.clearance - EPSILON
+      )
+        return false
+      if (
+        source.segments.some(
+          (segment) =>
+            other.via.spanLayers.includes(segment.layer) &&
+            distancePointToSegment(
+              other.via.center,
+              segment.start,
+              segment.end,
+            ) <
+              other.via.diameter / 2 +
+                segment.width / 2 +
+                params.clearance -
+                EPSILON,
+        )
+      )
+        return false
+      if (
+        source.segments.some((segment) =>
+          other.segments.some(
+            (otherSegment) =>
+              !segmentsAreClear(segment, otherSegment, params.clearance),
+          ),
+        )
+      )
+        return false
+    }
+  }
+  return true
+}
+
+/** Shorten the lower perimeter while preserving its source-layer escape topology. */
+export function* routeShallowSplitPerimeterBusSteps(
+  params: ShallowSplitBusParams,
+): Generator<
+  RouteViaMinimalWindingProgress,
+  ShallowSplitBusResult | null,
+  void
+> {
+  const { bus, traceWidth, clearance, viaDiameter } = params
+  if (
+    bus.exitEdge !== "left" ||
+    bus.termination.type !== "boundary" ||
+    params.bottomRemoteConnectionIndices.size !== 1
+  )
+    return null
+  const bottomIndex = [...params.bottomRemoteConnectionIndices][0]!
+  const originalBottom = params.sourceEscapes.find(
+    (source) => source.connectionIndex === bottomIndex,
+  )
+  const last = originalBottom?.segments.at(-1)
+  if (
+    !last ||
+    Math.abs(last.start.x - last.end.x) > EPSILON ||
+    last.start.y <= last.end.y
+  )
+    return null
+  const padPitch = Math.min(bus.pitchX, bus.pitchY)
+  if (!Number.isFinite(padPitch) || padPitch <= 0) return null
+  const pitch = traceWidth + clearance
+  const nativeRows = bus.yCoordinates
+    .slice(1)
+    .map((y, index) => (y + bus.yCoordinates[index]!) / 2)
+    .filter((y) => y > last.end.y + EPSILON && y < last.start.y - EPSILON)
+    .sort((a, b) => a - b)
+    .slice(0, 4)
+  const fixedIndices = new Set([
+    ...bus.connections.map((connection) => connection.connectionIndex),
+    // A nonlocal source escape already commits its topology before its first
+    // via. Only ordinary one-segment dogbones may move around the new band.
+    ...params.sourceEscapes
+      .filter((source) => source.segments.length > 1)
+      .map((source) => source.connectionIndex),
+  ])
+  const movableBuses = params.buses
+    .map((owner) => ({
+      ...owner,
+      connections: owner.connections.filter(
+        (connection) => !fixedIndices.has(connection.connectionIndex),
+      ),
+    }))
+    .filter((owner) => owner.connections.length)
+  const pendingIndices = new Set(
+    movableBuses
+      .flatMap((owner) => owner.connections)
+      .map((connection) => connection.connectionIndex),
+  )
+  for (const y of nativeRows) {
+    yield {
+      phase: "route-connection",
+      routeOrderAttempt: 0,
+      connectionIndex: 0,
+      connectionCount: bus.connections.length,
+      connectionName: originalBottom!.connectionName,
+      searchBatch: 0,
+      expandedStateCount: 0,
+      connectionComplete: false,
+    }
+    const sources = params.sourceEscapes.map((source) => ({
+      ...source,
+      segments: source.segments.map((segment) => ({
+        ...segment,
+        start: { ...segment.start },
+        end: { ...segment.end },
+      })),
+      via: { ...source.via, center: { ...source.via.center } },
+    }))
+    const viaPoints = new Map(params.viaPointsByConnectionIndex)
+    const bottom = sources.find(
+      (source) => source.connectionIndex === bottomIndex,
+    )!
+    bottom.via.center = { x: last.end.x, y }
+    bottom.segments.at(-1)!.end = bottom.via.center
+    viaPoints.set(bottomIndex, bottom.via.center)
+    const fixed = sources.filter((source) =>
+      fixedIndices.has(source.connectionIndex),
+    )
+    const rematch = (plans: FanoutRoutePlan[] = []) => {
+      const matched = matchComponentDogboneViaSites(movableBuses, {
+        ...params,
+        additionalObstacles: params.srj.obstacles,
+        maximumSearchStates: 300_000,
+        preferredViaPointsByConnectionIndex: viaPoints,
+        blockingSegments: [
+          ...fixed.flatMap((source) =>
+            source.segments.map((segment) => ({
+              connectionIndex: source.connectionIndex,
+              segment,
+            })),
+          ),
+          ...plans.flatMap((plan) =>
+            plan.segments
+              .filter((segment) => segment.layer === params.targetLayer)
+              .map((segment) => ({
+                connectionIndex: plan.connectionIndex,
+                segment,
+              })),
+          ),
+        ],
+        blockingVias: fixed.map((source) => ({
+          connectionIndex: source.connectionIndex,
+          ...source.via,
+        })),
+      })
+      if (!matched) return false
+      for (const source of sources)
+        if (pendingIndices.has(source.connectionIndex)) {
+          const end = matched.get(source.connectionIndex)!
+          source.via = { ...source.via, center: end }
+          source.segments = [{ ...source.segments[0]!, end }]
+          viaPoints.set(source.connectionIndex, end)
+        }
+      return sourcesAreClear(params, sources)
+    }
+    if (!rematch()) continue
+    // Center the middle lower rail on the preceding native interstitial row.
+    const sourceBoundary = {
+      ...params.sourceBoundary,
+      minY:
+        y -
+        padPitch +
+        viaDiameter / 2 +
+        traceWidth / 2 +
+        clearance +
+        1e-5 +
+        pitch,
+    }
+    const plans = yield* routeSplitPerimeterBusSteps({
+      ...params,
+      sourceEscapes: sources,
+      sourceBoundary,
+      viaPointsByConnectionIndex: viaPoints,
+      rematchPendingSources: {
+        connectionIndices: pendingIndices,
+        afterLowerStage: rematch,
+      },
+    })
+    if (plans && sourcesAreClear(params, sources))
+      return {
+        plans,
+        sourceEscapes: sources,
+        sourceBoundary: { ...params.sourceBoundary },
+        viaPointsByConnectionIndex: viaPoints,
+        remoteConnectionIndices: new Set(params.remoteConnectionIndices),
+        bottomRemoteConnectionIndices: new Set(
+          params.bottomRemoteConnectionIndices,
+        ),
+        lowerConnectionIndices: [...params.lowerConnectionIndices],
+      }
+  }
+  return null
+}

package/lib/route-split-perimeter-bus.ts

@@ -0,0 +1,397 @@
+import type { SimpleRouteJson } from "@tscircuit/capacity-autorouter"
+import {
+  distance,
+  distancePointToSegment,
+  distanceSegmentToSegment,
+} from "./geometry"
+import { fanoutPlansAreClear } from "./route-bus"
+import {
+  buildViaMinimalWindingPlan,
+  routeViaMinimalWindingAlternativesSteps,
+  type RouteViaMinimalWindingParams,
+  type RouteViaMinimalWindingProgress,
+  type ViaMinimalWindingTerminal,
+} from "./route-via-minimal-winding"
+import {
+  chamferSplitPerimeter,
+  type SplitPerimeterSources,
+} from "./route-split-perimeter-source-escapes"
+import type { FanoutRoutePlan, Point2D, PreparedBus } from "./types"
+
+export type SplitBusParams = SplitPerimeterSources & {
+  srj: SimpleRouteJson
+  bus: PreparedBus
+  targetLayer: string
+  layerNames: string[]
+  traceWidth: number
+  clearance: number
+  viaDiameter: number
+  viaHoleDiameter: number
+  /** Rematch pending sources around a lower band before routing its upper lanes. */
+  rematchPendingSources?: {
+    connectionIndices: ReadonlySet<number>
+    afterLowerStage: (plans: FanoutRoutePlan[]) => boolean
+  }
+}
+
+/** Promote a blocked terminal in a bounded search over complete lane orders. */
+function* routeOrderedStage(
+  params: RouteViaMinimalWindingParams,
+): Generator<RouteViaMinimalWindingProgress, FanoutRoutePlan[] | null, void> {
+  type Attempt = { order: number[]; bias: -1 | 0 | 1; completed: number }
+  const seen = new Set<string>(),
+    prefixes = new Set<string>(),
+    queue: Attempt[] = []
+  let evaluations = 0,
+    result: FanoutRoutePlan[] | null = null
+  function* evaluate(
+    order: number[],
+    bias: -1 | 0 | 1,
+  ): Generator<RouteViaMinimalWindingProgress, void, void> {
+    const key = order.join(",") + ":" + bias
+    if (seen.has(key) || evaluations >= 256) return
+    seen.add(key)
+    evaluations++
+    let completed = 0
+    const gen = routeViaMinimalWindingAlternativesSteps(
+      {
+        ...params,
+        routeOrder: order,
+        laneBias: bias,
+        maximumRouteOrderAttempts: 1,
+      },
+      1,
+      false,
+    )
+    let r = gen.next()
+    while (!r.done) {
+      completed = Math.max(completed, r.value.connectionIndex)
+      yield r.value
+      r = gen.next()
+    }
+    if (r.value.length) {
+      result = r.value[0]!
+      return
+    }
+    const prefix = order.slice(0, completed + 1).join(",") + ":" + bias
+    if (!prefixes.has(prefix)) {
+      prefixes.add(prefix)
+      queue.push({ order, bias, completed })
+    }
+  }
+  const indices = params.terminals.map((_, i) => i)
+  const target = indices.toSorted(
+    (a, b) =>
+      params.terminals[a]!.exitPoint.x - params.terminals[b]!.exitPoint.x,
+  )
+  for (const bias of [0, 1, -1] as const) {
+    yield* evaluate(target, bias)
+    if (result) return result
+    yield* evaluate(target.toReversed(), bias)
+    if (result) return result
+  }
+  while (queue.length && evaluations < 256) {
+    queue.sort((a, b) => b.completed - a.completed)
+    const { order, bias, completed } = queue.shift()!
+    if (queue.length > 256) queue.length = 256
+    for (let at = completed - 1; at >= 0; at--) {
+      const moved = [...order],
+        [failed] = moved.splice(completed, 1)
+      moved.splice(at, 0, failed!)
+      yield* evaluate(moved, bias)
+      if (result) return result
+      const swapped = [...order]
+      ;[swapped[completed], swapped[at]] = [swapped[at]!, swapped[completed]!]
+      yield* evaluate(swapped, bias)
+      if (result) return result
+    }
+  }
+  return null
+}
+
+/** Route a lower separator and an ordered upper bundle around a source field. */
+export function* routeSplitPerimeterBusSteps(
+  params: SplitBusParams,
+): Generator<RouteViaMinimalWindingProgress, FanoutRoutePlan[] | null, void> {
+  const {
+    bus,
+    srj,
+    sourceBoundary,
+    sourceEscapes,
+    remoteConnectionIndices,
+    bottomRemoteConnectionIndices,
+    lowerConnectionIndices,
+    targetLayer,
+    traceWidth: w,
+    clearance: c,
+  } = params
+  if (
+    bus.exitEdge !== "left" ||
+    bus.termination.type !== "boundary" ||
+    lowerConnectionIndices.length !== 3
+  )
+    return null
+  const padPitch = Math.min(bus.pitchX, bus.pitchY),
+    pitch = w + c,
+    byIndex = new Map(sourceEscapes.map((p) => [p.connectionIndex, p]))
+  const terminals: ViaMinimalWindingTerminal[] = bus.connections
+    .map((connection) => ({
+      connection,
+      viaPoint: byIndex.get(connection.connectionIndex)!.via.center,
+      exitPoint: {
+        x: bus.sharedBoundary.minX,
+        y: (connection.exitTargetPoint ?? connection.targetPoint).y,
+      },
+    }))
+    .sort((a, b) => a.exitPoint.y - b.exitPoint.y)
+  const byTerminal = new Map(
+    terminals.map((t) => [t.connection.connectionIndex, t]),
+  )
+  const lower = lowerConnectionIndices.map((i) => byTerminal.get(i)!),
+    lowerIds = new Set(lowerConnectionIndices)
+  const upper = terminals.filter(
+    (t) =>
+      !lowerIds.has(t.connection.connectionIndex) &&
+      !remoteConnectionIndices.has(t.connection.connectionIndex),
+  )
+  if (upper.length < 2 || lower.some((t) => !t)) return null
+  const sourcePoints = new Map(
+    sourceEscapes.map((p) => [
+      p.connectionIndex,
+      [p.segments[0]!.start, ...p.segments.map((s) => s.end)],
+    ]),
+  )
+  const build = (terminal: ViaMinimalWindingTerminal, points: Point2D[]) =>
+    buildViaMinimalWindingPlan({
+      ...params,
+      bus,
+      terminal,
+      targetLayerPoints: points,
+      sourceEscapePoints: sourcePoints.get(terminal.connection.connectionIndex),
+      allowBlindAndBuriedVias: false,
+    })
+  // A shifted exit can lie below the source field. Put every lower rail
+  // below its own endpoint before nesting the neighboring turns around it.
+  const lowerRoof = Math.min(
+    sourceBoundary.minY - params.viaDiameter / 2 - w / 2 - c - 1e-5,
+    ...lower.map(
+      (terminal, rank) =>
+        terminal.exitPoint.y + (lower.length - 1 - rank) * pitch - pitch - w,
+    ),
+  )
+  const outer = (
+    terminal: ViaMinimalWindingTerminal,
+    points: Point2D[],
+    up: boolean,
+  ) => {
+    const j = (up ? upper : lower).findIndex(
+      (t) =>
+        t.connection.connectionIndex === terminal.connection.connectionIndex,
+    )
+    const port = points.at(-1)!,
+      roof = up
+        ? sourceBoundary.maxY + padPitch - pitch / 2 + j * pitch
+        : lowerRoof - (lower.length - 1 - j) * pitch
+    const column =
+      sourceBoundary.minX -
+      params.viaDiameter / 2 -
+      w / 2 -
+      c -
+      1e-5 -
+      (up ? j : lower.length - 1 - j) * pitch
+    const extra = chamferSplitPerimeter(
+      [
+        port,
+        { x: port.x, y: roof },
+        { x: column, y: roof },
+        { x: column, y: terminal.exitPoint.y },
+        terminal.exitPoint,
+      ],
+      w,
+    )
+    return build(terminal, [...points, ...extra.slice(1)])
+  }
+  const remote = terminals
+    .filter((t) => remoteConnectionIndices.has(t.connection.connectionIndex))
+    .map((t) =>
+      bottomRemoteConnectionIndices.has(t.connection.connectionIndex)
+        ? outer(t, [t.viaPoint], false)
+        : build(t, [t.viaPoint, t.exitPoint]),
+    )
+  let deferPendingViaReservations = !!params.rematchPendingSources
+  const make = (
+    ts: ViaMinimalWindingTerminal[],
+    acceptedPlans: FanoutRoutePlan[],
+    up: boolean,
+    ports: Point2D[],
+    fullBoundary = false,
+  ): RouteViaMinimalWindingParams => {
+    const ids = new Set(ts.map((t) => t.connection.connectionIndex)),
+      stageBus: PreparedBus = {
+        ...bus,
+        connections: ts.map((t) => t.connection),
+        exitEdge: up ? "top" : "bottom",
+        direction: up ? "up" : "down",
+        preferredExit: undefined,
+        sharedBoundary: fullBoundary
+          ? bus.sharedBoundary
+          : {
+              ...bus.sharedBoundary,
+              maxY: sourceBoundary.maxY,
+              ...(!up ? { minY: sourceBoundary.minY } : {}),
+            },
+      }
+    return {
+      ...params,
+      bus: stageBus,
+      terminals: ts.map((t, i) => ({ ...t, exitPoint: ports[i]! })),
+      acceptedPlans,
+      reservedVias: sourceEscapes
+        .filter(
+          (p) =>
+            !ids.has(p.connectionIndex) &&
+            (!deferPendingViaReservations ||
+              !params.rematchPendingSources?.connectionIndices.has(
+                p.connectionIndex,
+              )),
+        )
+        .map((p) => ({ connectionName: p.connectionName, via: p.via })),
+      sourceEscapePaths: sourcePoints,
+      allowBlindAndBuriedVias: false,
+      allowSameNetMerges: false,
+      gridStepDivisor: 2,
+      gridStep: pitch / 2,
+      alignGridToPads: true,
+      reserveTerminalExitPoints: true,
+    }
+  }
+  const outerLower = lower[0]!,
+    innerLower = lower.at(-1)!,
+    firstUpper = upper[0]!,
+    lowerSource = innerLower.connection.sourcePoint,
+    column = lowerSource.x + padPitch
+  // The separator goes below the first upper source, then between that source
+  // group and the inner lower source before descending to the outer lower lane.
+  const guides = [
+    {
+      x: firstUpper.connection.sourcePoint.x,
+      y: firstUpper.connection.sourcePoint.y - padPitch,
+    },
+    { x: lowerSource.x - padPitch, y: lowerSource.y },
+    { x: column, y: lowerSource.y },
+  ]
+  let separatorPoints: Point2D[] = [outerLower.viaPoint]
+  for (const goal of guides) {
+    const temporary = { ...outerLower, viaPoint: separatorPoints.at(-1)! },
+      stage = make([temporary], remote, true, [goal], true)
+    stage.bus = { ...stage.bus, exitEdge: "right", direction: "right" }
+    stage.sourceEscapePaths = undefined
+    const routed = yield* routeOrderedStage(stage)
+    if (!routed) return null
+    separatorPoints.push(
+      ...routed[0]!.segments
+        .filter((s) => s.layer === targetLayer)
+        .map((s) => s.end),
+    )
+  }
+  separatorPoints = chamferSplitPerimeter(
+    [...separatorPoints, { x: column, y: sourceBoundary.minY }],
+    w,
+  )
+  const separator = outer(outerLower, separatorPoints, false)
+  const bottomVia = sourceEscapes.find((p) =>
+    bottomRemoteConnectionIndices.has(p.connectionIndex),
+  )!.via.center
+  const bottomPort = { x: bottomVia.x - padPitch, y: sourceBoundary.minY }
+  deferPendingViaReservations = false
+  const innerResult = yield* routeOrderedStage(
+    make([innerLower], [...remote, separator], false, [bottomPort]),
+  )
+  if (!innerResult) return null
+  const ips = innerResult[0]!.segments.filter((s) => s.layer === targetLayer),
+    inner = outer(innerLower, [ips[0]!.start, ...ips.map((s) => s.end)], false)
+  if (params.rematchPendingSources) {
+    if (
+      !params.rematchPendingSources.afterLowerStage([
+        ...remote,
+        separator,
+        inner,
+      ])
+    )
+      return null
+    for (const source of sourceEscapes) {
+      sourcePoints.set(source.connectionIndex, [
+        source.segments[0]!.start,
+        ...source.segments.map((segment) => segment.end),
+      ])
+    }
+  }
+  const minPadX = Math.min(
+      ...bus.componentObstacles.map((o) => o.center.x - o.width / 2),
+    ),
+    far = minPadX + params.viaDiameter / 2
+  const near =
+    Math.max(...upper.map((t) => t.connection.sourcePoint.x)) -
+    padPitch / 2 -
+    w / 2
+  if (near - far < (upper.length - 1) * pitch) return null
+  const upperPorts = upper.map((_, i) => ({
+    x: far + ((near - far) * i) / (upper.length - 1),
+    y: sourceBoundary.maxY,
+  }))
+  const upperResult = yield* routeOrderedStage(
+    make(upper, [...remote, separator, inner], true, upperPorts),
+  )
+  if (!upperResult) return null
+  const tops = upperResult.map((p) => {
+    const ss = p.segments.filter((s) => s.layer === targetLayer),
+      last = ss.at(-1)!
+    if (last.end.y <= last.start.y) return null
+    return outer(
+      byTerminal.get(p.connectionIndex)!,
+      [ss[0]!.start, ...ss.map((s) => s.end)],
+      true,
+    )
+  })
+  if (tops.some((p) => !p)) return null
+  const plans = [...remote, separator, inner, ...(tops as FanoutRoutePlan[])]
+  if (plans.length !== bus.connections.length) return null
+  const lengths = plans.map((p) => p.length)
+  if (
+    bus.maxLengthSkew !== undefined &&
+    Math.max(...lengths) - Math.min(...lengths) > bus.maxLengthSkew + EPS
+  )
+    return null
+  if (
+    !fanoutPlansAreClear({
+      plans,
+      srj,
+      sharedBoundary: bus.sharedBoundary,
+      clearance: c,
+      allowBlindAndBuriedVias: false,
+      allowSameNetMerges: false,
+    })
+  )
+    return null
+  for (const p of plans)
+    for (const other of sourceEscapes) {
+      if (p.connectionIndex === other.connectionIndex) continue
+      for (const s of p.segments) {
+        if (
+          other.via.spanLayers.includes(s.layer) &&
+          distancePointToSegment(other.via.center, s.start, s.end) <
+            other.via.diameter / 2 + s.width / 2 + c - EPS
+        )
+          return null
+        for (const t of other.segments)
+          if (
+            s.layer === t.layer &&
+            distanceSegmentToSegment(s.start, s.end, t.start, t.end) <
+              (s.width + t.width) / 2 + c - EPS
+          )
+            return null
+      }
+    }
+  return plans
+}
+const EPS = 1e-7