@enervance/insight-cim-model 1.0.0-dev2 → 1.0.0-dev4

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

@@ -1,85 +1,76 @@
-"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");
-const ConductingEquipment_1 = require("../../model/core/ConductingEquipment");
-const Switch_1 = require("../../model/wires/Switch");
-const SwitchingPlan_1 = require("../../model/operations/SwitchingPlan");
-const EVTerminalAction_1 = require("../../model/extensions/enervance/operations/EVTerminalAction");
-const SwitchActionKind_1 = require("../../model/operations/SwitchActionKind");
-const graph_1 = require("../../data-structures/graph/graph");
-const util_topology_1 = require("../../util/util-topology");
-const ConnectivityNode_1 = require("../../model/core/ConnectivityNode");
-const Terminal_1 = require("../../model/core/Terminal");
-const GraphEdge_1 = require("../../data-structures/graph/edges/GraphEdge");
-const GraphNode_1 = require("../../data-structures/graph/nodes/GraphNode");
-const Types_1 = require("../../data-structures/graph/Types");
-const connection_1 = require("../../data-structures/graph/connections/connection");
-const ExternalNetworkInjection_1 = require("../../model/wires/ExternalNetworkInjection");
-const graph_interfaces_1 = require("../../data-structures/graph/graph-interfaces");
-const graph_util_1 = require("../../data-structures/graph/graph-util");
-const ACLineSegment_1 = require("../../model/wires/ACLineSegment");
-const WNOutage_1 = require("../../model/extensions/westnetz-neplan/operations/WNOutage");
-const utils_1 = require("../../util/utils");
-const EVTerminal_1 = require("../../model/extensions/enervance/core/EVTerminal");
-const WNFaultConnectivityNode_1 = require("../../model/extensions/westnetz-neplan/faults/WNFaultConnectivityNode");
-const SwitchAction_1 = require("../../model/operations/SwitchAction");
-const sparql_utils_1 = require("../../util/sparql/sparql-utils");
-const common_utils_1 = require("../../utils2/common.utils");
-const cim_constants_1 = require("../../constants/cim-constants");
-const permutation_utils_1 = require("../../utils2/permutation.utils");
-const EVSwitchingPlanKind_1 = require("../../model/extensions/enervance/operations/EVSwitchingPlanKind");
-function performContingencyAnalysisV2(modelContainer) {
+import { WNConnectivityNode } from '../../model/extensions/westnetz-neplan/core/WNConnectivityNode';
+import { ConductingEquipment } from '../../model/core/ConductingEquipment';
+import { Switch } from '../../model/wires/Switch';
+import { SwitchingPlan } from '../../model/operations/SwitchingPlan';
+import { EVTerminalAction } from '../../model/extensions/enervance/operations/EVTerminalAction';
+import { SwitchActionKind } from '../../model/operations/SwitchActionKind';
+import { Graph } from '../../data-structures/graph/graph';
+import { determineComputableGrid, determineNetworksSlackElements, determineSubstations, determineTopologicalIslands } from '../../util/util-topology';
+import { ConnectivityNode } from '../../model/core/ConnectivityNode';
+import { Terminal } from '../../model/core/Terminal';
+import { GraphEdge } from '../../data-structures/graph/edges/GraphEdge';
+import { GraphNode } from '../../data-structures/graph/nodes/GraphNode';
+import { Type } from '../../data-structures/graph/Types';
+import { Connection } from '../../data-structures/graph/connections/connection';
+import { ExternalNetworkInjection } from '../../model/wires/ExternalNetworkInjection';
+import { SwitchTypeKind } from '../../data-structures/graph/graph-interfaces';
+import { determineOutageAffectedSubstations, evaluateSwitchActions, getOutageStationsCount, isBelongingToFeeder, isSwitchObjectInArray } from '../../data-structures/graph/graph-util';
+import { ACLineSegment } from '../../model/wires/ACLineSegment';
+import { WNOutage } from '../../model/extensions/westnetz-neplan/operations/WNOutage';
+import { splitArrayIntoChunks } from '../../util/utils';
+import { EVTerminal } from '../../model/extensions/enervance/core/EVTerminal';
+import { WNFaultConnectivityNode } from '../../model/extensions/westnetz-neplan/faults/WNFaultConnectivityNode';
+import { SwitchAction } from '../../model/operations/SwitchAction';
+import { createSPARQLStatement, getInsertDataPartStatement } from '../../util/sparql/sparql-utils';
+import { CommonUtils } from '../../utils2/common.utils';
+import { CimAssetAliasNames } from '../../constants/cim-constants';
+import { PermutationUtils } from '../../utils2/permutation.utils';
+import { EVSwitchingPlanKind } from '../../model/extensions/enervance/operations/EVSwitchingPlanKind';
+export 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);
+    const networks = determineTopologicalIslands(modelContainer);
     /** rechenbare Netze bestimmen */
