circuitscript 0.1.15 → 0.1.17

package/dist/cjs/graph.js

@@ -0,0 +1,372 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RenderItemType = exports.generateLayoutPinDefinition = exports.getWireName = exports.NetGraph = void 0;
+const graphlib_1 = require("@dagrejs/graphlib");
+const draw_symbols_js_1 = require("./draw_symbols.js");
+const globals_js_1 = require("./globals.js");
+const helpers_js_1 = require("./helpers.js");
+const layout_js_1 = require("./layout.js");
+const ExecutionScope_js_1 = require("./objects/ExecutionScope.js");
+const Frame_js_1 = require("./objects/Frame.js");
+const ParamDefinition_js_1 = require("./objects/ParamDefinition.js");
+const types_js_1 = require("./objects/types.js");
+const ml_matrix_1 = __importStar(require("ml-matrix"));
+const PinDefinition_js_1 = require("./objects/PinDefinition.js");
+class NetGraph {
+    constructor(logger) {
+        this.logger = logger;
+    }
+    generateLayoutGraph(sequence, nets) {
+        this.print('===== creating graph and populating with nodes =====');
+        let previousNode = null;
+        let previousPin = null;
+        const graph = new graphlib_1.Graph({
+            directed: true,
+            compound: true,
+        });
+        this.print('sequence length:', sequence.length);
+        const baseFrame = new layout_js_1.RenderFrame(new Frame_js_1.Frame(Frame_js_1.FixedFrameIds.BaseFrame));
+        const frameStack = [baseFrame];
+        const containerFrames = [baseFrame];
+        sequence.forEach((sequenceStep, index) => {
+            const action = sequenceStep[0];
+            let tmpComponent;
+            switch (action) {
+                case ExecutionScope_js_1.SequenceAction.To:
+                case ExecutionScope_js_1.SequenceAction.At: {
+                    this.print(...sequenceStep);
+                    const [, component, pin] = sequenceStep;
+                    const tmpInstanceName = component.instanceName;
+                    if (!graph.hasNode(tmpInstanceName)) {
+                        this.print('create instance', tmpInstanceName);
+                        const { displayProp = null } = component;
+                        let tmpSymbol;
+                        if (displayProp instanceof draw_symbols_js_1.SymbolDrawing) {
+                            tmpSymbol = new draw_symbols_js_1.SymbolPlaceholder(displayProp);
+                            tmpSymbol.drawing.logger = this.logger;
+                        }
+                        else {
+                            const symbolPinDefinitions = generateLayoutPinDefinition(component);
+                            if (component.typeProp === globals_js_1.ComponentTypes.module) {
+                                tmpSymbol = new draw_symbols_js_1.SymbolCustomModule(symbolPinDefinitions, component.pinsMaxPositions);
+                            }
+                            else {
+                                tmpSymbol = new draw_symbols_js_1.SymbolCustom(symbolPinDefinitions, component.pinsMaxPositions);
+                            }
+                        }
+                        (0, layout_js_1.applyComponentParamsToSymbol)(component, tmpSymbol);
+                        tmpSymbol.refreshDrawing();
+                        const { width: useWidth, height: useHeight } = tmpSymbol.size();
+                        tmpComponent = new layout_js_1.RenderComponent(component, useWidth, useHeight);
+                        tmpComponent.symbol = tmpSymbol;
+                        graph.setNode(tmpInstanceName, [RenderItemType.Component, tmpComponent, index]);
+                        const currentFrame = frameStack[frameStack.length - 1];
+                        currentFrame && currentFrame.innerItems.push(tmpComponent);
+                    }
+                    if (action === ExecutionScope_js_1.SequenceAction.To && previousNode && previousPin) {
+                        this.setGraphEdge(graph, previousNode, tmpInstanceName, makeEdgeValue(previousNode, previousPin, tmpInstanceName, pin, index));
+                    }
+                    previousNode = tmpInstanceName;
+                    previousPin = pin;
+                    break;
+                }
+                case ExecutionScope_js_1.SequenceAction.Wire: {
+                    const [, wireId, wireSegments] = sequenceStep;
+                    let useNet;
+                    if (previousNode !== null) {
+                        const [prevNodeType, prevNodeItem] = graph.node(previousNode);
+                        if (prevNodeType === RenderItemType.Component) {
+                            const matchingItem = nets.find(([comp, pin]) => {
+                                return comp.instanceName === previousNode
+                                    && pin.equals(previousPin);
+                            });
+                            if (matchingItem !== undefined) {
+                                useNet = matchingItem[2];
+                            }
+                        }
+                        else if (prevNodeType === RenderItemType.Wire) {
+                            useNet = prevNodeItem.net;
+                        }
+                    }
+                    const wire = new layout_js_1.RenderWire(useNet, (0, ParamDefinition_js_1.numeric)(0), (0, ParamDefinition_js_1.numeric)(0), wireSegments);
+                    wire.id = wireId;
+                    wire.netName = useNet.toString();
+                    const wireName = getWireName(wire.id);
+                    graph.setNode(wireName, [RenderItemType.Wire, wire, index]);
+                    this.setGraphEdge(graph, previousNode, wireName, makeEdgeValue(previousNode, previousPin, wireName, 0, index));
+                    previousNode = wireName;
+                    previousPin = 1;
+                    const wireSegmentsInfo = wireSegments.map(item => {
+                        const tmp = {
+                            direction: item.direction,
+                            value: item.value,
+                        };
+                        if (item.valueXY) {
+                            tmp.valueXY = item.valueXY;
+                        }
+                        if (item.until) {
+                            tmp.until = [item.until[0].toString(), item.until[1]];
+                        }
+                        return tmp;
+                    });
+                    this.print(ExecutionScope_js_1.SequenceAction.Wire, wireId, JSON.stringify(wireSegmentsInfo));
+                    break;
+                }
+                case ExecutionScope_js_1.SequenceAction.WireJump: {
+                    this.print(...sequenceStep);
+                    const wireId = sequenceStep[1];
+                    const wireName = getWireName(wireId);
+                    let wirePin = 1;
+                    if (sequenceStep.length === 3) {
+                        wirePin = sequenceStep[2];
+                    }
+                    previousNode = wireName;
+                    previousPin = wirePin;
+                    break;
+                }
+                case ExecutionScope_js_1.SequenceAction.Frame: {
+                    const [, frameObject, frameAction] = sequenceStep;
+                    if (frameAction === ExecutionScope_js_1.FrameAction.Enter) {
+                        const prevFrame = frameStack[frameStack.length - 1];
+                        const newFrame = new layout_js_1.RenderFrame(frameObject);
+                        if (frameObject.parameters.has(Frame_js_1.FrameParamKeys.Direction)) {
+                            newFrame.direction =
+                                frameObject.parameters.get(Frame_js_1.FrameParamKeys.Direction);
+                        }
+                        if (frameObject.parameters.has(Frame_js_1.FrameParamKeys.Padding)) {
+                            newFrame.padding = (0, helpers_js_1.milsToMM)(frameObject.parameters.get(Frame_js_1.FrameParamKeys.Padding));
+                        }
+                        if (frameObject.parameters.has(Frame_js_1.FrameParamKeys.Border)) {
+                            newFrame.borderWidth =
+                                frameObject.parameters.get(Frame_js_1.FrameParamKeys.Border);
+                        }
+                        if (frameObject.parameters.has(Frame_js_1.FrameParamKeys.Width)) {
+                            newFrame.width = (0, helpers_js_1.milsToMM)(frameObject.parameters.get(Frame_js_1.FrameParamKeys.Width));
+                        }
+                        if (frameObject.parameters.has(Frame_js_1.FrameParamKeys.Height)) {
+                            newFrame.height = (0, helpers_js_1.milsToMM)(frameObject.parameters.get(Frame_js_1.FrameParamKeys.Height));
+                        }
+                        containerFrames.push(newFrame);
+                        frameStack.push(newFrame);
+                        prevFrame && prevFrame.innerItems.push(newFrame);
+                    }
+                    else if (frameAction === ExecutionScope_js_1.FrameAction.Exit) {
+                        frameStack.pop();
+                    }
+                    break;
+                }
+            }
+        });
+        this.print('===== done populating graph =====');
+        this.print('');
+        const logNodesAndEdges = true;
+        if (logNodesAndEdges) {
+            this.print('===== graph edges =====');
+            const allEdges = graph.edges();
+            allEdges.forEach(edge => {
+                const [nodeId1, pin1, nodeId2, pin2] = graph.edge(edge);
+                this.print(nodeId1, 'pin', pin1, '-----', nodeId2, 'pin', pin2);
+            });
+            this.print('===== end edges =====');
+            this.print();
+            this.print('===== graph nodes =====');
+            const nodes = graph.nodes();
+            nodes.forEach(node => {
+                this.print(`name:${node}, value:${graph.node(node)}`);
+            });
+            this.print('===== end nodes =====');
+            this.print('');
+        }
+        return {
+            graph,
+            containerFrames,
+        };
+    }
+    setGraphEdge(graph, node1, node2, edgeValue) {
+        if (!graph.isDirected && graph.hasEdge(node1, node2)) {
+            this.print(`Warning: edge already exists ${node1} ${node2}`);
+        }
+        graph.setEdge(node1, node2, edgeValue);
+        this.print(`created edge: node1:${node1} node2:${node2} edgeValue:${edgeValue}`);
+    }
+    print(...params) {
+        this.logger.add(params.join(' '));
+    }
+    generateNetGraph(nets) {
+        const uniqueNets = new Set(nets.map(([, , net]) => net));
+        const components = new Set(nets.map(([component, ,]) => component));
+        const tmpNets = Array.from(uniqueNets);
+        const gndNet = tmpNets.find(item => {
+            return item.toString() === '/GND';
+        });
+        const otherNets = tmpNets.filter(item => {
+            return item !== gndNet;
+        });
+        const netsIndexed = [];
+        if (gndNet) {
+            netsIndexed.push(gndNet);
+        }
+        netsIndexed.push(...otherNets);
+        const netsLength = netsIndexed.length;
+        const conductanceMatrix = ml_matrix_1.default.zeros(netsLength, netsLength);
+        components.forEach(item => {
+            if (item.typeProp === types_js_1.TypeProps.Resistor) {
+                const net1 = item.pinNets.get(1);
+                const net2 = item.pinNets.get(2);
+                const net1Index = netsIndexed.indexOf(net1);
+                const net2Index = netsIndexed.indexOf(net2);
+                const resistance = item.parameters.get('value');
+                const resistanceValue = resistance.toNumber();
+                const conductanceValue = 1 / resistanceValue;
+                const currentValue1 = conductanceMatrix.get(net1Index, net1Index);
+                const currentValue2 = conductanceMatrix.get(net2Index, net2Index);
+                const currentValue3 = conductanceMatrix.get(net1Index, net2Index);
+                const currentValue4 = conductanceMatrix.get(net2Index, net1Index);
+                conductanceMatrix.set(net1Index, net1Index, currentValue1 + conductanceValue);
+                conductanceMatrix.set(net2Index, net2Index, currentValue2 + conductanceValue);
+                conductanceMatrix.set(net1Index, net2Index, currentValue3 - conductanceValue);
+                conductanceMatrix.set(net2Index, net1Index, currentValue4 - conductanceValue);
+            }
+        });
+        if (gndNet) {
+            conductanceMatrix.removeColumn(0);
+            conductanceMatrix.removeRow(0);
+        }
+        const netsWithoutGnd = netsIndexed.filter(net => {
+            return (net !== gndNet);
+        });
+        const netResistances = new Map();
+        try {
+            netsWithoutGnd.forEach((net, index) => {
+                if (net.type === types_js_1.NetTypes.Source) {
+                    const currentVector = ml_matrix_1.default.zeros(netsWithoutGnd.length, 1);
+                    currentVector.set(index, 0, 1);
+                    const solution = (0, ml_matrix_1.solve)(conductanceMatrix, currentVector);
+                    for (let i = 0; i < solution.rows; i++) {
+                        const resValue = solution.get(i, 0);
+                        if (resValue > 0) {
+                            const targetNet = netsIndexed[i];
+                            netResistances.set(targetNet, resValue);
+                        }
+                    }
+                }
+            });
+        }
+        catch (err) {
+        }
+        return {
+            nets,
+            netResistances,
+        };
+    }
+    findNodePaths(graph, startNode, endNode, seenNodes = []) {
+        const edges = graph.nodeEdges(startNode);
+        const paths = [];
+        for (let i = 0; i < edges.length; i++) {
+            const edge = edges[i];
+            const node1 = edge.v;
+            const node2 = edge.w;
+            let nextNode = "";
+            if (node1 === startNode) {
+                nextNode = node2;
+            }
+            else {
+                nextNode = node1;
+            }
+            if (nextNode === endNode) {
+                paths.push([startNode, endNode]);
+                continue;
+            }
+            else if (seenNodes.indexOf(nextNode) !== -1) {
+                continue;
+            }
+            seenNodes.push(startNode);
+            const routes = this.findNodePaths(graph, nextNode, endNode, seenNodes);
+            for (let j = 0; j < routes.length; j++) {
+                paths.push([startNode, ...routes[j]]);
+            }
+        }
+        return paths;
+    }
+    getNetNodeName(net) {
+        return 'net:' + net.toString();
+    }
+    getComponentName(component) {
+        return 'component:' + component.instanceName;
+    }
+}
+exports.NetGraph = NetGraph;
+function makeEdgeValue(instanceName1, instancePin1, instanceName2, instancePin2, priority) {
+    return [instanceName1, instancePin1, instanceName2, instancePin2, priority];
+}
+function getWireName(wireId) {
+    return 'wire:' + wireId;
+}
+exports.getWireName = getWireName;
+function generateLayoutPinDefinition(component) {
+    const pins = component.pins;
+    const symbolPinDefinitions = [];
+    const existingPinIds = Array.from(pins.keys());
+    const arrangeProps = component.arrangeProps ?? [];
+    const addedPins = [];
+    for (const [key, items] of arrangeProps) {
+        let useItems;
+        if (!Array.isArray(items)) {
+            useItems = [items];
+        }
+        else {
+            useItems = [...items];
+        }
+        useItems.forEach(pinId => {
+            const existingPin = existingPinIds.find(pin => pin.equals(pinId));
+            if (existingPin) {
+                const pin = (0, PinDefinition_js_1.getPinDefinition)(pins, existingPin);
+                symbolPinDefinitions.push({
+                    side: key,
+                    pinId: pinId,
+                    text: pin.name,
+                    position: pin.position,
+                    pinType: pin.pinType,
+                });
+                addedPins.push(pinId);
+            }
+        });
+    }
+    const unplacedPins = existingPinIds.filter(pinId => {
+        return addedPins.find(id => id.equals(pinId)) === undefined;
+    });
+    if (unplacedPins.length > 0) {
+        component._unplacedPins = unplacedPins;
+        console.warn("Warning: There are unplaced pins: " + unplacedPins);
+    }
+    return symbolPinDefinitions;
+}
+exports.generateLayoutPinDefinition = generateLayoutPinDefinition;
+var RenderItemType;
+(function (RenderItemType) {
+    RenderItemType["Wire"] = "wire";
+    RenderItemType["Component"] = "component";
+})(RenderItemType || (exports.RenderItemType = RenderItemType = {}));

