@tscircuit/matchpack 0.0.13 → 0.0.14

package/dist/index.d.ts

@@ -77,35 +77,6 @@ type InputProblem = {
     inferDecouplingCaps?: boolean;
 };
 
-/**
- * Creates partitions (small subset groups) surrounding complex chips.
- * Divides the layout problem into manageable sections for more efficient processing.
- */
-
-declare class ChipPartitionsSolver extends BaseSolver {
-    inputProblem: InputProblem;
-    partitions: InputProblem[];
-    constructor(inputProblem: InputProblem);
-    _step(): void;
-    /**
-     * Creates partitions by finding connected components through strong pin connections
-     */
-    private createPartitions;
-    /**
-     * Finds the owner chip of a given pin
-     */
-    private findPinOwner;
-    /**
-     * Depth-first search to find connected components
-     */
-    private dfs;
-    /**
-     * Creates a new InputProblem containing only the components in the given partition
-     */
-    private createInputProblemFromPartition;
-    visualize(): GraphicsObject;
-}
-
 /**
  * Identifies decoupling capacitor groups based on specific criteria:
  * 1. Component has exactly 2 pins and restricted rotation (0/180 only or no rotation)
@@ -116,6 +87,7 @@ declare class ChipPartitionsSolver extends BaseSolver {
 interface DecouplingCapGroup {
     decouplingCapGroupId: string;
     mainChipId: ChipId;
+    netPair: [NetId, NetId];
     decouplingCapChipIds: ChipId[];
 }
 /**
@@ -128,7 +100,7 @@ declare class IdentifyDecouplingCapsSolver extends BaseSolver {
     inputProblem: InputProblem;
     queuedChips: Chip[];
     outputDecouplingCapGroups: DecouplingCapGroup[];
-    /** Quick lookup of groups by main chip for accumulation */
+    /** Quick lookup of groups by main chip and net pair for accumulation */
     private groupsByMainChipId;
     constructor(inputProblem: InputProblem);
     /** Determine if chip is a 2-pin component with restricted rotation */
@@ -139,14 +111,54 @@ declare class IdentifyDecouplingCapsSolver extends BaseSolver {
     private getStronglyConnectedNeighborChips;
     /** Find the main chip id for a decoupling capacitor candidate */
     private findMainChipIdForCap;
-    /** Adds a decoupling capacitor to the group for the given main chip */
+    /** Get all net IDs connected to a pin */
+    private getNetIdsForPin;
+    /** Get a normalized, sorted pair of net IDs connected across the two pins of a capacitor chip */
+    private getNormalizedNetPair;
+    /** Adds a decoupling capacitor to the group for the given main chip and net pair */
     private addToGroup;
+    lastChip: Chip | null;
     _step(): void;
     visualize(): GraphicsObject;
     getConstructorParams(): [InputProblem];
     computeProgress(): number;
 }
 
+/**
+ * Creates partitions (small subset groups) surrounding complex chips.
+ * Divides the layout problem into manageable sections for more efficient processing.
+ */
+
+declare class ChipPartitionsSolver extends BaseSolver {
+    inputProblem: InputProblem;
+    partitions: InputProblem[];
+    decouplingCapGroups?: DecouplingCapGroup[];
+    constructor({ inputProblem, decouplingCapGroups, }: {
+        inputProblem: InputProblem;
+        decouplingCapGroups?: DecouplingCapGroup[];
+    });
+    _step(): void;
+    /**
+     * Creates partitions by:
+     * - Separating each decoupling capacitor group into its own partition (caps only, excluding the main chip)
+     * - Partitioning remaining chips by connected components through strong pin connections
+     */
+    private createPartitions;
+    /**
+     * Finds the owner chip of a given pin
+     */
+    private findPinOwner;
+    /**
+     * Depth-first search to find connected components
+     */
+    private dfs;
+    /**
+     * Creates a new InputProblem containing only the components in the given partition
+     */
+    private createInputProblemFromPartition;
+    visualize(): GraphicsObject;
+}
+
 type Placement = Point & {
     ccwRotationDegrees: number;
 };

package/dist/index.js

