@tscircuit/matchpack 0.0.22 → 0.0.23

package/dist/index.d.ts

@@ -175,6 +175,30 @@ type OutputLayout = {
     groupPlacements: Record<GroupId, Placement>;
 };
 
+declare class AlignPowerGroundRowsSolver extends BaseSolver {
+    inputProblem: InputProblem;
+    inputLayout: OutputLayout;
+    outputLayout: OutputLayout | null;
+    constructor(params: {
+        inputProblem: InputProblem;
+        inputLayout: OutputLayout;
+    });
+    _step(): void;
+    private isPowerGroundNet;
+    private getPinNetIds;
+    private getAlignmentGroupId;
+    private getAlignmentGroups;
+    private alignGroup;
+    private createAlignedLayout;
+    visualize(): GraphicsObject;
+    getConstructorParams(): [
+        {
+            inputProblem: InputProblem;
+            inputLayout: OutputLayout;
+        }
+    ];
+}
+
 /**
  * Packs components within a single partition to create an optimal internal layout.
  * Uses a packing algorithm to arrange chips and their connections within the partition.
@@ -266,6 +290,7 @@ declare class LayoutPipelineSolver extends BaseSolver {
     chipPartitionsSolver?: ChipPartitionsSolver;
     packInnerPartitionsSolver?: PackInnerPartitionsSolver;
     partitionPackingSolver?: PartitionPackingSolver;
+    alignPowerGroundRowsSolver?: AlignPowerGroundRowsSolver;
     startTimeOfPhase: Record<string, number>;
     endTimeOfPhase: Record<string, number>;
     timeSpentOnPhase: Record<string, number>;
@@ -274,7 +299,7 @@ declare class LayoutPipelineSolver extends BaseSolver {
     inputProblem: InputProblem;
     chipPartitions?: ChipPartitionsSolver["partitions"];
     packedPartitions?: PackedPartition[];
-    pipelineDef: (PipelineStep<typeof IdentifyDecouplingCapsSolver> | PipelineStep<typeof ChipPartitionsSolver> | PipelineStep<typeof PackInnerPartitionsSolver> | PipelineStep<typeof PartitionPackingSolver>)[];
+    pipelineDef: (PipelineStep<typeof IdentifyDecouplingCapsSolver> | PipelineStep<typeof ChipPartitionsSolver> | PipelineStep<typeof PackInnerPartitionsSolver> | PipelineStep<typeof PartitionPackingSolver> | PipelineStep<typeof AlignPowerGroundRowsSolver>)[];
     constructor(inputProblem: InputProblem);
     currentPipelineStepIndex: number;
     _step(): void;

package/dist/index.js

@@ -712,6 +712,136 @@ ${group.decouplingCapGroupId}`;
   }
 };
 
+// lib/solvers/AlignPowerGroundRowsSolver/AlignPowerGroundRowsSolver.ts
+var AlignPowerGroundRowsSolver = class extends BaseSolver {
+  inputProblem;
+  inputLayout;
+  outputLayout = null;
+  constructor(params) {
+    super();
+    this.inputProblem = params.inputProblem;
+    this.inputLayout = params.inputLayout;
+  }
+  _step() {
+    this.outputLayout = this.createAlignedLayout() ?? this.inputLayout;
+    this.solved = true;
+  }
+  isPowerGroundNet(netId) {
+    const net = this.inputProblem.netMap[netId];
+    return net?.isPositiveVoltageSource === true || net?.isGround === true;
+  }
+  getPinNetIds(pinId) {
+    const netIds = [];
+    for (const [connKey, connected] of Object.entries(
+      this.inputProblem.netConnMap
+    )) {
+      if (!connected) continue;
+      if (!connKey.startsWith(`${pinId}-`)) continue;
+      netIds.push(connKey.slice(pinId.length + 1));
+    }
+    return netIds;
+  }
+  getAlignmentGroupId(chip) {
+    if (chip.fixedPosition || chip.pins.length !== 2) return null;
+    const signalNetIds = /* @__PURE__ */ new Set();
+    let connectedPowerGroundPinCount = 0;
+    for (const pinId of chip.pins) {
+      const pinNetIds = this.getPinNetIds(pinId);
+      if (pinNetIds.length === 0) return null;
+      let pinHasPowerGroundNet = false;
+      for (const netId of pinNetIds) {
+        if (this.isPowerGroundNet(netId)) {
+          pinHasPowerGroundNet = true;
+        } else {
+          signalNetIds.add(netId);
+        }
+      }
+      if (pinHasPowerGroundNet) connectedPowerGroundPinCount++;
+    }
+    if (connectedPowerGroundPinCount === 0) return null;
+    if (signalNetIds.size === 0) return "power-ground";
+    if (signalNetIds.size === 1) return `signal:${[...signalNetIds][0]}`;
+    return null;
+  }
+  getAlignmentGroups() {
+    const chipIds = Object.keys(this.inputProblem.chipMap);
+    if (chipIds.length < 2) return null;
+    const groupMap = /* @__PURE__ */ new Map();
+    for (const chipId of chipIds) {
+      const chip = this.inputProblem.chipMap[chipId];
+      if (!chip) return null;
+      if (!this.inputLayout.chipPlacements[chipId]) return null;
+      const groupId = this.getAlignmentGroupId(chip);
+      if (!groupId) return null;
+      const groupChipIds = groupMap.get(groupId) ?? [];
+      groupChipIds.push(chipId);
+      groupMap.set(groupId, groupChipIds);
+    }
+    return [...groupMap.values()].map((groupChipIds) => ({
+      chipIds: groupChipIds.sort(
+        (chipIdA, chipIdB) => this.inputLayout.chipPlacements[chipIdA].x - this.inputLayout.chipPlacements[chipIdB].x
+      )
+    }));
+  }
+  alignGroup(chipPlacements, chipIds) {
+    if (chipIds.length < 2) return;
+    let cursorX = 0;
+    const rowY = chipIds.reduce(
+      (sum, chipId) => sum + this.inputLayout.chipPlacements[chipId].y,
+      0
+    ) / chipIds.length;
+    const rowCenterX = chipIds.reduce(
+      (sum, chipId) => sum + this.inputLayout.chipPlacements[chipId].x,
+      0
+    ) / chipIds.length;
+    for (const chipId of chipIds) {
+      const chip = this.inputProblem.chipMap[chipId];
+      const originalPlacement = this.inputLayout.chipPlacements[chipId];
+      const isRotated = originalPlacement.ccwRotationDegrees === 90 || originalPlacement.ccwRotationDegrees === 270;
+      const width = isRotated ? chip.size.y : chip.size.x;
+      const x = cursorX + width / 2;
+      chipPlacements[chipId] = {
+        x,
+        y: rowY,
+        ccwRotationDegrees: originalPlacement.ccwRotationDegrees
+      };
+      cursorX += width + this.inputProblem.partitionGap;
+    }
+    const rowWidth = cursorX - this.inputProblem.partitionGap;
+    for (const chipId of chipIds) {
+      chipPlacements[chipId].x += rowCenterX - rowWidth / 2;
+    }
+  }
+  createAlignedLayout() {
+    const groups = this.getAlignmentGroups();
+    if (!groups) return null;
+    const chipPlacements = {
+      ...this.inputLayout.chipPlacements
+    };
+    for (const group of groups) {
+      this.alignGroup(chipPlacements, group.chipIds);
+    }
+    return {
+      chipPlacements,
+      groupPlacements: { ...this.inputLayout.groupPlacements }
+    };
+  }
+  visualize() {
+    return visualizeInputProblem(
+      this.inputProblem,
+      this.outputLayout ?? this.inputLayout
+    );
+  }
+  getConstructorParams() {
+    return [
+      {
+        inputProblem: this.inputProblem,
+        inputLayout: this.inputLayout
+      }
+    ];
+  }
+};
+
 // lib/solvers/PackInnerPartitionsSolver/SingleInnerPartitionPackingSolver.ts
 import { PackSolver2 } from "calculate-packing";
 
