@tscircuit/fanout-solver 0.0.48 → 0.0.50

package/lib/match-component-dogbone-via-sites.ts

@@ -40,6 +40,17 @@ export interface DogboneViaSiteGeometryRules {
     connectionIndex: number
     segment: RoutedSegment
   }[]
+  /** Routed vias that every newly assigned through-via/dogbone must clear. */
+  blockingVias?: readonly {
+    connectionIndex: number
+    center: Point2D
+    diameter: number
+    spanLayers: readonly string[]
+  }[]
+  /** Board obstacles outside the source component that dogbones must clear. */
+  additionalObstacles?: readonly Obstacle[]
+  /** Alternate horizontal plane dogbones across BGA rows. */
+  preferPlaneCheckerboardSites?: boolean
   /** True only when the two connections are allowed to merge copper. */
   canShareCopper?: (
     firstConnectionIndex: number,
@@ -148,6 +159,7 @@ function getComponentMatchingInputs(
 ): ComponentMatchingInput[] {
   const byComponent = new Map<string, ComponentMatchingInput>()
   const componentByConnectionIndex = new Map<number, string>()
+  const obstacleSetByComponentId = new Map<string, Set<Obstacle>>()
 
   for (const bus of preparedBuses) {
     let component = byComponent.get(bus.componentId)
@@ -162,6 +174,7 @@ function getComponentMatchingInputs(
         pitchY: Number.POSITIVE_INFINITY,
       }
       byComponent.set(bus.componentId, component)
+      obstacleSetByComponentId.set(bus.componentId, new Set())
     }
 
     component.xCoordinates.push(...bus.xCoordinates)
@@ -172,8 +185,10 @@ function getComponentMatchingInputs(
     if (Number.isFinite(bus.pitchY) && bus.pitchY > EPSILON) {
       component.pitchY = Math.min(component.pitchY, bus.pitchY)
     }
+    const obstacleSet = obstacleSetByComponentId.get(bus.componentId)!
     for (const obstacle of bus.componentObstacles) {
-      if (!component.obstacles.includes(obstacle)) {
+      if (!obstacleSet.has(obstacle)) {
+        obstacleSet.add(obstacle)
         component.obstacles.push(obstacle)
       }
     }
@@ -325,6 +340,9 @@ function getConnectionCandidates(params: {
 }): ViaSiteCandidate[] {
   const { connection, component, rules } = params
   const { preparedConnection, direction } = connection
+  const obstacles = rules.additionalObstacles
+    ? [...new Set([...component.obstacles, ...rules.additionalObstacles])]
+    : component.obstacles
   const source = {
     x: preparedConnection.sourcePoint.x,
     y: preparedConnection.sourcePoint.y,
@@ -368,7 +386,7 @@ function getConnectionCandidates(params: {
     if (
       !viaSiteClearsObstacles({
         point,
-        obstacles: component.obstacles,
+        obstacles,
         viaDiameter: rules.viaDiameter,
         clearance: rules.clearance,
       })
@@ -385,7 +403,7 @@ function getConnectionCandidates(params: {
       !sourceSegmentClearsOtherObstacles({
         segment: sourceSegment,
         sourceObstacle: preparedConnection.sourceObstacle,
-        obstacles: component.obstacles,
+        obstacles,
         clearance: rules.clearance,
       })
     ) {
@@ -423,6 +441,35 @@ function getConnectionCandidates(params: {
       },
     )
     if (!candidateClearsRoutedCopper) continue
+    const candidateClearsRoutedVias = (rules.blockingVias ?? []).every(
+      (blocker) => {
+        if (blocker.connectionIndex === preparedConnection.connectionIndex) {
+          return true
+        }
+        if (
+          distance(point, blocker.center) <
+          (rules.viaDiameter + blocker.diameter) / 2 + rules.clearance - EPSILON
+        ) {
+          return false
+        }
+        if (
+          blocker.spanLayers.includes(sourceSegment.layer) &&
+          distancePointToSegment(
+            blocker.center,
+            sourceSegment.start,
+            sourceSegment.end,
+          ) <
+            blocker.diameter / 2 +
+              sourceSegment.width / 2 +
+              rules.clearance -
+              EPSILON
+        ) {
+          return false
+        }
+        return true
+      },
+    )
+    if (!candidateClearsRoutedVias) continue
     candidates.push({
       connectionIndex: preparedConnection.connectionIndex,
       point,
@@ -431,10 +478,30 @@ function getConnectionCandidates(params: {
     })
   }
 
+  const perpendicularCoordinates =
+    direction === "left" || direction === "right"
+      ? component.yCoordinates
+      : component.xCoordinates
+  const sourcePerpendicularCoordinate =
+    direction === "left" || direction === "right" ? source.y : source.x
+  const perpendicularGridIndex = perpendicularCoordinates.findIndex(
+    (coordinate) =>
+      Math.abs(coordinate - sourcePerpendicularCoordinate) <= EPSILON,
+  )
+  const planeCheckerboardSide =
+    perpendicularGridIndex >= 0
+      ? perpendicularGridIndex % 2 === 0
+        ? 1
+        : -1
+      : undefined
   const preferredPerpendicularSide =
     connection.terminationType === "boundary"
       ? rules.preferredBoundaryPerpendicularSideByBusId?.get(connection.busId)
-      : undefined
+      : rules.preferPlaneCheckerboardSites &&
+          connection.terminationType === "plane" &&
+          (direction === "left" || direction === "right")
+        ? planeCheckerboardSide
+        : undefined
   const preferOutward =
     connection.terminationType === "boundary"
       ? (rules.preferBoundaryOutwardByBusId?.get(connection.busId) ?? true)
@@ -525,6 +592,25 @@ function matchComponent(params: {
     }),
   )
   if (entries.some((entry) => entry.candidates.length === 0)) return null
+  const compatibilityCache = new Map<
+    ViaSiteCandidate,
+    Map<ViaSiteCandidate, boolean>
+  >()
+  const candidatesAreCompatible = (
+    first: ViaSiteCandidate,
+    second: ViaSiteCandidate,
+  ): boolean => {
+    const cached = compatibilityCache.get(first)?.get(second)
+    if (cached !== undefined) return cached
+    const compatible = candidatesAreMutuallyClear({ first, second, rules })
+    const firstCache = compatibilityCache.get(first) ?? new Map()
+    firstCache.set(second, compatible)
+    compatibilityCache.set(first, firstCache)
+    const secondCache = compatibilityCache.get(second) ?? new Map()
+    secondCache.set(first, compatible)
+    compatibilityCache.set(second, secondCache)
+    return compatible
+  }
   // Every solution must include each sole candidate. Seed and validate those
   // forced choices once so recursive matching only explores genuine choices.
   const forcedCandidates = entries.flatMap((entry) =>
@@ -542,11 +628,7 @@ function matchComponent(params: {
       previousIndex++
     ) {
       if (
-        !candidatesAreMutuallyClear({
-          first: candidate,
-          second: forcedCandidates[previousIndex]!,
-          rules,
-        })
+        !candidatesAreCompatible(candidate, forcedCandidates[previousIndex]!)
       ) {
         return null
       }
@@ -584,11 +666,7 @@ function matchComponent(params: {
   ): ViaSiteCandidate[] =>
     entry.candidates.filter((candidate) =>
       [...assignedCandidates.values()].every((assignedCandidate) =>
-        candidatesAreMutuallyClear({
-          first: candidate,
-          second: assignedCandidate,
-          rules,
-        }),
+        candidatesAreCompatible(candidate, assignedCandidate),
       ),
     )
 

package/lib/route-bus.ts

@@ -24,7 +24,8 @@ import {
   obstacleSharesElectricalNet,
 } from "./net-identity"
 import {
-  routeViaMinimalWindingAlternatives,
+  type RouteViaMinimalWindingProgress,
+  routeViaMinimalWindingAlternativesSteps,
   type ViaMinimalWindingReservedVia,
 } from "./route-via-minimal-winding"
 import type {
@@ -60,10 +61,21 @@ export interface RouteBusParams {
   fixedViaPointsByConnectionIndex?: ReadonlyMap<number, Point2D>
   reservedVias?: readonly ViaMinimalWindingReservedVia[]
   viaMinimalOnly?: boolean
+  /** Bounds the final fixed-via winding fallback after ordered attempts. */
+  fixedViaFallbackRouteOrderAttempts?: number
+  /** Skip this many otherwise-clear plane escapes when enumerating alternatives. */
+  planeCandidateSkipCount?: number
   /** Dense corner-band phase that preserves existing lane centers when leading lanes are prepended. */
   cornerBandTargetTrackOffset?: number
 }
 
+export interface RouteBusAlternativesProgress {
+  phase: "via-minimal-winding"
+  busId: string
+  targetLayer: string
+  winding: RouteViaMinimalWindingProgress
+}
+
 interface TrackCandidate {
   value: number
   kind: "corridor" | "gap" | "margin" | "preferred"
@@ -1865,6 +1877,24 @@ function planIsClearOfPlans(params: {
   return true
 }
 
+export function fanoutPlansAreMutuallyClear(params: {
+  plans: readonly FanoutRoutePlan[]
+  srj: SimpleRouteJson
+  clearance: number
+  allowSameNetMerges?: boolean
+}): boolean {
+  const { plans, srj, clearance, allowSameNetMerges = false } = params
+  return plans.every((plan, index) =>
+    planIsClearOfPlans({
+      plan,
+      otherPlans: plans.filter((_, otherIndex) => otherIndex !== index),
+      srj,
+      allowSameNetMerges,
+      clearance,
+    }),
+  )
+}
+
 function planIsClear(params: {
   plan: FanoutRoutePlan
   otherPlans: FanoutRoutePlan[]
@@ -1983,11 +2013,27 @@ function routePlaneTerminatedBus(
     allowBlindAndBuriedVias = true,
     allowSameNetMerges = false,
     fixedViaPointsByConnectionIndex,
+    planeCandidateSkipCount = 0,
   } = params
   const sourceObstacle = bus.connections[0]?.sourceObstacle
   if (!sourceObstacle || bus.termination.type !== "plane") return null
   const sourceLayer = bus.connections[0]!.sourceLayer
   if (targetLayer === sourceLayer) return null
+  let remainingPlaneCandidatesToSkip = planeCandidateSkipCount
+  const selectClearPlanePlan = (
+    plans: FanoutRoutePlan[],
+    isClear: (plan: FanoutRoutePlan, index: number) => boolean,
+  ): FanoutRoutePlan | undefined => {
+    for (const [index, plan] of plans.entries()) {
+      if (!isClear(plan, index)) continue
+      if (remainingPlaneCandidatesToSkip > 0) {
+        remainingPlaneCandidatesToSkip--
+        continue
+      }
+      return plan
+    }
+    return undefined
+  }
 
   if (fixedViaPointsByConnectionIndex) {
     const fixedPlans: FanoutRoutePlan[] = []
@@ -2044,19 +2090,21 @@ function routePlaneTerminatedBus(
         ),
         basePlan,
       ]
-      const clearPlan = plansToTry.find((candidatePlan, candidateIndex) =>
-        planIsClear({
-          plan: candidatePlan,
-          otherPlans: [...acceptedPlans, ...fixedPlans],
-          staticClearanceCache,
-          blockingBusCounts,
-          cacheKey: `plane-fixed:${bus.busId}:${targetLayer}:${preparedConnection.connectionIndex}:${candidateIndex}`,
-          srj,
-          sharedBoundary: bus.sharedBoundary,
-          clearance,
-          allowBlindAndBuriedVias,
-          allowSameNetMerges,
-        }),
+      const clearPlan = selectClearPlanePlan(
+        plansToTry,
+        (candidatePlan, candidateIndex) =>
+          planIsClear({
+            plan: candidatePlan,
+            otherPlans: [...acceptedPlans, ...fixedPlans],
+            staticClearanceCache,
+            blockingBusCounts,
+            cacheKey: `plane-fixed:${bus.busId}:${targetLayer}:${preparedConnection.connectionIndex}:${candidateIndex}`,
+            srj,
+            sharedBoundary: bus.sharedBoundary,
+            clearance,
+            allowBlindAndBuriedVias,
+            allowSameNetMerges,
+          }),
       )
       if (!clearPlan) return null
       fixedPlans.push(clearPlan)
@@ -2120,19 +2168,21 @@ function routePlaneTerminatedBus(
       ),
       viaInPadPlan,
     ]
-    const clearPlan = plansToTry.find((candidatePlan, candidateIndex) =>
-      planIsClear({
-        plan: candidatePlan,
-        otherPlans: acceptedPlans,
-        staticClearanceCache,
-        blockingBusCounts,
-        cacheKey: `plane-via-in-pad:${bus.busId}:${targetLayer}:${candidateIndex}`,
-        srj,
-        sharedBoundary: bus.sharedBoundary,
-        clearance,
-        allowBlindAndBuriedVias,
-        allowSameNetMerges,
-      }),
+    const clearPlan = selectClearPlanePlan(
+      plansToTry,
+      (candidatePlan, candidateIndex) =>
+        planIsClear({
+          plan: candidatePlan,
+          otherPlans: acceptedPlans,
+          staticClearanceCache,
+          blockingBusCounts,
+          cacheKey: `plane-via-in-pad:${bus.busId}:${targetLayer}:${candidateIndex}`,
+          srj,
+          sharedBoundary: bus.sharedBoundary,
+          clearance,
+          allowBlindAndBuriedVias,
+          allowSameNetMerges,
+        }),
     )
     if (clearPlan) return [clearPlan]
   }
@@ -2195,7 +2245,7 @@ function routePlaneTerminatedBus(
           )
           const perpendicularPitch = getPerpendicularPitch(directionalBus)
           const sourceEscapePaths: Point2D[][] = []
-          const maximumCandidatePaths = 32
+          const maximumCandidatePaths = 128
           for (
             let totalSteps = 0;
             totalSteps <= maximumEscapeSteps &&
@@ -2337,19 +2387,21 @@ function routePlaneTerminatedBus(
               ),
               basePlan,
             ]
-            plan = plansToTry.find((candidatePlan, candidateIndex) =>
-              planIsClear({
-                plan: candidatePlan,
-                otherPlans: [...acceptedPlans, ...candidatePlans],
-                staticClearanceCache,
-                blockingBusCounts,
-                cacheKey: `plane:${bus.busId}:${targetLayer}:${direction}:${preparedConnection.connectionIndex}:${viaHandedness}:${pathIndex}:${candidateIndex}`,
-                srj,
-                sharedBoundary: bus.sharedBoundary,
-                clearance,
-                allowBlindAndBuriedVias,
-                allowSameNetMerges,
-              }),
+            plan = selectClearPlanePlan(
+              plansToTry,
+              (candidatePlan, candidateIndex) =>
+                planIsClear({
+                  plan: candidatePlan,
+                  otherPlans: [...acceptedPlans, ...candidatePlans],
+                  staticClearanceCache,
+                  blockingBusCounts,
+                  cacheKey: `plane:${bus.busId}:${targetLayer}:${direction}:${preparedConnection.connectionIndex}:${viaHandedness}:${pathIndex}:${candidateIndex}`,
+                  srj,
+                  sharedBoundary: bus.sharedBoundary,
+                  clearance,
+                  allowBlindAndBuriedVias,
+                  allowSameNetMerges,
+                }),
             )
             if (plan) break
           }
@@ -2367,10 +2419,11 @@ function routePlaneTerminatedBus(
   return null
 }
 
-export function routeBusAlternatives(
+export function* routeBusAlternativesSteps(
   params: RouteBusParams,
   maxAlternatives = 1,
-): FanoutRoutePlan[][] {
+  includeVisualization = false,
+): Generator<RouteBusAlternativesProgress, FanoutRoutePlan[][], void> {
   const {
     srj,
     bus,
@@ -2391,6 +2444,7 @@ export function routeBusAlternatives(
     fixedViaPointsByConnectionIndex,
     reservedVias = [],
     viaMinimalOnly = false,
+    fixedViaFallbackRouteOrderAttempts = 24,
     cornerBandTargetTrackOffset,
   } = params
   if (!Number.isInteger(maxAlternatives) || maxAlternatives < 1) {
@@ -2408,8 +2462,20 @@ export function routeBusAlternatives(
     return []
   }
   if (bus.termination.type === "plane") {
-    const plan = routePlaneTerminatedBus(params)
-    return plan ? [plan] : []
+    const alternatives: FanoutRoutePlan[][] = []
+    for (
+      let planeCandidateSkipCount = 0;
+      planeCandidateSkipCount < maxAlternatives;
+      planeCandidateSkipCount++
+    ) {
+      const plan = routePlaneTerminatedBus({
+        ...params,
+        planeCandidateSkipCount,
+      })
+      if (!plan) break
+      alternatives.push(plan)
+    }
+    return alternatives
   }
   const exitAxis = getExitAxis(bus)
   const sourceObstacle = bus.connections[0]?.sourceObstacle
@@ -2685,7 +2751,7 @@ export function routeBusAlternatives(
                 )!,
               // Preserve the existing bounded search after every inexpensive
               // layer-interleave candidate has had one deterministic attempt.
-              maximumRouteOrderAttempts: maximumThroughAllRouteOrderAttempts,
+              maximumRouteOrderAttempts: fixedViaFallbackRouteOrderAttempts,
               windingOrderIndex: 0,
               preferTargetDirectedLaneBias: true,
             },
@@ -2765,7 +2831,7 @@ export function routeBusAlternatives(
         .join("|")}:${terminalPattern.maximumRouteOrderAttempts ?? "all"}`
       if (seenTerminalSignatures.has(terminalSignature)) continue
       seenTerminalSignatures.add(terminalSignature)
-      const viaMinimalAlternatives = routeViaMinimalWindingAlternatives(
+      const windingSteps = routeViaMinimalWindingAlternativesSteps(
         {
           srj,
           bus,
@@ -2796,7 +2862,19 @@ export function routeBusAlternatives(
           : terminalPattern.maximumRouteOrderAttempts === undefined
             ? Math.min(2, maxAlternatives - alternatives.length)
             : 2,
+        includeVisualization,
       )
+      let windingResult = windingSteps.next()
+      while (!windingResult.done) {
+        yield {
+          phase: "via-minimal-winding",
+          busId: bus.busId,
+          targetLayer,
+          winding: windingResult.value,
+        }
+        windingResult = windingSteps.next()
+      }
+      const viaMinimalAlternatives = windingResult.value
       for (const viaMinimalPlans of viaMinimalAlternatives) {
         const combinedPlansAreClear = fanoutPlansAreClear({
           plans: [...acceptedPlans, ...viaMinimalPlans],
@@ -2949,6 +3027,16 @@ export function routeBusAlternatives(
   return alternatives
 }
 
+export function routeBusAlternatives(
+  params: RouteBusParams,
+  maxAlternatives = 1,
+): FanoutRoutePlan[][] {
+  const steps = routeBusAlternativesSteps(params, maxAlternatives)
+  let result = steps.next()
+  while (!result.done) result = steps.next()
+  return result.value
+}
+
 export function routeBus(params: RouteBusParams): FanoutRoutePlan[] | null {
   return routeBusAlternatives(params, 1)[0] ?? null
 }