-    const computableGrids = (0, util_topology_1.determineComputableGrid)(networks);
+    const computableGrids = 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);
+    const computableGridsSlackElements = 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);
+    const substationElements = determineSubstations(modelContainer, computableGridsSlackElements);
     computableGridsSlackElements.push(substationElements);
     /** Graph initialisieren */
-    const graph = new graph_1.Graph(modelContainer);
+    const graph = new 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));
+        if (element instanceof ConnectivityNode) {
+            graph.addNode(new GraphNode(element.mrid, element.name, element));
         }
-        else if (element instanceof Terminal_1.Terminal) {
+        else if (element instanceof 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));
+        else if (element instanceof ConductingEquipment) {
+            if (element instanceof ExternalNetworkInjection) {
+                graph.addEdge(new GraphEdge(element.mrid, element.name, element, 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 if (element instanceof Switch) {
+                graph.addEdge(new GraphEdge(element.mrid, element.name, element, Type.Switch, element.open));
             }
             else {
-                graph.addEdge(new GraphEdge_1.GraphEdge(element.mrid, element.name, element, Types_1.Type.ConductingEquipment, false));
+                graph.addEdge(new GraphEdge(element.mrid, element.name, element, Type.ConductingEquipment, false));
             }
         }
     }
     /** Konnektivität durch terminals herstellen */
     for (const terminal of terminals) {
-        const node = graph.nodes.get(terminal.connectivityNode?.mrid);
-        const edge = graph.edges.get(terminal.conductingEquipment?.mrid);
+        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);
+            const term = new Connection(terminal.mrid, terminal.connected, node, edge);
             node.addTerminal(term);
             edge.addTerminal(term);
             graph.addTerminal(term);
@@ -99,21 +90,21 @@ function performContingencyAnalysisV2(modelContainer) {
         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) {
+            if (equip instanceof 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(terminal.connectivityNode?.mrid)) {
+                        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(terminal.connectivityNode?.mrid)) {
+                        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]))
+                            if (!isSwitchObjectInArray(terminal, [...disconnectedSelfTerminalCN, ...disconnectedSelfTerminalCE]))
                                 disconnectedSelfTerminalCN.push([terminal]);
                         }
                     }
@@ -129,20 +120,20 @@ function performContingencyAnalysisV2(modelContainer) {
                 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 (!wnFeeder.additionalGroupedEquipment.has(ce.mrid) && 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]))