@@ -317,21 +317,45 @@ function doBasicInputProblemLayout(inputProblem) {
 var ChipPartitionsSolver = class extends BaseSolver {
   inputProblem;
   partitions = [];
-  constructor(inputProblem) {
+  decouplingCapGroups;
+  constructor({
+    inputProblem,
+    decouplingCapGroups
+  }) {
     super();
     this.inputProblem = inputProblem;
+    this.decouplingCapGroups = decouplingCapGroups;
   }
   _step() {
     this.partitions = this.createPartitions(this.inputProblem);
     this.solved = true;
   }
   /**
-   * Creates partitions by finding connected components through strong pin connections
+   * Creates partitions by:
+   * - Separating each decoupling capacitor group into its own partition (caps only, excluding the main chip)
+   * - Partitioning remaining chips by connected components through strong pin connections
    */
   createPartitions(inputProblem) {
     const chipIds = Object.keys(inputProblem.chipMap);
+    const decapChipIdSet = /* @__PURE__ */ new Set();
+    const decapGroupPartitions = [];
+    if (this.decouplingCapGroups && this.decouplingCapGroups.length > 0) {
+      for (const group of this.decouplingCapGroups) {
+        const capsOnly = [];
+        for (const capId of group.decouplingCapChipIds) {
+          if (inputProblem.chipMap[capId]) {
+            capsOnly.push(capId);
+            decapChipIdSet.add(capId);
+          }
+        }
+        if (capsOnly.length > 0) {
+          decapGroupPartitions.push(capsOnly);
+        }
+      }
+    }
+    const nonDecapChipIds = chipIds.filter((id) => !decapChipIdSet.has(id));
     const adjacencyMap = /* @__PURE__ */ new Map();
-    for (const chipId of chipIds) {
+    for (const chipId of nonDecapChipIds) {
       adjacencyMap.set(chipId, /* @__PURE__ */ new Set());
     }
     for (const [connKey, isConnected] of Object.entries(
@@ -341,22 +365,23 @@ var ChipPartitionsSolver = class extends BaseSolver {
       const [pin1Id, pin2Id] = connKey.split("-");
       const owner1 = this.findPinOwner(pin1Id, inputProblem);
       const owner2 = this.findPinOwner(pin2Id, inputProblem);
-      if (owner1 && owner2 && owner1 !== owner2) {
+      if (owner1 && owner2 && owner1 !== owner2 && !decapChipIdSet.has(owner1) && !decapChipIdSet.has(owner2)) {
         adjacencyMap.get(owner1).add(owner2);
         adjacencyMap.get(owner2).add(owner1);
       }
     }
     const visited = /* @__PURE__ */ new Set();
-    const partitions = [];
-    for (const componentId of chipIds) {
+    const nonDecapPartitions = [];
+    for (const componentId of nonDecapChipIds) {
       if (!visited.has(componentId)) {
         const partition = this.dfs(componentId, adjacencyMap, visited);
         if (partition.length > 0) {
-          partitions.push(partition);
+          nonDecapPartitions.push(partition);
         }
       }
     }
-    return partitions.map(
+    const allPartitions = [...decapGroupPartitions, ...nonDecapPartitions];
+    return allPartitions.map(
       (partition) => this.createInputProblemFromPartition(partition, inputProblem)
     );
   }
@@ -468,10 +493,13 @@ var ChipPartitionsSolver = class extends BaseSolver {
 
 // lib/utils/getColorFromString.ts
 var getColorFromString = (string, alpha = 1) => {
-  const hash = string.split("").reduce((acc, char) => {
-    return acc * 31 + char.charCodeAt(0);
-  }, 0);
-  return `hsl(${hash % 360}, 100%, 50%, ${alpha})`;
+  let hash = 0;
+  for (let i = 0; i < string.length; i++) {
+    const char = string.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return `hsl(${Math.abs(hash) % 360}, 70%, 50%, ${alpha})`;
 };
 
 // lib/solvers/IdentifyDecouplingCapsSolver/IdentifyDecouplingCapsSolver.ts
@@ -479,7 +507,7 @@ var IdentifyDecouplingCapsSolver = class extends BaseSolver {
   inputProblem;
   queuedChips;
   outputDecouplingCapGroups = [];
-  /** Quick lookup of groups by main chip for accumulation */
+  /** Quick lookup of groups by main chip and net pair for accumulation */
   groupsByMainChipId = /* @__PURE__ */ new Map();
   constructor(inputProblem) {
     super();
@@ -539,33 +567,64 @@ var IdentifyDecouplingCapsSolver = class extends BaseSolver {
     }
     return best ? best.id : null;
   }
-  /** Adds a decoupling capacitor to the group for the given main chip */
-  addToGroup(mainChipId, capChipId) {
-    let group = this.groupsByMainChipId.get(mainChipId);
+  /** Get all net IDs connected to a pin */
+  getNetIdsForPin(pinId) {
+    const nets = /* @__PURE__ */ new Set();
+    for (const [connKey, connected] of Object.entries(
+      this.inputProblem.netConnMap
+    )) {
+      if (!connected) continue;
+      const [p, n] = connKey.split("-");
+      if (p === pinId) nets.add(n);
+    }
+    return nets;
+  }
+  /** Get a normalized, sorted pair of net IDs connected across the two pins of a capacitor chip */
+  getNormalizedNetPair(capChip) {
+    if (capChip.pins.length !== 2) return null;
+    const nets = /* @__PURE__ */ new Set();
+    for (const pinId of capChip.pins) {
+      const pinNets = this.getNetIdsForPin(pinId);
+      for (const n of pinNets) nets.add(n);
+    }
+    if (nets.size !== 2) return null;
+    const [a, b] = Array.from(nets).sort();
+    return [a, b];
+  }
+  /** Adds a decoupling capacitor to the group for the given main chip and net pair */
+  addToGroup(mainChipId, netPair, capChipId) {
+    const [n1, n2] = netPair;
+    const groupKey = `${mainChipId}__${n1}__${n2}`;
+    let group = this.groupsByMainChipId.get(groupKey);
     if (!group) {
       group = {
-        decouplingCapGroupId: `decap_group_${mainChipId}`,
+        decouplingCapGroupId: `decap_group_${mainChipId}__${n1}__${n2}`,
         mainChipId,
+        netPair: [n1, n2],
         decouplingCapChipIds: []
       };
-      this.groupsByMainChipId.set(mainChipId, group);
+      this.groupsByMainChipId.set(groupKey, group);
       this.outputDecouplingCapGroups.push(group);
     }
     if (!group.decouplingCapChipIds.includes(capChipId)) {
       group.decouplingCapChipIds.push(capChipId);
     }
   }
+  lastChip = null;
   _step() {
     const currentChip = this.queuedChips.shift();
+    this.lastChip = currentChip ?? null;
     if (!currentChip) {
       this.solved = true;
       return;
     }
-    const candidate = this.isTwoPinRestrictedRotation(currentChip) && this.pinsOnOppositeYSides(currentChip);
-    if (!candidate) return;
+    const isDecouplingCap = this.isTwoPinRestrictedRotation(currentChip) && this.pinsOnOppositeYSides(currentChip);
+    if (!isDecouplingCap) return;
     const mainChipId = this.findMainChipIdForCap(currentChip);
     if (!mainChipId) return;
-    this.addToGroup(mainChipId, currentChip.chipId);
+    const netPair = this.getNormalizedNetPair(currentChip);
+    if (!netPair) return;
+    this.addToGroup(mainChipId, netPair, currentChip.chipId);
   }
   visualize() {
     const basicLayout = doBasicInputProblemLayout(this.inputProblem);
@@ -573,38 +632,25 @@ var IdentifyDecouplingCapsSolver = class extends BaseSolver {
       this.inputProblem,
       basicLayout
     );
-    const chipRoleMap = /* @__PURE__ */ new Map();
+    const chipDecapGroupMap = /* @__PURE__ */ new Map();
     for (const group of this.outputDecouplingCapGroups) {
-      const color = getColorFromString(group.mainChipId, 0.8);
-      chipRoleMap.set(group.mainChipId, { type: "main", color });
+      chipDecapGroupMap.set(group.mainChipId, group);
       for (const capChipId of group.decouplingCapChipIds) {
-        chipRoleMap.set(capChipId, { type: "decap", color });
+        chipDecapGroupMap.set(capChipId, group);
       }
     }
     for (const rect of graphics.rects || []) {
-      rect.fill = "rgba(0,0,0,0.5)";
+      if (rect.label !== this.lastChip?.chipId) {
+        rect.fill = "rgba(0,0,0,0.5)";
+      }
     }
     for (const rect of graphics.rects || []) {
       const chipId = rect.label;
-      const role = chipRoleMap.get(chipId);
-      if (!role) continue;
-      const alpha = role.type === "main" ? 0.18 : 0.36;
+      const group = chipDecapGroupMap.get(chipId);
+      if (!group) continue;
       rect.label = `${rect.label}
-${role.type}`;
-      rect.fill = getColorFromString(role.color, alpha);
-    }
-    if (!graphics.texts) graphics.texts = [];
-    for (const rect of graphics.rects || []) {
-      const chipId = rect.label;
-      const role = chipRoleMap.get(chipId);
-      if (!role) continue;
-      graphics.texts.push({
-        x: rect.center.x,
-        y: rect.center.y - (rect.height || 0) / 2,
-        text: role.type === "main" ? "MAIN" : "DECAP",
-        fillColor: role.type === "main" ? role.color : "rgba(0,0,0,0.6)",
-        fontSize: 8
-      });
+${group.decouplingCapGroupId}`;
+      rect.fill = getColorFromString(group.decouplingCapGroupId, 0.8);
     }
     return graphics;
   }
@@ -1213,7 +1259,12 @@ var LayoutPipelineSolver = class extends BaseSolver {
     definePipelineStep(
       "chipPartitionsSolver",
       ChipPartitionsSolver,
-      () => [this.inputProblem],
+      () => [
+        {
+          inputProblem: this.inputProblem,
+          decouplingCapGroups: this.identifyDecouplingCapsSolver?.outputDecouplingCapGroups
+        }
+      ],
       {
         onSolved: (_layoutSolver) => {
           this.chipPartitions = this.chipPartitionsSolver.partitions;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@tscircuit/matchpack",
   "main": "dist/index.js",
   "type": "module",
-  "version": "0.0.13",
+  "version": "0.0.14",
   "files": [
     "dist"
   ],
@@ -23,7 +23,7 @@
     "bpc-graph": "^0.0.66",
     "calculate-packing": "^0.0.31",
     "circuit-json": "^0.0.226",
-    "graphics-debug": "^0.0.62",
+    "graphics-debug": "^0.0.64",
     "react-cosmos": "^7.0.0",
     "react-cosmos-plugin-vite": "^7.0.0",
     "tscircuit": "^0.0.593",