@enervance/insight-cim-model 1.0.0-dev3 → 1.0.0-dev5

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

@@ -1,718 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ContingencyAnalysisNeplanWestnetz = void 0;
-const ACLineSegment_1 = require("../../model/wires/ACLineSegment");
-const EVSwitchingPlanKind_1 = require("../../model/extensions/enervance/operations/EVSwitchingPlanKind");
-const WNConnectivityNode_1 = require("../../model/extensions/westnetz-neplan/core/WNConnectivityNode");
-const WNOutage_1 = require("../../model/extensions/westnetz-neplan/operations/WNOutage");
-const common_utils_1 = require("../../utils2/common.utils");
-const ConductingEquipment_1 = require("../../model/core/ConductingEquipment");
-const EVTerminal_1 = require("../../model/extensions/enervance/core/EVTerminal");
-const WNFaultConnectivityNode_1 = require("../../model/extensions/westnetz-neplan/faults/WNFaultConnectivityNode");
-const etl_neplan_contingency_analysis_1 = require("../../etl/etl-neplan/etl-neplan-contingency-analysis");
-const SwitchActionKind_1 = require("../../model/operations/SwitchActionKind");
-const neplan_contingency_analysis_1 = require("../../etl/etl-neplan/neplan-contingency-analysis");
-const sparql_utils_1 = require("../../util/sparql/sparql-utils");
-const ExternalNetworkInjection_1 = require("../../model/wires/ExternalNetworkInjection");
-const Switch_1 = require("../../model/wires/Switch");
-const WNSwitchTypeKind_1 = require("../../model/extensions/westnetz-neplan/core/WNSwitchTypeKind");
-const EnergySource_1 = require("../../model/wires/EnergySource");
-const EnergyConsumer_1 = require("../../model/wires/EnergyConsumer");
-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