@enervance/insight-cim-model 0.0.433 → 0.0.435

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

@@ -1,379 +1,372 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.performContingencyAnalysisV2 = performContingencyAnalysisV2;
-exports.createSwitchingPlan = createSwitchingPlan;
-exports.createTerminalAction = createTerminalAction;
-exports.createSwitchAction = createSwitchAction;
-exports.getPartiallySwitchingActionForSubstations = getPartiallySwitchingActionForSubstations;
-exports.addNewRepairActions = addNewRepairActions;
-exports.sort2DArray = sort2DArray;
-exports.getDeenergizedSubstations = getDeenergizedSubstations;
-const WNConnectivityNode_1 = require("../../model/extensions/westnetz-neplan/core/WNConnectivityNode.js");
-const ConductingEquipment_1 = require("../../model/core/ConductingEquipment.js");
-const Switch_1 = require("../../model/wires/Switch.js");
-const SwitchingPlan_1 = require("../../model/operations/SwitchingPlan.js");
-const EVTerminalAction_1 = require("../../model/extensions/enervance/operations/EVTerminalAction.js");
-const SwitchActionKind_1 = require("../../model/operations/SwitchActionKind.js");
-const graph_1 = require("../../data-structures/graph/graph.js");
-const util_topology_1 = require("../../util/util-topology.js");
-const ConnectivityNode_1 = require("../../model/core/ConnectivityNode.js");
-const Terminal_1 = require("../../model/core/Terminal.js");
-const GraphEdge_1 = require("../../data-structures/graph/edges/GraphEdge.js");
-const GraphNode_1 = require("../../data-structures/graph/nodes/GraphNode.js");
-const Types_1 = require("../../data-structures/graph/Types.js");
-const connection_1 = require("../../data-structures/graph/connections/connection.js");
-const ExternalNetworkInjection_1 = require("../../model/wires/ExternalNetworkInjection.js");
-const graph_interfaces_1 = require("../../data-structures/graph/graph-interfaces.js");
-const graph_util_1 = require("../../data-structures/graph/graph-util.js");
-const ACLineSegment_1 = require("../../model/wires/ACLineSegment.js");
-const WNOutage_1 = require("../../model/extensions/westnetz-neplan/operations/WNOutage.js");
-const utils_1 = require("../../util/utils.js");
-const EVTerminal_1 = require("../../model/extensions/enervance/core/EVTerminal.js");
-const WNFaultConnectivityNode_1 = require("../../model/extensions/westnetz-neplan/faults/WNFaultConnectivityNode.js");
-const SwitchAction_1 = require("../../model/operations/SwitchAction.js");
-const sparql_utils_1 = require("../../util/sparql/sparql-utils.js");
-const common_utils_1 = require("../../utils2/common.utils.js");
-const cim_constants_1 = require("../../constants/cim-constants.js");
-const permutation_utils_1 = require("../../utils2/permutation.utils.js");
-const EVSwitchingPlanKind_1 = require("../../model/extensions/enervance/operations/EVSwitchingPlanKind.js");
-function performContingencyAnalysisV2(modelContainer) {
-    var _a, _b, _c, _d;
-    const graphURI = modelContainer.getGraphURI();
-    const limit = 0;
-    /** alle elektrisch zusammenhängende Teilnetze bestimmen mit Berücksichtigung des Schaltzustandes */
-    const networks = (0, util_topology_1.determineTopologicalIslands)(modelContainer);
-    /** rechenbare Netze bestimmen */
-    const computableGrids = (0, util_topology_1.determineComputableGrid)(networks);
-    /** Slackelemente für rechenbare Netze, unabhängig vom Schaltzustand */
-    /** Key Netzindex, Value alle vom Slack aus erreichbare Elemente (ACLineSegments trennen Slack-UAs) */
-    const computableGridsSlackElements = (0, util_topology_1.determineNetworksSlackElements)(modelContainer, computableGrids);
-    /** KRUECKE Anlagen mit mehr als 10 Switchelementen und Slacks werden als Umspannanlagen markiert. */
-    const substationElements = (0, util_topology_1.determineSubstations)(modelContainer, computableGridsSlackElements);
-    computableGridsSlackElements.push(substationElements);
-    /** Graph initialisieren */
-    const graph = new graph_1.Graph(modelContainer);
-    const slackUUIDs = [];
-    const terminals = [];
-    /** Graph initialisieren */
-    for (const element of modelContainer.objects.values()) {
-        if (element instanceof ConnectivityNode_1.ConnectivityNode) {
-            graph.addNode(new GraphNode_1.GraphNode(element.mrid, element.name, element));
-        }
-        else if (element instanceof Terminal_1.Terminal) {
-            terminals.push(element);
-        }
-        else if (element instanceof ConductingEquipment_1.ConductingEquipment) {
-            if (element instanceof ExternalNetworkInjection_1.ExternalNetworkInjection) {
-                graph.addEdge(new GraphEdge_1.GraphEdge(element.mrid, element.name, element, Types_1.Type.ExternalNetworkinjection, true));
-                slackUUIDs.push(element.mrid);
-            }
-            else if (element instanceof Switch_1.Switch) {
-                graph.addEdge(new GraphEdge_1.GraphEdge(element.mrid, element.name, element, Types_1.Type.Switch, element.open));
-            }
-            else {
-                graph.addEdge(new GraphEdge_1.GraphEdge(element.mrid, element.name, element, Types_1.Type.ConductingEquipment, false));
-            }
-        }
-    }
-    /** Konnektivität durch terminals herstellen */
-    for (const terminal of terminals) {
-        const node = graph.nodes.get((_a = terminal.connectivityNode) === null || _a === void 0 ? void 0 : _a.mrid);
-        const edge = graph.edges.get((_b = terminal.conductingEquipment) === null || _b === void 0 ? void 0 : _b.mrid);
-        if (node && edge) {
-            const term = new connection_1.Connection(terminal.mrid, terminal.connected, node, edge);
-            node.addTerminal(term);
-            edge.addTerminal(term);
-            graph.addTerminal(term);
-        }
-    }
-    /** 1.1 Bestimme pro Abgang alle elektrisch nicht verbundene Elemente (Knoten und ConductingEquipments) und bbfs. offene Switches */
-    /** 1.2 Überrpüfe nicht verbundene Elemente auf die Abgangszugehörigkeit zu anderen Abgängen */
-    /** 2 Erstelle für jedes nicht verbundenes Element, das zu einem anderen Abgang gehört, eine Schaltmaßname. */
-    const insertSPARQL = [];
-    for (const feeder of modelContainer.feeders.values()) {
-        const wnFeeder = feeder;
-        const disconnectedTerminalCNs = []; // nicht verbundene Knoten zu anderen Abgängen
-        const disconnectedTerminalCEs = []; // nicht verbundene leitende Equipments
-        const disconnectedSwitches = []; // nicht verbundene Schaltelemente mit allen offenen Terminals zu anderen Abgängen
-        const disconnectedSelfTerminalCN = []; // nicht verbundene Knoten zum gleichen Abgang
-        const disconnectedSelfTerminalCE = []; // nicht verbundene Knoten zum gleichen Abgang
-        const disconnectedSelfSwitches = []; // nicht verbundene Schaltelemente mit allen offenen Terminals zum gleichen Abgang
-        /** 1.1) nicht verbundene Knoten und Switches bestimmen von Equipments aus*/
-        for (const equip of wnFeeder.additionalGroupedEquipment.values()) {
-            if (equip instanceof ConductingEquipment_1.ConductingEquipment) {
-                const ce = equip;
-                // Bestimme nicht verbundene CNs
-                for (const terminal of ce.terminals.values()) {
-                    /** Offene Terminals */
-                    if (!terminal.isClosed()) {
-                        /** verbindungen zu anderen Angängen */
-                        if (!wnFeeder.normalEnergizedConnectivityNodes.has((_c = terminal.connectivityNode) === null || _c === void 0 ? void 0 : _c.mrid)) {
-                            if (terminal.connectivityNode && terminal.connectivityNode.additionalConnectivityNodeContainer) {
-                                disconnectedTerminalCNs.push([terminal]);
-                            }
-                        }
-                        else if (wnFeeder.normalEnergizedConnectivityNodes.has((_d = terminal.connectivityNode) === null || _d === void 0 ? void 0 : _d.mrid)) {
-                            /** offene Verbindungen zu sich selbst */
-                            if (!(0, graph_util_1.isSwitchObjectInArray)(terminal, [...disconnectedSelfTerminalCN, ...disconnectedSelfTerminalCE]))
-                                disconnectedSelfTerminalCN.push([terminal]);
-                        }
-                    }
-                    /** geschlossener Terminal mit offenem Switch */
-                }
-            }
-        }
-        /** 1.2) nicht verbundene leitende Elemente bestimmen von ConnectivityNodes aus*/
-        for (const cn of wnFeeder.normalEnergizedConnectivityNodes.values()) {
-            // Bestimme nicht verbundene CNs
-            for (const terminal of cn.terminals.values()) {
-                /** offene Terminals */
-                if (!terminal.isClosed()) {
-                    /** ist offen und gehört zu einem anderen Abgang */
-                    const ce = terminal.conductingEquipment;
-                    if (!wnFeeder.additionalGroupedEquipment.has(ce.mrid) && (0, graph_util_1.isBelongingToFeeder)(ce.mrid, modelContainer.feeders, false)) {
-                        if (terminal.conductingEquipment.additionalEquipmentContainer.size) {
-                            disconnectedTerminalCEs.push([terminal]);
-                        }
-                    }
-                    else if (wnFeeder.additionalGroupedEquipment.has(ce.mrid)) {
-                        /** offene Verbindungen zu sich selbst */
-                        if (!(0, graph_util_1.isSwitchObjectInArray)(terminal, [...disconnectedSelfTerminalCN, ...disconnectedSelfTerminalCE]))
-                            disconnectedSelfTerminalCE.push([terminal]);
-                    }
-                    else {
-                        /** offenes Schaltalement,das zu keinem Abgang gehört
-                         * Schwerpunktanlage NICHT BERÜCKSICHTIGEN. */
-                        if (terminal.conductingEquipment instanceof Switch_1.Switch) {
-                            const swtch = terminal.conductingEquipment;
-                            if (!swtch.isClosed()) {
-                                /** Bestimme, ob der offene Switch
-                                 * -eine Verbindung in den gleichen Abgang
-                                 * -oder zu einem anderen Abgang darstellt */
-                                for (const trm of swtch.terminals.values()) {
-                                    /** suche den 'anderen Terminal' */
-                                    if (!trm.connectivityNode) {
-                                        console.log(`Terminal ${trm.mrid} hat keine ConnectivityNode-Instanz`);
-                                    }
-                                    if (trm.mrid !== terminal.mrid && trm.connectivityNode) {
-                                        const switchConnNodeUUID = trm.connectivityNode.mrid;
-                                        /** gehört zum gleichen Abgang */
-                                        if (wnFeeder.normalEnergizedConnectivityNodes.has(switchConnNodeUUID)) {
-                                            const switchArray = addSwitchTerminalToSwitchAction(terminal, trm, swtch);
-                                            disconnectedSelfSwitches.push(switchArray);
-                                        }
-                                        else if ((0, graph_util_1.isBelongingToFeeder)(switchConnNodeUUID, modelContainer.feeders, true)) {
-                                            /** gehört zum anderen Abgang? */
-                                            const switchArray = addSwitchTerminalToSwitchAction(terminal, trm, swtch);
-                                            disconnectedSwitches.push(switchArray);
-                                            /** Wenn der Knoten zu keinem Abgang gehört, dann ist er spannungslos
-                                             * und wird daher nicht berücksichtigt? */
-                                        }
-                                    }
-                                }
-                            }
-                        } /*else {
-                          console.log(`n-1 unbekanntes ce am terminal ${terminal.conductingEquipment.mrid}`);
-                        }*/
-                    }
-                }
-            }
-        }
-        /** relevante Ausfälle bestimmen */
-        const outageNodes = [];
-        for (const headTerminal of feeder.normalHeadTerminal.values()) {
-            outageNodes.push(headTerminal.connectivityNode);
-        }
-        for (const cn of wnFeeder.normalEnergizedConnectivityNodes.values()) {
-            // Muffen sind für N-1-Betrachtung nicht relevant
-            // if (cn.getType() === CimAssetAliasNames.Muffe) continue;
-            let connectedACLineSegments = 0;
-            for (const terminal of cn.terminals.values()) {
-                if (terminal.isClosed() && terminal.conductingEquipment instanceof ACLineSegment_1.ACLineSegment) {
-                    connectedACLineSegments++;
-                }
-            }
-            /** ab 3 ACLineSegments ist der Knoten für die Ausfallanalyse relevant */
-            if (connectedACLineSegments > 2)
-                outageNodes.push(cn);
-        }
-        // Ausfälle
-        const proceededContingencyNodes = [];
-        for (const outageSfCN of outageNodes) {
-            console.log(`Ausfallknoten ${outageSfCN.name} | ${outageSfCN.description}`);
-            /** abgearbeitete Knoten überspringen. Tritt auf, wenn ein Feederknoten untergeklemmte Leitungen besitzt */
-            if (proceededContingencyNodes.indexOf(outageSfCN.mrid) !== -1)
-                continue;
-            proceededContingencyNodes.push(outageSfCN.mrid);
-            const disconnectedTerminals = getDeenergizedSubstations(outageSfCN);
-            console.log('\tStationsfreischaltungen:');
-            disconnectedTerminals.forEach(it => console.log('\t\t' + it.connectivityNode.name + ' ' + it.connectivityNode.description));
-            const outageGraphNode = graph.nodes.get(outageSfCN.mrid);
-            const graphConnections = disconnectedTerminals.map(outage => graph.terminals.get(outage === null || outage === void 0 ? void 0 : outage.mrid)).filter(it => it);
-            /** Freischaltung der Fehlerstelle bestimmen - Muffen überspringen */
-            if (graphConnections.length) {
-                /** Stellen der Freischaltung vom Netz öffnen */
-                graphConnections.forEach(outage => {
-                    /** Als Ausfall markieren */
-                    outage.connected = false;
-                });
-                outageGraphNode.inService = false;
-                const outageUUID = outageSfCN.getUUID();
-                const outageResult = (0, graph_util_1.determineOutageAffectedSubstations)(graph, outageUUID, wnFeeder.normalEnergizedConnectivityNodes, slackUUIDs);
-                /** 2 Schaltmaßnahmen bestimmen */
-                const switchActionsFullyReenergized = [];
-                const switchActionsCombinedFullyReenergized = [];
-                const switchActionsPartiallyReenergized = [];
-                /** Ausfall führt zum Zerfall des Netzes */
-                if (outageResult.outageStations.size) {
-                    /** Schaltmaßnahmen evaluieren */
-                    // Schaltmaßnahmen von den CNs
-                    const switchActionsTerminalsCN = (0, graph_util_1.evaluateSwitchActions)(outageUUID, outageResult.outageStations, wnFeeder.normalEnergizedConnectivityNodes, graph, disconnectedTerminalCNs, slackUUIDs, graph_interfaces_1.SwitchTypeKind.otherFeeder);
-                    const switchActionsSelfTerminalsCN = (0, graph_util_1.evaluateSwitchActions)(outageUUID, outageResult.outageStations, wnFeeder.normalEnergizedConnectivityNodes, graph, disconnectedSelfTerminalCN, slackUUIDs, graph_interfaces_1.SwitchTypeKind.sameFeeder);
-                    // Schaltmaßnahmen von den CEs
-                    const switchActionsTerminalsCE = (0, graph_util_1.evaluateSwitchActions)(outageUUID, outageResult.outageStations, wnFeeder.normalEnergizedConnectivityNodes, graph, disconnectedTerminalCEs, slackUUIDs, graph_interfaces_1.SwitchTypeKind.otherFeeder);
-                    const switchActionsSelfTerminalsCE = (0, graph_util_1.evaluateSwitchActions)(outageUUID, outageResult.outageStations, wnFeeder.normalEnergizedConnectivityNodes, graph, disconnectedSelfTerminalCE, slackUUIDs, graph_interfaces_1.SwitchTypeKind.sameFeeder);
-                    // Schaltmaßnahmen von den Switches
-                    const switchActionsSwitches = (0, graph_util_1.evaluateSwitchActions)(outageUUID, outageResult.outageStations, wnFeeder.normalEnergizedConnectivityNodes, graph, disconnectedSwitches, slackUUIDs, graph_interfaces_1.SwitchTypeKind.otherFeeder);
-                    switchActionsFullyReenergized.push(...switchActionsTerminalsCN.filter(elem => elem.kind === EVSwitchingPlanKind_1.EVSwitchingPlanKind.fullyResupply), ...switchActionsTerminalsCE.filter(elem => elem.kind === EVSwitchingPlanKind_1.EVSwitchingPlanKind.fullyResupply), ...switchActionsSwitches.filter(elem => elem.kind === EVSwitchingPlanKind_1.EVSwitchingPlanKind.fullyResupply), ...switchActionsSelfTerminalsCN.filter(elem => elem.kind === EVSwitchingPlanKind_1.EVSwitchingPlanKind.fullyResupply), ...switchActionsSelfTerminalsCE.filter(elem => elem.kind === EVSwitchingPlanKind_1.EVSwitchingPlanKind.fullyResupply));
-                    const switchActionsPartially = [
-                        ...switchActionsTerminalsCN.filter(elem => elem.kind === EVSwitchingPlanKind_1.EVSwitchingPlanKind.partiallyResupply),
-                        ...switchActionsTerminalsCE.filter(elem => elem.kind === EVSwitchingPlanKind_1.EVSwitchingPlanKind.partiallyResupply),
-                        ...switchActionsSwitches.filter(elem => elem.kind === EVSwitchingPlanKind_1.EVSwitchingPlanKind.partiallyResupply),
-                        ...switchActionsSelfTerminalsCN.filter(elem => elem.kind === EVSwitchingPlanKind_1.EVSwitchingPlanKind.partiallyResupply),
-                        ...switchActionsSelfTerminalsCE.filter(elem => elem.kind === EVSwitchingPlanKind_1.EVSwitchingPlanKind.partiallyResupply),
-                    ];
-                    const switchActionsSelfNoResupply = [
-                        ...switchActionsSwitches.filter(elem => elem.kind === EVSwitchingPlanKind_1.EVSwitchingPlanKind.noResupply && elem.resupplyType === graph_interfaces_1.SwitchTypeKind.sameFeeder),
-                        ...switchActionsSelfTerminalsCN.filter(elem => elem.kind === EVSwitchingPlanKind_1.EVSwitchingPlanKind.noResupply && elem.resupplyType === graph_interfaces_1.SwitchTypeKind.sameFeeder),
-                        ...switchActionsSelfTerminalsCE.filter(elem => elem.kind === EVSwitchingPlanKind_1.EVSwitchingPlanKind.noResupply && elem.resupplyType === graph_interfaces_1.SwitchTypeKind.sameFeeder),
-                    ];
-                    /** Wenn es mehr als eine Maßnahme mit partieller Wiederversorgung gibt,
-                     * dann versuche eine Kombination zur vollständigen Wiederversorgung zu finden */
-                    const resultCombinedActions = new Array();
-                    if ([...switchActionsPartially, ...switchActionsSelfNoResupply].length > 1) {
-                        /** Relevante Permutationen bestimmen */
-                        const permutationElements = [...switchActionsPartially, ...switchActionsSelfNoResupply].map(it => it.uuid);
-                        const permutations = permutation_utils_1.PermutationUtils.getAllPermutation(permutationElements, 2);
-                        for (const currentPermutation of permutations) {
-                            // Schaltelemente aus den Permutationen bestimmen
-                            const cmobinedSwitchObjects = [...switchActionsPartially, ...switchActionsSelfNoResupply].filter(it => {
-                                return currentPermutation.find(permutationUUID => permutationUUID === it.uuid);
-                            }).map(it => it.switchObjects).flat();
-                            const combinedSwitchActions = (0, graph_util_1.evaluateSwitchActions)(outageUUID, outageResult.outageStations, wnFeeder.normalEnergizedConnectivityNodes, graph, [cmobinedSwitchObjects], slackUUIDs, graph_interfaces_1.SwitchTypeKind.combined);
-                            resultCombinedActions.push(...combinedSwitchActions);
-                        }
-                    }
-                    /** Maßnahmen mit größter Anzahl wiederversorgten Stationen finden */
-                    /** vollständige Wiederversorgung */
-                    const fl = resultCombinedActions.filter(elem => elem.kind === EVSwitchingPlanKind_1.EVSwitchingPlanKind.fullyResupply);
-                    if (fl.length)
-                        switchActionsCombinedFullyReenergized.push(...fl);
-                    const partiallyResupply = resultCombinedActions.filter(elem => elem.kind === EVSwitchingPlanKind_1.EVSwitchingPlanKind.partiallyResupply);
-                    if ([...switchActionsPartially, ...partiallyResupply].length) {
-                        const maxResupply = [...switchActionsPartially, ...partiallyResupply]
-                            .reduce((prev, current) => {
-                            return (prev && (0, graph_util_1.getOutageStationsCount)(prev.outageResult.outageStations) < (0, graph_util_1.getOutageStationsCount)(current.outageResult.outageStations)) ? prev : current;
-                        });
-                        if (maxResupply)
-                            switchActionsPartiallyReenergized.push(maxResupply);
-                    }
-                    else if (switchActionsPartially.length) {
-                        switchActionsPartiallyReenergized.push(...switchActionsPartially);
-                    }
-                }
-                /** 2 Schaltmaßnahmen: Modell erstellen und speichern */
-                const switchActions = [...switchActionsFullyReenergized, ...switchActionsCombinedFullyReenergized, ...switchActionsPartiallyReenergized];
-                // if (switchActionsFullyReenergised.length) {
-                if (switchActions.length) {
-                    //Ausfallschaltmaßnahme anlegen
-                    const faultCN = outageSfCN;
-                    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 = createSwitchingPlan(common_utils_1.CommonUtils.generateUUID(), wnFeeder.baseIRI, `Schaltmaßnahme-Ausfall`, -1, 'de-energise', outageNew, insertSPARQL);
-                    modelContainer.addSwitchingPlan(switchingPlanDeEnergise);
-                    /** SwitchingAction de-energise*/
-                    const switchingActionDeEnergise = 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 disconnectedTerminals) {
-                        insertSPARQL.push(switchingActionDeEnergise.addTerminal(terminal));
-                    }
-                    /** SwitchingPlan restore*/
-                    const switchingPlanRestore = createSwitchingPlan(common_utils_1.CommonUtils.generateUUID(), wnFeeder.baseIRI, `Schaltmaßnahme-Restore`, 0, 'restore', outageNew, insertSPARQL);
-                    modelContainer.addSwitchingPlan(switchingPlanRestore);
-                    /** SwitchingAction restore*/
-                    const switchingActionRestore = 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 disconnectedTerminals) {
-                        insertSPARQL.push(switchingActionRestore.addTerminal(terminal));
-                    }
-                    // Wiederversorgungsmaßnahmen
-                    for (let i = 0; i < switchActions.length; i++) {
-                        const switchAction = switchActions[i];
-                        //console.log('\tActions ' + switchAction.switchObjects);
-                        /** SwitchingPlan restore*/
-                        const switchingPlanRestore = createSwitchingPlan(common_utils_1.CommonUtils.generateUUID(), wnFeeder.baseIRI, `Schaltmaßnahme-Restore`, (i + 1), 'energise', outageNew, insertSPARQL);
-                        insertSPARQL.push(switchingPlanRestore.setKind(switchAction.kind));
-                        modelContainer.addSwitchingPlan(switchingPlanRestore);
-                        /** SwitchingAction restore*/
-                        for (const cimSwitchObject of switchAction.switchObjects) {
-                            //const cimSwitchObject = modelContainer.getObject(switchObjectUUID);
-                            if (cimSwitchObject) {
-                                if (cimSwitchObject instanceof Terminal_1.Terminal) {
-                                    const switchingActionRestore = createTerminalAction(common_utils_1.CommonUtils.generateUUID(), wnFeeder.baseIRI, `Schaltung-Restore`, SwitchActionKind_1.SwitchActionKind.close, switchingPlanRestore, insertSPARQL);
-                                    modelContainer.addSwitchingAction(switchingActionRestore);
-                                    insertSPARQL.push(switchingActionRestore.addTerminal(cimSwitchObject));
-                                }
-                                else if (cimSwitchObject instanceof Switch_1.Switch) {
-                                    const switchingActionRestore = createSwitchAction(common_utils_1.CommonUtils.generateUUID(), wnFeeder.baseIRI, `Schaltung-Restore`, SwitchActionKind_1.SwitchActionKind.close, switchingPlanRestore, insertSPARQL);
-                                    modelContainer.addSwitchingAction(switchingActionRestore);
-                                    insertSPARQL.push(switchingActionRestore.setSwitch(cimSwitchObject));
-                                }
-                            }
-                        }
-                    }
-                }
-                /** Stellen der Freischaltung wieder schliessen */
-                graphConnections.forEach(outage => {
-                    /** Als Ausfall markieren */
-                    outage.connected = true;
-                });
-                outageGraphNode.inService = true;
-            }
-        }
-    }
-    const length = insertSPARQL.length;
-    if (limit && length) {
-        const splittedStatements = (0, utils_1.splitArrayIntoChunks)(insertSPARQL, limit);
-        return (0, sparql_utils_1.createSPARQLStatement)('INSERT_DATA', graphURI, splittedStatements);
-    }
-    else if (length) {
-        return [
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDeenergizedSubstations = exports.sort2DArray = exports.addNewRepairActions = exports.getPartiallySwitchingActionForSubstations = exports.createSwitchAction = exports.createTerminalAction = exports.createSwitchingPlan = exports.performContingencyAnalysisV2 = void 0;
+const WNConnectivityNode_1 = require("../../model/extensions/westnetz-neplan/core/WNConnectivityNode.js");
+const ConductingEquipment_1 = require("../../model/core/ConductingEquipment.js");
+const Switch_1 = require("../../model/wires/Switch.js");
+const SwitchingPlan_1 = require("../../model/operations/SwitchingPlan.js");
+const EVTerminalAction_1 = require("../../model/extensions/enervance/operations/EVTerminalAction.js");
+const SwitchActionKind_1 = require("../../model/operations/SwitchActionKind.js");
+const graph_1 = require("../../data-structures/graph/graph.js");
+const util_topology_1 = require("../../util/util-topology.js");
+const ConnectivityNode_1 = require("../../model/core/ConnectivityNode.js");
+const Terminal_1 = require("../../model/core/Terminal.js");
+const GraphEdge_1 = require("../../data-structures/graph/edges/GraphEdge.js");
+const GraphNode_1 = require("../../data-structures/graph/nodes/GraphNode.js");
+const Types_1 = require("../../data-structures/graph/Types.js");
+const connection_1 = require("../../data-structures/graph/connections/connection.js");
+const ExternalNetworkInjection_1 = require("../../model/wires/ExternalNetworkInjection.js");
+const graph_interfaces_1 = require("../../data-structures/graph/graph-interfaces.js");
+const graph_util_1 = require("../../data-structures/graph/graph-util.js");
+const ACLineSegment_1 = require("../../model/wires/ACLineSegment.js");
+const WNOutage_1 = require("../../model/extensions/westnetz-neplan/operations/WNOutage.js");
+const utils_1 = require("../../util/utils.js");
+const EVTerminal_1 = require("../../model/extensions/enervance/core/EVTerminal.js");
+const WNFaultConnectivityNode_1 = require("../../model/extensions/westnetz-neplan/faults/WNFaultConnectivityNode.js");
+const SwitchAction_1 = require("../../model/operations/SwitchAction.js");
+const sparql_utils_1 = require("../../util/sparql/sparql-utils.js");
+const common_utils_1 = require("../../utils2/common.utils.js");
+const cim_constants_1 = require("../../constants/cim-constants.js");
+const permutation_utils_1 = require("../../utils2/permutation.utils.js");
+const EVSwitchingPlanKind_1 = require("../../model/extensions/enervance/operations/EVSwitchingPlanKind.js");
+function performContingencyAnalysisV2(modelContainer) {
+    var _a, _b, _c, _d;
+    const graphURI = modelContainer.getGraphURI();
+    const limit = 0;
+    /** alle elektrisch zusammenhängende Teilnetze bestimmen mit Berücksichtigung des Schaltzustandes */
+    const networks = (0, util_topology_1.determineTopologicalIslands)(modelContainer);
+    /** rechenbare Netze bestimmen */
+    const computableGrids = (0, util_topology_1.determineComputableGrid)(networks);
+    /** Slackelemente für rechenbare Netze, unabhängig vom Schaltzustand */
+    /** Key Netzindex, Value alle vom Slack aus erreichbare Elemente (ACLineSegments trennen Slack-UAs) */
+    const computableGridsSlackElements = (0, util_topology_1.determineNetworksSlackElements)(modelContainer, computableGrids);
+    /** KRUECKE Anlagen mit mehr als 10 Switchelementen und Slacks werden als Umspannanlagen markiert. */
+    const substationElements = (0, util_topology_1.determineSubstations)(modelContainer, computableGridsSlackElements);
+    computableGridsSlackElements.push(substationElements);
+    /** Graph initialisieren */
+    const graph = new graph_1.Graph(modelContainer);
+    const slackUUIDs = [];
+    const terminals = [];
+    /** Graph initialisieren */
+    for (const element of modelContainer.objects.values()) {
+        if (element instanceof ConnectivityNode_1.ConnectivityNode) {
+            graph.addNode(new GraphNode_1.GraphNode(element.mrid, element.name, element));
+        }
+        else if (element instanceof Terminal_1.Terminal) {
+            terminals.push(element);
+        }
+        else if (element instanceof ConductingEquipment_1.ConductingEquipment) {
+            if (element instanceof ExternalNetworkInjection_1.ExternalNetworkInjection) {
+                graph.addEdge(new GraphEdge_1.GraphEdge(element.mrid, element.name, element, Types_1.Type.ExternalNetworkinjection, true));
+                slackUUIDs.push(element.mrid);
+            }
+            else if (element instanceof Switch_1.Switch) {
+                graph.addEdge(new GraphEdge_1.GraphEdge(element.mrid, element.name, element, Types_1.Type.Switch, element.open));
+            }
+            else {
+                graph.addEdge(new GraphEdge_1.GraphEdge(element.mrid, element.name, element, Types_1.Type.ConductingEquipment, false));
+            }
+        }
+    }
+    /** Konnektivität durch terminals herstellen */
+    for (const terminal of terminals) {
+        const node = graph.nodes.get((_a = terminal.connectivityNode) === null || _a === void 0 ? void 0 : _a.mrid);
+        const edge = graph.edges.get((_b = terminal.conductingEquipment) === null || _b === void 0 ? void 0 : _b.mrid);
+        if (node && edge) {
+            const term = new connection_1.Connection(terminal.mrid, terminal.connected, node, edge);
+            node.addTerminal(term);
+            edge.addTerminal(term);
+            graph.addTerminal(term);
+        }
+    }
+    /** 1.1 Bestimme pro Abgang alle elektrisch nicht verbundene Elemente (Knoten und ConductingEquipments) und bbfs. offene Switches */
+    /** 1.2 Überrpüfe nicht verbundene Elemente auf die Abgangszugehörigkeit zu anderen Abgängen */
+    /** 2 Erstelle für jedes nicht verbundenes Element, das zu einem anderen Abgang gehört, eine Schaltmaßname. */
+    const insertSPARQL = [];
+    for (const feeder of modelContainer.feeders.values()) {
+        const wnFeeder = feeder;
+        const disconnectedTerminalCNs = []; // nicht verbundene Knoten zu anderen Abgängen
+        const disconnectedTerminalCEs = []; // nicht verbundene leitende Equipments
+        const disconnectedSwitches = []; // nicht verbundene Schaltelemente mit allen offenen Terminals zu anderen Abgängen
+        const disconnectedSelfTerminalCN = []; // nicht verbundene Knoten zum gleichen Abgang
+        const disconnectedSelfTerminalCE = []; // nicht verbundene Knoten zum gleichen Abgang
+        const disconnectedSelfSwitches = []; // nicht verbundene Schaltelemente mit allen offenen Terminals zum gleichen Abgang
+        /** 1.1) nicht verbundene Knoten und Switches bestimmen von Equipments aus*/
+        for (const equip of wnFeeder.additionalGroupedEquipment.values()) {
+            if (equip instanceof ConductingEquipment_1.ConductingEquipment) {
+                const ce = equip;
+                // Bestimme nicht verbundene CNs
+                for (const terminal of ce.terminals.values()) {
+                    /** Offene Terminals */
+                    if (!terminal.isClosed()) {
+                        /** verbindungen zu anderen Angängen */
+                        if (!wnFeeder.normalEnergizedConnectivityNodes.has((_c = terminal.connectivityNode) === null || _c === void 0 ? void 0 : _c.mrid)) {
+                            if (terminal.connectivityNode && terminal.connectivityNode.additionalConnectivityNodeContainer) {
+                                disconnectedTerminalCNs.push([terminal]);
+                            }
+                        }
+                        else if (wnFeeder.normalEnergizedConnectivityNodes.has((_d = terminal.connectivityNode) === null || _d === void 0 ? void 0 : _d.mrid)) {
+                            /** offene Verbindungen zu sich selbst */
+                            if (!(0, graph_util_1.isSwitchObjectInArray)(terminal, [...disconnectedSelfTerminalCN, ...disconnectedSelfTerminalCE]))
+                                disconnectedSelfTerminalCN.push([terminal]);
+                        }
+                    }
+                    /** geschlossener Terminal mit offenem Switch */
+                }
+            }
+        }
+        /** 1.2) nicht verbundene leitende Elemente bestimmen von ConnectivityNodes aus*/
+        for (const cn of wnFeeder.normalEnergizedConnectivityNodes.values()) {
+            // Bestimme nicht verbundene CNs
+            for (const terminal of cn.terminals.values()) {
+                /** offene Terminals */
+                if (!terminal.isClosed()) {
+                    /** ist offen und gehört zu einem anderen Abgang */
+                    const ce = terminal.conductingEquipment;
+                    if (!wnFeeder.additionalGroupedEquipment.has(ce.mrid) && (0, graph_util_1.isBelongingToFeeder)(ce.mrid, modelContainer.feeders, false)) {
+                        if (terminal.conductingEquipment.additionalEquipmentContainer.size) {
+                            disconnectedTerminalCEs.push([terminal]);
+                        }
+                    }
+                    else if (wnFeeder.additionalGroupedEquipment.has(ce.mrid)) {
+                        /** offene Verbindungen zu sich selbst */
+                        if (!(0, graph_util_1.isSwitchObjectInArray)(terminal, [...disconnectedSelfTerminalCN, ...disconnectedSelfTerminalCE]))
+                            disconnectedSelfTerminalCE.push([terminal]);
+                    }
+                    else {
+                        /** offenes Schaltalement,das zu keinem Abgang gehört
+                         * Schwerpunktanlage NICHT BERÜCKSICHTIGEN. */
+                        if (terminal.conductingEquipment instanceof Switch_1.Switch) {
+                            const swtch = terminal.conductingEquipment;
+                            if (!swtch.isClosed()) {
+                                /** Bestimme, ob der offene Switch
+                                 * -eine Verbindung in den gleichen Abgang
+                                 * -oder zu einem anderen Abgang darstellt */
+                                for (const trm of swtch.terminals.values()) {
+                                    /** suche den 'anderen Terminal' */
+                                    if (!trm.connectivityNode) {
+                                        console.log(`Terminal ${trm.mrid} hat keine ConnectivityNode-Instanz`);
+                                    }
+                                    if (trm.mrid !== terminal.mrid && trm.connectivityNode) {
+                                        const switchConnNodeUUID = trm.connectivityNode.mrid;
+                                        /** gehört zum gleichen Abgang */
+                                        if (wnFeeder.normalEnergizedConnectivityNodes.has(switchConnNodeUUID)) {
+                                            const switchArray = addSwitchTerminalToSwitchAction(terminal, trm, swtch);
+                                            disconnectedSelfSwitches.push(switchArray);
+                                        }
+                                        else if ((0, graph_util_1.isBelongingToFeeder)(switchConnNodeUUID, modelContainer.feeders, true)) {
+                                            /** gehört zum anderen Abgang? */
+                                            const switchArray = addSwitchTerminalToSwitchAction(terminal, trm, swtch);
+                                            disconnectedSwitches.push(switchArray);
+                                            /** Wenn der Knoten zu keinem Abgang gehört, dann ist er spannungslos
+                                             * und wird daher nicht berücksichtigt? */
+                                        }
+                                    }
+                                }
+                            }
+                        } /*else {
+                          console.log(`n-1 unbekanntes ce am terminal ${terminal.conductingEquipment.mrid}`);
+                        }*/
+                    }
+                }
+            }
+        }
+        /** relevante Ausfälle bestimmen */
+        const outageNodes = [];
+        for (const headTerminal of feeder.normalHeadTerminal.values()) {
+            outageNodes.push(headTerminal.connectivityNode);
+        }
+        for (const cn of wnFeeder.normalEnergizedConnectivityNodes.values()) {
+            // Muffen sind für N-1-Betrachtung nicht relevant
+            // if (cn.getType() === CimAssetAliasNames.Muffe) continue;
+            let connectedACLineSegments = 0;
+            for (const terminal of cn.terminals.values()) {
+                if (terminal.isClosed() && terminal.conductingEquipment instanceof ACLineSegment_1.ACLineSegment) {
+                    connectedACLineSegments++;
+                }
+            }
+            /** ab 3 ACLineSegments ist der Knoten für die Ausfallanalyse relevant */
+            if (connectedACLineSegments > 2)
+                outageNodes.push(cn);
+        }
+        // Ausfälle
+        const proceededContingencyNodes = [];
+        for (const outageSfCN of outageNodes) {
+            console.log(`Ausfallknoten ${outageSfCN.name} | ${outageSfCN.description}`);
+            /** abgearbeitete Knoten überspringen. Tritt auf, wenn ein Feederknoten untergeklemmte Leitungen besitzt */
+            if (proceededContingencyNodes.indexOf(outageSfCN.mrid) !== -1)
+                continue;
+            proceededContingencyNodes.push(outageSfCN.mrid);
+            const disconnectedTerminals = getDeenergizedSubstations(outageSfCN);
+            console.log('\tStationsfreischaltungen:');
+            disconnectedTerminals.forEach(it => console.log('\t\t' + it.connectivityNode.name + ' ' + it.connectivityNode.description));
+            const outageGraphNode = graph.nodes.get(outageSfCN.mrid);
+            const graphConnections = disconnectedTerminals.map(outage => graph.terminals.get(outage === null || outage === void 0 ? void 0 : outage.mrid)).filter(it => it);
+            /** Freischaltung der Fehlerstelle bestimmen - Muffen überspringen */
+            if (graphConnections.length) {
+                /** Stellen der Freischaltung vom Netz öffnen */
+                graphConnections.forEach(outage => {
+                    /** Als Ausfall markieren */
+                    outage.connected = false;
+                });
+                outageGraphNode.inService = false;
+                const outageUUID = outageSfCN.getUUID();
+                const outageResult = (0, graph_util_1.determineOutageAffectedSubstations)(graph, outageUUID, wnFeeder.normalEnergizedConnectivityNodes, slackUUIDs);
+                /** 2 Schaltmaßnahmen bestimmen */
+                const switchActionsFullyReenergized = [];
+                const switchActionsCombinedFullyReenergized = [];
+                const switchActionsPartiallyReenergized = [];
+                /** Ausfall führt zum Zerfall des Netzes */
+                if (outageResult.outageStations.size) {
+                    /** Schaltmaßnahmen evaluieren */
+                    // Schaltmaßnahmen von den CNs
+                    const switchActionsTerminalsCN = (0, graph_util_1.evaluateSwitchActions)(outageUUID, outageResult.outageStations, wnFeeder.normalEnergizedConnectivityNodes, graph, disconnectedTerminalCNs, slackUUIDs, graph_interfaces_1.SwitchTypeKind.otherFeeder);
+                    const switchActionsSelfTerminalsCN = (0, graph_util_1.evaluateSwitchActions)(outageUUID, outageResult.outageStations, wnFeeder.normalEnergizedConnectivityNodes, graph, disconnectedSelfTerminalCN, slackUUIDs, graph_interfaces_1.SwitchTypeKind.sameFeeder);
+                    // Schaltmaßnahmen von den CEs
+                    const switchActionsTerminalsCE = (0, graph_util_1.evaluateSwitchActions)(outageUUID, outageResult.outageStations, wnFeeder.normalEnergizedConnectivityNodes, graph, disconnectedTerminalCEs, slackUUIDs, graph_interfaces_1.SwitchTypeKind.otherFeeder);
+                    const switchActionsSelfTerminalsCE = (0, graph_util_1.evaluateSwitchActions)(outageUUID, outageResult.outageStations, wnFeeder.normalEnergizedConnectivityNodes, graph, disconnectedSelfTerminalCE, slackUUIDs, graph_interfaces_1.SwitchTypeKind.sameFeeder);
+                    // Schaltmaßnahmen von den Switches
+                    const switchActionsSwitches = (0, graph_util_1.evaluateSwitchActions)(outageUUID, outageResult.outageStations, wnFeeder.normalEnergizedConnectivityNodes, graph, disconnectedSwitches, slackUUIDs, graph_interfaces_1.SwitchTypeKind.otherFeeder);
+                    switchActionsFullyReenergized.push(...switchActionsTerminalsCN.filter(elem => elem.kind === EVSwitchingPlanKind_1.EVSwitchingPlanKind.fullyResupply), ...switchActionsTerminalsCE.filter(elem => elem.kind === EVSwitchingPlanKind_1.EVSwitchingPlanKind.fullyResupply), ...switchActionsSwitches.filter(elem => elem.kind === EVSwitchingPlanKind_1.EVSwitchingPlanKind.fullyResupply), ...switchActionsSelfTerminalsCN.filter(elem => elem.kind === EVSwitchingPlanKind_1.EVSwitchingPlanKind.fullyResupply), ...switchActionsSelfTerminalsCE.filter(elem => elem.kind === EVSwitchingPlanKind_1.EVSwitchingPlanKind.fullyResupply));
+                    const switchActionsPartially = [
+                        ...switchActionsTerminalsCN.filter(elem => elem.kind === EVSwitchingPlanKind_1.EVSwitchingPlanKind.partiallyResupply),
+                        ...switchActionsTerminalsCE.filter(elem => elem.kind === EVSwitchingPlanKind_1.EVSwitchingPlanKind.partiallyResupply),
+                        ...switchActionsSwitches.filter(elem => elem.kind === EVSwitchingPlanKind_1.EVSwitchingPlanKind.partiallyResupply),
+                        ...switchActionsSelfTerminalsCN.filter(elem => elem.kind === EVSwitchingPlanKind_1.EVSwitchingPlanKind.partiallyResupply),
+                        ...switchActionsSelfTerminalsCE.filter(elem => elem.kind === EVSwitchingPlanKind_1.EVSwitchingPlanKind.partiallyResupply),
+                    ];
+                    const switchActionsSelfNoResupply = [
+                        ...switchActionsSwitches.filter(elem => elem.kind === EVSwitchingPlanKind_1.EVSwitchingPlanKind.noResupply && elem.resupplyType === graph_interfaces_1.SwitchTypeKind.sameFeeder),
+                        ...switchActionsSelfTerminalsCN.filter(elem => elem.kind === EVSwitchingPlanKind_1.EVSwitchingPlanKind.noResupply && elem.resupplyType === graph_interfaces_1.SwitchTypeKind.sameFeeder),
+                        ...switchActionsSelfTerminalsCE.filter(elem => elem.kind === EVSwitchingPlanKind_1.EVSwitchingPlanKind.noResupply && elem.resupplyType === graph_interfaces_1.SwitchTypeKind.sameFeeder),
+                    ];
+                    /** Wenn es mehr als eine Maßnahme mit partieller Wiederversorgung gibt,
+                     * dann versuche eine Kombination zur vollständigen Wiederversorgung zu finden */
+                    const resultCombinedActions = new Array();
+                    if ([...switchActionsPartially, ...switchActionsSelfNoResupply].length > 1) {
+                        /** Relevante Permutationen bestimmen */
+                        const permutationElements = [...switchActionsPartially, ...switchActionsSelfNoResupply].map(it => it.uuid);
+                        const permutations = permutation_utils_1.PermutationUtils.getAllPermutation(permutationElements, 2);
+                        for (const currentPermutation of permutations) {
+                            // Schaltelemente aus den Permutationen bestimmen
+                            const cmobinedSwitchObjects = [...switchActionsPartially, ...switchActionsSelfNoResupply].filter(it => {
+                                return currentPermutation.find(permutationUUID => permutationUUID === it.uuid);
+                            }).map(it => it.switchObjects).flat();
+                            const combinedSwitchActions = (0, graph_util_1.evaluateSwitchActions)(outageUUID, outageResult.outageStations, wnFeeder.normalEnergizedConnectivityNodes, graph, [cmobinedSwitchObjects], slackUUIDs, graph_interfaces_1.SwitchTypeKind.combined);
+                            resultCombinedActions.push(...combinedSwitchActions);
+                        }
+                    }
+                    /** Maßnahmen mit größter Anzahl wiederversorgten Stationen finden */
+                    /** vollständige Wiederversorgung */
+                    const fl = resultCombinedActions.filter(elem => elem.kind === EVSwitchingPlanKind_1.EVSwitchingPlanKind.fullyResupply);
+                    if (fl.length)
+                        switchActionsCombinedFullyReenergized.push(...fl);
+                    const partiallyResupply = resultCombinedActions.filter(elem => elem.kind === EVSwitchingPlanKind_1.EVSwitchingPlanKind.partiallyResupply);
+                    if ([...switchActionsPartially, ...partiallyResupply].length) {
+                        const maxResupply = [...switchActionsPartially, ...partiallyResupply]
+                            .reduce((prev, current) => {
+                            return (prev && (0, graph_util_1.getOutageStationsCount)(prev.outageResult.outageStations) < (0, graph_util_1.getOutageStationsCount)(current.outageResult.outageStations)) ? prev : current;
+                        });
+                        if (maxResupply)
+                            switchActionsPartiallyReenergized.push(maxResupply);
+                    }
+                    else if (switchActionsPartially.length) {
+                        switchActionsPartiallyReenergized.push(...switchActionsPartially);
+                    }
+                }
+                /** 2 Schaltmaßnahmen: Modell erstellen und speichern */
+                const switchActions = [...switchActionsFullyReenergized, ...switchActionsCombinedFullyReenergized, ...switchActionsPartiallyReenergized];
+                // if (switchActionsFullyReenergised.length) {
+                if (switchActions.length) {
+                    //Ausfallschaltmaßnahme anlegen
+                    const faultCN = outageSfCN;
+                    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 = createSwitchingPlan(common_utils_1.CommonUtils.generateUUID(), wnFeeder.baseIRI, `Schaltmaßnahme-Ausfall`, -1, 'de-energise', outageNew, insertSPARQL);
+                    modelContainer.addSwitchingPlan(switchingPlanDeEnergise);
+                    /** SwitchingAction de-energise*/
+                    const switchingActionDeEnergise = 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 disconnectedTerminals) {
+                        insertSPARQL.push(switchingActionDeEnergise.addTerminal(terminal));
+                    }
+                    /** SwitchingPlan restore*/
+                    const switchingPlanRestore = createSwitchingPlan(common_utils_1.CommonUtils.generateUUID(), wnFeeder.baseIRI, `Schaltmaßnahme-Restore`, 0, 'restore', outageNew, insertSPARQL);
+                    modelContainer.addSwitchingPlan(switchingPlanRestore);
+                    /** SwitchingAction restore*/
+                    const switchingActionRestore = 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 disconnectedTerminals) {
+                        insertSPARQL.push(switchingActionRestore.addTerminal(terminal));
+                    }
+                    // Wiederversorgungsmaßnahmen
+                    for (let i = 0; i < switchActions.length; i++) {
+                        const switchAction = switchActions[i];
+                        //console.log('\tActions ' + switchAction.switchObjects);
+                        /** SwitchingPlan restore*/
+                        const switchingPlanRestore = createSwitchingPlan(common_utils_1.CommonUtils.generateUUID(), wnFeeder.baseIRI, `Schaltmaßnahme-Restore`, (i + 1), 'energise', outageNew, insertSPARQL);
+                        insertSPARQL.push(switchingPlanRestore.setKind(switchAction.kind));
+                        modelContainer.addSwitchingPlan(switchingPlanRestore);
+                        /** SwitchingAction restore*/
+                        for (const cimSwitchObject of switchAction.switchObjects) {
+                            //const cimSwitchObject = modelContainer.getObject(switchObjectUUID);
+                            if (cimSwitchObject) {
+                                if (cimSwitchObject instanceof Terminal_1.Terminal) {
+                                    const switchingActionRestore = createTerminalAction(common_utils_1.CommonUtils.generateUUID(), wnFeeder.baseIRI, `Schaltung-Restore`, SwitchActionKind_1.SwitchActionKind.close, switchingPlanRestore, insertSPARQL);
+                                    modelContainer.addSwitchingAction(switchingActionRestore);
+                                    insertSPARQL.push(switchingActionRestore.addTerminal(cimSwitchObject));
+                                }
+                                else if (cimSwitchObject instanceof Switch_1.Switch) {
+                                    const switchingActionRestore = createSwitchAction(common_utils_1.CommonUtils.generateUUID(), wnFeeder.baseIRI, `Schaltung-Restore`, SwitchActionKind_1.SwitchActionKind.close, switchingPlanRestore, insertSPARQL);
+                                    modelContainer.addSwitchingAction(switchingActionRestore);
+                                    insertSPARQL.push(switchingActionRestore.setSwitch(cimSwitchObject));
+                                }
+                            }
+                        }
+                    }
+                }
+                /** Stellen der Freischaltung wieder schliessen */
+                graphConnections.forEach(outage => {
+                    /** Als Ausfall markieren */
+                    outage.connected = true;
+                });
+                outageGraphNode.inService = true;
+            }
+        }
+    }
+    const length = insertSPARQL.length;
+    if (limit && length) {
+        const splittedStatements = (0, utils_1.splitArrayIntoChunks)(insertSPARQL, limit);
+        return (0, sparql_utils_1.createSPARQLStatement)('INSERT_DATA', graphURI, splittedStatements);
+    }
+    else if (length) {
+        return [
             `
                         PREFIX rdf:             <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
                         PREFIX cim:             <http://iec.ch/TC57/2013/CIM-schema-cim16#>
@@ -381,200 +374,208 @@ function performContingencyAnalysisV2(modelContainer) {
                         PREFIX westnetzneplan:  <http://westnetzneplan.de/CIM/Extensions#>
                         PREFIX enervance:       <http://enervance.com/CIM/Extensions#>
                         ${(0, sparql_utils_1.getInsertDataPartStatement)(graphURI, insertSPARQL)}
-        `
-        ];
-    }
-    else {
-        return [];
-    }
-}
-function createSwitchingPlan(uuid, baseIRI, name, rank, purpose, outage, insertSPARQL) {
-    const switchingPlan = new SwitchingPlan_1.SwitchingPlan(uuid, name, '', '', baseIRI);
-    // switchingPlanNew.rank undefined
-    // console.log(switchingPlan.createNewStatementSPARQL());
-    insertSPARQL.push(switchingPlan.createNewStatementSPARQL());
-    if (rank)
-        insertSPARQL.push(switchingPlan.setRank(rank));
-    if (purpose)
-        insertSPARQL.push(switchingPlan.setPurpose(purpose));
-    insertSPARQL.push(switchingPlan.setOutage(outage));
-    return switchingPlan;
-}
-function createTerminalAction(uuid, baseIRI, name, kind, switchingPlan, insertSPARQL) {
-    const switchingActionNew = new EVTerminalAction_1.EVTerminalAction(uuid, name, '', '', baseIRI);
-    insertSPARQL.push(switchingActionNew.createNewStatementSPARQL());
-    insertSPARQL.push(switchingActionNew.setKind(kind));
-    insertSPARQL.push(switchingActionNew.setSwitchingPlan(switchingPlan));
-    return switchingActionNew;
-}
-function createSwitchAction(uuid, baseIRI, name, kind, switchingPlan, insertSPARQL) {
-    const switchActionNew = new SwitchAction_1.SwitchAction(uuid, name, '', '', baseIRI);
-    insertSPARQL.push(switchActionNew.createNewStatementSPARQL());
-    insertSPARQL.push(switchActionNew.setKind(kind));
-    insertSPARQL.push(switchActionNew.setSwitchingPlan(switchingPlan));
-    return switchActionNew;
-}
-/** Bestimmt, ob aussgefallene substations durch die übergenen Maßnahmen wiederversorgt werden können */
-function getPartiallySwitchingActionForSubstations(substations, partiallySwitchActions) {
-    return partiallySwitchActions.filter(elem => {
-        const outageStationUUID = substations.map(it => it.id);
-        const feededSubstations = elem.outageResult.feededStations;
-        for (const feededNodes of feededSubstations.values()) {
-            const feederNodesUUID = feededNodes.map(node => node.id);
-            const feededSubstation = feederNodesUUID.filter(value => outageStationUUID.includes(value));
-            return feededSubstation;
-        }
-    });
-}
-function addNewRepairActions(repairActions, newRepairActions) {
-    for (const newRepairAction of newRepairActions) {
-        if (!arrayContains(repairActions, newRepairAction)) {
-            repairActions.push(newRepairAction);
-        }
-    }
-}
-function arrayContains(arrays, b) {
-    for (const a of arrays) {
-        if (arraysEqual(a, b)) {
-            return true;
-        }
-    }
-    return false;
-}
-function arraysEqual(a, b) {
-    if (a === b)
-        return true;
-    if (a == null || b == null)
-        return false;
-    if (a.length !== b.length)
-        return false;
-    for (let i = 0; i < a.length; ++i) {
-        if (a[i] !== b[i])
-            return false;
-    }
-    return true;
-}
-function addSwitchTerminalToSwitchAction(trm1, trm2, swtch) {
-    const switchArray = [];
-    if (!trm1.isClosed())
-        switchArray.push(trm1);
-    if (!swtch.isClosed())
-        switchArray.push(swtch);
-    if (!trm2.isClosed())
-        switchArray.push(trm2);
-    return switchArray;
-}
-function sort2DArray(array) {
-    for (let _i = 0; _i < array.length; _i++) {
-        array[_i].sort();
-    }
-}
-function checkFaultConnectivityNode(faultCN, objectsFound, connectedLine) {
-    /** Fall 1 der Ausfallkonten ist schaltbar und kann direkt isoliert werden*/
-    if (faultCN.isSwitchable() && faultCN.getType() !== cim_constants_1.CimAssetAliasNames.Muffe) {
-        if (connectedLine) {
-            /** der Knoten wird über den verbundenen Stromkreisabschnitt isoliert */
-            const terminal = [...connectedLine.terminals.values()].find(terminal => {
-                if (terminal.connectivityNode.getUUID() === faultCN.getUUID()) {
-                    return terminal;
-                }
-            });
-            if (terminal)
-                objectsFound.push(terminal);
-        }
-        else {
-        }
-    }
-}
-/**
- * Bestimmt Stationen zur Freischaltung eines Fehlerfalls
- * @param faultCN Ausfallknoten
- * @return Ein Array mit zu einem VoltageLevel gehörigen Objekte
- * */
-function getDeenergizedSubstations(faultCN) {
-    const objectsFound = new Array();
-    if (faultCN.isSwitchable()) {
-        /** der Knoten wird vollständig isoliert */
-        const terminals = [...faultCN.terminals.values()].filter(terminal => {
-            if (terminal.conductingEquipment instanceof ACLineSegment_1.ACLineSegment || terminal.conductingEquipment instanceof Switch_1.Switch) {
-                return terminal;
-            }
-        });
-        objectsFound.push(...terminals);
-    }
-    let nodesOnCurrentLevel = new Array();
-    let nodesOnNextLevel = new Array(faultCN);
-    let nodesVisited = new Array();
-    while (nodesOnNextLevel.length && !faultCN.isSwitchable()) {
-        nodesOnCurrentLevel.length = 0;
-        nodesOnCurrentLevel = [...nodesOnNextLevel];
-        /** next level nodes leeren */
-        nodesOnNextLevel.length = 0;
-        for (const currentNode of nodesOnCurrentLevel) {
-            nodesVisited.push(currentNode.getUUID());
-            /** verbundene ConductingEquipments */
-            const connectedConductingEquipments = [...currentNode.terminals.values()].filter(terminal => {
-                if (!nodesVisited.includes(terminal.getUUID()) &&
-                    (terminal === null || terminal === void 0 ? void 0 : terminal.isClosed()) &&
-                    terminal.conductingEquipment &&
-                    !nodesVisited.includes(terminal.conductingEquipment.getUUID())) {
-                    nodesVisited.push(terminal.getUUID());
-                    nodesVisited.push(terminal.conductingEquipment.getUUID());
-                    return terminal.conductingEquipment;
-                }
-            }).map(terminal => terminal.conductingEquipment);
-            for (const ce of connectedConductingEquipments) {
-                if (!ce.isConnected())
-                    continue;
-                for (const terminal of ce.terminals.values()) {
-                    /** Terminal ist offen -> überspringe */
-                    if (!terminal.connected)
-                        continue;
-                    const connectedCn = terminal.connectivityNode;
-                    /** CN ist nicht definiert -> überspringe */
-                    if (!connectedCn)
-                        continue;
-                    /** bereits besucht -> überspringe */
-                    if (nodesVisited.indexOf(connectedCn.getUUID()) !== -1)
-                        continue;
-                    if (!connectedCn.isSwitchable()) {
-                        /** der Knoten ist nicht schaltbar -> für die nächste Iteration hinzufügen */
-                        nodesOnNextLevel.push(terminal.connectivityNode);
-                    }
-                    else {
-                        /** Freischaltstelle gefunden */
-                        objectsFound.push(terminal);
-                    }
-                    nodesVisited.push(connectedCn.getUUID());
-                }
-            }
-        }
-    }
-    return objectsFound;
-}
-function getConnectedConductingEquipments(cn) {
-    return [...cn.terminals.values()].filter(terminal => {
-        if ((terminal === null || terminal === void 0 ? void 0 : terminal.isClosed()) && terminal.conductingEquipment) {
-            return terminal.conductingEquipment;
-        }
-    }).map(terminal => terminal.conductingEquipment);
-}
-function getSwitchingActionCombinations(switchingActions) {
-    const combi = new Array();
-    const slent = Math.pow(2, switchingActions.length);
-    let temp = new Array();
-    for (let i = 0; i < slent; i++) {
-        temp = new Array();
-        for (let j = 0; j < switchingActions.length; j++) {
-            if ((i & Math.pow(2, j))) {
-                temp.push(switchingActions[j]);
-            }
-        }
-        if (temp.length > 0) {
-            combi.push(temp);
-        }
-    }
-    combi.sort((a, b) => a.length - b.length);
-    return combi;
-}
+        `
+        ];
+    }
+    else {
+        return [];
+    }
+}
+exports.performContingencyAnalysisV2 = performContingencyAnalysisV2;
+function createSwitchingPlan(uuid, baseIRI, name, rank, purpose, outage, insertSPARQL) {
+    const switchingPlan = new SwitchingPlan_1.SwitchingPlan(uuid, name, '', '', baseIRI);
+    // switchingPlanNew.rank undefined
+    // console.log(switchingPlan.createNewStatementSPARQL());
+    insertSPARQL.push(switchingPlan.createNewStatementSPARQL());
+    if (rank)
+        insertSPARQL.push(switchingPlan.setRank(rank));
+    if (purpose)
+        insertSPARQL.push(switchingPlan.setPurpose(purpose));
+    insertSPARQL.push(switchingPlan.setOutage(outage));
+    return switchingPlan;
+}
+exports.createSwitchingPlan = createSwitchingPlan;
+function createTerminalAction(uuid, baseIRI, name, kind, switchingPlan, insertSPARQL) {
+    const switchingActionNew = new EVTerminalAction_1.EVTerminalAction(uuid, name, '', '', baseIRI);
+    insertSPARQL.push(switchingActionNew.createNewStatementSPARQL());
+    insertSPARQL.push(switchingActionNew.setKind(kind));
+    insertSPARQL.push(switchingActionNew.setSwitchingPlan(switchingPlan));
+    return switchingActionNew;
+}
+exports.createTerminalAction = createTerminalAction;
+function createSwitchAction(uuid, baseIRI, name, kind, switchingPlan, insertSPARQL) {
+    const switchActionNew = new SwitchAction_1.SwitchAction(uuid, name, '', '', baseIRI);
+    insertSPARQL.push(switchActionNew.createNewStatementSPARQL());
+    insertSPARQL.push(switchActionNew.setKind(kind));
+    insertSPARQL.push(switchActionNew.setSwitchingPlan(switchingPlan));
+    return switchActionNew;
+}
+exports.createSwitchAction = createSwitchAction;
+/** Bestimmt, ob aussgefallene substations durch die übergenen Maßnahmen wiederversorgt werden können */
+function getPartiallySwitchingActionForSubstations(substations, partiallySwitchActions) {
+    return partiallySwitchActions.filter(elem => {
+        const outageStationUUID = substations.map(it => it.id);
+        const feededSubstations = elem.outageResult.feededStations;
+        for (const feededNodes of feededSubstations.values()) {
+            const feederNodesUUID = feededNodes.map(node => node.id);
+            const feededSubstation = feederNodesUUID.filter(value => outageStationUUID.includes(value));
+            return feededSubstation;
+        }
+    });
+}
+exports.getPartiallySwitchingActionForSubstations = getPartiallySwitchingActionForSubstations;
+function addNewRepairActions(repairActions, newRepairActions) {
+    for (const newRepairAction of newRepairActions) {
+        if (!arrayContains(repairActions, newRepairAction)) {
+            repairActions.push(newRepairAction);
+        }
+    }
+}
+exports.addNewRepairActions = addNewRepairActions;
+function arrayContains(arrays, b) {
+    for (const a of arrays) {
+        if (arraysEqual(a, b)) {
+            return true;
+        }
+    }
+    return false;
+}
+function arraysEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a == null || b == null)
+        return false;
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; ++i) {
+        if (a[i] !== b[i])
+            return false;
+    }
+    return true;
+}
+function addSwitchTerminalToSwitchAction(trm1, trm2, swtch) {
+    const switchArray = [];
+    if (!trm1.isClosed())
+        switchArray.push(trm1);
+    if (!swtch.isClosed())
+        switchArray.push(swtch);
+    if (!trm2.isClosed())
+        switchArray.push(trm2);
+    return switchArray;
+}
+function sort2DArray(array) {
+    for (let _i = 0; _i < array.length; _i++) {
+        array[_i].sort();
+    }
+}
+exports.sort2DArray = sort2DArray;
+function checkFaultConnectivityNode(faultCN, objectsFound, connectedLine) {
+    /** Fall 1 der Ausfallkonten ist schaltbar und kann direkt isoliert werden*/
+    if (faultCN.isSwitchable() && faultCN.getType() !== cim_constants_1.CimAssetAliasNames.Muffe) {
+        if (connectedLine) {
+            /** der Knoten wird über den verbundenen Stromkreisabschnitt isoliert */
+            const terminal = [...connectedLine.terminals.values()].find(terminal => {
+                if (terminal.connectivityNode.getUUID() === faultCN.getUUID()) {
+                    return terminal;
+                }
+            });
+            if (terminal)
+                objectsFound.push(terminal);
+        }
+        else {
+        }
+    }
+}
+/**
+ * Bestimmt Stationen zur Freischaltung eines Fehlerfalls
+ * @param faultCN Ausfallknoten
+ * @return Ein Array mit zu einem VoltageLevel gehörigen Objekte
+ * */
+function getDeenergizedSubstations(faultCN) {
+    const objectsFound = new Array();
+    if (faultCN.isSwitchable()) {
+        /** der Knoten wird vollständig isoliert */
+        const terminals = [...faultCN.terminals.values()].filter(terminal => {
+            if (terminal.conductingEquipment instanceof ACLineSegment_1.ACLineSegment || terminal.conductingEquipment instanceof Switch_1.Switch) {
+                return terminal;
+            }
+        });
+        objectsFound.push(...terminals);
+    }
+    let nodesOnCurrentLevel = new Array();
+    let nodesOnNextLevel = new Array(faultCN);
+    let nodesVisited = new Array();
+    while (nodesOnNextLevel.length && !faultCN.isSwitchable()) {
+        nodesOnCurrentLevel.length = 0;
+        nodesOnCurrentLevel = [...nodesOnNextLevel];
+        /** next level nodes leeren */
+        nodesOnNextLevel.length = 0;
+        for (const currentNode of nodesOnCurrentLevel) {
+            nodesVisited.push(currentNode.getUUID());
+            /** verbundene ConductingEquipments */
+            const connectedConductingEquipments = [...currentNode.terminals.values()].filter(terminal => {
+                if (!nodesVisited.includes(terminal.getUUID()) &&
+                    (terminal === null || terminal === void 0 ? void 0 : terminal.isClosed()) &&
+                    terminal.conductingEquipment &&
+                    !nodesVisited.includes(terminal.conductingEquipment.getUUID())) {
+                    nodesVisited.push(terminal.getUUID());
+                    nodesVisited.push(terminal.conductingEquipment.getUUID());
+                    return terminal.conductingEquipment;
+                }
+            }).map(terminal => terminal.conductingEquipment);
+            for (const ce of connectedConductingEquipments) {
+                if (!ce.isConnected())
+                    continue;
+                for (const terminal of ce.terminals.values()) {
+                    /** Terminal ist offen -> überspringe */
+                    if (!terminal.connected)
+                        continue;
+                    const connectedCn = terminal.connectivityNode;
+                    /** CN ist nicht definiert -> überspringe */
+                    if (!connectedCn)
+                        continue;
+                    /** bereits besucht -> überspringe */
+                    if (nodesVisited.indexOf(connectedCn.getUUID()) !== -1)
+                        continue;
+                    if (!connectedCn.isSwitchable()) {
+                        /** der Knoten ist nicht schaltbar -> für die nächste Iteration hinzufügen */
+                        nodesOnNextLevel.push(terminal.connectivityNode);
+                    }
+                    else {
+                        /** Freischaltstelle gefunden */
+                        objectsFound.push(terminal);
+                    }
+                    nodesVisited.push(connectedCn.getUUID());
+                }
+            }
+        }
+    }
+    return objectsFound;
+}
+exports.getDeenergizedSubstations = getDeenergizedSubstations;
+function getConnectedConductingEquipments(cn) {
+    return [...cn.terminals.values()].filter(terminal => {
+        if ((terminal === null || terminal === void 0 ? void 0 : terminal.isClosed()) && terminal.conductingEquipment) {
+            return terminal.conductingEquipment;
+        }
+    }).map(terminal => terminal.conductingEquipment);
+}
+function getSwitchingActionCombinations(switchingActions) {
+    const combi = new Array();
+    const slent = Math.pow(2, switchingActions.length);
+    let temp = new Array();
+    for (let i = 0; i < slent; i++) {
+        temp = new Array();
+        for (let j = 0; j < switchingActions.length; j++) {
+            if ((i & Math.pow(2, j))) {
+                temp.push(switchingActions[j]);
+            }
+        }
+        if (temp.length > 0) {
+            combi.push(temp);
+        }
+    }
+    combi.sort((a, b) => a.length - b.length);
+    return combi;
+}
 //# sourceMappingURL=neplan-contingency-analysis.js.map