Merge pull request #16 from tscircuit/region-zmask

Add support for region z mask, fixes impossible single-layer nodes being created

Author: seveibar

lib/compat/convertToSerializedHyperGraph.ts

@@ -28,6 +28,18 @@ const toObjectRecord = (value: unknown): Record<string, unknown> => {
 const normalizePortIdFallback = (value: string) =>
   value.includes("::") ? value.slice(0, value.indexOf("::")) : value
 
+const getAvailableZFromMask = (mask: number): number[] => {
+  const availableZ: number[] = []
+
+  for (let z = 0; z < 31; z++) {
+    if ((mask & (1 << z)) !== 0) {
+      availableZ.push(z)
+    }
+  }
+
+  return availableZ
+}
+
 const getSerializedRegionId = (
   solver: TinyHyperGraphSolver,
   regionId: RegionId,
@@ -89,6 +101,13 @@ const getSerializedRegionData = (
     data.height = solver.topology.regionHeight[regionId]
   }
 
+  if (!Array.isArray(data.availableZ)) {
+    const availableZMask = solver.topology.regionAvailableZMask?.[regionId] ?? 0
+    if (availableZMask !== 0) {
+      data.availableZ = getAvailableZFromMask(availableZMask)
+    }
+  }
+
   return data
 }
 

lib/compat/loadSerializedHyperGraph.ts

@@ -176,6 +176,25 @@ const getRegionGeometry = (
   }
 }
 
