@tscircuit/matchpack 0.0.14 → 0.0.15

package/dist/index.d.ts

@@ -74,8 +74,13 @@ type InputProblem = {
     chipGap: number;
     /** The minimum gap between two partitions */
     partitionGap: number;
+    decouplingCapsGap?: number;
     inferDecouplingCaps?: boolean;
 };
+interface PartitionInputProblem extends InputProblem {
+    isPartition?: true;
+    partitionType?: "default" | "decoupling_caps";
+}
 
 /**
  * Identifies decoupling capacitor groups based on specific criteria:
@@ -131,7 +136,7 @@ declare class IdentifyDecouplingCapsSolver extends BaseSolver {
 
 declare class ChipPartitionsSolver extends BaseSolver {
     inputProblem: InputProblem;
-    partitions: InputProblem[];
+    partitions: PartitionInputProblem[];
     decouplingCapGroups?: DecouplingCapGroup[];
     constructor({ inputProblem, decouplingCapGroups, }: {
         inputProblem: InputProblem;
@@ -173,10 +178,14 @@ type OutputLayout = {
  */
 
 declare class SingleInnerPartitionPackingSolver extends BaseSolver {
-    inputProblem: InputProblem;
+    partitionInputProblem: PartitionInputProblem;
     layout: OutputLayout | null;
     activeSubSolver: PackSolver2 | null;
-    constructor(inputProblem: InputProblem);
+    pinIdToStronglyConnectedPins: Record<PinId, ChipPin[]>;
+    constructor(params: {
+        partitionInputProblem: PartitionInputProblem;
+        pinIdToStronglyConnectedPins: Record<PinId, ChipPin[]>;
+    });
     _step(): void;
     private createPackInput;
     private createLayoutFromPackingResult;
@@ -200,7 +209,12 @@ declare class PackInnerPartitionsSolver extends BaseSolver {
     completedSolvers: SingleInnerPartitionPackingSolver[];
     activeSolver: SingleInnerPartitionPackingSolver | null;
     currentPartitionIndex: number;
-    constructor(partitions: InputProblem[]);
+    activeSubSolver: SingleInnerPartitionPackingSolver | null;
+    pinIdToStronglyConnectedPins: Record<PinId, ChipPin[]>;
+    constructor(params: {
+        partitions: InputProblem[];
+        pinIdToStronglyConnectedPins: Record<PinId, ChipPin[]>;
+    });
     _step(): void;
     visualize(): GraphicsObject;
     getConstructorParams(): [InputProblem[]];
@@ -249,6 +263,7 @@ declare class LayoutPipelineSolver extends BaseSolver {
     endTimeOfPhase: Record<string, number>;
     timeSpentOnPhase: Record<string, number>;
     firstIterationOfPhase: Record<string, number>;
+    pinIdToStronglyConnectedPins: Record<PinId, ChipPin[]>;
     inputProblem: InputProblem;
     chipPartitions?: ChipPartitionsSolver["partitions"];
     packedPartitions?: PackedPartition[];
@@ -284,4 +299,4 @@ declare class LayoutPipelineSolver extends BaseSolver {
     getOutputLayout(): OutputLayout;
 }
 
-export { type Chip, type ChipId, type ChipPin, type Group, type GroupId, type GroupPin, type InputProblem, LayoutPipelineSolver, type Net, type NetId, type OutputLayout, type PinId, type Placement };
+export { type Chip, type ChipId, type ChipPin, type Group, type GroupId, type GroupPin, type InputProblem, LayoutPipelineSolver, type Net, type NetId, type OutputLayout, type PartitionInputProblem, type PinId, type Placement };

package/dist/index.js

@@ -380,10 +380,16 @@ var ChipPartitionsSolver = class extends BaseSolver {
         }
       }
     }
-    const allPartitions = [...decapGroupPartitions, ...nonDecapPartitions];
-    return allPartitions.map(
-      (partition) => this.createInputProblemFromPartition(partition, inputProblem)
-    );
+    return [
+      ...decapGroupPartitions.map(
+        (partition) => this.createInputProblemFromPartition(partition, inputProblem, {
+          partitionType: "decoupling_caps"
+        })
+      ),
+      ...nonDecapPartitions.map(
+        (partition) => this.createInputProblemFromPartition(partition, inputProblem)
+      )
+    ];
   }
   /**
    * Finds the owner chip of a given pin
@@ -422,7 +428,7 @@ var ChipPartitionsSolver = class extends BaseSolver {
   /**
    * Creates a new InputProblem containing only the components in the given partition
    */
