@tscircuit/matchpack 0.0.12 → 0.0.14

package/dist/index.d.ts

@@ -47,6 +47,7 @@ type Chip = {
     chipId: ChipId;
     pins: PinId[];
     size: Point;
+    isDecouplingCap?: boolean;
     availableRotations?: Array<0 | 90 | 180 | 270>;
 };
 type Group = {
@@ -73,8 +74,56 @@ type InputProblem = {
     chipGap: number;
     /** The minimum gap between two partitions */
     partitionGap: number;
+    inferDecouplingCaps?: boolean;
 };
 
+/**
+ * Identifies decoupling capacitor groups based on specific criteria:
+ * 1. Component has exactly 2 pins and restricted rotation (0/180 only or no rotation)
+ * 2. One pin indirectly connected to net with "y+" restriction, one to "y-" restriction
+ * 3. At least one pin directly connected to another chip
+ */
+
+interface DecouplingCapGroup {
+    decouplingCapGroupId: string;
+    mainChipId: ChipId;
+    netPair: [NetId, NetId];
+    decouplingCapChipIds: ChipId[];
+}
+/**
+ * Identify decoupling capacitor groups based on specific criteria:
+ * 1. Component has exactly 2 pins and restricted rotation (0/180 only or no rotation)
+ * 2. One pin indirectly connected to net with "y+" restriction, one to "y-" restriction
+ * 3. At least one pin directly connected to a chip (the main chip, typically a microcontroller)
+ */
+declare class IdentifyDecouplingCapsSolver extends BaseSolver {
+    inputProblem: InputProblem;
+    queuedChips: Chip[];
+    outputDecouplingCapGroups: DecouplingCapGroup[];
+    /** 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 */
+    private isTwoPinRestrictedRotation;
+    /** Check that the two pins are on opposite Y sides (y+ and y-) */
+    private pinsOnOppositeYSides;
+    /** Get chips strongly connected (direct pin-to-pin) to this pin */
+    private getStronglyConnectedNeighborChips;
+    /** Find the main chip id for a decoupling capacitor candidate */
+    private findMainChipIdForCap;
+    /** 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.
@@ -83,10 +132,16 @@ type InputProblem = {
 declare class ChipPartitionsSolver extends BaseSolver {
     inputProblem: InputProblem;
     partitions: InputProblem[];
-    constructor(inputProblem: InputProblem);
+    decouplingCapGroups?: DecouplingCapGroup[];
+    constructor({ inputProblem, decouplingCapGroups, }: {
+        inputProblem: InputProblem;
+        decouplingCapGroups?: DecouplingCapGroup[];
+    });
     _step(): void;
     /**
-     * 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
      */
     private createPartitions;
     /**
@@ -186,6 +241,7 @@ type PipelineStep<T extends new (...args: any[]) => BaseSolver> = {
     onSolved?: (instance: LayoutPipelineSolver) => void;
 };
 declare class LayoutPipelineSolver extends BaseSolver {
+    identifyDecouplingCapsSolver?: IdentifyDecouplingCapsSolver;
     chipPartitionsSolver?: ChipPartitionsSolver;
     packInnerPartitionsSolver?: PackInnerPartitionsSolver;
     partitionPackingSolver?: PartitionPackingSolver;
@@ -196,7 +252,7 @@ declare class LayoutPipelineSolver extends BaseSolver {
     inputProblem: InputProblem;
     chipPartitions?: ChipPartitionsSolver["partitions"];
     packedPartitions?: PackedPartition[];
-    pipelineDef: (PipelineStep<typeof ChipPartitionsSolver> | PipelineStep<typeof PackInnerPartitionsSolver> | PipelineStep<typeof PartitionPackingSolver>)[];
+    pipelineDef: (PipelineStep<typeof IdentifyDecouplingCapsSolver> | PipelineStep<typeof ChipPartitionsSolver> | PipelineStep<typeof PackInnerPartitionsSolver> | PipelineStep<typeof PartitionPackingSolver>)[];
     constructor(inputProblem: InputProblem);
     currentPipelineStepIndex: number;
     _step(): void;

package/dist/index.js

@@ -239,7 +239,19 @@ function visualizeInputProblem(inputProblem, basicLayout) {
 
 // lib/solvers/LayoutPipelineSolver/doBasicInputProblemLayout.ts
 import { pack } from "calculate-packing";
+
+// lib/solvers/LayoutPipelineSolver/hashInputProblem.ts
+var hashInputProblem = (inputProblem) => {
+  return JSON.stringify(inputProblem);
+};
+
+// lib/solvers/LayoutPipelineSolver/doBasicInputProblemLayout.ts
+var cachedProblems = /* @__PURE__ */ new Map();
 function doBasicInputProblemLayout(inputProblem) {
+  const problemHash = hashInputProblem(inputProblem);
+  if (cachedProblems.has(problemHash)) {
+    return structuredClone(cachedProblems.get(problemHash));
+  }
   const components = Object.entries(inputProblem.chipMap).map(
     ([chipId, chip]) => {
       const chipPins = chip.pins.map((pinId) => inputProblem.chipPinMap[pinId]);
@@ -292,32 +304,58 @@ function doBasicInputProblemLayout(inputProblem) {
       ccwRotationDegrees: component.ccwRotationOffset
     };
   }
-  return {
+  const outputLayout = {
     chipPlacements,
     groupPlacements: {}
     // No groups for now
   };
+  cachedProblems.set(problemHash, outputLayout);
+  return structuredClone(outputLayout);
 }
 
 // lib/solvers/ChipPartitionsSolver/ChipPartitionsSolver.ts
 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(
@@ -327,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)
     );
   }
@@ -452,6 +491,179 @@ var ChipPartitionsSolver = class extends BaseSolver {
   }
 };
 
+// lib/utils/getColorFromString.ts
+var getColorFromString = (string, alpha = 1) => {
+  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
+var IdentifyDecouplingCapsSolver = class extends BaseSolver {
+  inputProblem;
+  queuedChips;
+  outputDecouplingCapGroups = [];
+  /** Quick lookup of groups by main chip and net pair for accumulation */
+  groupsByMainChipId = /* @__PURE__ */ new Map();
+  constructor(inputProblem) {
+    super();
+    this.inputProblem = inputProblem;
+    this.queuedChips = Object.values(inputProblem.chipMap);
+  }
+  /** Determine if chip is a 2-pin component with restricted rotation */
+  isTwoPinRestrictedRotation(chip) {
+    if (chip.pins.length !== 2) return false;
+    if (!chip.availableRotations) return false;
+    const allowed = /* @__PURE__ */ new Set([0, 180]);
+    return chip.availableRotations.length > 0 && chip.availableRotations.every((r) => allowed.has(r));
+  }
+  /** Check that the two pins are on opposite Y sides (y+ and y-) */
+  pinsOnOppositeYSides(chip) {
+    if (chip.pins.length !== 2) return false;
+    const [p1, p2] = chip.pins;
+    const cp1 = this.inputProblem.chipPinMap[p1];
+    const cp2 = this.inputProblem.chipPinMap[p2];
+    if (!cp1 || !cp2) return false;
+    const sides = /* @__PURE__ */ new Set([cp1.side, cp2.side]);
+    return sides.has("y+") && sides.has("y-");
+  }
+  /** Get chips strongly connected (direct pin-to-pin) to this pin */
+  getStronglyConnectedNeighborChips(pinId) {
+    const neighbors = /* @__PURE__ */ new Set();
+    for (const [connKey, connected] of Object.entries(
+      this.inputProblem.pinStrongConnMap
+    )) {
+      if (!connected) continue;
+      const [a, b] = connKey.split("-");
+      if (a === pinId) {
+        const otherChipId = b.split(".")[0];
+        neighbors.add(otherChipId);
+      } else if (b === pinId) {
+        const otherChipId = a.split(".")[0];
+        neighbors.add(otherChipId);
+      }
+    }
+    return neighbors;
+  }
+  /** Find the main chip id for a decoupling capacitor candidate */
+  findMainChipIdForCap(capChip) {
+    const strongNeighbors = /* @__PURE__ */ new Map();
+    for (const pinId of capChip.pins) {
+      const neighbors = this.getStronglyConnectedNeighborChips(pinId);
+      for (const n of neighbors) {
+        if (n === capChip.chipId) continue;
+        strongNeighbors.set(n, (strongNeighbors.get(n) || 0) + 1);
+      }
+    }
+    if (strongNeighbors.size === 0) return null;
+    let best = null;
+    for (const [id, score] of strongNeighbors.entries()) {
+      if (!best || score > best.score || score === best.score && id < best.id)
+        best = { id, score };
+    }
+    return best ? best.id : null;
+  }
+  /** 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}__${n1}__${n2}`,
+        mainChipId,
+        netPair: [n1, n2],
+        decouplingCapChipIds: []
+      };
+      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 isDecouplingCap = this.isTwoPinRestrictedRotation(currentChip) && this.pinsOnOppositeYSides(currentChip);
+    if (!isDecouplingCap) return;
+    const mainChipId = this.findMainChipIdForCap(currentChip);
+    if (!mainChipId) return;
+    const netPair = this.getNormalizedNetPair(currentChip);
+    if (!netPair) return;
+    this.addToGroup(mainChipId, netPair, currentChip.chipId);
+  }
+  visualize() {
+    const basicLayout = doBasicInputProblemLayout(this.inputProblem);
+    const graphics = visualizeInputProblem(
+      this.inputProblem,
+      basicLayout
+    );
+    const chipDecapGroupMap = /* @__PURE__ */ new Map();
+    for (const group of this.outputDecouplingCapGroups) {
+      chipDecapGroupMap.set(group.mainChipId, group);
+      for (const capChipId of group.decouplingCapChipIds) {
+        chipDecapGroupMap.set(capChipId, group);
+      }
+    }
+    for (const rect of graphics.rects || []) {
+      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 group = chipDecapGroupMap.get(chipId);
+      if (!group) continue;
+      rect.label = `${rect.label}
+${group.decouplingCapGroupId}`;
+      rect.fill = getColorFromString(group.decouplingCapGroupId, 0.8);
+    }
+    return graphics;
+  }
+  getConstructorParams() {
+    return [this.inputProblem];
+  }
+  computeProgress() {
+    const total = Object.keys(this.inputProblem.chipMap).length || 1;
+    const processed = total - this.queuedChips.length;
+    return Math.min(1, Math.max(0, processed / total));
+  }
+};
+
 // lib/solvers/PackInnerPartitionsSolver/SingleInnerPartitionPackingSolver.ts
 import { PackSolver2 } from "calculate-packing";
 
@@ -1023,6 +1235,7 @@ function definePipelineStep(solverName, solverClass, getConstructorParams, opts
   };
 }
 var LayoutPipelineSolver = class extends BaseSolver {
+  identifyDecouplingCapsSolver;
   chipPartitionsSolver;
   packInnerPartitionsSolver;
   partitionPackingSolver;
@@ -1034,10 +1247,24 @@ var LayoutPipelineSolver = class extends BaseSolver {
   chipPartitions;
   packedPartitions;
   pipelineDef = [
+    definePipelineStep(
+      "identifyDecouplingCapsSolver",
+      IdentifyDecouplingCapsSolver,
+      () => [this.inputProblem],
+      {
+        onSolved: (_layoutSolver) => {
+        }
+      }
+    ),
     definePipelineStep(
       "chipPartitionsSolver",
       ChipPartitionsSolver,
-      () => [this.inputProblem],
+      () => [
+        {
+          inputProblem: this.inputProblem,
+          decouplingCapGroups: this.identifyDecouplingCapsSolver?.outputDecouplingCapGroups
+        }
+      ],
       {
         onSolved: (_layoutSolver) => {
           this.chipPartitions = this.chipPartitionsSolver.partitions;
@@ -1121,6 +1348,7 @@ var LayoutPipelineSolver = class extends BaseSolver {
     if (this.solved && this.partitionPackingSolver?.solved) {
       return this.partitionPackingSolver.visualize();
     }
+    const identifyDecouplingCapsViz = this.identifyDecouplingCapsSolver?.visualize();
     const chipPartitionsViz = this.chipPartitionsSolver?.visualize();
     const packInnerPartitionsViz = this.packInnerPartitionsSolver?.visualize();
     const partitionPackingViz = this.partitionPackingSolver?.visualize();
@@ -1128,6 +1356,7 @@ var LayoutPipelineSolver = class extends BaseSolver {
     const inputViz = visualizeInputProblem(this.inputProblem, basicLayout);
     const visualizations = [
       inputViz,
+      identifyDecouplingCapsViz,
       chipPartitionsViz,
       packInnerPartitionsViz,
       partitionPackingViz
@@ -1175,6 +1404,9 @@ var LayoutPipelineSolver = class extends BaseSolver {
     if (this.chipPartitionsSolver?.solved) {
       return this.chipPartitionsSolver.visualize();
     }
+    if (this.identifyDecouplingCapsSolver?.solved) {
+      return this.identifyDecouplingCapsSolver.visualize();
+    }
     return super.preview();
   }
   /**

package/package.json

@@ -2,7 +2,7 @@
   "name": "@tscircuit/matchpack",
   "main": "dist/index.js",
   "type": "module",
-  "version": "0.0.12",
+  "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",