package/dist/cjs/helpers.js

@@ -23,6 +23,7 @@ const globals_js_1 = require("./globals.js");
 const Frame_js_1 = require("./objects/Frame.js");
 const big_js_1 = __importDefault(require("big.js"));
 const logger_js_1 = require("./logger.js");
+const graph_js_1 = require("./graph.js");
 var JSModuleType;
 (function (JSModuleType) {
     JSModuleType["CommonJs"] = "cjs";
@@ -247,11 +248,14 @@ async function renderScript(scriptData, outputPath, options) {
                     errors,
                 };
             }
-            const layoutEngine = new layout_js_1.LayoutEngine();
+            const logger = new logger_js_1.Logger();
+            const graphEngine = new graph_js_1.NetGraph(logger);
+            const layoutEngine = new layout_js_1.LayoutEngine(logger);
             const layoutTimer = new utils_js_1.SimpleStopwatch();
             let sheetFrames;
             try {
-                sheetFrames = layoutEngine.runLayout(sequence, nets);
+                const { graph, containerFrames } = graphEngine.generateLayoutGraph(sequence, nets);
+                sheetFrames = layoutEngine.runLayout(graph, containerFrames, nets);
             }
             catch (err) {
                 throw new utils_js_1.RenderError(`Error during layout generation: ${err}`, 'layout');