mohan-bee/four-gang-wifi-switch-layout

default-capacity.test.ts

PCB

Schematic

import { expect, test } from "bun:test"
import { defaultCapacity } from "./default-capacity"
import { validateOriginalEndpointConnectivity, validateRoutedCopperDrc } from "@tscircuit/fanout-solver"

test("default capacity solves a whole phase containing a tree and another net",async()=>{
  const connections=[
    {name:"A",nominalTraceWidth:0.3,pointsToConnect:[{x:-5,y:-6,layer:"top"},{x:0,y:-6,layer:"top"},{x:5,y:-6,layer:"top"}]},
    {name:"B",nominalTraceWidth:0.3,pointsToConnect:[{x:-5,y:-8,layer:"top"},{x:5,y:-8,layer:"top"}]},
  ]
  const input={bounds:{minX:-10,maxX:10,minY:-10,maxY:10},layerCount:2,minTraceWidth:0.3,minTraceToPadEdgeClearance:0.2,minBoardEdgeClearance:0.5,
    connections,obstacles:[{type:"rect" as const,center:{x:0,y:0},width:20,height:6,layers:["top","bottom"],connectedTo:[]},
      ...connections.flatMap(c=>c.pointsToConnect.map(p=>({type:"rect" as const,center:{x:p.x,y:p.y},width:0.6,height:0.6,layers:["top"],connectedTo:[c.name]})))],
  }
  const router=await defaultCapacity({name:"whole-phase-test",side:"below",layer:"top"})(input)
  const traces=await new Promise<any[]>((resolve,reject)=>{
    router.on("complete",e=>resolve(e.traces))
    router.on("error",e=>reject(e.error))
    router.start()
  })
  expect(new Set(traces.map(t=>t.connection_name))).toEqual(new Set(["A","B"]))
  expect(traces.length).toBeGreaterThanOrEqual(3)
  expect(traces.flatMap(t=>t.route).every(p=>p.route_type==="wire"&&p.layer==="top")).toBe(true)
  expect(validateOriginalEndpointConnectivity({inputSrj:input,routedSrj:{...input,traces}}).valid).toBe(true)
},20000)

test("preserved capacity paths keep wide mains copper away from a neighboring pad",async()=>{
  const input={bounds:{minX:-12,maxX:12,minY:-12,maxY:10},layerCount:2,minTraceWidth:2.2,nominalTraceWidth:2.4,minTraceToPadEdgeClearance:1.5,minBoardEdgeClearance:0.5,
    connections:[{name:"LIVE",nominalTraceWidth:2.4,pointsToConnect:[{x:-6,y:-4,layer:"top"},{x:6,y:-4,layer:"top"}]}],
    obstacles:[{type:"rect" as const,center:{x:0,y:4},width:24,height:6,layers:["top","bottom"],connectedTo:[]},
      ...[-6,6].map(x=>({type:"rect" as const,center:{x,y:-4},width:2.2,height:2.2,layers:["top","bottom"],connectedTo:["LIVE"]})),
      {type:"rect" as const,center:{x:0,y:-1.46},width:2.2,height:2.2,layers:["top","bottom"],connectedTo:["OTHER"]}],
  }
  const router=await defaultCapacity({name:"wide-mains-preserved",side:"below",layer:"top",preserveHighDensityPaths:true})(input)
  const traces=await new Promise<any[]>((resolve,reject)=>{
    router.on("complete",e=>resolve(e.traces));router.on("error",e=>reject(e.error));router.start()
  })
  expect(validateOriginalEndpointConnectivity({inputSrj:input,routedSrj:{...input,traces}}).valid).toBe(true)
  expect(validateRoutedCopperDrc({inputSrj:input,routedSrj:{...input,traces},clearance:1.5,allowBlindAndBuriedVias:false}).valid).toBe(true)
  expect(traces.every(t=>t.route.every(p=>p.route_type==="wire"&&p.width>=2.2-1e-5))).toBe(true)
},20000)