Handle inferred vias in trace clearance relaxation

Author: imrishabh18

lib/solvers/GlobalDrcForceImproveSolver/traceToPadClearanceRelaxation.ts

@@ -47,6 +47,31 @@ const getRouteViaDiameter = (srj: SimpleRouteJson, route: HighDensityRoute) =>
 const pointsEqual = (left: Point2D, right: Point2D) =>
   distance(left, right) < CLEARANCE_EPSILON
 
+const getRouteViaCenters = (route: HighDensityRoute): Point2D[] => {
+  const viaCenters: Point2D[] = []
+
+  const addViaCenter = (center: Point2D) => {
+    if (viaCenters.some((viaCenter) => pointsEqual(viaCenter, center))) {
+      return
+    }
+    viaCenters.push({ x: center.x, y: center.y })
+  }
+
+  for (const via of route.vias) {
+    addViaCenter(via)
+  }
+
+  for (let i = 0; i < route.route.length - 1; i += 1) {
+    const start = route.route[i]
+    const end = route.route[i + 1]
+    if (!start || !end || start.z === end.z) continue
+    if (!pointsEqual(start, end)) continue
+    addViaCenter(start)
+  }
+
+  return viaCenters
+}
+
 const normalizeVector = (vector: Point2D): Point2D => {
   const magnitude = distance({ x: 0, y: 0 }, vector)
   if (magnitude < CLEARANCE_EPSILON) return { x: 0, y: 0 }
@@ -113,7 +138,7 @@ const getClearanceBlockersForRoute = (
   for (const otherRoute of routes) {
     if (otherRoute === route || routesAreConnected(route, otherRoute)) continue
 
-    for (const via of otherRoute.vias) {
+    for (const via of getRouteViaCenters(otherRoute)) {
       blockers.push({
         kind: "via",
         center: { x: via.x, y: via.y },
@@ -292,7 +317,7 @@ const getRouteOtherTraceClearancePenalty = (
         if (violation > 0) penalty += violation * violation
       }
 
-      for (const via of otherRoute.vias) {
+      for (const via of getRouteViaCenters(otherRoute)) {
         const clearance =
           pointToSegmentDistance(via, start, end) -
           getTraceHalfWidth(srj, route) -

tests/solver-route-behavior.test.ts

@@ -186,6 +186,72 @@ test("does not move a trace away from a same-net pad", () => {
   }
 })
 
+test("moves a trace until its edge clears an inferred different-net via edge", () => {
+  const srj: SimpleRouteJson = {
+    bounds: { minX: -1, minY: -1, maxX: 5, maxY: 3 },
+    connections: [
+      { name: "A", pointsToConnect: [] },
+      { name: "B", pointsToConnect: [] },
+    ],
+    obstacles: [],
+    layerCount: 2,
+    minTraceWidth: 0.1,
+    minViaDiameter: 0.3,
+    minTraceToPadEdgeClearance: 0.2,
+  }
+  const hdRoutes = [
+    {
+      connectionName: "A",
+      route: [
+        { x: 0, y: 0, z: 0 },
+        { x: 0, y: 1.1, z: 0 },
+        { x: 4, y: 1.1, z: 0 },
+        { x: 4, y: 0, z: 0 },
+      ],
+      vias: [],
+      traceThickness: 0.1,
+      viaDiameter: 0.3,
+    },
+    {
+      connectionName: "B",
+      route: [
+        { x: 2, y: 1, z: 0 },
+        { x: 2, y: 1, z: 1 },
+        { x: 2, y: 2, z: 1 },
+      ],
+      vias: [],
+      traceThickness: 0.1,
+      viaDiameter: 0.3,
+    },
+  ]
+  const solver = new GlobalDrcForceImproveSolver({
+    srj,
+    hdRoutes,
+    maxIterations: 1,
+    drcEvaluator: () => [],
+  })
+
+  solver.solve()
+
+  const output = solver.getOutput()
+  const movedStart = output[0]?.route[1]
+  const movedEnd = output[0]?.route[2]
+  const inferredViaCenter = { x: 2, y: 1 }
+  const viaRadius = 0.15
+  const traceHalfWidth = 0.05
+  const requiredClearance = 0.2
+
+  expect(movedStart?.y).toBeGreaterThan(1.1)
+  expect(movedEnd?.y).toBeCloseTo(movedStart!.y, 6)
+  expect(movedStart?.x).toBeCloseTo(0, 6)
+  expect(movedEnd?.x).toBeCloseTo(4, 6)
+  expect(output[1]?.route[0]).toMatchObject(inferredViaCenter)
+  expect(output[1]?.route[1]).toMatchObject(inferredViaCenter)
+  const traceEdgeToViaEdgeClearance =
+    movedStart!.y - inferredViaCenter.y - viaRadius - traceHalfWidth
+  expect(traceEdgeToViaEdgeClearance).toBeGreaterThanOrEqual(requiredClearance)
+})
+
 test("moves a via until its edge clears a different-net pad edge", () => {
   const srj: SimpleRouteJson = {
     bounds: { minX: -2, minY: -2, maxX: 6, maxY: 4 },