@tscircuit/fanout-solver 0.0.32 → 0.0.33

package/lib/complete-original-endpoints.ts

@@ -10,7 +10,6 @@ import {
   distancePointToSegment,
   pointIsInsideObstacle,
 } from "./geometry"
-import { getCopperLayerNames, getLayerSpan } from "./layer-names"
 import { obstacleSharesElectricalNet } from "./net-identity"
 import type {
   FanoutEndpointCompletionReport,
@@ -593,58 +592,6 @@ function trimCompletedFanoutTails(params: {
   return { ...fanoutSrj, traces }
 }
 
-function createFanoutCopperObstacles(srj: SimpleRouteJson): Obstacle[] {
-  const layerNames = getCopperLayerNames(srj.layerCount)
-  const obstacles: Obstacle[] = []
-  for (const trace of srj.traces ?? []) {
-    let previousWire:
-      | Extract<SimplifiedPcbTrace["route"][number], { route_type: "wire" }>
-      | undefined
-    for (const point of trace.route) {
-      if (point.route_type === "via") {
-        obstacles.push({
-          obstacleId: `endpoint-completion-keepout:${trace.pcb_trace_id}:via:${obstacles.length}`,
-          type: "rect",
-          center: { x: point.x, y: point.y },
-          width: point.via_diameter ?? srj.minViaPadDiameter ?? 0.3,
-          height: point.via_diameter ?? srj.minViaPadDiameter ?? 0.3,
-          layers: getLayerSpan(point.from_layer, point.to_layer, layerNames),
-          connectedTo: [trace.connection_name],
-        })
-        previousWire = undefined
-        continue
-      }
-      if (point.route_type !== "wire") {
-        previousWire = undefined
-        continue
-      }
-      if (previousWire?.layer === point.layer) {
-        const segmentLength = distance(previousWire, point)
-        if (segmentLength > EPSILON) {
-          obstacles.push({
-            obstacleId: `endpoint-completion-keepout:${trace.pcb_trace_id}:segment:${obstacles.length}`,
-            type: "rect",
-            center: {
-              x: (previousWire.x + point.x) / 2,
-              y: (previousWire.y + point.y) / 2,
-            },
-            width: segmentLength,
-            height: Math.max(previousWire.width, point.width),
-            ccwRotationDegrees:
-              (Math.atan2(point.y - previousWire.y, point.x - previousWire.x) *
-                180) /
-              Math.PI,
-            layers: [point.layer],
-            connectedTo: [trace.connection_name],
-          })
-        }
-      }
-      previousWire = point
-    }
-  }
-  return obstacles
-}
-
 function acceptDownstreamTraces(params: {
   inputSrj: SimpleRouteJson
   fanoutSrj: SimpleRouteJson
@@ -1092,11 +1039,8 @@ export function completeOriginalEndpoints(params: {
           ),
         }))
         .filter((bus) => bus.connectionNames.length > 0),
-      obstacles: [
-        ...fanoutSrj.obstacles,
-        ...createFanoutCopperObstacles(fanoutSrj),
-      ],
-      traces: [],
+      obstacles: fanoutSrj.obstacles,
+      traces: directSrj.traces,
     }
     try {
       const candidates = routeDownstreamConnections(downstreamInput, { effort })

package/lib/fanout-solver.ts

@@ -374,6 +374,7 @@ export class FanoutSolver extends BaseSolver {
   readonly attempts: FanoutAttemptSummary[] = []
   readonly layerAssignments: Array<Readonly<Record<string, string>>>
   readonly config: ResolvedFanoutConfig
+  private readonly routingSrj: SimpleRouteJson
   private readonly escapeLayersByBusId: Readonly<
     Record<string, readonly string[]>
   >
@@ -404,8 +405,12 @@ export class FanoutSolver extends BaseSolver {
     public readonly options: FanoutSolverOptions = {},
   ) {
     super()
+    this.routingSrj = {
+      ...inputSrj,
+      obstacles: [...inputSrj.obstacles],
+    }
     this.config = resolveConfig(inputSrj, options)
-    this.preparedBuses = prepareFanoutBuses(inputSrj, options)
+    this.preparedBuses = prepareFanoutBuses(this.routingSrj, options)
     for (const bus of this.preparedBuses) {
       for (const allowedLayer of bus.allowedLayers ?? []) {
         if (!this.config.layerNames.includes(allowedLayer)) {
@@ -468,7 +473,7 @@ export class FanoutSolver extends BaseSolver {
             bus.busId,
             getCandidateEscapeLayersForBus({
               bus,
-              srj: inputSrj,
+              srj: this.routingSrj,
               config: this.config,
               staticClearanceCache: this.routeStaticClearanceCache,
             }),
@@ -511,7 +516,7 @@ export class FanoutSolver extends BaseSolver {
       return
     }
     this.endpointCompletion = completeOriginalEndpoints({
-      inputSrj: this.inputSrj,
+      inputSrj: this.routingSrj,
       fanoutSrj: this.bestAttempt.outputSrj,
       plans: this.bestAttempt.plans,
       traceWidth: this.config.traceWidth,
@@ -563,7 +568,7 @@ export class FanoutSolver extends BaseSolver {
     const isSingleLayerFanout = this.config.escapeLayers.length === 1
     if (isSingleLayerFanout && this.config.singleLayerPushAndShove) {
       const singleLayerParams = {
-        srj: this.inputSrj,
+        srj: this.routingSrj,
         buses: this.preparedBuses,
         traceWidth: this.config.traceWidth,
         clearance: this.config.clearance,
@@ -628,7 +633,7 @@ export class FanoutSolver extends BaseSolver {
       }
       const currentBusBlockingCounts = new Map<string, number>()
       const busPlans = routeBus({
-        srj: this.inputSrj,
+        srj: this.routingSrj,
         bus,
         targetLayer,
         acceptedPlans: plans,
@@ -884,7 +889,7 @@ export class FanoutSolver extends BaseSolver {
         for (const targetLayer of orderedLayers) {
           const busAlternatives = routeBusAlternatives(
             {
-              srj: this.inputSrj,
+              srj: this.routingSrj,
               bus,
               targetLayer,
               acceptedPlans: state.plans,

package/lib/get-routed-trace-copper.ts

@@ -0,0 +1,83 @@
+import type {
+  SimpleRouteJson,
+  SimplifiedPcbTrace,
+} from "@tscircuit/capacity-autorouter"
+import { getCopperLayerNames, getLayerSpan } from "./layer-names"
+import type { Point2D, RoutedSegment } from "./types"
+
+export interface RoutedTraceVia {
+  center: Point2D
+  diameter: number
+  spanLayers: string[]
+}
+
+export interface RoutedTraceCopper {
+  trace: SimplifiedPcbTrace
+  connectionName: string
+  segments: RoutedSegment[]
+  vias: RoutedTraceVia[]
+}
+
+export function getRoutedTraceCopper(
+  srj: SimpleRouteJson,
+  trace: SimplifiedPcbTrace,
+): RoutedTraceCopper {
+  const layerNames = getCopperLayerNames(srj.layerCount)
+  const segments: RoutedSegment[] = []
+  const vias: RoutedTraceVia[] = []
+  let previousWire:
+    | Extract<SimplifiedPcbTrace["route"][number], { route_type: "wire" }>
+    | undefined
+
+  for (const routePoint of trace.route) {
+    if (routePoint.route_type === "via") {
+      vias.push({
+        center: { x: routePoint.x, y: routePoint.y },
+        diameter:
+          routePoint.via_diameter ??
+          srj.minViaPadDiameter ??
+          srj.min_via_pad_diameter ??
+          srj.minViaDiameter ??
+          srj.minTraceWidth,
+        spanLayers: getLayerSpan(
+          routePoint.from_layer,
+          routePoint.to_layer,
+          layerNames,
+        ),
+      })
+      previousWire = undefined
+      continue
+    }
+
+    if (routePoint.route_type !== "wire") {
+      previousWire = undefined
+      continue
+    }
+
+    if (
+      previousWire?.layer === routePoint.layer &&
+      (previousWire.x !== routePoint.x || previousWire.y !== routePoint.y)
+    ) {
+      segments.push({
+        start: { x: previousWire.x, y: previousWire.y },
+        end: { x: routePoint.x, y: routePoint.y },
+        width: Math.max(previousWire.width, routePoint.width),
+        layer: routePoint.layer,
+      })
+    }
+    previousWire = routePoint
+  }
+
+  return {
+    trace,
+    connectionName: trace.connection_name,
+    segments,
+    vias,
+  }
+}
+
+export function getAllRoutedTraceCopper(
+  srj: SimpleRouteJson,
+): RoutedTraceCopper[] {
+  return (srj.traces ?? []).map((trace) => getRoutedTraceCopper(srj, trace))
+}

package/lib/net-identity.ts

@@ -62,12 +62,16 @@ function createElectricalNetIdentity(
   }
 
   for (const trace of srj.traces ?? []) {
-    const netKey = trace.connection_name
-      ? connectionNetKeys.get(trace.connection_name)
-      : undefined
-    if (!netKey) continue
-    addTokenNet(tokenNetKeys, trace.pcb_trace_id, netKey)
-    for (const token of trace.connectsTo ?? []) {
+    const traceTokens = [
+      trace.connection_name,
+      trace.pcb_trace_id,
+      ...(trace.connectsTo ?? []),
+    ]
+    const knownNetKeys = getKnownNetKeys(tokenNetKeys, traceTokens)
+    if (knownNetKeys.size !== 1) continue
+    const netKey = [...knownNetKeys][0]!
+    connectionNetKeys.set(trace.connection_name, netKey)
+    for (const token of traceTokens) {
       addTokenNet(tokenNetKeys, token, netKey)
     }
   }

package/lib/route-bus.ts

@@ -11,6 +11,7 @@ import {
   segmentsAreClear,
 } from "./geometry"
 import { createFanoutOutputIds } from "./fanout-output-ids"
+import { getAllRoutedTraceCopper } from "./get-routed-trace-copper"
 import { getLayerSpan } from "./layer-names"
 import {
   connectionsShareElectricalNet,
@@ -1000,6 +1001,66 @@ function planIsStaticallyClear(params: {
     }
   }
 
+  for (const traceCopper of getAllRoutedTraceCopper(srj)) {
+    if (
+      plan.connectionName === traceCopper.connectionName ||
+      (allowSameNetMerges &&
+        connectionsShareElectricalNet(
+          srj,
+          plan.connectionName,
+          traceCopper.connectionName,
+        ))
+    ) {
+      continue
+    }
+    for (const segment of getPlanSegments(plan)) {
+      for (const existingSegment of traceCopper.segments) {
+        if (!segmentsAreClear(segment, existingSegment, clearance)) {
+          return false
+        }
+      }
+      for (const existingVia of traceCopper.vias) {
+        if (
+          existingVia.spanLayers.includes(segment.layer) &&
+          distancePointToSegment(
+            existingVia.center,
+            segment.start,
+            segment.end,
+          ) <
+            existingVia.diameter / 2 + segment.width / 2 + clearance - 1e-9
+        ) {
+          return false
+        }
+      }
+    }
+    for (const via of getPlanVias(plan)) {
+      for (const existingSegment of traceCopper.segments) {
+        if (
+          via.spanLayers.includes(existingSegment.layer) &&
+          distancePointToSegment(
+            via.center,
+            existingSegment.start,
+            existingSegment.end,
+          ) <
+            via.diameter / 2 + existingSegment.width / 2 + clearance - 1e-9
+        ) {
+          return false
+        }
+      }
+      for (const existingVia of traceCopper.vias) {
+        if (
+          via.spanLayers.some((layer) =>
+            existingVia.spanLayers.includes(layer),
+          ) &&
+          distance(via.center, existingVia.center) <
+            (via.diameter + existingVia.diameter) / 2 + clearance - 1e-9
+        ) {
+          return false
+        }
+      }
+    }
+  }
+
   return true
 }
 

package/lib/validate-fanout-solution.ts

@@ -15,6 +15,7 @@ import {
   connectionsShareElectricalNet,
   obstacleSharesElectricalNet,
 } from "./net-identity"
+import { getAllRoutedTraceCopper } from "./get-routed-trace-copper"
 import type {
   Bounds,
   FanoutRoutePlan,
@@ -664,6 +665,89 @@ function validateClearances(params: {
         }
       }
     }
+
+    for (const traceCopper of getAllRoutedTraceCopper(inputSrj)) {
+      if (
+        plan.connectionName === traceCopper.connectionName ||
+        connectionsShareElectricalNet(
+          inputSrj,
+          plan.connectionName,
+          traceCopper.connectionName,
+        )
+      ) {
+        continue
+      }
+      for (const segment of getPlanSegments(plan)) {
+        for (const existingSegment of traceCopper.segments) {
+          if (!segmentsAreClear(segment, existingSegment, clearance)) {
+            addIssue(
+              issues,
+              "different-net-trace-clearance",
+              `Trace ${plan.connectionName} violates routed trace ${traceCopper.trace.pcb_trace_id} on ${segment.layer}`,
+              plan,
+              traceCopper.connectionName,
+            )
+          }
+        }
+        for (const existingVia of traceCopper.vias) {
+          if (
+            existingVia.spanLayers.includes(segment.layer) &&
+            distancePointToSegment(
+              existingVia.center,
+              segment.start,
+              segment.end,
+            ) <
+              existingVia.diameter / 2 + segment.width / 2 + clearance - 1e-9
+          ) {
+            addIssue(
+              issues,
+              "different-net-trace-via-clearance",
+              `Trace ${plan.connectionName} violates a via in routed trace ${traceCopper.trace.pcb_trace_id} on ${segment.layer}`,
+              plan,
+              traceCopper.connectionName,
+            )
+          }
+        }
+      }
+      for (const via of getPlanVias(plan)) {
+        for (const existingSegment of traceCopper.segments) {
+          if (
+            via.spanLayers.includes(existingSegment.layer) &&
+            distancePointToSegment(
+              via.center,
+              existingSegment.start,
+              existingSegment.end,
+            ) <
+              via.diameter / 2 + existingSegment.width / 2 + clearance - 1e-9
+          ) {
+            addIssue(
+              issues,
+              "different-net-trace-via-clearance",
+              `Via ${plan.connectionName} violates routed trace ${traceCopper.trace.pcb_trace_id} on ${existingSegment.layer}`,
+              plan,
+              traceCopper.connectionName,
+            )
+          }
+        }
+        for (const existingVia of traceCopper.vias) {
+          if (
+            via.spanLayers.some((layer) =>
+              existingVia.spanLayers.includes(layer),
+            ) &&
+            distance(via.center, existingVia.center) <
+              (via.diameter + existingVia.diameter) / 2 + clearance - 1e-9
+          ) {
+            addIssue(
+              issues,
+              "different-net-via-clearance",
+              `Via ${plan.connectionName} violates a via in routed trace ${traceCopper.trace.pcb_trace_id}`,
+              plan,
+              traceCopper.connectionName,
+            )
+          }
+        }
+      }
+    }
   }
 
   for (let firstIndex = 0; firstIndex < plans.length; firstIndex++) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/fanout-solver",
-  "version": "0.0.32",
+  "version": "0.0.33",
   "description": "BGA fanout solver with coordinated bus-layer escapes for SimpleRouteJson",
   "module": "lib/index.ts",
   "type": "module",