+                        if (!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) {
+                        if (terminal.conductingEquipment instanceof Switch) {
                             const swtch = terminal.conductingEquipment;
                             if (!swtch.isClosed()) {
                                 /** Bestimme, ob der offene Switch
@@ -160,7 +151,7 @@ function performContingencyAnalysisV2(modelContainer) {
                                             const switchArray = addSwitchTerminalToSwitchAction(terminal, trm, swtch);
                                             disconnectedSelfSwitches.push(switchArray);
                                         }
-                                        else if ((0, graph_util_1.isBelongingToFeeder)(switchConnNodeUUID, modelContainer.feeders, true)) {
+                                        else if (isBelongingToFeeder(switchConnNodeUUID, modelContainer.feeders, true)) {
                                             /** gehört zum anderen Abgang? */
                                             const switchArray = addSwitchTerminalToSwitchAction(terminal, trm, swtch);
                                             disconnectedSwitches.push(switchArray);
@@ -187,7 +178,7 @@ function performContingencyAnalysisV2(modelContainer) {
             // 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) {
+                if (terminal.isClosed() && terminal.conductingEquipment instanceof ACLineSegment) {
                     connectedACLineSegments++;
                 }
             }
@@ -207,7 +198,7 @@ function performContingencyAnalysisV2(modelContainer) {
             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?.mrid)).filter(it => it);
+            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 */
@@ -217,7 +208,7 @@ function performContingencyAnalysisV2(modelContainer) {
                 });
                 outageGraphNode.inService = false;
                 const outageUUID = outageSfCN.getUUID();
-                const outageResult = (0, graph_util_1.determineOutageAffectedSubstations)(graph, outageUUID, wnFeeder.normalEnergizedConnectivityNodes, slackUUIDs);
+                const outageResult = determineOutageAffectedSubstations(graph, outageUUID, wnFeeder.normalEnergizedConnectivityNodes, slackUUIDs);
                 /** 2 Schaltmaßnahmen bestimmen */
                 const switchActionsFullyReenergized = [];
                 const switchActionsCombinedFullyReenergized = [];
@@ -226,25 +217,25 @@ function performContingencyAnalysisV2(modelContainer) {
                 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);
+                    const switchActionsTerminalsCN = evaluateSwitchActions(outageUUID, outageResult.outageStations, wnFeeder.normalEnergizedConnectivityNodes, graph, disconnectedTerminalCNs, slackUUIDs, SwitchTypeKind.otherFeeder);
+                    const switchActionsSelfTerminalsCN = evaluateSwitchActions(outageUUID, outageResult.outageStations, wnFeeder.normalEnergizedConnectivityNodes, graph, disconnectedSelfTerminalCN, slackUUIDs, 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);
+                    const switchActionsTerminalsCE = evaluateSwitchActions(outageUUID, outageResult.outageStations, wnFeeder.normalEnergizedConnectivityNodes, graph, disconnectedTerminalCEs, slackUUIDs, SwitchTypeKind.otherFeeder);
+                    const switchActionsSelfTerminalsCE = evaluateSwitchActions(outageUUID, outageResult.outageStations, wnFeeder.normalEnergizedConnectivityNodes, graph, disconnectedSelfTerminalCE, slackUUIDs, 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 switchActionsSwitches = evaluateSwitchActions(outageUUID, outageResult.outageStations, wnFeeder.normalEnergizedConnectivityNodes, graph, disconnectedSwitches, slackUUIDs, SwitchTypeKind.otherFeeder);
+                    switchActionsFullyReenergized.push(...switchActionsTerminalsCN.filter(elem => elem.kind === EVSwitchingPlanKind.fullyResupply), ...switchActionsTerminalsCE.filter(elem => elem.kind === EVSwitchingPlanKind.fullyResupply), ...switchActionsSwitches.filter(elem => elem.kind === EVSwitchingPlanKind.fullyResupply), ...switchActionsSelfTerminalsCN.filter(elem => elem.kind === EVSwitchingPlanKind.fullyResupply), ...switchActionsSelfTerminalsCE.filter(elem => elem.kind === 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),
+                        ...switchActionsTerminalsCN.filter(elem => elem.kind === EVSwitchingPlanKind.partiallyResupply),
+                        ...switchActionsTerminalsCE.filter(elem => elem.kind === EVSwitchingPlanKind.partiallyResupply),
+                        ...switchActionsSwitches.filter(elem => elem.kind === EVSwitchingPlanKind.partiallyResupply),
+                        ...switchActionsSelfTerminalsCN.filter(elem => elem.kind === EVSwitchingPlanKind.partiallyResupply),
+                        ...switchActionsSelfTerminalsCE.filter(elem => elem.kind === 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),
+                        ...switchActionsSwitches.filter(elem => elem.kind === EVSwitchingPlanKind.noResupply && elem.resupplyType === SwitchTypeKind.sameFeeder),
+                        ...switchActionsSelfTerminalsCN.filter(elem => elem.kind === EVSwitchingPlanKind.noResupply && elem.resupplyType === SwitchTypeKind.sameFeeder),
+                        ...switchActionsSelfTerminalsCE.filter(elem => elem.kind === EVSwitchingPlanKind.noResupply && elem.resupplyType === SwitchTypeKind.sameFeeder),
                     ];
                     /** Wenn es mehr als eine Maßnahme mit partieller Wiederversorgung gibt,
                      * dann versuche eine Kombination zur vollständigen Wiederversorgung zu finden */
@@ -252,26 +243,26 @@ function performContingencyAnalysisV2(modelContainer) {
                     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);
+                        const permutations = 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);
+                            const combinedSwitchActions = evaluateSwitchActions(outageUUID, outageResult.outageStations, wnFeeder.normalEnergizedConnectivityNodes, graph, [cmobinedSwitchObjects], slackUUIDs, 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);
+                    const fl = resultCombinedActions.filter(elem => elem.kind === EVSwitchingPlanKind.fullyResupply);
                     if (fl.length)
                         switchActionsCombinedFullyReenergized.push(...fl);
-                    const partiallyResupply = resultCombinedActions.filter(elem => elem.kind === EVSwitchingPlanKind_1.EVSwitchingPlanKind.partiallyResupply);
+                    const partiallyResupply = resultCombinedActions.filter(elem => elem.kind === 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;
+                            return (prev && getOutageStationsCount(prev.outageResult.outageStations) < getOutageStationsCount(current.outageResult.outageStations)) ? prev : current;
                         });
                         if (maxResupply)
                             switchActionsPartiallyReenergized.push(maxResupply);
