fix: enforce Pipeline9 bus layers per connection

Author: ShiboSoftwareDev

lib/autorouter-pipelines/AutoroutingPipeline9_PreloadedTraceGraph/add-pipeline9-connection-allowed-z-to-port-points.ts

@@ -0,0 +1,34 @@
+import type {
+  AllowedZByConnectionName,
+  NodeWithPortPoints,
+  PortPoint,
+} from "lib/types/high-density-types"
+
+const addAllowedZToPortPoint = ({
+  portPoint,
+  allowedZByConnectionName,
+}: {
+  portPoint: PortPoint
+  allowedZByConnectionName: AllowedZByConnectionName
+}): PortPoint => {
+  const allowedZ = allowedZByConnectionName[portPoint.connectionName]
+  return allowedZ ? { ...portPoint, allowedZ } : portPoint
+}
+
+export const addPipeline9ConnectionAllowedZToPortPoints = ({
+  nodes,
+  allowedZByConnectionName,
+}: {
+  nodes: NodeWithPortPoints[]
+  allowedZByConnectionName: AllowedZByConnectionName
+}): NodeWithPortPoints[] =>
+  nodes.map((node) => ({
+    ...node,
+    portPoints: node.portPoints.map((portPoint) =>
+      addAllowedZToPortPoint({ portPoint, allowedZByConnectionName }),
+    ),
+    portPointsInPairs: node.portPointsInPairs?.map(([start, end]) => [
+      addAllowedZToPortPoint({ portPoint: start, allowedZByConnectionName }),
+      addAllowedZToPortPoint({ portPoint: end, allowedZByConnectionName }),
+    ]),
+  }))

lib/autorouter-pipelines/AutoroutingPipeline9_PreloadedTraceGraph/assert-pipeline9-traces-use-allowed-z.ts

@@ -0,0 +1,27 @@
+import type { SimplifiedPcbTraces } from "lib/types"
+import type { AllowedZByConnectionName } from "lib/types/high-density-types"
+import { mapLayerNameToZ } from "lib/utils/mapLayerNameToZ"
+
+export const assertPipeline9TracesUseAllowedZ = ({
+  traces,
+  allowedZByConnectionName,
+  layerCount,
+}: {
+  traces: SimplifiedPcbTraces
+  allowedZByConnectionName: AllowedZByConnectionName
+  layerCount: number
+}): void => {
+  for (const trace of traces) {
+    const allowedZ = allowedZByConnectionName[trace.connection_name]
+    if (!allowedZ) continue
+    const disallowedWire = trace.route.find(
+      (routePoint) =>
+        routePoint.route_type === "wire" &&
+        !allowedZ.includes(mapLayerNameToZ(routePoint.layer, layerCount)),
+    )
+    if (disallowedWire?.route_type !== "wire") continue
+    throw new Error(
+      `Pipeline9 routed "${trace.connection_name}" on disallowed layer "${disallowedWire.layer}"`,
+    )
+  }
+}

lib/autorouter-pipelines/AutoroutingPipeline9_PreloadedTraceGraph/autorouting-pipeline-solver9-preloaded-trace-graph.ts

@@ -27,6 +27,7 @@ import {
   SimplifiedPcbTraces,
 } from "lib/types"
 import {
+  AllowedZByConnectionName,
   HighDensityRoute,
   NodeWithPortPoints,
 } from "lib/types/high-density-types"
@@ -66,8 +67,11 @@ import { SingleLayerNodeMergerSolver } from "../../solvers/SingleLayerNodeMerger
 import { StrawSolver } from "../../solvers/StrawSolver/StrawSolver"
 import { TraceSimplificationSolver } from "../../solvers/TraceSimplificationSolver/TraceSimplificationSolver"
 import { TraceWidthSolver } from "../../solvers/TraceWidthSolver/TraceWidthSolver"
+import { addPipeline9ConnectionAllowedZToPortPoints } from "./add-pipeline9-connection-allowed-z-to-port-points"
 import { applyFixedRouteReplacementsToPreloadedTraces } from "./apply-fixed-route-replacements-to-preloaded-traces"
+import { assertPipeline9TracesUseAllowedZ } from "./assert-pipeline9-traces-use-allowed-z"
 import { assignUniquePcbTraceIdsToNewTraces } from "./assign-unique-pcb-trace-ids-to-new-traces"