@@ -1369,6 +1499,7 @@ var LayoutPipelineSolver = class extends BaseSolver {
   chipPartitionsSolver;
   packInnerPartitionsSolver;
   partitionPackingSolver;
+  alignPowerGroundRowsSolver;
   startTimeOfPhase;
   endTimeOfPhase;
   timeSpentOnPhase;
@@ -1431,6 +1562,16 @@ var LayoutPipelineSolver = class extends BaseSolver {
         onSolved: (_solver) => {
         }
       }
+    ),
+    definePipelineStep(
+      "alignPowerGroundRowsSolver",
+      AlignPowerGroundRowsSolver,
+      () => [
+        {
+          inputProblem: this.inputProblem,
+          inputLayout: this.partitionPackingSolver.finalLayout
+        }
+      ]
     )
   ];
   constructor(inputProblem) {
@@ -1483,6 +1624,9 @@ var LayoutPipelineSolver = class extends BaseSolver {
   visualize() {
     if (!this.solved && this.activeSubSolver)
       return this.activeSubSolver.visualize();
+    if (this.solved && this.alignPowerGroundRowsSolver?.solved) {
+      return this.alignPowerGroundRowsSolver.visualize();
+    }
     if (this.solved && this.partitionPackingSolver?.solved) {
       return this.partitionPackingSolver.visualize();
     }
@@ -1490,6 +1634,7 @@ var LayoutPipelineSolver = class extends BaseSolver {
     const chipPartitionsViz = this.chipPartitionsSolver?.visualize();
     const packInnerPartitionsViz = this.packInnerPartitionsSolver?.visualize();
     const partitionPackingViz = this.partitionPackingSolver?.visualize();
+    const alignPowerGroundRowsViz = this.alignPowerGroundRowsSolver?.visualize();
     const basicLayout = doBasicInputProblemLayout(this.inputProblem);
     const inputViz = visualizeInputProblem(this.inputProblem, basicLayout);
     const visualizations = [
@@ -1497,7 +1642,8 @@ var LayoutPipelineSolver = class extends BaseSolver {
       identifyDecouplingCapsViz,
       chipPartitionsViz,
       packInnerPartitionsViz,
-      partitionPackingViz
+      partitionPackingViz,
+      alignPowerGroundRowsViz
     ].filter(Boolean).map((viz, stepIndex) => {
       for (const rect of viz.rects ?? []) {
         rect.step = stepIndex;
@@ -1533,6 +1679,9 @@ var LayoutPipelineSolver = class extends BaseSolver {
     if (this.activeSubSolver) {
       return this.activeSubSolver.preview();
     }
+    if (this.alignPowerGroundRowsSolver?.solved) {
+      return this.alignPowerGroundRowsSolver.visualize();
+    }
     if (this.partitionPackingSolver?.solved) {
       return this.partitionPackingSolver.visualize();
     }
@@ -1613,7 +1762,9 @@ var LayoutPipelineSolver = class extends BaseSolver {
       );
     }
     let finalLayout;
-    if (this.partitionPackingSolver?.solved && this.partitionPackingSolver.finalLayout) {
+    if (this.alignPowerGroundRowsSolver?.solved && this.alignPowerGroundRowsSolver.outputLayout) {
+      finalLayout = this.alignPowerGroundRowsSolver.outputLayout;
+    } else if (this.partitionPackingSolver?.solved && this.partitionPackingSolver.finalLayout) {
       finalLayout = this.partitionPackingSolver.finalLayout;
     } else {
       throw new Error(

package/package.json

@@ -2,7 +2,7 @@
   "name": "@tscircuit/matchpack",
   "main": "dist/index.js",
   "type": "module",
-  "version": "0.0.22",
+  "version": "0.0.23",
   "files": [
     "dist"
   ],
@@ -28,7 +28,7 @@
     "graphics-debug": "^0.0.95",
     "react-cosmos": "^7.3.0",
     "react-cosmos-plugin-vite": "^7.3.0",
-    "tscircuit": "^0.0.1887",
+    "tscircuit": "^0.0.1891",
     "tsup": "^8.5.1",
     "circuit-to-svg": "^0.0.351"
   },