@@ -286,18 +277,18 @@ function performContingencyAnalysisV2(modelContainer) {
                 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);
+                    const outageNew = new WNOutage(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) {
+                        if (object instanceof ConductingEquipment) {
                             insertSPARQL.push(outageNew.addOutageIsolationEquipment(object));
                         }
-                        else if (object instanceof WNConnectivityNode_1.WNConnectivityNode) {
+                        else if (object instanceof WNConnectivityNode) {
                             insertSPARQL.push(outageNew.addOutageIsolationConnectivityNodes(object));
                         }
-                        else if (object instanceof EVTerminal_1.EVTerminal) {
+                        else if (object instanceof EVTerminal) {
                             // TBD
                         }
                     }
@@ -306,26 +297,26 @@ function performContingencyAnalysisV2(modelContainer) {
                         insertSPARQL.push(outageNew.addOutageIsolationConnectivityNodes(object));
                     }
                     /** Fault */
-                    const cnFaultNew = new WNFaultConnectivityNode_1.WNFaultConnectivityNode(common_utils_1.CommonUtils.generateUUID(), `${faultCN.name}`, '', '', wnFeeder.baseIRI);
+                    const cnFaultNew = new WNFaultConnectivityNode(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);
+                    const switchingPlanDeEnergise = createSwitchingPlan(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);
+                    const switchingActionDeEnergise = createTerminalAction(CommonUtils.generateUUID(), wnFeeder.baseIRI, `Schaltung-Ausfall`, 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);
+                    const switchingPlanRestore = createSwitchingPlan(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);
+                    const switchingActionRestore = createTerminalAction(CommonUtils.generateUUID(), wnFeeder.baseIRI, `Schaltung-Restore`, SwitchActionKind.close, switchingPlanRestore, insertSPARQL);
                     modelContainer.addSwitchingAction(switchingActionRestore);
                     // Alle terminals des Ausfallknotens
                     for (const terminal of disconnectedTerminals) {
@@ -336,20 +327,20 @@ function performContingencyAnalysisV2(modelContainer) {
                         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);
+                        const switchingPlanRestore = createSwitchingPlan(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);
+                                if (cimSwitchObject instanceof Terminal) {
+                                    const switchingActionRestore = createTerminalAction(CommonUtils.generateUUID(), wnFeeder.baseIRI, `Schaltung-Restore`, 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);
+                                else if (cimSwitchObject instanceof Switch) {
+                                    const switchingActionRestore = createSwitchAction(CommonUtils.generateUUID(), wnFeeder.baseIRI, `Schaltung-Restore`, SwitchActionKind.close, switchingPlanRestore, insertSPARQL);
                                     modelContainer.addSwitchingAction(switchingActionRestore);
                                     insertSPARQL.push(switchingActionRestore.setSwitch(cimSwitchObject));
                                 }
@@ -368,8 +359,8 @@ function performContingencyAnalysisV2(modelContainer) {
     }
     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);
+        const splittedStatements = splitArrayIntoChunks(insertSPARQL, limit);
+        return createSPARQLStatement('INSERT_DATA', graphURI, splittedStatements);
     }
     else if (length) {
         return [
@@ -379,7 +370,7 @@ function performContingencyAnalysisV2(modelContainer) {
                         PREFIX entsoe:	 	      <http://entsoe.eu/CIM/SchemaExtension/3/1#>
                         PREFIX westnetzneplan:  <http://westnetzneplan.de/CIM/Extensions#>
                         PREFIX enervance:       <http://enervance.com/CIM/Extensions#>
-                        ${(0, sparql_utils_1.getInsertDataPartStatement)(graphURI, insertSPARQL)}
+                        ${getInsertDataPartStatement(graphURI, insertSPARQL)}
         `
         ];
     }
@@ -387,8 +378,8 @@ function performContingencyAnalysisV2(modelContainer) {
         return [];
     }
 }
-function createSwitchingPlan(uuid, baseIRI, name, rank, purpose, outage, insertSPARQL) {
-    const switchingPlan = new SwitchingPlan_1.SwitchingPlan(uuid, name, '', '', baseIRI);
+export function createSwitchingPlan(uuid, baseIRI, name, rank, purpose, outage, insertSPARQL) {
+    const switchingPlan = new SwitchingPlan(uuid, name, '', '', baseIRI);
     // switchingPlanNew.rank undefined
     // console.log(switchingPlan.createNewStatementSPARQL());
     insertSPARQL.push(switchingPlan.createNewStatementSPARQL());
@@ -399,22 +390,22 @@ function createSwitchingPlan(uuid, baseIRI, name, rank, purpose, outage, insertS
     insertSPARQL.push(switchingPlan.setOutage(outage));
     return switchingPlan;
 }
-function createTerminalAction(uuid, baseIRI, name, kind, switchingPlan, insertSPARQL) {
-    const switchingActionNew = new EVTerminalAction_1.EVTerminalAction(uuid, name, '', '', baseIRI);
+export function createTerminalAction(uuid, baseIRI, name, kind, switchingPlan, insertSPARQL) {
+    const switchingActionNew = new 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);
+export function createSwitchAction(uuid, baseIRI, name, kind, switchingPlan, insertSPARQL) {
+    const switchActionNew = new 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) {
+export function getPartiallySwitchingActionForSubstations(substations, partiallySwitchActions) {
     return partiallySwitchActions.filter(elem => {
         const outageStationUUID = substations.map(it => it.id);
         const feededSubstations = elem.outageResult.feededStations;
@@ -425,7 +416,7 @@ function getPartiallySwitchingActionForSubstations(substations, partiallySwitchA
         }
     });
 }
-function addNewRepairActions(repairActions, newRepairActions) {
+export function addNewRepairActions(repairActions, newRepairActions) {
     for (const newRepairAction of newRepairActions) {
         if (!arrayContains(repairActions, newRepairAction)) {
             repairActions.push(newRepairAction);
@@ -463,14 +454,14 @@ function addSwitchTerminalToSwitchAction(trm1, trm2, swtch) {
         switchArray.push(trm2);
     return switchArray;
 }
-function sort2DArray(array) {
+export 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 (faultCN.isSwitchable() && faultCN.getType() !== CimAssetAliasNames.Muffe) {
         if (connectedLine) {
             /** der Knoten wird über den verbundenen Stromkreisabschnitt isoliert */
             const terminal = [...connectedLine.terminals.values()].find(terminal => {
@@ -490,12 +481,12 @@ function checkFaultConnectivityNode(faultCN, objectsFound, connectedLine) {
  * @param faultCN Ausfallknoten
  * @return Ein Array mit zu einem VoltageLevel gehörigen Objekte
  * */
-function getDeenergizedSubstations(faultCN) {
+export 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) {
+            if (terminal.conductingEquipment instanceof ACLineSegment || terminal.conductingEquipment instanceof Switch) {
                 return terminal;
             }
         });
@@ -514,7 +505,7 @@ function getDeenergizedSubstations(faultCN) {
             /** verbundene ConductingEquipments */
             const connectedConductingEquipments = [...currentNode.terminals.values()].filter(terminal => {
                 if (!nodesVisited.includes(terminal.getUUID()) &&
-                    terminal?.isClosed() &&
+                    (terminal === null || terminal === void 0 ? void 0 : terminal.isClosed()) &&
                     terminal.conductingEquipment &&
                     !nodesVisited.includes(terminal.conductingEquipment.getUUID())) {
                     nodesVisited.push(terminal.getUUID());
@@ -553,7 +544,7 @@ function getDeenergizedSubstations(faultCN) {
 }
 function getConnectedConductingEquipments(cn) {
     return [...cn.terminals.values()].filter(terminal => {
-        if (terminal?.isClosed() && terminal.conductingEquipment) {
+        if ((terminal === null || terminal === void 0 ? void 0 : terminal.isClosed()) && terminal.conductingEquipment) {
             return terminal.conductingEquipment;
         }
     }).map(terminal => terminal.conductingEquipment);