+import { getPipeline9AllowedZByConnectionName } from "./get-pipeline9-allowed-z-by-connection-name"
 import { getPipeline9NetByConnectionName } from "./get-pipeline9-net-by-connection-name"
 import {
   getMaterializedPreloadedSectionHdRoutes,
@@ -298,6 +302,7 @@ export class AutoroutingPipelineSolver9_PreloadedTraceGraph extends BaseSolver {
   /** Available segment points after non-component cramped points are filtered. */
   sharedEdgeSegmentsWithNecessaryCrampedPortPoints?: SharedEdgeSegment[]
   highDensityNodePortPoints?: NodeWithPortPoints[]
+  allowedZByConnectionName: AllowedZByConnectionName = {}
 
   cacheProvider: CacheProvider | null = null
   pipelineDef = [
@@ -354,6 +359,13 @@ export class AutoroutingPipelineSolver9_PreloadedTraceGraph extends BaseSolver {
         onSolved: (cms) => {
           cms.srjWithPointPairs =
             cms.netToPointPairsSolver?.getNewSimpleRouteJson()
+          cms.allowedZByConnectionName = getPipeline9AllowedZByConnectionName({
+            srj: cms.originalSrj,
+            connections: [
+              ...cms.originalSrj.connections,
+              ...cms.srjWithPointPairs!.connections,
+            ],
+          })
           cms.colorMap = getColorMap(cms.srjWithPointPairs!, cms.connMap)
           cms.connMap = getConnectivityMapFromSimpleRouteJson(
             cms.srjWithPointPairs!,
@@ -527,6 +539,7 @@ export class AutoroutingPipelineSolver9_PreloadedTraceGraph extends BaseSolver {
             effort: cms.effort,
             preserveTerminalPcbPortIds: true,
             minViaPadDiameter: cms.viaDiameter,
+            allowedZByConnectionName: cms.allowedZByConnectionName,
             flags: {
               FORCE_CENTER_FIRST: true,
               RIPPING_ENABLED: true,
@@ -587,8 +600,14 @@ export class AutoroutingPipelineSolver9_PreloadedTraceGraph extends BaseSolver {
         const uniformNodes =
           cms.uniformPortDistributionSolver?.getOutput() ?? []
         const fallbackNodes = portPointPathingOutput.nodesWithPortPoints
-        const nodePortPointsSource =
+        const unconstrainedNodePortPointsSource =
           uniformNodes.length > 0 ? uniformNodes : fallbackNodes
+        const nodePortPointsSource = addPipeline9ConnectionAllowedZToPortPoints(
+          {
+            nodes: unconstrainedNodePortPointsSource,
+            allowedZByConnectionName: cms.allowedZByConnectionName,
+          },
+        )
 
         cms.highDensityNodePortPoints = structuredClone(nodePortPointsSource)
         const originalFixedHdRoutes = (cms.originalSrj.traces ?? []).flatMap(
@@ -1458,6 +1477,11 @@ export class AutoroutingPipelineSolver9_PreloadedTraceGraph extends BaseSolver {
       defaultViaHoleDiameter: this.viaHoleDiameter,
       connMap: this.connMap,
     })
+    assertPipeline9TracesUseAllowedZ({
+      traces: routedTraces,
+      allowedZByConnectionName: this.allowedZByConnectionName,
+      layerCount: this.srj.layerCount,
+    })
     return assignUniquePcbTraceIdsToNewTraces(
       routedTraces,
       this.originalSrj.traces ?? [],
@@ -1485,12 +1509,18 @@ export class AutoroutingPipelineSolver9_PreloadedTraceGraph extends BaseSolver {
         "Pipeline9 invariant violated: solved pipeline is missing the unconditional power-trace expansion solver",
       )
     }
-    return [
+    const traces = [
       ...this.getPowerTraceExpansionFixedTraces().filter(
         (trace) => trace.__replaces_pcb_trace_id !== undefined,
       ),
       ...this.powerTraceExpansionSolver.getOutput(),
     ]
+    assertPipeline9TracesUseAllowedZ({
+      traces,
+      allowedZByConnectionName: this.allowedZByConnectionName,
+      layerCount: this.srj.layerCount,
+    })
+    return traces
   }
 
   getOutputSimpleRouteJson(): SimpleRouteJson {
@@ -1506,6 +1536,11 @@ export class AutoroutingPipelineSolver9_PreloadedTraceGraph extends BaseSolver {
       ...this.getPowerTraceExpansionFixedTraces(),
       ...this.powerTraceExpansionSolver.getOutput(),
     ]
+    assertPipeline9TracesUseAllowedZ({
+      traces,
+      allowedZByConnectionName: this.allowedZByConnectionName,
+      layerCount: this.srj.layerCount,
+    })
     return {
       ...this.originalSrj,
       traces,

lib/autorouter-pipelines/AutoroutingPipeline9_PreloadedTraceGraph/get-pipeline9-allowed-z-by-connection-name.ts

@@ -0,0 +1,59 @@
+import type { SimpleRouteConnection, SimpleRouteJson } from "lib/types"
+import type { AllowedZByConnectionName } from "lib/types/high-density-types"
+import type { ConnectionName } from "lib/types/srj-types"
+import { getUniqueValidZLayersFromLayerNames } from "lib/utils/mapLayerNameToZ"
+
+export const getPipeline9AllowedZByConnectionName = ({
+  srj,
+  connections,
+}: {
+  srj: SimpleRouteJson
+  connections: SimpleRouteConnection[]
+}): AllowedZByConnectionName => {
+  const busAllowedZByConnectionName = new Map<ConnectionName, number[][]>()
+  for (const bus of srj.buses ?? []) {
+    if (!bus.allowedLayers) continue
+    const allowedZ = getUniqueValidZLayersFromLayerNames(
+      bus.allowedLayers,
+      srj.layerCount,
+    )
+    if (allowedZ.length === 0) {
+      throw new Error(`Bus "${bus.busId}" does not allow a valid board layer`)
+    }
+    for (const connectionName of bus.connectionNames) {
+      const constraints = busAllowedZByConnectionName.get(connectionName) ?? []
+      constraints.push(allowedZ)
+      busAllowedZByConnectionName.set(connectionName, constraints)
+    }
+  }
+
+  const allowedZByConnectionName: Record<ConnectionName, readonly number[]> = {}
+  for (const connection of connections) {
+    const rootConnectionNames = new Set([
+      connection.name,
+      connection.rootConnectionName,
+      ...(connection.__rootConnectionNames ?? []),
+    ])
+    const constraints = [...rootConnectionNames].flatMap((connectionName) =>
+      connectionName
+        ? (busAllowedZByConnectionName.get(connectionName) ?? [])
+        : [],
+    )
+    if (constraints.length === 0) continue
+
+    const allowedZ = constraints
+      .slice(1)
+      .reduce(
+        (intersection, current) =>
+          intersection.filter((z) => current.includes(z)),
+        constraints[0]!,
+      )
+    if (allowedZ.length === 0) {
+      throw new Error(
+        `Connection "${connection.name}" has incompatible bus layer constraints`,
+      )
+    }
+    allowedZByConnectionName[connection.name] = allowedZ
+  }
+  return allowedZByConnectionName
+}

lib/autorouter-pipelines/AutoroutingPipeline9_PreloadedTraceGraph/pipeline9-high-density-solver.ts

@@ -61,6 +61,42 @@ type NodeBounds = {
 
 const PRELOADED_TRACE_CLEARANCE = 0.15
 
+type NodeLayerConstraint =
+  | { kind: "none" }
+  | { kind: "shared"; allowedZ: readonly number[] }
+  | { kind: "mixed" }
+
+const getNodeLayerConstraint = (
+  node: NodeWithPortPoints,
+): NodeLayerConstraint => {
+  const connectionNames = [
+    ...new Set(node.portPoints.map((portPoint) => portPoint.connectionName)),
+  ]
+  const allowedZByConnection = connectionNames.map(
+    (connectionName) =>
+      node.portPoints.find(
+        (portPoint) =>
+          portPoint.connectionName === connectionName && portPoint.allowedZ,
+      )?.allowedZ,
+  )
+  if (allowedZByConnection.every((allowedZ) => allowedZ === undefined)) {
+    return { kind: "none" }
+  }
+  const firstAllowedZ = allowedZByConnection[0]
+  if (
+    !firstAllowedZ ||
+    allowedZByConnection.some(
+      (allowedZ) =>
+        !allowedZ ||
+        allowedZ.length !== firstAllowedZ.length ||
+        allowedZ.some((z, index) => z !== firstAllowedZ[index]),
+    )
+  ) {
+    return { kind: "mixed" }
+  }
+  return { kind: "shared", allowedZ: firstAllowedZ }
+}
+
 const getNodeBounds = (
   node: NodeWithPortPoints,
   margin: number,
@@ -460,13 +496,22 @@ export class Pipeline9HighDensitySolver extends BaseSolver {
       this.activeNode,
       this.connMap,
     )
+    const layerConstraint = getNodeLayerConstraint(normalizedNode)
+    if (layerConstraint.kind === "mixed") {
+      throw new Error(
+        `Pipeline9 cannot use regional fallback for node "${normalizedNode.capacityMeshNodeId}" with mixed per-connection layer constraints`,
+      )
+    }
     const regionalNode = {
       ...normalizedNode,
       // The capacity path fixes each ordinary node to its assigned layers.
       // Once B01 has proved that assignment unroutable, the regional repair
       // must be able to add a legal layer transition; board obstacles still
       // constrain which of these layers it can actually use.
-      availableZ: Array.from({ length: this.layerCount }, (_, z) => z),
+      availableZ:
+        layerConstraint.kind === "shared"
+          ? [...layerConstraint.allowedZ]
+          : Array.from({ length: this.layerCount }, (_, z) => z),
     }
     const fallbackProblem = createRegionalFallbackProblem(
       regionalNode,
@@ -907,17 +952,27 @@ export class Pipeline9HighDensitySolver extends BaseSolver {
       return
     }
 
-    const nodeBounds = getNodeBounds(node, this.obstacleMargin)
+    const layerConstraint = getNodeLayerConstraint(node)
+    const routableNode =
+      layerConstraint.kind === "shared"
+        ? { ...node, availableZ: [...layerConstraint.allowedZ] }
+        : node
+    const nodeBounds = getNodeBounds(routableNode, this.obstacleMargin)
     const routedCopperRadius = Math.max(this.traceWidth, this.viaDiameter) / 2
     const fixedObstacles = this.getUpdatedFixedHdRoutes()
       .filter((route) =>
-        routeOverlapsNode(route, node, nodeBounds, routedCopperRadius),
+        routeOverlapsNode(route, routableNode, nodeBounds, routedCopperRadius),
       )
-      .flatMap((route) => convertFixedRouteToB01Obstacles(route, node))
+      .flatMap((route) => convertFixedRouteToB01Obstacles(route, routableNode))
     this.stats.fixedObstacleUses =
       Number(this.stats.fixedObstacleUses ?? 0) + fixedObstacles.length
     if (fixedObstacles.length === 0) {
-      this.startRegularSolver(node)
+      this.startRegularSolver(routableNode)
+      return
+    }
+    if (layerConstraint.kind === "mixed") {
+      this.error = `Pipeline9 cannot route node "${node.capacityMeshNodeId}" with mixed per-connection layer constraints around fixed copper`
+      this.failed = true
       return
     }
 
@@ -926,7 +981,7 @@ export class Pipeline9HighDensitySolver extends BaseSolver {
       .map((obstacle) =>
         convertObstacleToB01Obstacle({
           obstacle,
-          node,
+          node: routableNode,
           connMap: this.connMap,
           layerCount: this.layerCount,
         }),
@@ -938,14 +993,17 @@ export class Pipeline9HighDensitySolver extends BaseSolver {
     this.stats.boardObstacleUses =
       Number(this.stats.boardObstacleUses ?? 0) + boardObstacles.length
 
-    this.activeNode = node
-    if (node.width > 15 || node.height > 15) {
-      this.activeFallbackReason = `B01 node "${node.capacityMeshNodeId}" exceeds the 15x15mm routing limit (${node.width}x${node.height}mm)`
+    this.activeNode = routableNode
+    if (routableNode.width > 15 || routableNode.height > 15) {
+      this.activeFallbackReason = `B01 node "${routableNode.capacityMeshNodeId}" exceeds the 15x15mm routing limit (${routableNode.width}x${routableNode.height}mm)`
       this.startRegionalFallback()
       return
     }
 
-    const normalizedNode = normalizeNodeRootConnectionNames(node, this.connMap)
+    const normalizedNode = normalizeNodeRootConnectionNames(
+      routableNode,
+      this.connMap,
+    )
     this.stats.b01NodeCount = Number(this.stats.b01NodeCount ?? 0) + 1
     this.activeB01Solver = new HighDensitySolverB01({
       ...defaultB01Params,

lib/solvers/HighDensitySolver/HighDensitySolver.ts

@@ -388,9 +388,18 @@ export class HighDensitySolver extends BaseSolver {
       growShrinkSolutionValidator: this.growShrinkSolutionValidator,
       captureSearchDebug: this.captureSearchDebug,
     }
-    this.activeSubSolver = this.useGrowShrinkHighDensityIntraNodeSolver
-      ? new GrowShrinkHighDensityIntraNodeSolver(intraNodeSolverParams)
-      : new PortfolioSingleIntraNodeSolver(intraNodeSolverParams)
+    const nodeAllowedZ = node.availableZ ?? []
+    const requiresPerConnectionLayerConstraints = node.portPoints.some(
+      (portPoint) =>
+        portPoint.allowedZ !== undefined &&
+        (portPoint.allowedZ.length !== nodeAllowedZ.length ||
+          portPoint.allowedZ.some((z, index) => z !== nodeAllowedZ[index])),
+    )
+    this.activeSubSolver = requiresPerConnectionLayerConstraints
+      ? new IntraNodeRouteSolver(intraNodeSolverParams)
+      : this.useGrowShrinkHighDensityIntraNodeSolver
+        ? new GrowShrinkHighDensityIntraNodeSolver(intraNodeSolverParams)
+        : new PortfolioSingleIntraNodeSolver(intraNodeSolverParams)
     this.updateCacheStats()
   }