+const getRegionAvailableZMask = (
+  region: SerializedHyperGraph["regions"][number],
+): number => {
+  const availableZ = region.d?.availableZ
+  if (!Array.isArray(availableZ)) {
+    return 0
+  }
+
+  let mask = 0
+  for (const z of availableZ) {
+    if (!Number.isInteger(z) || z < 0 || z >= 31) {
+      continue
+    }
+    mask |= 1 << z
+  }
+
+  return mask
+}
+
 const computePortAngle = (
   port: SerializedHyperGraph["ports"][number],
   region: SerializedHyperGraph["regions"][number] | undefined,
@@ -300,6 +319,7 @@ export const loadSerializedHyperGraph = (
   const regionHeight = new Float64Array(regionCount)
   const regionCenterX = new Float64Array(regionCount)
   const regionCenterY = new Float64Array(regionCount)
+  const regionAvailableZMask = new Int32Array(regionCount)
   const regionNetId = new Int32Array(regionCount).fill(-1)
 
   filteredHyperGraph.regions.forEach((region, regionIndex) => {
@@ -308,6 +328,7 @@ export const loadSerializedHyperGraph = (
     regionHeight[regionIndex] = geometry.height
     regionCenterX[regionIndex] = geometry.centerX
     regionCenterY[regionIndex] = geometry.centerY
+    regionAvailableZMask[regionIndex] = getRegionAvailableZMask(region)
   })
 
   const portAngleForRegion1 = new Int32Array(portCount)
@@ -450,6 +471,7 @@ export const loadSerializedHyperGraph = (
     regionHeight,
     regionCenterX,
     regionCenterY,
+    regionAvailableZMask,
     regionMetadata: filteredHyperGraph.regions.map((region) =>
       addSerializedRegionIdToMetadata(region),
     ),

lib/computeRegionCost.ts

@@ -1,6 +1,10 @@
 const viaSize = 0.45
 const viaSizeSq = viaSize ** 2
 const traceWidth = 0.1
+const IMPOSSIBLE_SINGLE_LAYER_INTERSECTION_COST = 10
+
+const isKnownSingleLayerMask = (regionAvailableZMask: number) =>
+  regionAvailableZMask === 1 || regionAvailableZMask === 2
 
 export const computeRegionCost = (
   regionWidth: number,
@@ -9,6 +13,7 @@ export const computeRegionCost = (
   numCrossLayerIntersections: number,
   numEntryExitChanges: number,
   traceCount: number,
+  regionAvailableZMask = 0,
 ) => {
   const area = regionWidth * regionHeight
 
@@ -18,6 +23,14 @@ export const computeRegionCost = (
     numEntryExitChanges * 1
 
   const traceCountMult = 1 + traceCount / 5
+  const impossibleSingleLayerIntersectionCost = isKnownSingleLayerMask(
+    regionAvailableZMask,
+  )
+    ? numSameLayerIntersections * IMPOSSIBLE_SINGLE_LAYER_INTERSECTION_COST
+    : 0
 
-  return (estViasRequired * viaSizeSq * traceCountMult) / area
+  return (
+    (estViasRequired * viaSizeSq * traceCountMult) / area +
+    impossibleSingleLayerIntersectionCost
+  )
 }

lib/core.ts

@@ -44,6 +44,12 @@ export interface TinyHyperGraphTopology {
   regionHeight: Float64Array
   regionCenterX: Float64Array
   regionCenterY: Float64Array
+  /**
+   * regionAvailableZMask[regionId] is a bitmask of the routed layers available
+   * within the region. A zero mask means "unknown", which preserves legacy cost
+   * behavior for manually-constructed topologies that do not provide this data.
+   */
+  regionAvailableZMask?: Int32Array
 
   /** regionMetadata[regionId] = metadata for the region */
   regionMetadata?: any[]
@@ -392,6 +398,7 @@ export class TinyHyperGraphSolver extends BaseSolver {
       if (problem.portSectionMask[neighborPortId] === 0) continue
 
       const g = this.computeG(currentCandidate, neighborPortId)
+      if (!Number.isFinite(g)) continue
       const h = this.computeH(neighborPortId)
 
       const nextRegionId =
@@ -504,6 +511,11 @@ export class TinyHyperGraphSolver extends BaseSolver {
     )
   }
 
+  isKnownSingleLayerRegion(regionId: RegionId): boolean {
+    const regionAvailableZMask = this.topology.regionAvailableZMask?.[regionId] ?? 0
+    return regionAvailableZMask === 1 || regionAvailableZMask === 2
+  }
+
   populateSegmentGeometryScratch(
     regionId: RegionId,
     port1Id: PortId,
@@ -600,6 +612,7 @@ export class TinyHyperGraphSolver extends BaseSolver {
         existingCrossingLayerIntersections,
         existingEntryExitLayerChanges,
         existingSegmentCount,
+        topology.regionAvailableZMask?.[regionId] ?? 0,
       ),
     }
   }
@@ -787,6 +800,13 @@ export class TinyHyperGraphSolver extends BaseSolver {
       segmentGeometry.entryExitLayerChanges,
     )
 
+    if (
+      newSameLayerIntersections > 0 &&
+      this.isKnownSingleLayerRegion(nextRegionId)
+    ) {
+      return Number.POSITIVE_INFINITY
+    }
+
     const newRegionCost =
       computeRegionCost(
         topology.regionWidth[nextRegionId],
@@ -796,6 +816,7 @@ export class TinyHyperGraphSolver extends BaseSolver {
           newCrossLayerIntersections,
         regionCache.existingEntryExitLayerChanges + newEntryExitLayerChanges,
         regionCache.existingSegmentCount + 1,
+        topology.regionAvailableZMask?.[nextRegionId] ?? 0,
       ) - regionCache.existingRegionCost
 
     return (

tests/compat/region-available-z.test.ts

@@ -0,0 +1,49 @@
+import { expect, test } from "bun:test"
+import type { SerializedHyperGraph } from "@tscircuit/hypergraph"
+import { loadSerializedHyperGraph } from "lib/compat/loadSerializedHyperGraph"
+
+test("loadSerializedHyperGraph maps region availableZ arrays into layer masks", () => {
+  const graph: SerializedHyperGraph = {
+    regions: [
+      {
+        regionId: "single-layer",
+        pointIds: [],
+        d: {
+          center: { x: 0, y: 0 },
+          width: 1,
+          height: 1,
+          availableZ: [0],
+        },
+      },
+      {
+        regionId: "inner-layers",
+        pointIds: [],
+        d: {
+          center: { x: 1, y: 0 },
+          width: 1,
+          height: 1,
+          availableZ: [1, 2],
+        },
+      },
+      {
+        regionId: "unknown",
+        pointIds: [],
+        d: {
+          center: { x: 2, y: 0 },
+          width: 1,
+          height: 1,
+        },
+      },
+    ],
+    ports: [],
+    connections: [],
+  }
+
+  const { topology } = loadSerializedHyperGraph(graph)
+
+  expect(Array.from(topology.regionAvailableZMask ?? [])).toEqual([
+    1 << 0,
+    (1 << 1) | (1 << 2),
+    0,
+  ])
+})

tests/solver/single-layer-region-cost.test.ts

@@ -0,0 +1,72 @@
+import { expect, test } from "bun:test"
+import {
+  type TinyHyperGraphProblem,
+  TinyHyperGraphSolver,
+  type TinyHyperGraphTopology,
+} from "lib/index"
+
+const createTopology = (
+  regionAvailableZMask: number,
+  portZ: number,
+): TinyHyperGraphTopology => ({
+  portCount: 4,
+  regionCount: 2,
+  regionIncidentPorts: [[0, 1, 2, 3], []],
+  incidentPortRegion: [
+    [0, 1],
+    [0, 1],
+    [0, 1],
+    [0, 1],
+  ],
+  regionWidth: new Float64Array([3, 1]),
+  regionHeight: new Float64Array([3, 1]),
+  regionCenterX: new Float64Array(2).fill(0),
+  regionCenterY: new Float64Array(2).fill(0),
+  regionAvailableZMask: new Int32Array([regionAvailableZMask, 0]),
+  portAngleForRegion1: new Int32Array([0, 9000, 18000, 27000]),
+  portAngleForRegion2: new Int32Array(4),
+  portX: new Float64Array([1, 0, -1, 0]),
+  portY: new Float64Array([0, 1, 0, -1]),
+  portZ: new Int32Array([portZ, portZ, portZ, portZ]),
+})
+
+const createProblem = (): TinyHyperGraphProblem => ({
+  routeCount: 2,
+  portSectionMask: new Int8Array(4).fill(1),
+  routeStartPort: new Int32Array([0, 1]),
+  routeEndPort: new Int32Array([2, 3]),
+  routeNet: new Int32Array([0, 1]),
+  regionNetId: new Int32Array(2).fill(-1),
+})
+
+const getCrossingCost = (regionAvailableZMask: number, portZ: number) => {
+  const solver = new TinyHyperGraphSolver(
+    createTopology(regionAvailableZMask, portZ),
+    createProblem(),
+  )
+
+  solver.state.currentRouteNetId = 0
+  solver.appendSegmentToRegionCache(0, 0, 2)
+
+  solver.state.currentRouteNetId = 1
+  return solver.computeG(
+    {
+      nextRegionId: 0,
+      portId: 1,
+      f: 0,
+      g: 0,
+      h: 0,
+    },
+    3,
+  )
+}
+
+test("same-layer crossings in known single-layer regions are rejected as candidates", () => {
+  const topLayerCrossingCost = getCrossingCost(1 << 0, 0)
+  const bottomLayerCrossingCost = getCrossingCost(1 << 1, 1)
+  const multiLayerCrossingCost = getCrossingCost((1 << 0) | (1 << 1), 0)
+
+  expect(topLayerCrossingCost).toBe(Number.POSITIVE_INFINITY)
+  expect(bottomLayerCrossingCost).toBe(Number.POSITIVE_INFINITY)
+  expect(multiLayerCrossingCost).toBeLessThan(0.1)
+})