@tscircuit/fanout-solver 0.0.63 → 0.0.65

package/lib/match-angularly-ordered-local-vias.ts

@@ -0,0 +1,239 @@
+import { distance, distancePointToSegment, segmentsAreClear } from "./geometry"
+import {
+  getComponentDogboneViaSiteCandidates,
+  matchComponentDogboneViaSites,
+  type DogboneViaSiteGeometryRules,
+} from "./match-component-dogbone-via-sites"
+import type {
+  Point2D,
+  PreparedBus,
+  PreparedConnection,
+  RoutedSegment,
+} from "./types"
+
+const EPSILON = 1e-9
+const TAU = Math.PI * 2
+interface Candidate {
+  connectionIndex: number
+  point: Point2D
+  angle: number
+  sourceSegment: RoutedSegment
+  siteIndex: number
+}
+
+/** Reserve ordered source vias, then assign every remaining source via together. */
+export function matchAngularlyOrderedLocalVias(params: {
+  buses: readonly PreparedBus[]
+  busId: string
+  rules: DogboneViaSiteGeometryRules
+  maximumOrderingStates?: number
+  maximumCompleteAssignments?: number
+}): Map<number, Point2D> | null {
+  const { buses, rules } = params
+  const bus = buses.find((b) => b.busId === params.busId)
+  if (
+    !bus ||
+    bus.termination.type !== "boundary" ||
+    !bus.exitEdge ||
+    bus.connections.length < 3
+  )
+    return null
+  const maximumOrderingStates = params.maximumOrderingStates ?? 10_000
+  const maximumCompleteAssignments = params.maximumCompleteAssignments ?? 16
+  for (const [name, value] of Object.entries({
+    maximumOrderingStates,
+    maximumCompleteAssignments,
+  })) {
+    if (!Number.isSafeInteger(value) || value < 1)
+      throw new Error(`FanoutSolver: ${name} must be a positive safe integer`)
+  }
+  const center = {
+    x: (bus.componentBounds.minX + bus.componentBounds.maxX) / 2,
+    y: (bus.componentBounds.minY + bus.componentBounds.maxY) / 2,
+  }
+  const angle = (p: Point2D) => Math.atan2(p.y - center.y, p.x - center.x)
+  const targetCoordinate = (c: PreparedConnection) => {
+    const p = c.exitTargetPoint ?? c.targetPoint
+    return bus.exitEdge === "right"
+      ? p.y
+      : bus.exitEdge === "top"
+        ? -p.x
+        : bus.exitEdge === "left"
+          ? -p.y
+          : p.x
+  }
+  const ordered = bus.connections.toSorted(
+    (a, b) =>
+      targetCoordinate(a) - targetCoordinate(b) ||
+      a.connectionIndex - b.connectionIndex,
+  )
+  const sourceAngles: number[] = []
+  for (const c of ordered) {
+    if (distance(c.sourcePoint, center) < EPSILON) return null
+    let a = angle(c.sourcePoint)
+    while (a < (sourceAngles.at(-1) ?? a) - EPSILON) a += TAU
+    sourceAngles.push(a)
+  }
+  if (sourceAngles.at(-1)! - sourceAngles[0]! >= TAU - EPSILON) return null
+  const connections = new Map(
+    buses.flatMap((b) =>
+      b.connections.map((c) => [c.connectionIndex, c] as const),
+    ),
+  )
+  const orderedIndex = new Map(ordered.map((c, i) => [c.connectionIndex, i]))
+  const sites = new Map<string, number>()
+  const candidateGroups = new Map<number, Candidate[]>()
+  for (const c of connections.values())
+    candidateGroups.set(c.connectionIndex, [])
+  for (const raw of getComponentDogboneViaSiteCandidates(buses, rules)) {
+    const c = connections.get(raw.connectionIndex)!
+    const key = `${raw.point.x.toFixed(9)},${raw.point.y.toFixed(9)}`
+    if (!sites.has(key)) sites.set(key, sites.size)
+    const index = orderedIndex.get(raw.connectionIndex)
+    const sourceAngle = angle(c.sourcePoint)
+    const a =
+      index === undefined
+        ? angle(raw.point)
+        : sourceAngles[index]! +
+          Math.atan2(
+            Math.sin(angle(raw.point) - sourceAngle),
+            Math.cos(angle(raw.point) - sourceAngle),
+          )
+    candidateGroups.get(raw.connectionIndex)!.push({
+      ...raw,
+      angle: a,
+      siteIndex: sites.get(key)!,
+      sourceSegment: {
+        start: c.sourcePoint,
+        end: raw.point,
+        layer: c.sourceLayer,
+        width: rules.traceWidth,
+      },
+    })
+  }
+  const groups = [...candidateGroups.entries()].map(
+    ([connectionIndex, candidates]) => ({ connectionIndex, candidates }),
+  )
+  if (groups.some((g) => g.candidates.length === 0)) return null
+  const domains = ordered.map((c, i) =>
+    candidateGroups
+      .get(c.connectionIndex)!
+      .toSorted(
+        (a, b) =>
+          Math.abs(a.angle - sourceAngles[i]!) -
+            Math.abs(b.angle - sourceAngles[i]!) ||
+          distance(b.point, center) - distance(a.point, center),
+      ),
+  )
+  const requiredHoleSeparation = rules.viaHoleDiameter
+    ? rules.viaHoleDiameter + (rules.holeToHoleClearance ?? rules.clearance)
+    : 0
+  const requiredViaToTraceSeparation =
+    rules.viaDiameter / 2 + rules.traceWidth / 2 + rules.clearance
+  const compatible = (a: Candidate, b: Candidate) => {
+    const share =
+      rules.canShareCopper?.(a.connectionIndex, b.connectionIndex) ?? false
+    const minimumViaDistance = share
+      ? requiredHoleSeparation
+      : Math.max(requiredHoleSeparation, rules.viaDiameter + rules.clearance)
+    if (distance(a.point, b.point) < minimumViaDistance - EPSILON) return false
+    if (share) return true
+    return (
+      distancePointToSegment(
+        a.point,
+        b.sourceSegment.start,
+        b.sourceSegment.end,
+      ) >=
+        requiredViaToTraceSeparation - EPSILON &&
+      distancePointToSegment(
+        b.point,
+        a.sourceSegment.start,
+        a.sourceSegment.end,
+      ) >=
+        requiredViaToTraceSeparation - EPSILON &&
+      segmentsAreClear(a.sourceSegment, b.sourceSegment, rules.clearance)
+    )
+  }
+  const forbidden = new Map<Candidate, Set<Candidate>>()
+  for (const domain of domains)
+    for (const a of domain) {
+      const conflicts = new Set<Candidate>()
+      for (const group of groups)
+        for (const b of group.candidates) {
+          if (a.connectionIndex !== b.connectionIndex && !compatible(a, b))
+            conflicts.add(b)
+        }
+      forbidden.set(a, conflicts)
+    }
+  const chosen: Candidate[] = []
+  // A perfect matching is necessary because distinct drilled holes cannot use
+  // the same site. It is a pruning test; native matching still validates copper.
+  const canUseDistinctSiteCheck =
+    requiredHoleSeparation > EPSILON || !rules.canShareCopper
+  const remainingSitesCanMatch = () => {
+    if (!canUseDistinctSiteCheck) return true
+    const selected = new Map(
+      chosen.map((c) => [c.connectionIndex, c.siteIndex]),
+    )
+    const allowed = groups
+      .map((g) =>
+        g.candidates
+          .filter(
+            (c) =>
+              (!selected.has(c.connectionIndex) ||
+                selected.get(c.connectionIndex) === c.siteIndex) &&
+              chosen.every((a) => !forbidden.get(a)!.has(c)),
+          )
+          .map((c) => c.siteIndex),
+      )
+      .sort((a, b) => a.length - b.length)
+    if (allowed.some((d) => d.length === 0)) return false
+    const owner = new Int32Array(sites.size).fill(-1)
+    const augment = (index: number, visited: Uint8Array): boolean => {
+      for (const site of allowed[index]!) {
+        if (visited[site]) continue
+        visited[site] = 1
+        if (owner[site] === -1 || augment(owner[site]!, visited)) {
+          owner[site] = index
+          return true
+        }
+      }
+      return false
+    }
+    return allowed.every((_, i) => augment(i, new Uint8Array(sites.size)))
+  }
+  let states = 0
+  let completeAssignments = 0
+  let result: Map<number, Point2D> | null = null
+  const search = (index: number): boolean => {
+    if (++states > maximumOrderingStates) return false
+    if (index === domains.length) {
+      if (++completeAssignments > maximumCompleteAssignments) return false
+      const fixed = new Map(rules.fixedViaPointsByConnectionIndex)
+      for (const c of chosen) fixed.set(c.connectionIndex, c.point)
+      result = matchComponentDogboneViaSites(buses, {
+        ...rules,
+        fixedViaPointsByConnectionIndex: fixed,
+      })
+      return result !== null
+    }
+    for (const candidate of domains[index]!) {
+      if (
+        candidate.angle < (chosen.at(-1)?.angle ?? -Infinity) - EPSILON ||
+        chosen.some((c) => forbidden.get(c)!.has(candidate))
+      )
+        continue
+      chosen.push(candidate)
+      if (remainingSitesCanMatch() && search(index + 1)) return true
+      chosen.pop()
+      if (
+        states > maximumOrderingStates ||
+        completeAssignments >= maximumCompleteAssignments
+      )
+        break
+    }
+    return false
+  }
+  search(0)
+  return result
+}

