@enervance/insight-cim-model 1.0.2 → 1.0.3

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

@@ -0,0 +1,718 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContingencyAnalysisNeplanWestnetz = void 0;
+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 common_utils_1 = require("../../utils2/common.utils.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 etl_neplan_contingency_analysis_1 = require("../../etl/etl-neplan/etl-neplan-contingency-analysis.js");
+const SwitchActionKind_1 = require("../../model/operations/SwitchActionKind.js");
+const neplan_contingency_analysis_1 = require("../../etl/etl-neplan/neplan-contingency-analysis.js");
+const sparql_utils_1 = require("../../util/sparql/sparql-utils.js");
+const ExternalNetworkInjection_1 = require("../../model/wires/ExternalNetworkInjection.js");
+const Switch_1 = require("../../model/wires/Switch.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) {
+        const insertSPARQL = new Array;
+        const report = new Array();
+        report.push(`Netz ${modelContainer.modelsContainer.graphUri}`);
+        for (const feeder of modelContainer.feeders.values()) {
+            const wnFeeder = feeder;
+            report.push(`Starte mit Feeder ${wnFeeder.name}`);
+            /** relevante Ausfälle
+             *  1 Ausfall des ersten ConnectivityNodes im Abgang
+             *  2 Alle ConnectivityNodes mit drei und mehr ACLineSegments */
+            const outageNodes = Array.from(feeder.normalHeadTerminal.values())?.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 = resupplyResult.find(it => it.faultConnectivityNode)?.faultConnectivityNode;
+                if (outageNode === undefined) {
+                    continue;
+                }
+                // Freischaltungsmaßnahme
+                const deenergizedAction = resupplyResult.find(it => it.deenergizedActions)?.deenergizedActions;
+                // Schaltmaßnahmen ohne Zyklen
+                const resupplyActionsWithoudCycles = resupplyResult.filter(it => !it.cycle);
+                // Schaltmaßnahmen mit vollständiger Wiederversorgung
+                const fullyResuppliedActions = resupplyActionsWithoudCycles.filter(it => it.resupplyType === EVSwitchingPlanKind_1.EVSwitchingPlanKind.fullyResupply);
+                // Schaltmaßnahmen mit partieller Wiederversorgung
+                const partiallyResuppliedActionsAll = resupplyActionsWithoudCycles.filter(it => it.resupplyType === EVSwitchingPlanKind_1.EVSwitchingPlanKind.partiallyResupply);
+                const partiallyResuppliedActions = ContingencyAnalysisNeplanWestnetz.findWithSmallestDeenergizedNodes(partiallyResuppliedActionsAll);
+                report.push(`Ausfall ${outageNode.getUUID()} | ${outageNode.name}\n
+                    \tSchaltmaßnahmen mit vollständiger Wiederversorgung: ${fullyResuppliedActions.length}\n
+                    \tSchaltmaßnahmen mit partieller Wiederversorgung: ${partiallyResuppliedActions.length}`);
+                const actions = fullyResuppliedActions.length ? fullyResuppliedActions : partiallyResuppliedActions;
+                if (actions.length === 0)
+                    continue;
+                /** Ausfallschaltmaßnahme anlegen */
+                const faultCN = outageNode;
+                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, etl_neplan_contingency_analysis_1.createSwitchingPlan)(common_utils_1.CommonUtils.generateUUID(), wnFeeder.baseIRI, `Schaltmaßnahme-Ausfall`, -1, 'de-energise', outageNew, insertSPARQL);
+                modelContainer.addSwitchingPlan(switchingPlanDeEnergise);
+                /** SwitchingActions de-energise*/
+                const switchingActionDeEnergise = (0, etl_neplan_contingency_analysis_1.createTerminalAction)(common_utils_1.CommonUtils.generateUUID(), wnFeeder.baseIRI, `Ausfall Freischaltung`, SwitchActionKind_1.SwitchActionKind.open, switchingPlanDeEnergise, insertSPARQL);
+                modelContainer.addSwitchingAction(switchingActionDeEnergise);
+                for (const switchElement of deenergizedAction) {
+                    if (switchElement.type === 'ViaSwitch') {
+                        // TODO
+                    }
+                    else if (switchElement.type === 'ViaSchaltbarerNode') {
+                        insertSPARQL.push(switchingActionDeEnergise.addTerminal(switchElement.terminal));
+                    }
+                }
+                /** SwitchingPlan re-energise*/
+                const switchingPlanRestore = (0, etl_neplan_contingency_analysis_1.createSwitchingPlan)(common_utils_1.CommonUtils.generateUUID(), wnFeeder.baseIRI, `Schaltmaßnahme-Restore`, '0', 're-energise', outageNew, insertSPARQL);
+                modelContainer.addSwitchingPlan(switchingPlanRestore);
+                /** SwitchingAction re-energise*/
+                const switchingActionRestore = (0, etl_neplan_contingency_analysis_1.createTerminalAction)(common_utils_1.CommonUtils.generateUUID(), wnFeeder.baseIRI, `Schaltmaßnahme-Restore`, SwitchActionKind_1.SwitchActionKind.close, switchingPlanRestore, insertSPARQL);
+                modelContainer.addSwitchingAction(switchingActionRestore);
+                for (const switchElement of deenergizedAction) {
+                    if (switchElement.type === 'ViaSwitch') {
+                        // TODO
+                    }
+                    else if (switchElement.type === 'ViaSchaltbarerNode') {
+                        insertSPARQL.push(switchingActionRestore.addTerminal(switchElement.terminal));
+                    }
+                }
+                for (let i = 0; i < actions.length; i++) {
+                    const action = actions[i];
+                    // Bei partieller Wiederversorgung wird zunächst max 2 Maßahmen berücksichtigt.
+                    if (action.resupplyType === EVSwitchingPlanKind_1.EVSwitchingPlanKind.partiallyResupply) {
+                        if (i > 3)
+                            continue;
+                    }
+                    /** SwitchingPlan restore*/
+                    const switchingPlanRestore = (0, etl_neplan_contingency_analysis_1.createSwitchingPlan)(common_utils_1.CommonUtils.generateUUID(), wnFeeder.baseIRI, `Schaltmaßnahme-Restore`, (i + 1), 'energise', outageNew, insertSPARQL);
+                    insertSPARQL.push(switchingPlanRestore.setKind(action.resupplyType));
+                    modelContainer.addSwitchingPlan(switchingPlanRestore);
+                    /** Wiederversorgungsmaßnahmen */
+                    for (const switchAction of action.switchElements) {
+                        /** 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, etl_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();
+        const sparql = 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)}
+        `
+        ];
+        return { sparql: sparql, report: report };
+    }
+    static findRessuplySwitchingActions(outageConnectivityNodes, baseModel) {
+        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 changedPath = this.findDeenergiseSwitchingActionWithPaths(faultConnectivityNode);
+            const deeenrgizedTerminalUUIDs = new Array();
+            const deeenrgizedCn = new Array(faultConnectivityNode);
+            changedPath.forEach(it => {
+                if (it.type === 'ViaSwitch') {
+                    deeenrgizedTerminalUUIDs.push(...Array.from(it.switchInstance.terminals.values()).map(it => it.getUUID()));
+                    deeenrgizedCn.push(...Array.from(it.switchInstance.terminals.values()).map(it => it?.connectivityNode));
+                }
+                if (it.type === 'ViaSchaltbarerNode') {
+                    deeenrgizedTerminalUUIDs.push(it.terminal.getUUID());
+                    deeenrgizedCn.push(it.terminal?.connectivityNode);
+                }
+            });
+            // Fehler elektrisch isolieren
+            this.invertSwitchStates(changedPath);
+            const failedSubstation = faultConnectivityNode.getSubstation();
+            const feederHeadNode = failedSubstation.getPsrType()?.getName() === 'Umspannanlage';
+            // 1. CNs der ausgefallenen Station ignorieren
+            const failedCNs = feederHeadNode ? [faultConnectivityNode] : allCNs.filter(cn => cn.getSubstation().getUUID() === failedSubstation.getUUID());
+            const failedFeeder = feederHeadNode ? Array.from(faultConnectivityNode.terminals.values()).find(it => it.conductingEquipment?.getAdditionalEquipmentContainer())?.conductingEquipment?.getAdditionalEquipmentContainer() : failedSubstation.getNormalEnergizingFeeder();
+            if (!failedFeeder) {
+                console.log(`faultCN ${faultConnectivityNode.getName()} | ${faultConnectivityNode.description} hat keinen Feeder`);
+                continue;
+            }
+            // CNs der Ortsnetzstationen (nicht Umspannanlage, nicht failed)
+            const candidateCNs = allCNs.filter(cn => {
+                return (cn.getSubstation().getPsrType()?.getName() !== 'Umspannanlage' && // alle CNs von Umspannanlagen
+                    cn.getSubstation().getUUID() !== failedSubstation.getUUID()) && // alle CNs der ausgefallenen ONS
+                    cn.getSubstation()?.getNormalEnergizingFeeder() && // Substation muss einen Abgang besitzen
+                    cn?.additionalConnectivityNodeContainer; // 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) {
+                const involvedFeeder = new Array();
+                console.log(`Prüfe Combo ${combinations.indexOf(combo)}`);
+                for (const combination of combo) {
+                    console.log('\tinvolved CNs');
+                    combination.terminals.forEach(t => console.log(`\t\t${t.connectivityNode?.getUUID()}`));
+                    console.log('\tinvolved Switches', combination.swtch?.getUUID(), switches.find(it => it.getUUID() === combination.swtch?.getUUID()) !== undefined);
+                    console.log('\tinvolved Feeder');
+                    combination.feeders.forEach(feeder => console.log(`\t\t${feeder.name}`));
+                    involvedFeeder.push(...combination.feeders.filter(it => it));
+                }
+                const isUseful = ContingencyAnalysisNeplanWestnetz.isSwitchCombinationUseful(combo, disconnectedCNs, terminals, switches, externalNetworkInjections);
+                console.log(`\tisUseful ${isUseful}`);
+                if (!isUseful)
+                    continue;
+                // Schaltzustand anwenden
+                const s = new Array();
+                for (const c of combo) {
+                    c.terminals.forEach(it => s.push(it.name));
+                }
+                // const involvedFeeder: Array<Feeder> = this.getFeedersFromCombo(failedFeeder, combo);
+                // Die Maßnahmen einzeln anwenden, um wirksamkeit zu prüfen
+                ContingencyAnalysisNeplanWestnetz.applySwitchCombination(combo);
+                // Abgang auf Zyklen prüfen
+                const cycle = ContingencyAnalysisNeplanWestnetz.hasCycleInFeeder(involvedFeeder, terminals, switches);
+                const resupplyResult = {
+                    uuid: common_utils_1.CommonUtils.generateUUID(),
+                    faultConnectivityNode: faultConnectivityNode,
+                    deenergizedActions: changedPath,
+                    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;
+                }
+                const resuppledConnectivityNodesUUID = resupplyResult.resuppledConnectivityNodes.map(it => it.getUUID());
+                resupplyResult.deenergezedConnectivityNodes.forEach(it => {
+                    if (!resuppledConnectivityNodesUUID.includes(it.getUUID()))
+                        console.log(it.getUUID());
+                });
+                // 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
+            this.invertSwitchStates(changedPath);
+            evaluatedResupplyActions.set(faultConnectivityNode.getUUID(), resupplyResults);
+        }
+        return evaluatedResupplyActions;
+    }
+    static hasCycleInFeeder(involvedFeeders, allTerminals, allSwitches) {
+        const feederUUID = involvedFeeders.map(it => it.getUUID())?.filter(it => it);
+        // 1. Relevante ACLineSegment-Terminals filtern
+        const feederTerminals = allTerminals.filter(it => feederUUID.includes(it.connectivityNode?.additionalConnectivityNodeContainer?.getUUID()) && it.connected);
+        const relevantTerminals = feederTerminals.filter(t => t.getConnectivityNode()?.getSubstation()?.getPsrType()?.getName() !== "Umspannanlage" &&
+            (t.conductingEquipment instanceof ACLineSegment_1.ACLineSegment || t.conductingEquipment instanceof Switch_1.Switch));
+        // 2. Geschlossene Switches mit einem Feeder
+        const aaa = allSwitches.find(it => it.getUUID() === 'ad29f120-a6c0-4577-9adf-af7562b289f6');
+        const closedSwitches = allSwitches.filter(sw => !sw.open);
+        const bbb = closedSwitches.find(it => it.getUUID() === 'ad29f120-a6c0-4577-9adf-af7562b289f6');
+        // 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);
+            }
+        }
+        const switchFeedersArray = new Array;
+        // 4. Union aller über Switches verbundenen ConnectivityNodes
+        for (const sw of closedSwitches) {
+            if (sw.getUUID() === 'ad29f120-a6c0-4577-9adf-af7562b289f6') {
+                console.log();
+            }
+            const swTerminals = allTerminals.filter(t => t.conductingEquipment?.getUUID() === sw?.getUUID() &&
+                t.connected &&
+                feederUUID.includes(t.connectivityNode?.additionalConnectivityNodeContainer?.getUUID()));
+            if (swTerminals.length === 2) {
+                const [a, b] = swTerminals.map(t => t.getConnectivityNode()?.getUUID());
+                console.log('union', sw.getUUID(), a, b);
+                union(a, b);
+                switchFeedersArray.push(...swTerminals.map(it => it.connectivityNode?.additionalConnectivityNodeContainer));
+            }
+        }
+        // 5. Adjazenzmatrix 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()) as Array<Feeder>;
+        const switchFeeders = switchFeedersArray.filter(t => t);
+        const feeders = new Set([...involvedFeeders, ...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 => t.conductingEquipment?.getUUID() === eq?.getUUID());
+                if (lineTerminals.length === 2) {
+                    const [a, b] = lineTerminals.map(t => t.connectivityNode?.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 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) {
+        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?.connected)
+                continue;
+            if (!t?.connectivityNode)
+                continue;
+            const cnUUID = t.connectivityNode?.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 = cnToTerminals.get(currentId) ?? [];
+            for (const terminal of cnTerminals) {
+                if (!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?.connected)
+                        continue;
+                    if (!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) {
+        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 switchTerminals = Array.from(swtch.terminals.values())?.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 feeder = switchConnectivityNodes.map(it => it.additionalConnectivityNodeContainer?.getUUID()).filter(it => it);
+            // Wenn Feederanzahl < 2 ist, dann ist mind. einer ConnectivityNode spannungslos
+            if (feeder.length < 2)
+                continue;
+            const switchConductingEquipments2dArray = switchConnectivityNodes.map(it => {
+                return Array.from(it.terminals.values()).map(it => it.conductingEquipment);
+            });
+            // in ein eindimensionales Array überführen
+            const flattenSwitchConductingEquipments = switchConductingEquipments2dArray?.flat();
+            // Datenfehler filtern -> Terminal hat kein conductingEquipment und ist keinem Abgang zugeordnet
+            const switchConductingEquipments = flattenSwitchConductingEquipments?.filter(it => it && it.getAdditionalEquipmentContainer());
+            if ( /*ceFeeder?.getUUID() !== failedFeeder.getUUID() &&*/!feeder.includes(failedFeeder.getUUID()))
+                continue;
+            const feeders = feeder.map(it => baseModel.getFeeder(it));
+            results.push({
+                swtch,
+                terminals: Array.from(swtch.terminals.values()).filter(it => !it.connected),
+                feeders
+            });
+        }
+        return results;
+    }
+    static findOpenedTerminalsToOtherFeeders(connectivityNodes, deeenrgizedTerminalUUIDs, failedFeeder, baseModel) {
+        // 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;
+            if (!terminal.conductingEquipment || !terminal.connectivityNode)
+                continue;
+            // Verbundungen zu Switches werden übersprungen
+            if (terminal.conductingEquipment instanceof Switch_1.Switch)
+                continue;
+            // Verbundungen zu Switches Lasten und Einspeisern werden übersprungen
+            if (terminal.conductingEquipment instanceof EnergySource_1.EnergySource)
+                continue;
+            if (terminal.conductingEquipment instanceof EnergyConsumer_1.EnergyConsumer)
+                continue;
+            if (connectivityNodes.includes(terminal.connectivityNode))
+                continue;
+            const connectivityNode = terminal.connectivityNode;
+            // Nur Terminals mit einer Verbindung zum Feeder des betrachteten ConnectivityNodes, um offene Trennstellen zwischen anderen Abgängen zu ignorieren
+            const ceFeeder = terminal.conductingEquipment?.getAdditionalEquipmentContainer();
+            const cnFeeder = connectivityNode.getSubstation()?.getNormalEnergizingFeeder();
+            if (ceFeeder?.getUUID() !== failedFeeder.getUUID() && cnFeeder?.getUUID() !== failedFeeder.getUUID())
+                continue;
+            // Offene Trennstellen zu Objekten ohne Feeder werden nicht betrachtet, da spannungslose Querverbindungen zu anderen UAs
+            if (!ceFeeder || !cnFeeder)
+                continue;
+            results.push({
+                swtch: null,
+                terminals: new Array(terminal),
+                feeders: [ceFeeder, cnFeeder]
+            });
+        }
+        return results;
+    }
+    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?.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);
+                const matchedTerminals = new Array();
+                // Finde den Terminal, der mit dem letzten Equipment verbunden ist
+                if (lastEquipment) {
+                    for (const terminal of currentNode.terminals.values()) {
+                        if (terminal.conductingEquipment === lastEquipment) {
+                            matchedTerminals.push(terminal);
+                            break;
+                        }
+                    }
+                }
+                else {
+                    // Ausfallknoten ist schaltbar - füge alle Terminals zur Maßnahme hinzu
+                    for (const terminal of currentNode.terminals.values()) {
+                        if (terminal.conductingEquipment !== undefined) {
+                            matchedTerminals.push(terminal);
+                        }
+                    }
+                }
+                for (const terminal of matchedTerminals) {
+                    result.push({
+                        type: 'ViaSchaltbarerNode',
+                        terminal: terminal,
+                        path: [...path]
+                    });
+                }
+                continue;
+            }
+            for (const terminal of currentNode.terminals.values()) {
+                const equipment = 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?.connectivityNode;
+                    if (!nextNode || visitedNodes.has(nextNode.getUUID()))
+                        continue;
+                    toVisit.push({
+                        node: nextNode,
+                        path: [...path, { node: currentNode, equipment }]
+                    });
+                }
+            }
+        }
+        return result;
+    }
+    static invertSwitchStates(obj) {
+        obj.forEach(it => {
+            if (it.type === 'ViaSwitch') {
+                it.switchInstance.open = !it.switchInstance.open;
+            }
+            if (it.type === 'ViaSchaltbarerNode') {
+                it.terminal.connected = !it.terminal.connected;
+            }
+        });
+    }
+    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);
+    }
+    /** Funktion zur Entnahme n-Elemente aus einem beliebig langen Array
+     * @param arr Array mit Objekten
+     * @param max Anzahl der zu entnehmenden Objekte aus dem Array */
+    /*
+      public static getFeedersFromCombo(failedFeeder: Feeder, combos: Array<ICombination>): Array<Feeder> {
+        const feederSet = new Set<Feeder>();
+        feederSet.add(failedFeeder);
+        for (const combo of combos) {
+  
+          combo.terminals.forEach(it => feederSet.add(it.getConnectivityNode().getSubstation()?.getNormalEnergizingFeeder()));
+          combo.swtch?.terminals.forEach(it => feederSet.add((it.getConnectivityNode() as ConnectivityNode)?.getSubstation()?.getNormalEnergizingFeeder()));
+        }
+  
+        return Array.from(feederSet).filter(it => it !== undefined);
+      }
+    */
+    static isSwitchCombinationUseful(combo, disconnectedCNs, terminals, switches, externalNetworkInjections) {
+        const resuppliedNodes = new Set();
+        const processedSwitches = new Array();
+        const processedTerminals = new Array();
+        let useful = true;
+        for (const switchElement of combo) {
+            for (const terminal of switchElement.terminals) {
+                terminal.connected = !terminal.connected;
+            }
+            if (switchElement.swtch) {
+                switchElement.swtch.open = !switchElement.swtch.open;
+            }
+            for (const terminal of switchElement.terminals) {
+                // terminal.connected = !terminal.connected;
+                processedTerminals.push(terminal);
+                const reachableNodes = ContingencyAnalysisNeplanWestnetz.getSuppliedNodes(disconnectedCNs, terminals, switches, externalNetworkInjections);
+                if (reachableNodes.size === 0)
+                    useful = false;
+                if (!ContingencyAnalysisNeplanWestnetz.setContainsElement(resuppliedNodes, reachableNodes)) {
+                    // ContingencyAnalysisNeplanWestnetz.resetSwitchStates(processedTerminals, processedSwitches);
+                    useful = false;
+                }
+                reachableNodes.forEach(it => resuppliedNodes.add(it));
+                // terminal.connected = !terminal.connected;
+            }
+            if (switchElement.swtch) {
+                //switchElement.swtch.open = !switchElement.swtch.open;
+                processedSwitches.push(switchElement.swtch);
+                const reachableNodes = ContingencyAnalysisNeplanWestnetz.getSuppliedNodes(disconnectedCNs, terminals, switches, externalNetworkInjections);
+                if (reachableNodes.size === 0)
+                    useful = false;
+                if (!ContingencyAnalysisNeplanWestnetz.setContainsElement(resuppliedNodes, reachableNodes)) {
+                    // ContingencyAnalysisNeplanWestnetz.resetSwitchStates(processedTerminals, processedSwitches);
+                    useful = false;
+                }
+                reachableNodes.forEach(it => resuppliedNodes.add(it));
+                // switchElement.swtch.open = !switchElement.swtch.open;
+            }
+            for (const terminal of switchElement.terminals) {
+                terminal.connected = !terminal.connected;
+            }
+            if (switchElement.swtch) {
+                switchElement.swtch.open = !switchElement.swtch.open;
+            }
+        }
+        //ContingencyAnalysisNeplanWestnetz.resetSwitchStates(processedTerminals, processedSwitches);
+        return useful;
+    }
+    static setContainsElement(resuppledNodes, reachableNodes) {
+        const resuppliedMrids = new Set([...resuppledNodes].map(o => o.mrid));
+        if (resuppledNodes.size === 0 || reachableNodes.size > 1)
+            return true;
+        else
+            return [...reachableNodes].some(obj => !resuppliedMrids.has(obj.mrid));
+    }
+    static resetSwitchStates(terminals, switches) {
+        for (const terminal of terminals) {
+            terminal.connected = !terminal.connected;
+        }
+        for (const swtch of switches) {
+            swtch.open = !swtch.open;
+        }
+    }
+    static getSuppliedNodes(disconnectedCNs, terminals, switches, externalNetworkInjections) {
+        const reachableNodes = new Set();
+        for (const cn of disconnectedCNs) {
+            const reachable = ContingencyAnalysisNeplanWestnetz.isNodeSupplied(cn, terminals, switches, externalNetworkInjections);
+            if (reachable)
+                reachableNodes.add(cn);
+        }
+        return reachableNodes;
+    }
+}
+exports.ContingencyAnalysisNeplanWestnetz = ContingencyAnalysisNeplanWestnetz;
+//# sourceMappingURL=contingency-analysis.neplan.westnetz.js.map