@enervance/insight-cim-model 0.0.448 → 0.0.455

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

@@ -1,27 +1,32 @@
 "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 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 neplan_contingency_analysis_1 = require("../../etl/etl-neplan/neplan-contingency-analysis.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) {
         var _a, _b, _c;
         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 */
@@ -40,72 +45,92 @@ class ContingencyAnalysisNeplanWestnetz {
             for (const resupplyResult of resupplyResults.values()) {
                 // Ausfall
                 const outageNode = (_b = resupplyResult.find(it => it.faultConnectivityNode)) === null || _b === void 0 ? void 0 : _b.faultConnectivityNode;
+                if (outageNode === undefined) {
+                    continue;
+                }
                 // Freischaltungsmaßnahme
                 const deenergizedAction = (_c = resupplyResult.find(it => it.deenergizedActions)) === null || _c === void 0 ? void 0 : _c.deenergizedActions;
+                // Schaltmaßnahmen ohne Zyklen
+                const resupplyActionsWithoudCycles = resupplyResult.filter(it => !it.cycle);
                 // Schaltmaßnahmen mit vollständiger Wiederversorgung
-                const fullyResuppliedActions = resupplyResult.filter(it => !it.cycle && it.resupplyType === EVSwitchingPlanKind_1.EVSwitchingPlanKind.fullyResupply);
+                const fullyResuppliedActions = resupplyActionsWithoudCycles.filter(it => 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
+                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}`);
-                if (fullyResuppliedActions.length === 0)
+                const actions = fullyResuppliedActions.length ? fullyResuppliedActions : partiallyResuppliedActions;
+                if (actions.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
-                        }
+                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));
                     }
-                    /** WNConnectivityNodes */
-                    for (const object of wnFeeder.normalEnergizedConnectivityNodes.values()) {
+                    else if (object instanceof WNConnectivityNode_1.WNConnectivityNode) {
                         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));
+                    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, neplan_contingency_analysis_1.createSwitchingPlan)(common_utils_1.CommonUtils.generateUUID(), wnFeeder.baseIRI, `Schaltmaßnahme-Restore`, 0, 'restore', outageNew, insertSPARQL);
+                    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);
-                    /** 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);
+                    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);
@@ -114,7 +139,7 @@ class ContingencyAnalysisNeplanWestnetz {
                         }
                         /** 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);
+                            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));
                         }
@@ -124,7 +149,7 @@ class ContingencyAnalysisNeplanWestnetz {
         }
         const length = insertSPARQL.length;
         const graphURI = modelContainer.getGraphURI();
-        return length === 0 ? [] : [
+        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#>
@@ -134,9 +159,10 @@ class ContingencyAnalysisNeplanWestnetz {
                         ${(0, sparql_utils_1.getInsertDataPartStatement)(graphURI, insertSPARQL)}
         `
         ];
+        return { sparql: sparql, report: report };
     }
     static findRessuplySwitchingActions(outageConnectivityNodes, baseModel) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         const evaluatedResupplyActions = new Map();
         const terminals = (Array.from(baseModel.terminals.values()));
         const allCNs = (Array.from(baseModel.connectivityNodes.values()));
@@ -149,31 +175,35 @@ class ContingencyAnalysisNeplanWestnetz {
             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);
                 }
             });
+            // Fehler elektrisch isolieren
+            this.invertSwitchStates(changedPath);
             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();
+            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 => {
                 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
+                    ((_b = cn.getSubstation()) === null || _b === void 0 ? void 0 : _b.getNormalEnergizingFeeder()) && // Substation muss einen Abgang besitzen
+                    (cn === null || cn === void 0 ? void 0 : cn.additionalConnectivityNodeContainer); // Substation muss einen Abgang besitzen
             });
             // 3. Suche nach CNs, die spannungslos sind
-            const failedFeederCNs = candidateCNs.filter(cn => { var _a, _b; return ((_b = (_a = cn === null || cn === void 0 ? void 0 : cn.getSubstation()) === null || _a === void 0 ? void 0 : _a.getNormalEnergizingFeeder()) === null || _b === void 0 ? void 0 : _b.getUUID()) === failedFeeder.getUUID(); });
-            const disconnectedCNs = failedFeederCNs.filter(cn => !ContingencyAnalysisNeplanWestnetz.isNodeSupplied(cn, terminals.filter(t => !failedCNs.includes(t.connectivityNode)), switches, externalNetworkInjections));
+            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];
@@ -182,18 +212,30 @@ class ContingencyAnalysisNeplanWestnetz {
             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 => { var _a; return console.log(`\t\t${(_a = t.connectivityNode) === null || _a === void 0 ? void 0 : _a.getUUID()}`); });