package/lib/reflect-fanout-x.ts

@@ -0,0 +1,67 @@
+/**
+ * View horizontal fanout geometry from its opposite edge. A shared memo keeps
+ * pad identity intact: clearance checks compare a plan's sourceObstacle with
+ * the same obstacle in the transformed SRJ.
+ */
+export function reflectFanoutX<T>(value: T): T {
+  const memo = new Map<object, unknown>()
+  const reflect = (item: unknown): unknown => {
+    if (item === null || typeof item !== "object") return item
+    if (memo.has(item)) return memo.get(item)
+    if (item instanceof Map) {
+      const result = new Map()
+      memo.set(item, result)
+      for (const [key, entry] of item) result.set(key, reflect(entry))
+      return result
+    }
+    if (item instanceof Set) {
+      const result = new Set(item)
+      memo.set(item, result)
+      return result
+    }
+    if (Array.isArray(item)) {
+      const result: unknown[] = []
+      memo.set(item, result)
+      for (const entry of item) result.push(reflect(entry))
+      return result
+    }
+    const original = item as Record<string, unknown>
+    const result: Record<string, unknown> = {}
+    memo.set(item, result)
+    for (const [key, entry] of Object.entries(original))
+      result[key] = reflect(entry)
+    if (typeof original.x === "number" && typeof original.y === "number")
+      result.x = -original.x
+    if (
+      typeof original.minX === "number" &&
+      typeof original.maxX === "number"
+    ) {
+      result.minX = -original.maxX
+      result.maxX = -original.minX
+    }
+    if (Array.isArray(original.xCoordinates))
+      result.xCoordinates = original.xCoordinates
+        .map((x: number) => -x)
+        .sort((a, b) => a - b)
+    if (typeof original.ccwRotationDegrees === "number")
+      result.ccwRotationDegrees = -original.ccwRotationDegrees
+    const edge = (direction: string) =>
+      direction === "left"
+        ? "right"
+        : direction === "right"
+          ? "left"
+          : direction
+    for (const key of ["direction", "exitEdge", "preferredExit"] as const) {
+      if (typeof original[key] === "string")
+        result[key] = original[key].split("-").map(edge).join("-")
+    }
+    if (
+      original.cornerBandSide &&
+      (original.exitEdge === "top" || original.exitEdge === "bottom")
+    )
+      result.cornerBandSide =
+        original.cornerBandSide === "minimum" ? "maximum" : "minimum"
+    return result
+  }
+  return reflect(value) as T
+}