-  createInputProblemFromPartition(partition, originalProblem) {
+  createInputProblemFromPartition(partition, originalProblem, opts) {
     const chipIds = partition;
     const relevantPinIds = /* @__PURE__ */ new Set();
     for (const chipId of chipIds) {
@@ -469,13 +475,14 @@ var ChipPartitionsSolver = class extends BaseSolver {
       }
     }
     return {
+      ...originalProblem,
       chipMap,
       chipPinMap,
       netMap,
       pinStrongConnMap,
       netConnMap,
-      chipGap: originalProblem.chipGap,
-      partitionGap: originalProblem.partitionGap
+      isPartition: true,
+      partitionType: opts?.partitionType
     };
   }
   visualize() {
@@ -668,14 +675,17 @@ ${group.decouplingCapGroupId}`;
 import { PackSolver2 } from "calculate-packing";
 
 // lib/utils/networkFiltering.ts
-function createFilteredNetworkMapping(inputProblem) {
+function createFilteredNetworkMapping(params) {
+  const { inputProblem, pinIdToStronglyConnectedPins } = params;
   const pinToNetworkMap = /* @__PURE__ */ new Map();
   const filteredPins = /* @__PURE__ */ new Set();
+  let hasStrongConnections = false;
   const strongConnectedChipSides = /* @__PURE__ */ new Map();
   for (const [connKey, connected] of Object.entries(
     inputProblem.pinStrongConnMap
   )) {
     if (!connected) continue;
+    hasStrongConnections = true;
     const pins = connKey.split("-");
     if (pins.length === 2 && pins[0] && pins[1]) {
       const pin1 = inputProblem.chipPinMap[pins[0]];
@@ -698,45 +708,59 @@ function createFilteredNetworkMapping(inputProblem) {
       }
     }
   }
-  for (const [connKey, connected] of Object.entries(inputProblem.netConnMap)) {
-    if (!connected) continue;
-    const [pinId, netId] = connKey.split("-");
-    if (pinId && netId) {
-      const pin = inputProblem.chipPinMap[pinId];
-      if (!pin) continue;
-      const chipId = pinId.split(".")[0];
-      let shouldIncludeInNetwork = true;
-      for (const [
-        strongKey,
-        strongSides
-      ] of strongConnectedChipSides.entries()) {
-        const [fromChip, toChip] = strongKey.split("-");
-        if (fromChip === chipId) {
-          for (const [otherConnKey, otherConnected] of Object.entries(
-            inputProblem.netConnMap
-          )) {
-            if (!otherConnected) continue;
-            const [otherPinId, otherNetId] = otherConnKey.split("-");
-            if (otherNetId === netId && otherPinId && otherPinId !== pinId) {
-              const otherPin = inputProblem.chipPinMap[otherPinId];
-              if (!otherPin) continue;
-              const otherChipId = otherPinId.split(".")[0];
-              if (otherChipId === toChip) {
-                if (!strongSides.has(otherPin.side)) {
-                  shouldIncludeInNetwork = false;
-                  break;
+  if (hasStrongConnections) {
+    for (const [connKey, connected] of Object.entries(
+      inputProblem.netConnMap
+    )) {
+      if (!connected) continue;
+      const [pinId, netId] = connKey.split("-");
+      if (pinId && netId) {
+        filteredPins.add(pinId);
+      }
+    }
+  } else {
+    for (const [connKey, connected] of Object.entries(
+      inputProblem.netConnMap
+    )) {
+      if (!connected) continue;
+      const [pinId, netId] = connKey.split("-");
+      if (pinId && netId) {
+        const pin = inputProblem.chipPinMap[pinId];
+        if (!pin) continue;
+        const chipId = pinId.split(".")[0];
+        let shouldIncludeInNetwork = true;
+        for (const [
+          strongKey,
+          strongSides
+        ] of strongConnectedChipSides.entries()) {
+          const [fromChip, toChip] = strongKey.split("-");
+          if (fromChip === chipId) {
+            for (const [otherConnKey, otherConnected] of Object.entries(
+              inputProblem.netConnMap
+            )) {
+              if (!otherConnected) continue;
+              const [otherPinId, otherNetId] = otherConnKey.split("-");
+              if (otherNetId === netId && otherPinId && otherPinId !== pinId) {
+                const otherPin = inputProblem.chipPinMap[otherPinId];
+                if (!otherPin) continue;
+                const otherChipId = otherPinId.split(".")[0];
+                if (otherChipId === toChip) {
+                  if (!strongSides.has(otherPin.side)) {
+                    shouldIncludeInNetwork = false;
+                    break;
+                  }
                 }
               }
             }
           }
         }
-      }
-      if (shouldIncludeInNetwork) {
-        pinToNetworkMap.set(pinId, netId);
-      } else {
-        const disconnectedNetworkId = `${pinId}_opposite-strong-side-disconnected`;
-        pinToNetworkMap.set(pinId, disconnectedNetworkId);
-        filteredPins.add(pinId);
+        if (shouldIncludeInNetwork) {
+          pinToNetworkMap.set(pinId, netId);
+        } else {
+          const disconnectedNetworkId = `${pinId}_opposite-strong-side-disconnected`;
+          pinToNetworkMap.set(pinId, disconnectedNetworkId);
+          filteredPins.add(pinId);
+        }
       }
     }
   }
@@ -782,11 +806,13 @@ var getPadsBoundingBox = (pads) => {
 // lib/solvers/PackInnerPartitionsSolver/SingleInnerPartitionPackingSolver.ts
 var PIN_SIZE = 0.1;
 var SingleInnerPartitionPackingSolver = class extends BaseSolver {
-  inputProblem;
+  partitionInputProblem;
   layout = null;
-  constructor(inputProblem) {
+  pinIdToStronglyConnectedPins;
+  constructor(params) {
     super();
-    this.inputProblem = inputProblem;
+    this.partitionInputProblem = params.partitionInputProblem;
+    this.pinIdToStronglyConnectedPins = params.pinIdToStronglyConnectedPins;
   }
   _step() {
     if (!this.activeSubSolver) {
@@ -809,53 +835,55 @@ var SingleInnerPartitionPackingSolver = class extends BaseSolver {
     }
   }
   createPackInput() {
-    const { pinToNetworkMap } = createFilteredNetworkMapping(this.inputProblem);
-    const packComponents = Object.entries(this.inputProblem.chipMap).map(
-      ([chipId, chip]) => {
-        const pads = [];
-        for (const pinId of chip.pins) {
-          const pin = this.inputProblem.chipPinMap[pinId];
-          if (!pin) continue;
-          const networkId = pinToNetworkMap.get(pinId) || `${pinId}_isolated`;
-          pads.push({
-            padId: pinId,
-            networkId,
-            type: "rect",
-            offset: { x: pin.offset.x, y: pin.offset.y },
-            size: { x: PIN_SIZE, y: PIN_SIZE }
-            // Small size for pins
-          });
-        }
-        const padsBoundingBox = getPadsBoundingBox(pads);
-        const padsBoundingBoxSize = {
-          x: padsBoundingBox.maxX - padsBoundingBox.minX,
-          y: padsBoundingBox.maxY - padsBoundingBox.minY
-        };
+    const pinToNetworkMap = createFilteredNetworkMapping({
+      inputProblem: this.partitionInputProblem,
+      pinIdToStronglyConnectedPins: this.pinIdToStronglyConnectedPins
+    }).pinToNetworkMap;
+    const packComponents = Object.entries(
+      this.partitionInputProblem.chipMap
+    ).map(([chipId, chip]) => {
+      const pads = [];
+      for (const pinId of chip.pins) {
+        const pin = this.partitionInputProblem.chipPinMap[pinId];
+        if (!pin) continue;
+        const networkId = pinToNetworkMap.get(pinId) || `${pinId}_isolated`;
         pads.push({
-          padId: `${chipId}_body`,
-          networkId: `${chipId}_body_disconnected`,
+          padId: pinId,
+          networkId,
           type: "rect",
-          offset: { x: 0, y: 0 },
-          size: {
-            x: Math.max(padsBoundingBoxSize.x, chip.size.x),
-            y: Math.max(padsBoundingBoxSize.y, chip.size.y)
-          }
+          offset: { x: pin.offset.x, y: pin.offset.y },
+          size: { x: PIN_SIZE, y: PIN_SIZE }
+          // Small size for pins
         });
-        return {
-          componentId: chipId,
-          pads,
-          availableRotationDegrees: chip.availableRotations || [
-            0,
-            90,
-            180,
-            270
-          ]
-        };
       }
-    );
+      const padsBoundingBox = getPadsBoundingBox(pads);
+      const padsBoundingBoxSize = {
+        x: padsBoundingBox.maxX - padsBoundingBox.minX,
+        y: padsBoundingBox.maxY - padsBoundingBox.minY
+      };
+      pads.push({
+        padId: `${chipId}_body`,
+        networkId: `${chipId}_body_disconnected`,
+        type: "rect",
+        offset: { x: 0, y: 0 },
+        size: {
+          x: Math.max(padsBoundingBoxSize.x, chip.size.x),
+          y: Math.max(padsBoundingBoxSize.y, chip.size.y)
+        }
+      });
+      return {
+        componentId: chipId,
+        pads,
+        availableRotationDegrees: chip.availableRotations || [0, 90, 180, 270]
+      };
+    });
+    let minGap = this.partitionInputProblem.chipGap;
+    if (this.partitionInputProblem.partitionType === "decoupling_caps") {
+      minGap = this.partitionInputProblem.decouplingCapsGap ?? minGap;
+    }
     return {
       components: packComponents,
-      minGap: this.inputProblem.chipGap,
+      minGap,
       packOrderStrategy: "largest_to_smallest",
       packPlacementStrategy: "minimum_closest_sum_squared_distance"
     };
@@ -880,13 +908,13 @@ var SingleInnerPartitionPackingSolver = class extends BaseSolver {
       return this.activeSubSolver.visualize();
     }
     if (!this.layout) {
-      const basicLayout = doBasicInputProblemLayout(this.inputProblem);
-      return visualizeInputProblem(this.inputProblem, basicLayout);
+      const basicLayout = doBasicInputProblemLayout(this.partitionInputProblem);
+      return visualizeInputProblem(this.partitionInputProblem, basicLayout);
     }
-    return visualizeInputProblem(this.inputProblem, this.layout);
+    return visualizeInputProblem(this.partitionInputProblem, this.layout);
   }
   getConstructorParams() {
-    return [this.inputProblem];
+    return [this.partitionInputProblem];
   }
 };
 
@@ -898,9 +926,11 @@ var PackInnerPartitionsSolver = class extends BaseSolver {
   completedSolvers = [];
   activeSolver = null;
   currentPartitionIndex = 0;
-  constructor(partitions) {
+  pinIdToStronglyConnectedPins;
+  constructor(params) {
     super();
-    this.partitions = partitions;
+    this.partitions = params.partitions;
+    this.pinIdToStronglyConnectedPins = params.pinIdToStronglyConnectedPins;
   }
   _step() {
     if (this.currentPartitionIndex >= this.partitions.length) {
@@ -909,9 +939,10 @@ var PackInnerPartitionsSolver = class extends BaseSolver {
     }
     if (!this.activeSolver) {
       const currentPartition = this.partitions[this.currentPartitionIndex];
-      this.activeSolver = new SingleInnerPartitionPackingSolver(
-        currentPartition
-      );
+      this.activeSolver = new SingleInnerPartitionPackingSolver({
+        partitionInputProblem: currentPartition,
+        pinIdToStronglyConnectedPins: this.pinIdToStronglyConnectedPins
+      });
       this.activeSubSolver = this.activeSolver;
     }
     this.activeSolver.step();
@@ -1225,6 +1256,29 @@ var PartitionPackingSolver = class extends BaseSolver {
   }
 };
 
+// lib/solvers/LayoutPipelineSolver/getPinIdToStronglyConnectedPinsObj.ts
+var getPinIdToStronglyConnectedPinsObj = (inputProblem) => {
+  const pinIdToStronglyConnectedPins = {};
+  const pinIds = Object.keys(inputProblem.chipPinMap);
+  for (let i = 0; i < pinIds.length; i++) {
+    for (let j = i + 1; j < pinIds.length; j++) {
+      const pinId1 = pinIds[i];
+      const pinId2 = pinIds[j];
+      if (inputProblem.pinStrongConnMap[`${pinId1}-${pinId2}`] || inputProblem.pinStrongConnMap[`${pinId2}-${pinId1}`]) {
+        pinIdToStronglyConnectedPins[pinId1] ??= [];
+        pinIdToStronglyConnectedPins[pinId2] ??= [];
+        pinIdToStronglyConnectedPins[pinId1].push(
+          inputProblem.chipPinMap[pinId2]
+        );
+        pinIdToStronglyConnectedPins[pinId2].push(
+          inputProblem.chipPinMap[pinId1]
+        );
+      }
+    }
+  }
+  return pinIdToStronglyConnectedPins;
+};
+
 // lib/solvers/LayoutPipelineSolver/LayoutPipelineSolver.ts
 function definePipelineStep(solverName, solverClass, getConstructorParams, opts = {}) {
   return {
@@ -1243,6 +1297,8 @@ var LayoutPipelineSolver = class extends BaseSolver {
   endTimeOfPhase;
   timeSpentOnPhase;
   firstIterationOfPhase;
+  // Computed utility objects
+  pinIdToStronglyConnectedPins;
   inputProblem;
   chipPartitions;
   packedPartitions;
@@ -1274,7 +1330,12 @@ var LayoutPipelineSolver = class extends BaseSolver {
     definePipelineStep(
       "packInnerPartitionsSolver",
       PackInnerPartitionsSolver,
-      () => [this.chipPartitions || [this.inputProblem]],
+      () => [
+        {
+          partitions: this.chipPartitions,
+          pinIdToStronglyConnectedPins: this.pinIdToStronglyConnectedPins
+        }
+      ],
       {
         onSolved: (_solver) => {
           this.packedPartitions = this.packInnerPartitionsSolver.packedPartitions;
@@ -1304,6 +1365,7 @@ var LayoutPipelineSolver = class extends BaseSolver {
     this.endTimeOfPhase = {};
     this.timeSpentOnPhase = {};
     this.firstIterationOfPhase = {};
+    this.pinIdToStronglyConnectedPins = getPinIdToStronglyConnectedPinsObj(inputProblem);
   }
   currentPipelineStepIndex = 0;
   _step() {

package/package.json

@@ -2,7 +2,7 @@
   "name": "@tscircuit/matchpack",
   "main": "dist/index.js",
   "type": "module",
-  "version": "0.0.14",
+  "version": "0.0.15",
   "files": [
     "dist"
   ],