+                    console.log('\tinvolved Switches', (_d = combination.swtch) === null || _d === void 0 ? void 0 : _d.getUUID(), switches.find(it => { var _a; return it.getUUID() === ((_a = combination.swtch) === null || _a === void 0 ? void 0 : _a.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 switchNames = new Array();
+                const s = new Array();
                 for (const c of combo) {
-                    c.terminals.forEach(it => switchNames.push(it.name));
+                    c.terminals.forEach(it => s.push(it.name));
                 }
-                // hier die Kombinationen einzeln anwenden und auf sinnhaftigkeit prüfen.
+                // 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(failedFeeder, terminals, switches);
+                const cycle = ContingencyAnalysisNeplanWestnetz.hasCycleInFeeder(involvedFeeder, terminals, switches);
                 const resupplyResult = {
                     uuid: common_utils_1.CommonUtils.generateUUID(),
                     faultConnectivityNode: faultConnectivityNode,
@@ -219,37 +261,39 @@ class ContingencyAnalysisNeplanWestnetz {
                 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} ${switchNames.join(' ')} 
-                  \n cycle ${cycle} 
-                  \n resupplyResult ${resupplyResult.resupplyType} 
-                  \n ${resupplyResult.resuppledConnectivityNodes.map(it => it.name).join(' -> ')}`);
-                console.log();
+                /*        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
-            changedPath.forEach(it => {
-                if (it.type === 'ViaSwitch') {
-                    it.switchInstance.open = !it.switchInstance.open;
-                }
-                if (it.type === 'ViaSchaltbarerNode') {
-                    it.terminal.connected = !it.terminal.connected;
-                }
-            });
+            this.invertSwitchStates(changedPath);
             evaluatedResupplyActions.set(faultConnectivityNode.getUUID(), resupplyResults);
         }
         return evaluatedResupplyActions;
     }
-    static hasCycleInFeeder(feeder, terminals, switches) {
+    static hasCycleInFeeder(involvedFeeders, allTerminals, allSwitches) {
+        var _a;
+        const feederUUID = (_a = involvedFeeders.map(it => it.getUUID())) === null || _a === void 0 ? void 0 : _a.filter(it => it);
         // 1. Relevante ACLineSegment-Terminals filtern
-        const relevantTerminals = terminals.filter(t => {
+        const feederTerminals = allTerminals.filter(it => { var _a, _b; return feederUUID.includes((_b = (_a = it.connectivityNode) === null || _a === void 0 ? void 0 : _a.additionalConnectivityNodeContainer) === null || _b === void 0 ? void 0 : _b.getUUID()) && it.connected; });
+        const relevantTerminals = feederTerminals.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()));
+        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) {
@@ -269,19 +313,26 @@ class ContingencyAnalysisNeplanWestnetz {
                 // parent.set(rootV, rootU);
             }
         }
+        const switchFeedersArray = new Array;
         // 4. Union aller über Switches verbundenen ConnectivityNodes
         for (const sw of closedSwitches) {
-            const swTerminals = terminals.filter(t => {
-                var _a;
+            if (sw.getUUID() === 'ad29f120-a6c0-4577-9adf-af7562b289f6') {
+                console.log();
+            }
+            const swTerminals = allTerminals.filter(t => {
+                var _a, _b, _c;
                 return ((_a = t.conductingEquipment) === null || _a === void 0 ? void 0 : _a.getUUID()) === (sw === null || sw === void 0 ? void 0 : sw.getUUID()) &&
-                    t.connected;
+                    t.connected &&
+                    feederUUID.includes((_c = (_b = t.connectivityNode) === null || _b === void 0 ? void 0 : _b.additionalConnectivityNodeContainer) === null || _c === void 0 ? void 0 : _c.getUUID());
             });
             if (swTerminals.length === 2) {
                 const [a, b] = swTerminals.map(t => { var _a; return (_a = t.getConnectivityNode()) === null || _a === void 0 ? void 0 : _a.getUUID(); });
+                console.log('union', sw.getUUID(), a, b);
                 union(a, b);
+                switchFeedersArray.push(...swTerminals.map(it => { var _a; return (_a = it.connectivityNode) === null || _a === void 0 ? void 0 : _a.additionalConnectivityNodeContainer; }));
             }
         }
-        // 5. Adjazenzliste basierend auf den "komprimierten" Knoten
+        // 5. Adjazenzmatrix basierend auf den "komprimierten" Knoten
         const adjacency = new Map();
         function addEdgeCompressed(a, b) {
             const u = find(a);
@@ -296,8 +347,9 @@ class ContingencyAnalysisNeplanWestnetz {
             adjacency.get(v).add(u);
         }
         // 6. ACLineSegment-Verbindungen hinzufügen
-        const switchFeeders = closedSwitches.map(it => it.getAdditionalEquipmentContainer());
-        const feeders = new Set([feeder, ...switchFeeders]);
+        //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))
@@ -355,7 +407,7 @@ class ContingencyAnalysisNeplanWestnetz {
                 switchElement.swtch.open = !switchElement.swtch.open;
         }
     }
-    static isNodeSupplied(startNode, terminals, switches, externalNetworkInjections) {
+    static isNodeSupplied(startNode, terminals, switches, externalInjections) {
         var _a, _b;
         const visitedCN = new Set();
         const visitedEquipments = new Set();
@@ -395,7 +447,7 @@ class ContingencyAnalysisNeplanWestnetz {
                 visitedEquipments.add(eqId);
                 // Prüfe: Ist das Equipment ein ExternalNetworkInjection?
                 if (eq instanceof ExternalNetworkInjection_1.ExternalNetworkInjection) {
-                    const isExternalNetworkInjection = externalNetworkInjections.some(ext => ext.getUUID() === eq.getUUID());
+                    const isExternalNetworkInjection = externalInjections.some(ext => ext.getUUID() === eq.getUUID());
                     if (isExternalNetworkInjection)
                         return true;
                 }
@@ -418,7 +470,7 @@ class ContingencyAnalysisNeplanWestnetz {
         return false;
     }
     static findOpenedSwitchesToOtherFeeders(failedConnectivityNodes, failedFeeder, baseModel) {
-        var _a, _b;
+        var _a;
         const results = new Array();
         // Relevante Switches finden
         const switches = [...baseModel.switches.values(), ...baseModel.loadBreakSwitches.values(), ...baseModel.disconnectors.values(), ...baseModel.breakers.values()];
@@ -426,26 +478,33 @@ class ContingencyAnalysisNeplanWestnetz {
             // 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, _c; return (_c = (_b = (_a = it.connectivityNode) === null || _a === void 0 ? void 0 : _a.getSubstation()) === null || _b === void 0 ? void 0 : _b.getNormalEnergizingFeeder()) === null || _c === void 0 ? void 0 : _c.getUUID(); });
-            const switchConductingEquipments = (_b = switchConnectivityNodes.map(it => {
+            const feeder = switchConnectivityNodes.map(it => { var _a; return (_a = it.additionalConnectivityNodeContainer) === null || _a === void 0 ? void 0 : _a.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);
-            })) === 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()))
+            });
+            // in ein eindimensionales Array überführen
+            const flattenSwitchConductingEquipments = switchConductingEquipments2dArray === null || switchConductingEquipments2dArray === void 0 ? void 0 : switchConductingEquipments2dArray.flat();
+            // Datenfehler filtern -> Terminal hat kein conductingEquipment und ist keinem Abgang zugeordnet
+            const switchConductingEquipments = flattenSwitchConductingEquipments === null || flattenSwitchConductingEquipments === void 0 ? void 0 : 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)
+                terminals: Array.from(swtch.terminals.values()).filter(it => !it.connected),
+                feeders
             });
         }
         return results;
     }
     static findOpenedTerminalsToOtherFeeders(connectivityNodes, deeenrgizedTerminalUUIDs, failedFeeder, baseModel) {
-        var _a, _b, _c;
+        var _a, _b;
         // Relevante Terminals finden
         const results = new Array();
         for (const terminal of baseModel.terminals.values()) {
@@ -454,25 +513,31 @@ class ContingencyAnalysisNeplanWestnetz {
                 continue;
             if (deeenrgizedTerminalUUIDs.includes(terminal.getUUID()))
                 continue;
-            // Verbundungen zu Switches werden übersprungen
             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;
-            // Nur Terminals, die eine Verbindung zum Feeder des betrachteten ConnectivityNodes
+            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 = (_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();
+            const cnFeeder = (_b = connectivityNode.getSubstation()) === null || _b === void 0 ? void 0 : _b.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;
+            // 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)
+                terminals: new Array(terminal),
+                feeders: [ceFeeder, cnFeeder]
             });
         }
         return results;
@@ -494,30 +559,30 @@ class ContingencyAnalysisNeplanWestnetz {
             const lastStep = path[path.length - 1];
             const lastEquipment = lastStep === null || lastStep === void 0 ? void 0 : lastStep.equipment;
             // Prüfe auf schaltbaren Node
-            if ((currentNode.isSwitchableAtAll()) && !visitedSchaltbareNodes.has(nodeId)) {
+            if ((currentNode.switchable === WNSwitchTypeKind_1.WNSwitchTypeKind.S || currentNode.switchable === WNSwitchTypeKind_1.WNSwitchTypeKind.E) && !visitedSchaltbareNodes.has(nodeId)) {
                 visitedSchaltbareNodes.add(nodeId);
-                let matchedTerminal;
+                const matchedTerminals = new Array();
                 // Finde den Terminal, der mit dem letzten Equipment verbunden ist
-                for (const terminal of currentNode.terminals.values()) {
-                    if (lastEquipment && terminal.conductingEquipment === lastEquipment) {
-                        matchedTerminal = terminal;
-                        break;
+                if (lastEquipment) {
+                    for (const terminal of currentNode.terminals.values()) {
+                        if (terminal.conductingEquipment === lastEquipment) {
+                            matchedTerminals.push(terminal);
+                            break;
+                        }
                     }
                 }
-                // Fallback: irgendein Terminal (z.B. Startpunkt ist schaltbar)
-                if (!matchedTerminal && currentNode.terminals.size > 0) {
+                else {
+                    // Ausfallknoten ist schaltbar - füge alle Terminals zur Maßnahme hinzu
                     for (const terminal of currentNode.terminals.values()) {
-                        result.push({
-                            type: 'ViaSchaltbarerNode',
-                            terminal: terminal,
-                            path: [...path]
-                        });
+                        if (terminal.conductingEquipment !== undefined) {
+                            matchedTerminals.push(terminal);
+                        }
                     }
                 }
-                else {
+                for (const terminal of matchedTerminals) {
                     result.push({
                         type: 'ViaSchaltbarerNode',
-                        terminal: matchedTerminal,
+                        terminal: terminal,
                         path: [...path]
                     });
                 }
@@ -556,6 +621,16 @@ class ContingencyAnalysisNeplanWestnetz {
         }
         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 [];
@@ -564,38 +639,69 @@ class ContingencyAnalysisNeplanWestnetz {
         // 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)
-                    return false;
+                    useful = false;
                 if (!ContingencyAnalysisNeplanWestnetz.setContainsElement(resuppliedNodes, reachableNodes)) {
-                    ContingencyAnalysisNeplanWestnetz.resetSwitchStates(processedTerminals, processedSwitches);
-                    return false;
+                    // 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;
+                //switchElement.swtch.open = !switchElement.swtch.open;
                 processedSwitches.push(switchElement.swtch);
                 const reachableNodes = ContingencyAnalysisNeplanWestnetz.getSuppliedNodes(disconnectedCNs, terminals, switches, externalNetworkInjections);
                 if (reachableNodes.size === 0)
-                    return false;
+                    useful = false;
                 if (!ContingencyAnalysisNeplanWestnetz.setContainsElement(resuppliedNodes, reachableNodes)) {
-                    ContingencyAnalysisNeplanWestnetz.resetSwitchStates(processedTerminals, processedSwitches);
-                    return false;
+                    // 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 true;
+        //ContingencyAnalysisNeplanWestnetz.resetSwitchStates(processedTerminals, processedSwitches);
+        return useful;
     }
     static setContainsElement(resuppledNodes, reachableNodes) {
         const resuppliedMrids = new Set([...resuppledNodes].map(o => o.mrid));