package/lib/repair-peripheral-bus-lengths.ts

@@ -0,0 +1,167 @@
+import type { SimpleRouteJson } from "@tscircuit/capacity-autorouter"
+import { getCornerBandSide } from "./boundary-exit"
+import { matchBusPlanLengths } from "./match-bus-lengths"
+import type { RouteBusParams } from "./route-bus"
+import {
+  routeViaMinimalWindingAlternativesSteps,
+  type RouteViaMinimalWindingProgress,
+} from "./route-via-minimal-winding"
+import type { Bounds, FanoutRoutePlan, PreparedBus } from "./types"
+
+interface Params
+  extends Omit<RouteBusParams, "bus" | "targetLayer" | "acceptedPlans"> {
+  inputSrj: SimpleRouteJson
+  sharedBoundary: Bounds
+  preparedBuses: readonly PreparedBus[]
+  plans: readonly FanoutRoutePlan[]
+}
+
+/** Move a pair within its boundary band when its first route leaves no tuning room. */
+export function* repairPeripheralBusLengthsSteps(
+  params: Params,
+): Generator<RouteViaMinimalWindingProgress, FanoutRoutePlan[] | null, void> {
+  const match = (
+    plans: readonly FanoutRoutePlan[],
+    buses = params.preparedBuses,
+  ) =>
+    matchBusPlanLengths({
+      plans,
+      preparedBuses: buses,
+      inputSrj: params.inputSrj,
+      sharedBoundary: params.sharedBoundary,
+      clearance: params.clearance,
+      allowBlindAndBuriedVias: params.allowBlindAndBuriedVias,
+      allowSameNetMerges: params.allowSameNetMerges,
+    })
+  const skew = (plans: readonly FanoutRoutePlan[]) =>
+    Math.max(...plans.map((plan) => plan.length)) -
+    Math.min(...plans.map((plan) => plan.length))
+  const repaired = new Set<string>()
+  let current = [...params.plans]
+  while (repaired.size < 3) {
+    const matched = match(current)
+    if (matched.plans) return matched.plans
+    const bus = matched.failedBus
+    if (
+      repaired.has(bus.busId) ||
+      bus.connections.length !== 2 ||
+      bus.termination.type !== "boundary" ||
+      !bus.exitEdge
+    )
+      return null
+    repaired.add(bus.busId)
+    const own = current.filter((plan) => plan.busId === bus.busId)
+    if (
+      own.length !== 2 ||
+      own.some((plan) => !plan.via || plan.additionalVias?.length) ||
+      own[0]!.targetLayer !== own[1]!.targetLayer
+    )
+      return null
+    const accepted = current.filter((plan) => plan.busId !== bus.busId)
+    const sourceEscapePaths = new Map(
+      own.map((plan) => [
+        plan.connectionIndex,
+        [
+          plan.sourcePoint,
+          ...plan.segments
+            .slice(0, plan.sourceEscapeSegmentCount ?? 1)
+            .map((segment) => segment.end),
+        ],
+      ]),
+    )
+    const horizontal = bus.exitEdge === "left" || bus.exitEdge === "right"
+    const axis = horizontal ? "y" : "x"
+    const minimum = horizontal
+      ? params.sharedBoundary.minY
+      : params.sharedBoundary.minX
+    const maximum = horizontal
+      ? params.sharedBoundary.maxY
+      : params.sharedBoundary.maxX
+    const middle = (minimum + maximum) / 2
+    const side = getCornerBandSide(bus.exitEdge, bus.preferredExit)
+    const pitch = params.traceWidth + params.clearance
+    const initialSkew = skew(own)
+    const candidates: FanoutRoutePlan[][] = []
+    let replacement: FanoutRoutePlan[] | null = null
+    search: for (const multiplier of [0, 1, -1, 2, -2, 3, -3, 4, -4]) {
+      const offset = multiplier * pitch
+      if (
+        own.some((plan) => {
+          const track = plan.exitPoint[axis] + offset
+          return (
+            track < minimum + params.traceWidth / 2 ||
+            track > maximum - params.traceWidth / 2 ||
+            (side === "minimum" && track >= middle) ||
+            (side === "maximum" && track <= middle)
+          )
+        })
+      )
+        continue
+      for (const laneBias of [0, -1, 1] as const) {
+        for (const routeOrder of [
+          [0, 1],
+          [1, 0],
+        ]) {
+          const alternatives = yield* routeViaMinimalWindingAlternativesSteps(
+            {
+              ...params,
+              bus,
+              targetLayer: own[0]!.targetLayer,
+              acceptedPlans: accepted,
+              terminals: bus.connections.map((connection) => {
+                const original = own.find(
+                  (plan) => plan.connectionIndex === connection.connectionIndex,
+                )!
+                return {
+                  connection,
+                  viaPoint: original.via!.center,
+                  exitPoint: {
+                    ...original.exitPoint,
+                    [axis]: original.exitPoint[axis] + offset,
+                  },
+                }
+              }),
+              sourceEscapePaths,
+              reservedVias: undefined,
+              gridStep: pitch / 2,
+              gridStepDivisor: 2,
+              alignGridToPads: true,
+              maximumRouteOrderAttempts: 1,
+              routeOrder,
+              laneBias,
+            },
+            1,
+            false,
+          )
+          if (!alternatives.length || skew(alternatives[0]!) >= initialSkew)
+            continue
+          const candidate = alternatives[0]!.map((plan) => ({
+            ...plan,
+            cornerBandSide: side,
+          }))
+          candidates.push(candidate)
+          // A small remaining deficit is inexpensive to tune. Larger deficits
+          // are attempted below after collecting the best available geometry.
+          if (skew(candidate) > 2 * bus.maxLengthSkew!) continue
+          const tuned = match([...accepted, ...candidate], [bus])
+          if (!tuned.plans) continue
+          replacement = tuned.plans
+          break search
+        }
+      }
+    }
+    if (!replacement) {
+      for (const candidate of candidates
+        .toSorted((a, b) => skew(a) - skew(b))
+        .slice(0, 3)) {
+        const tuned = match([...accepted, ...candidate], [bus])
+        if (!tuned.plans) continue
+        replacement = tuned.plans
+        break
+      }
+    }
+    if (!replacement) return null
+    current = replacement
+  }
+  return match(current).plans
+}