@enervance/insight-cim-model 0.0.369 → 0.0.370

package/dist/analysis/analysis-neplan/contingency-analysis.neplan.westnetz.js

@@ -0,0 +1,615 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContingencyAnalysisNeplanWestnetz = void 0;
+const Switch_1 = require("../../model/wires/Switch.js");
+const ExternalNetworkInjection_1 = require("../../model/wires/ExternalNetworkInjection.js");
+const common_utils_1 = require("../../utils2/common.utils.js");
+const ACLineSegment_1 = require("../../model/wires/ACLineSegment.js");
+const EVSwitchingPlanKind_1 = require("../../model/extensions/enervance/operations/EVSwitchingPlanKind.js");
+const WNConnectivityNode_1 = require("../../model/extensions/westnetz-neplan/core/WNConnectivityNode.js");
+const WNOutage_1 = require("../../model/extensions/westnetz-neplan/operations/WNOutage.js");
+const ConductingEquipment_1 = require("../../model/core/ConductingEquipment.js");
+const EVTerminal_1 = require("../../model/extensions/enervance/core/EVTerminal.js");
+const WNFaultConnectivityNode_1 = require("../../model/extensions/westnetz-neplan/faults/WNFaultConnectivityNode.js");
+const neplan_contingency_analysis_1 = require("../../etl/etl-neplan/neplan-contingency-analysis.js");
+const SwitchActionKind_1 = require("../../model/operations/SwitchActionKind.js");
+const sparql_utils_1 = require("../../util/sparql/sparql-utils.js");
+const WNSwitchTypeKind_1 = require("../../model/extensions/westnetz-neplan/core/WNSwitchTypeKind.js");
+const EnergySource_1 = require("../../model/wires/EnergySource.js");
+const EnergyConsumer_1 = require("../../model/wires/EnergyConsumer.js");
+class ContingencyAnalysisNeplanWestnetz {
+    static performContingencyAnalysis(modelContainer) {
+        var _a, _b, _c;
+        const insertSPARQL = new Array;
+        for (const feeder of modelContainer.feeders.values()) {
+            const wnFeeder = feeder;
+            /** relevante Ausfälle
+             *  1 Ausfall des ersten ConnectivityNodes im Abgang
+             *  2 Alle ConnectivityNodes mit drei und mehr ACLineSegments */
+            const outageNodes = (_a = Array.from(feeder.normalHeadTerminal.values())) === null || _a === void 0 ? void 0 : _a.map(it => it.connectivityNode);
+            for (const cn of wnFeeder.normalEnergizedConnectivityNodes.values()) {
+                // Muffen sind für N-1-Betrachtung nicht relevant
+                // if (cn.getType() === CimAssetAliasNames.Muffe) continue;
+                const connectedACLineSegments = Array.from(cn.terminals.values())
+                    .filter(t => t.isClosed() && t.conductingEquipment instanceof ACLineSegment_1.ACLineSegment)
+                    .length;
+                /** ab 3 ACLineSegments ist der Knoten für die Ausfallanalyse relevant */
+                if (connectedACLineSegments >= 3)
+                    outageNodes.push(cn);
+            }
+            const resupplyResults = ContingencyAnalysisNeplanWestnetz.findRessuplySwitchingActions(outageNodes, modelContainer);
+            for (const resupplyResult of resupplyResults.values()) {
+                // Ausfall
+                const outageNode = (_b = resupplyResult.find(it => it.faultConnectivityNode)) === null || _b === void 0 ? void 0 : _b.faultConnectivityNode;
+                // Freischaltungsmaßnahme
+                const deenergizedAction = (_c = resupplyResult.find(it => it.deenergizedActions)) === null || _c === void 0 ? void 0 : _c.deenergizedActions;
+                // Schaltmaßnahmen mit vollständiger Wiederversorgung
+                const fullyResuppliedActions = resupplyResult.filter(it => !it.cycle && it.resupplyType === EVSwitchingPlanKind_1.EVSwitchingPlanKind.fullyResupply);
+                // Schaltmaßnahmen mit partieller Wiederversorgung
+                const partiallyResuppliedActions = resupplyResult.filter(it => !it.cycle && it.resupplyType === EVSwitchingPlanKind_1.EVSwitchingPlanKind.partiallyResupply);
+                console.log(`Ausfall ${outageNode.getUUID()} | ${outageNode.name}\n
+                    \tSchaltmaßnahmen mit vollständiger Wiederversorgung: ${fullyResuppliedActions.length}\n
+                    \tSchaltmaßnahmen mit partieller Wiederversorgung: ${partiallyResuppliedActions.length}`);
+                if (fullyResuppliedActions.length === 0)
+                    continue;
+                /** Ausfallschaltmaßnahme anlegen */
+                const faultCN = outageNode;
+                for (const fullyResuppliedAction of fullyResuppliedActions) {
+                    const outageNew = new WNOutage_1.WNOutage(common_utils_1.CommonUtils.generateUUID(), `Ausfall-${faultCN.name}`, `${wnFeeder.shortName}`, '', wnFeeder.baseIRI);
+                    modelContainer.addOutage(outageNew);
+                    insertSPARQL.push(outageNew.createNewStatementSPARQL());
+                    /** Equipments */
+                    for (const object of wnFeeder.additionalGroupedEquipment.values()) {
+                        if (object instanceof ConductingEquipment_1.ConductingEquipment) {
+                            insertSPARQL.push(outageNew.addOutageIsolationEquipment(object));
+                        }
+                        else if (object instanceof WNConnectivityNode_1.WNConnectivityNode) {
+                            insertSPARQL.push(outageNew.addOutageIsolationConnectivityNodes(object));
+                        }
+                        else if (object instanceof EVTerminal_1.EVTerminal) {
+                            // TBD
+                        }
+                    }
+                    /** WNConnectivityNodes */
+                    for (const object of wnFeeder.normalEnergizedConnectivityNodes.values()) {
+                        insertSPARQL.push(outageNew.addOutageIsolationConnectivityNodes(object));
+                    }
+                    /** Fault */
+                    const cnFaultNew = new WNFaultConnectivityNode_1.WNFaultConnectivityNode(common_utils_1.CommonUtils.generateUUID(), `${faultCN.name}`, '', '', wnFeeder.baseIRI);
+                    modelContainer.addCustomFault(cnFaultNew);
+                    insertSPARQL.push(cnFaultNew.createNewStatementSPARQL());
+                    insertSPARQL.push(cnFaultNew.setConnectivityNode(faultCN));
+                    insertSPARQL.push(cnFaultNew.setOutage(outageNew));
+                    /** SwitchingPlan de-energise*/
+                    const switchingPlanDeEnergise = (0, neplan_contingency_analysis_1.createSwitchingPlan)(common_utils_1.CommonUtils.generateUUID(), wnFeeder.baseIRI, `Schaltmaßnahme-Ausfall`, -1, 'de-energise', outageNew, insertSPARQL);
+                    modelContainer.addSwitchingPlan(switchingPlanDeEnergise);
+                    /** SwitchingAction de-energise*/
+                    const switchingActionDeEnergise = (0, neplan_contingency_analysis_1.createTerminalAction)(common_utils_1.CommonUtils.generateUUID(), wnFeeder.baseIRI, `Schaltung-Ausfall`, SwitchActionKind_1.SwitchActionKind.open, switchingPlanDeEnergise, insertSPARQL);
+                    modelContainer.addSwitchingAction(switchingActionDeEnergise);
+                    /** Alle Terminals zur Freischaltung des Ausfallknotens */
+                    for (const terminal of fullyResuppliedAction.deenergizedActions) {
+                        // insertSPARQL.push(switchingActionDeEnergise.addTerminal(terminal as EVTerminal));
+                    }
+                    /** SwitchingPlan restore*/
+                    const switchingPlanRestore = (0, neplan_contingency_analysis_1.createSwitchingPlan)(common_utils_1.CommonUtils.generateUUID(), wnFeeder.baseIRI, `Schaltmaßnahme-Restore`, 0, 'restore', outageNew, insertSPARQL);
+                    modelContainer.addSwitchingPlan(switchingPlanRestore);
+                    /** SwitchingAction re-energise*/
+                    const switchingActionRestore = (0, neplan_contingency_analysis_1.createTerminalAction)(common_utils_1.CommonUtils.generateUUID(), wnFeeder.baseIRI, `Schaltung-Restore`, SwitchActionKind_1.SwitchActionKind.close, switchingPlanRestore, insertSPARQL);
+                    modelContainer.addSwitchingAction(switchingActionRestore);
+                    /** Alle terminals des Ausfallknotens */
+                    for (const terminal of fullyResuppliedAction.deenergizedActions) {
+                        //insertSPARQL.push(switchingActionRestore.addTerminal(terminal as EVTerminal));
+                    }
+                    /** Wiederversorgungsmaßnahmen */
+                    for (let i = 0; i < fullyResuppliedAction.switchElements.length; i++) {
+                        const switchAction = fullyResuppliedAction.switchElements[i];
+                        /** SwitchingPlan restore*/
+                        const switchingPlanRestore = (0, neplan_contingency_analysis_1.createSwitchingPlan)(common_utils_1.CommonUtils.generateUUID(), wnFeeder.baseIRI, `Schaltmaßnahme-Restore`, (i + 1), 'energise', outageNew, insertSPARQL);
+                        insertSPARQL.push(switchingPlanRestore.setKind(fullyResuppliedAction.resupplyType));
+                        modelContainer.addSwitchingPlan(switchingPlanRestore);
+                        /** Switch-Element */
+                        if (switchAction.swtch) {
+                            const switchingActionRestore = (0, neplan_contingency_analysis_1.createSwitchAction)(common_utils_1.CommonUtils.generateUUID(), wnFeeder.baseIRI, `Schaltung-Restore`, SwitchActionKind_1.SwitchActionKind.close, switchingPlanRestore, insertSPARQL);
+                            modelContainer.addSwitchingAction(switchingActionRestore);
+                            insertSPARQL.push(switchingActionRestore.setSwitch(switchAction.swtch));
+                        }
+                        /** Switch-Element */
+                        for (const terminal of switchAction.terminals) {
+                            const switchingActionRestore = (0, neplan_contingency_analysis_1.createTerminalAction)(common_utils_1.CommonUtils.generateUUID(), wnFeeder.baseIRI, `Schaltung-Restore`, SwitchActionKind_1.SwitchActionKind.close, switchingPlanRestore, insertSPARQL);
+                            modelContainer.addSwitchingAction(switchingActionRestore);
+                            insertSPARQL.push(switchingActionRestore.addTerminal(terminal));
+                        }
+                    }
+                }
+            }
+        }
+        const length = insertSPARQL.length;
+        const graphURI = modelContainer.getGraphURI();
+        return length === 0 ? [] : [
+            `
+                        PREFIX rdf:             <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+                        PREFIX cim:             <http://iec.ch/TC57/2013/CIM-schema-cim16#>
+                        PREFIX entsoe:	 	      <http://entsoe.eu/CIM/SchemaExtension/3/1#>
+                        PREFIX westnetzneplan:  <http://westnetzneplan.de/CIM/Extensions#>
+                        PREFIX enervance:       <http://enervance.com/CIM/Extensions#>
+                        ${(0, sparql_utils_1.getInsertDataPartStatement)(graphURI, insertSPARQL)}
+        `
+        ];
+    }
+    static findRessuplySwitchingActions(outageConnectivityNodes, baseModel) {
+        var _a, _b, _c;
+        const evaluatedResupplyActions = new Map();
+        const terminals = (Array.from(baseModel.terminals.values()));
+        const allCNs = (Array.from(baseModel.connectivityNodes.values()));
+        const externalNetworkInjections = (Array.from(baseModel.externalNetworkInjections.values()));
+        const switches = [...baseModel.switches.values(), ...baseModel.loadBreakSwitches.values(), ...baseModel.disconnectors.values(), ...baseModel.breakers.values()];
+        for (const faultConnectivityNode of outageConnectivityNodes) {
+            //const changedTerminalsUUIDs =  this.findDeenergiseSwitchingActionWithPaths(faultConnectivityNode as WNConnectivityNode);
+            const changedTerminals = this.findDeenergiseSwitchingAction2(faultConnectivityNode);
+            const changedPath = this.findDeenergiseSwitchingActionWithPaths(faultConnectivityNode);
+            const deeenrgizedTerminalUUIDs = new Array();
+            const deeenrgizedCn = new Array(faultConnectivityNode);
+            changedPath.forEach(it => {
+                var _a;
+                if (it.type === 'ViaSwitch') {
+                    it.switchInstance.open = !it.switchInstance.open;
+                    deeenrgizedTerminalUUIDs.push(...Array.from(it.switchInstance.terminals.values()).map(it => it.getUUID()));
+                    deeenrgizedCn.push(...Array.from(it.switchInstance.terminals.values()).map(it => it === null || it === void 0 ? void 0 : it.connectivityNode));
+                }
+                if (it.type === 'ViaSchaltbarerNode') {
+                    it.terminal.connected = !it.terminal.connected;
+                    deeenrgizedTerminalUUIDs.push(it.terminal.getUUID());
+                    deeenrgizedCn.push((_a = it.terminal) === null || _a === void 0 ? void 0 : _a.connectivityNode);
+                }
+            });
+            const failedSubstation = faultConnectivityNode.getSubstation();
+            const feederHeadNode = ((_a = failedSubstation.getPsrType()) === null || _a === void 0 ? void 0 : _a.getName()) === 'Umspannanlage';
+            // 1. CNs der ausgefallenen Station ignorieren
+            const failedCNs = feederHeadNode ? [faultConnectivityNode] : allCNs.filter(cn => cn.getSubstation().getUUID() === failedSubstation.getUUID());
+            const failedFeeder = feederHeadNode ? (_c = (_b = Array.from(faultConnectivityNode.terminals.values()).find(it => { var _a; return (_a = it.conductingEquipment) === null || _a === void 0 ? void 0 : _a.getAdditionalEquipmentContainer(); })) === null || _b === void 0 ? void 0 : _b.conductingEquipment) === null || _c === void 0 ? void 0 : _c.getAdditionalEquipmentContainer() : failedSubstation.getNormalEnergizingFeeder();
+            // CNs der Ortsnetzstationen (nicht Umspannanlage, nicht failed)
+            const candidateCNs = allCNs.filter(cn => {
+                var _a, _b;
+                return (((_a = cn.getSubstation().getPsrType()) === null || _a === void 0 ? void 0 : _a.getName()) !== 'Umspannanlage' && // alle CNs von Umspannanlagen
+                    cn.getSubstation().getUUID() !== failedSubstation.getUUID()) && // alle CNs der ausgefallenen ONS
+                    ((_b = cn.getSubstation()) === null || _b === void 0 ? void 0 : _b.getNormalEnergizingFeeder()); // Substation muss einen Abgang besitzen
+            });
+            // 3. Suche nach CNs, die spannungslos sind
+            const disconnectedCNs = candidateCNs.filter(cn => !ContingencyAnalysisNeplanWestnetz.isNodeSupplied(cn, terminals.filter(t => !failedCNs.includes(t.connectivityNode)), switches, externalNetworkInjections));
+            const openTerminals = ContingencyAnalysisNeplanWestnetz.findOpenedTerminalsToOtherFeeders(deeenrgizedCn, deeenrgizedTerminalUUIDs, failedFeeder, baseModel);
+            const openSwitches = ContingencyAnalysisNeplanWestnetz.findOpenedSwitchesToOtherFeeders(deeenrgizedCn, failedFeeder, baseModel);
+            const possibleActions = [...openTerminals, ...openSwitches];
+            // 4. Finde alle Kombinationen (1er, 2er, 3er etc.)
+            const combinations = ContingencyAnalysisNeplanWestnetz.buildSupplyCombinations(possibleActions).filter(set => set.length > 0);
+            const results = [];
+            const resupplyResults = new Array();
+            for (const combo of combinations) {
+                // Schaltzustand anwenden
+                const s = new Array();
+                for (const c of combo) {
+                    c.terminals.forEach(it => s.push(it.name));
+                }
+                ContingencyAnalysisNeplanWestnetz.applySwitchCombination(combo);
+                // Abgang auf Zyklen prüfen
+                const cycle = ContingencyAnalysisNeplanWestnetz.hasCycleInFeeder(failedFeeder, terminals, switches);
+                const resupplyResult = {
+                    uuid: common_utils_1.CommonUtils.generateUUID(),
+                    faultConnectivityNode: faultConnectivityNode,
+                    deenergizedActions: changedTerminals,
+                    cycle: cycle,
+                    switchElements: combo,
+                    deenergezedConnectivityNodes: disconnectedCNs,
+                    resuppledConnectivityNodes: new Array(),
+                    resupplyType: EVSwitchingPlanKind_1.EVSwitchingPlanKind.noResupply
+                };
+                resupplyResults.push(resupplyResult);
+                for (const cn of disconnectedCNs) {
+                    const reachable = ContingencyAnalysisNeplanWestnetz.isNodeSupplied(cn, terminals, switches, externalNetworkInjections);
+                    if (reachable) {
+                        resupplyResult.resuppledConnectivityNodes.push(cn);
+                        results.push({ restoredCN: cn, actions: combo });
+                    }
+                }
+                // resupplyType
+                if (resupplyResult.deenergezedConnectivityNodes.length === resupplyResult.resuppledConnectivityNodes.length) {
+                    resupplyResult.resupplyType = EVSwitchingPlanKind_1.EVSwitchingPlanKind.fullyResupply;
+                }
+                else if (resupplyResult.resuppledConnectivityNodes.length > 0) {
+                    resupplyResult.resupplyType = EVSwitchingPlanKind_1.EVSwitchingPlanKind.partiallyResupply;
+                }
+                // Schaltzustand rückgängig machen
+                ContingencyAnalysisNeplanWestnetz.applySwitchCombination(combo);
+                console.log(`${combinations.indexOf(combo) + 1} ${s.join(' ')} 
+                  \n cycle ${cycle} 
+                  \n resupplyResult ${resupplyResult.resupplyType} 
+                  \n ${resupplyResult.resuppledConnectivityNodes.map(it => it.name).join(' -> ')}`);
+                console.log();
+            }
+            // Schaltzustand wiederherstellen
+            changedTerminals.forEach(it => {
+                if (it.type === 'ViaSwitch') {
+                    it.switchInstance.open = !it.switchInstance.open;
+                }
+                if (it.type === 'ViaSchaltbarerNode') {
+                    it.terminal.connected = !it.terminal.connected;
+                }
+            });
+            evaluatedResupplyActions.set(faultConnectivityNode.getUUID(), resupplyResults);
+        }
+        return evaluatedResupplyActions;
+    }
+    static hasCycleInFeeder(feeder, terminals, switches) {
+        // 1. Relevante ACLineSegment-Terminals filtern
+        const relevantTerminals = terminals.filter(t => {
+            var _a, _b, _c;
+            return ((_c = (_b = (_a = t.getConnectivityNode()) === null || _a === void 0 ? void 0 : _a.getSubstation()) === null || _b === void 0 ? void 0 : _b.getPsrType()) === null || _c === void 0 ? void 0 : _c.getName()) !== "Umspannanlage" &&
+                t.connected &&
+                (t.conductingEquipment instanceof ACLineSegment_1.ACLineSegment || t.conductingEquipment instanceof Switch_1.Switch);
+        });
+        // 2. Geschlossene Switches mit einem Feeder
+        const closedSwitches = switches.filter(sw => !sw.open && (sw === null || sw === void 0 ? void 0 : sw.getAdditionalEquipmentContainer()));
+        // 3. Union-Find Struktur für ConnectivityNodes (Komponentenbildung über Switches)
+        const parent = new Map();
+        function find(u) {
+            if (!parent.has(u))
+                parent.set(u, u);
+            if (parent.get(u) === u)
+                return u;
+            const root = find(parent.get(u));
+            parent.set(u, root); // Pfadkompression
+            return root;
+        }
+        function union(u, v) {
+            const rootU = find(u);
+            const rootV = find(v);
+            if (rootU !== rootV) {
+                parent.set(rootU, rootV);
+                // parent.set(rootV, rootU);
+            }
+        }
+        // 4. Union aller über Switches verbundenen ConnectivityNodes
+        for (const sw of closedSwitches) {
+            const swTerminals = terminals.filter(t => {
+                var _a;
+                return ((_a = t.conductingEquipment) === null || _a === void 0 ? void 0 : _a.getUUID()) === (sw === null || sw === void 0 ? void 0 : sw.getUUID()) &&
+                    t.connected;
+            });
+            if (swTerminals.length === 2) {
+                const [a, b] = swTerminals.map(t => { var _a; return (_a = t.getConnectivityNode()) === null || _a === void 0 ? void 0 : _a.getUUID(); });
+                union(a, b);
+            }
+        }
+        // 5. Adjazenzliste basierend auf den "komprimierten" Knoten
+        const adjacency = new Map();
+        function addEdgeCompressed(a, b) {
+            const u = find(a);
+            const v = find(b);
+            if (u === v)
+                return; // kein echter Kantenübergang, gleiches Cluster
+            if (!adjacency.has(u))
+                adjacency.set(u, new Set());
+            if (!adjacency.has(v))
+                adjacency.set(v, new Set());
+            adjacency.get(u).add(v);
+            adjacency.get(v).add(u);
+        }
+        // 6. ACLineSegment-Verbindungen hinzufügen
+        const switchFeeders = closedSwitches.map(it => it.getAdditionalEquipmentContainer());
+        const feeders = new Set([feeder, ...switchFeeders]);
+        for (const feeder of feeders) {
+            for (const eq of feeder.getAdditionalGroupedEquipments().values()) {
+                if (!(eq instanceof ACLineSegment_1.ACLineSegment || eq instanceof Switch_1.Switch))
+                    continue;
+                const lineTerminals = relevantTerminals.filter(t => { var _a; return ((_a = t.conductingEquipment) === null || _a === void 0 ? void 0 : _a.getUUID()) === (eq === null || eq === void 0 ? void 0 : eq.getUUID()); });
+                if (lineTerminals.length === 2) {
+                    const [a, b] = lineTerminals.map(t => { var _a; return (_a = t.connectivityNode) === null || _a === void 0 ? void 0 : _a.getUUID(); });
+                    addEdgeCompressed(a, b);
+                }
+            }
+        }
+        // 7. DFS-Zyklusprüfung auf dem komprimierten Graph
+        const visited = new Set();
+        function dfs(node, parent) {
+            visited.add(node);
+            for (const neighbor of adjacency.get(node) || []) {
+                if (neighbor === parent)
+                    continue;
+                if (visited.has(neighbor))
+                    return true;
+                if (dfs(neighbor, node))
+                    return true;
+            }
+            return false;
+        }
+        for (const node of adjacency.keys()) {
+            if (!visited.has(node)) {
+                if (dfs(node, null))
+                    return true;
+            }
+        }
+        return false;
+    }
+    static buildSupplyCombinations(arr) {
+        const result = [];
+        const n = arr.length;
+        const max = 1 << n;
+        for (let i = 1; i < max; i++) {
+            const subset = [];
+            for (let j = 0; j < n; j++) {
+                if ((i & (1 << j)) !== 0) {
+                    subset.push(arr[j]);
+                }
+            }
+            result.push(subset);
+        }
+        return result;
+    }
+    static disconnectTerminals(faultConnectivityNode) {
+        const changedTerminals = new Array();
+        for (const terminal of faultConnectivityNode.terminals.values()) {
+            if (terminal.connected) {
+                terminal.connected = false;
+                changedTerminals.push(terminal);
+            }
+        }
+        return changedTerminals;
+    }
+    static applySwitchCombination(switchElements) {
+        for (const switchElement of switchElements) {
+            for (const terminal of switchElement.terminals) {
+                terminal.connected = !terminal.connected;
+            }
+            if (switchElement.swtch)
+                switchElement.swtch.open = !switchElement.swtch.open;
+        }
+    }
+    static isNodeSupplied(startNode, terminals, switches, externalInjections) {
+        var _a, _b;
+        const visitedCN = new Set();
+        const visitedEquipments = new Set();
+        const equipmentIsOpen = new Set();
+        for (const sw of switches) {
+            if (sw.open)
+                equipmentIsOpen.add(sw.getUUID());
+        }
+        const cnToTerminals = new Map();
+        for (const t of terminals) {
+            if (!(t === null || t === void 0 ? void 0 : t.connected))
+                continue;
+            if (!(t === null || t === void 0 ? void 0 : t.connectivityNode))
+                continue;
+            const cnUUID = (_a = t.connectivityNode) === null || _a === void 0 ? void 0 : _a.getUUID();
+            if (!cnToTerminals.has(cnUUID))
+                cnToTerminals.set(cnUUID, []);
+            cnToTerminals.get(cnUUID).push(t);
+        }
+        const stack = [startNode];
+        while (stack.length > 0) {
+            const currentCN = stack.pop();
+            const currentId = currentCN.getUUID();
+            if (visitedCN.has(currentId))
+                continue;
+            visitedCN.add(currentId);
+            const cnTerminals = (_b = cnToTerminals.get(currentId)) !== null && _b !== void 0 ? _b : [];
+            for (const terminal of cnTerminals) {
+                if (!(terminal === null || terminal === void 0 ? void 0 : terminal.conductingEquipment))
+                    continue;
+                const eq = terminal.conductingEquipment;
+                const eqId = eq.getUUID();
+                if (equipmentIsOpen.has(eqId))
+                    continue;
+                if (visitedEquipments.has(eqId))
+                    continue;
+                visitedEquipments.add(eqId);
+                // Prüfe: Ist das Equipment ein ExternalNetworkInjection?
+                if (eq instanceof ExternalNetworkInjection_1.ExternalNetworkInjection) {
+                    const isExternalNetworkInjection = externalInjections.some(ext => ext.getUUID() === eq.getUUID());
+                    if (isExternalNetworkInjection)
+                        return true;
+                }
+                // Traverse zu anderen Terminals
+                for (const otherTerminal of eq.terminals.values()) {
+                    if (otherTerminal.getUUID() === terminal.getUUID())
+                        continue;
+                    if (!(otherTerminal === null || otherTerminal === void 0 ? void 0 : otherTerminal.connected))
+                        continue;
+                    if (!(otherTerminal === null || otherTerminal === void 0 ? void 0 : otherTerminal.connectivityNode))
+                        continue;
+                    const nextCN = otherTerminal.connectivityNode;
+                    const nextId = nextCN.getUUID();
+                    if (!visitedCN.has(nextId) && !stack.includes(nextCN)) {
+                        stack.push(nextCN);
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    static findOpenedSwitchesToOtherFeeders(failedConnectivityNodes, failedFeeder, baseModel) {
+        var _a, _b;
+        const results = new Array();
+        // Relevante Switches finden
+        const switches = [...baseModel.switches.values(), ...baseModel.loadBreakSwitches.values(), ...baseModel.disconnectors.values(), ...baseModel.breakers.values()];
+        for (const swtch of switches) {
+            // Nur nicht verbundene Switsches
+            if (!swtch.open)
+                continue;
+            const ceFeeder = swtch.getAdditionalEquipmentContainer();
+            const switchTerminals = (_a = Array.from(swtch.terminals.values())) === null || _a === void 0 ? void 0 : _a.filter(it => it.connectivityNode && !failedConnectivityNodes.includes(it.connectivityNode));
+            // sind an der Switch-Kombination ACLineSegments von anderen Abgängen angeschlossen
+            const switchConnectivityNodes = switchTerminals.map(it => it.connectivityNode);
+            const cnFeeders = switchTerminals.map(it => { var _a, _b; return (_b = (_a = it.connectivityNode.getSubstation()) === null || _a === void 0 ? void 0 : _a.getNormalEnergizingFeeder()) === null || _b === void 0 ? void 0 : _b.getUUID(); });
+            const switchConductingEquipments = (_b = switchConnectivityNodes.map(it => {
+                return Array.from(it.terminals.values()).map(it => it.conductingEquipment);
+            })) === null || _b === void 0 ? void 0 : _b.flat();
+            cnFeeders.push(...switchConductingEquipments.map(it => { var _a; return (_a = it.getAdditionalEquipmentContainer()) === null || _a === void 0 ? void 0 : _a.getUUID(); }));
+            if ((ceFeeder === null || ceFeeder === void 0 ? void 0 : ceFeeder.getUUID()) !== failedFeeder.getUUID() && !cnFeeders.includes(failedFeeder.getUUID()))
+                continue;
+            results.push({
+                swtch,
+                terminals: Array.from(swtch.terminals.values()).filter(it => !it.connected)
+            });
+        }
+        return results;
+    }
+    static findOpenedTerminalsToOtherFeeders(connectivityNodes, deeenrgizedTerminalUUIDs, failedFeeder, baseModel) {
+        var _a, _b, _c;
+        // Relevante Terminals finden
+        const results = new Array();
+        for (const terminal of baseModel.terminals.values()) {
+            // Nur nicht verbundene Terminals
+            if (terminal.connected)
+                continue;
+            if (deeenrgizedTerminalUUIDs.includes(terminal.getUUID()))
+                continue;
+            // Verbundungen zu Switches werden übersprungen
+            if (!terminal.conductingEquipment || !terminal.connectivityNode)
+                continue;
+            if (terminal.conductingEquipment instanceof Switch_1.Switch)
+                continue;
+            if (terminal.conductingEquipment instanceof EnergySource_1.EnergySource)
+                continue;
+            if (terminal.conductingEquipment instanceof EnergyConsumer_1.EnergyConsumer)
+                continue;
+            if (connectivityNodes.includes(terminal.connectivityNode))
+                continue;
+            if (terminal.getUUID() === '254a082a-c503-4c19-911b-9766edeac3b5') {
+                console.log();
+            }
+            // Nur Terminals, die eine Verbindung zum Feeder des betrachteten ConnectivityNodes
+            const ceFeeder = (_a = terminal.conductingEquipment) === null || _a === void 0 ? void 0 : _a.getAdditionalEquipmentContainer();
+            const cnFeeder = (_c = (_b = terminal.connectivityNode) === null || _b === void 0 ? void 0 : _b.getSubstation()) === null || _c === void 0 ? void 0 : _c.getNormalEnergizingFeeder();
+            if ((ceFeeder === null || ceFeeder === void 0 ? void 0 : ceFeeder.getUUID()) !== failedFeeder.getUUID() && (cnFeeder === null || cnFeeder === void 0 ? void 0 : cnFeeder.getUUID()) !== failedFeeder.getUUID())
+                continue;
+            results.push({
+                swtch: null,
+                terminals: new Array(terminal)
+            });
+        }
+        return results;
+    }
+    static findDeenergiseSwitchingAction2(failedNode) {
+        const visitedNodes = new Set();
+        const toVisit = [failedNode];
+        const result = [];
+        while (toVisit.length > 0) {
+            const currentNode = toVisit.pop();
+            if (visitedNodes.has(currentNode.getUUID()))
+                continue;
+            visitedNodes.add(currentNode.getUUID());
+            if (currentNode.switchable === WNSwitchTypeKind_1.WNSwitchTypeKind.S || currentNode.switchable === WNSwitchTypeKind_1.WNSwitchTypeKind.E) {
+                // Schaltbarer Node gefunden → ViaSchaltbarerNode über Terminal einfügen
+                for (const terminal of currentNode.terminals.values()) {
+                    result.push({ type: 'ViaSchaltbarerNode', terminal: terminal });
+                }
+                continue; // keine weitere Traversierung notwendig
+            }
+            for (const terminal of currentNode.terminals.values()) {
+                const equipment = terminal === null || terminal === void 0 ? void 0 : terminal.conductingEquipment;
+                if (!equipment)
+                    continue;
+                if (equipment instanceof Switch_1.Switch) {
+                    result.push({ type: 'ViaSwitch', switchInstance: equipment });
+                    continue; // Switch → Ende dieses Pfads
+                }
+                for (const otherTerminal of equipment.terminals.values()) {
+                    if (otherTerminal === terminal)
+                        continue;
+                    const nextNode = otherTerminal === null || otherTerminal === void 0 ? void 0 : otherTerminal.connectivityNode;
+                    if (!nextNode)
+                        continue;
+                    if (!visitedNodes.has(nextNode.getUUID())) {
+                        toVisit.push(nextNode);
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    static findDeenergiseSwitchingActionWithPaths(failedNode) {
+        const visitedNodes = new Set();
+        const visitedSwitches = new Set(); // Zum Filtern doppelter Switches
+        const visitedSchaltbareNodes = new Set(); // Zum Filtern doppelter schaltbarer Nodes
+        const toVisit = [
+            { node: failedNode, path: [{ node: failedNode }] }
+        ];
+        const result = [];
+        while (toVisit.length > 0) {
+            const { node: currentNode, path } = toVisit.pop();
+            const nodeId = currentNode.getUUID();
+            if (visitedNodes.has(nodeId))
+                continue;
+            visitedNodes.add(nodeId);
+            const lastStep = path[path.length - 1];
+            const lastEquipment = lastStep === null || lastStep === void 0 ? void 0 : lastStep.equipment;
+            // Prüfe auf schaltbaren Node
+            if ((currentNode.switchable === WNSwitchTypeKind_1.WNSwitchTypeKind.S || currentNode.switchable === WNSwitchTypeKind_1.WNSwitchTypeKind.E) &&
+                !visitedSchaltbareNodes.has(nodeId)) {
+                visitedSchaltbareNodes.add(nodeId);
+                let matchedTerminal;
+                // Finde den Terminal, der mit dem letzten Equipment verbunden ist
+                if (lastEquipment) {
+                    for (const terminal of currentNode.terminals.values()) {
+                        if (terminal.conductingEquipment === lastEquipment) {
+                            matchedTerminal = terminal;
+                            break;
+                        }
+                    }
+                }
+                // Fallback: irgendein Terminal (z. B. Startpunkt ist schaltbar)
+                if (!matchedTerminal && currentNode.terminals.size > 0) {
+                    matchedTerminal = currentNode.terminals.values().next().value;
+                }
+                if (matchedTerminal) {
+                    result.push({
+                        type: 'ViaSchaltbarerNode',
+                        terminal: matchedTerminal,
+                        path: [...path]
+                    });
+                }
+                continue;
+            }
+            for (const terminal of currentNode.terminals.values()) {
+                const equipment = terminal === null || terminal === void 0 ? void 0 : terminal.conductingEquipment;
+                if (!equipment)
+                    continue;
+                // Switch behandeln (aber nur einmal pro UUID)
+                if (equipment instanceof Switch_1.Switch) {
+                    const switchId = equipment.getUUID();
+                    if (!visitedSwitches.has(switchId)) {
+                        visitedSwitches.add(switchId);
+                        result.push({
+                            type: 'ViaSwitch',
+                            switchInstance: equipment,
+                            path: [...path, { node: currentNode, equipment }]
+                        });
+                    }
+                    continue; // Stop bei Switch
+                }
+                // Weiter durch anderes Equipment
+                for (const otherTerminal of equipment.terminals.values()) {
+                    if (otherTerminal === terminal)
+                        continue;
+                    const nextNode = otherTerminal === null || otherTerminal === void 0 ? void 0 : otherTerminal.connectivityNode;
+                    if (!nextNode || visitedNodes.has(nextNode.getUUID()))
+                        continue;
+                    toVisit.push({
+                        node: nextNode,
+                        path: [...path, { node: currentNode, equipment }]
+                    });
+                }
+            }
+        }
+        return result;
+    }
+    static findWithSmallestDeenergizedNodes(arr) {
+        if (arr.length === 0)
+            return [];
+        // Finde die kleinste Länge
+        const maxLength = Math.max(...arr.map(item => item.resuppledConnectivityNodes.length));
+        // Filtere alle Objekte, die genau diese Länge haben
+        return arr.filter(item => !item.cycle && item.resuppledConnectivityNodes.length === maxLength);
+    }
+}
+exports.ContingencyAnalysisNeplanWestnetz = ContingencyAnalysisNeplanWestnetz;
+//# sourceMappingURL=contingency-analysis.neplan.westnetz.js.map