@enervance/insight-cim-model 0.0.1 → 0.0.3

package/src/etl-neplan/neplan-contingency-analysis.ts

@@ -0,0 +1,572 @@
+import { Model } from '../model/model/Model';
+import { WNFeeder } from '../model/extensions/neplan-westnetz/core/WNFeeder';
+import { WNConnectivityNode } from '../model/extensions/neplan-westnetz/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 { IOutage } from '../interfaces/model/operations/IOutage';
+import { Graph } from '../graph/graph';
+import { IIdentifiedObject } from '../interfaces/model/core/IIdentifiedObject';
+import {
+  determineComputableGrid,
+  determineNetworksSlackElements, determineSubstations,
+  determineTopologicalIslands
+} from '../util/util-topology';
+import { ConnectivityNode } from '../model/core/ConnectivityNode';
+import { Terminal } from '../model/core/Terminal';
+import { Edge } from '../graph/edges/edge';
+import { Node } from '../graph/nodes/node';
+import { Type } from '../graph/Types';
+import { Connection } from '../graph/connections/connection';
+import { ExternalNetworkInjection } from '../model/wires/ExternalNetworkInjection';
+import { OutageResult, SwitchEvalResult } from '../graph/graph-interfaces';
+import {
+  determineOutageAffectedSubstations, evaluateSwitchActions, isBelongingToFeeder, isSwitchObjectInArray
+} from '../graph/graph-util';
+import { IdentifiedObject } from '../model/core/IdentifiedObject';
+import { ITerminal } from '../interfaces/model/core/ITerminal';
+import { ACLineSegment } from '../model/wires/ACLineSegment';
+import { WNOutage } from '../model/extensions/neplan-westnetz/operations/WNOutage';
+import { generateUUID } from '../util/utils';
+import { EVTerminal } from '../model/extensions/enervance/core/EVTerminal';
+import { WNFaultConnectivityNode } from '../model/extensions/neplan-westnetz/faults/WNFaultConnectivityNode';
+
+export function performContingencyAnalysisV2(cimModel: Model): string[] {
+
+  /** alle elektrisch zusammenhängende Teilnetze bestimmen mit Berücksichtigung des Schaltzustandes */
+  const networks: IIdentifiedObject[][] = determineTopologicalIslands(cimModel);
+
+  /** rechenbare Netze bestimmen */
+  const computableGrids: IIdentifiedObject[][] = 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: IIdentifiedObject[][] = determineNetworksSlackElements(cimModel, computableGrids);
+
+  /** KRUECKE Anlagen mit mehr als 10 Switchelementen und Slacks werden als Umspannanlagen markiert. */
+  const substationElements = determineSubstations(cimModel, computableGridsSlackElements);
+
+  computableGridsSlackElements.push(substationElements);
+
+  /** Graph initialisieren */
+  const graph = new Graph();
+  const slackUUIDs = [];
+  const terminals = [];
+
+  /** Graph initialisieren */
+  for (const element of cimModel.objects.values()) {
+    if (element instanceof ConnectivityNode) {
+      graph.addNode(new Node(element.mrid));
+    } else if (element instanceof Terminal) {
+      terminals.push(element as Terminal);
+    } else if (element instanceof ConductingEquipment) {
+      if (element instanceof ExternalNetworkInjection) {
+        graph.addEdge(new Edge(element.mrid, Type.ExternalNetworkinjection, true));
+        slackUUIDs.push(element.mrid);
+      } else if (element instanceof Switch) {
+        graph.addEdge(new Edge(element.mrid, Type.Switch, (element as Switch).open));
+      } else {
+        graph.addEdge(new Edge(element.mrid, Type.ConductingEquipment, false));
+      }
+    }
+  }
+
+  /* for (const network of networks) {
+     for (const element of network) {
+       if (element instanceof ConnectivityNode) {
+         graph.addNode(new Node(element.mrid));
+       } else if (element instanceof Terminal) {
+         terminals.push(element as Terminal);
+       } else if (element instanceof ConductingEquipment) {
+         if (element instanceof ExternalNetworkInjection) {
+           graph.addEdge(new Edge(element.mrid, Type.ExternalNetworkinjection, true));
+           slackUUIDs.push(element.mrid);
+         }
+         else if (element instanceof Switch) {
+           graph.addEdge(new Edge(element.mrid, Type.Switch, (element as Switch).open));
+         } else {
+           graph.addEdge(new Edge(element.mrid, Type.ConductingEquipment, false));
+         }
+       }
+     }
+   }*/
+
+  /*  // Spannunsglose Schaltelemente bestimmen und dem Graph hinzufügen
+    for (const trm of cimModel.terminals.values()) {
+      if (!graph.terminals.has(trm.mrid) && !graph.edges.has(trm.conductingEquipment.mrid)) {
+
+      }
+      if (!graph.edges.has(trm.conductingEquipment.mrid) && trm.conductingEquipment instanceof Switch) {
+        if (trm.connectivityNode && ) {
+          const swtch = trm.conductingEquipment as Switch;
+          const cn = trm.connectivityNode;
+        }
+      }
+
+    }*/
+
+  /** 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);
+    if (node && edge) {
+      const term = new 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 cimModel.feeders.values()) {
+    const wnFeeder = feeder as WNFeeder;
+
+    const disconnectedTerminalCNs: IdentifiedObject[][] = []; // nicht verbundene Knoten zu anderen Abgängen
+    const disconnectedTerminalCEs: IdentifiedObject[][] = []; // nicht verbundene leitende Equipments
+    const disconnectedSwitches: IdentifiedObject[][] = []; // nicht verbundene Schaltelemente mit allen offenen Terminals zu anderen Abgängen
+
+    const disconnectedSelfTerminalCN: IdentifiedObject[][] = []; // nicht verbundene Knoten zum gleichen Abgang
+    const disconnectedSelfTerminalCE: IdentifiedObject[][] = []; // nicht verbundene Knoten zum gleichen Abgang
+    const disconnectedSelfSwitches: IdentifiedObject[][] = []; // 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) {
+        const ce = equip as ConductingEquipment;
+        //95e7f7b6-4f7a-4468-bb9a-97cdd1c1f56a
+        // 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 (terminal.connectivityNode && (terminal.connectivityNode as WNConnectivityNode).additionalConnectivityNodeContainer) {
+                disconnectedTerminalCNs.push([terminal as Terminal]);
+              }
+            } else if (wnFeeder.normalEnergizedConnectivityNodes.has(terminal.connectivityNode.mrid)) {
+              /** offene Verbindungen zu sich selbst */
+              if (!isSwitchObjectInArray(terminal as Terminal, disconnectedSelfTerminalCN)) disconnectedSelfTerminalCN.push([terminal as 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()) {
+
+        if (cn.mrid === '7b01c8f9-69a3-41dc-af60-f4e68ee68400') {
+          console.log();
+        }
+
+        /** offene Terminals */
+        if (!terminal.isClosed()) {
+          /** ist offen und gehört zu einem anderen Abgang */
+          const ce = terminal.conductingEquipment;
+          if (cn.mrid === 'a9b2f23b-c799-4edf-9972-8f594d67446b') {
+            console.log();
+          }
+          if (!wnFeeder.additionalGroupedEquipment.has(ce.mrid) && isBelongingToFeeder(ce.mrid, cimModel.feeders, false)) {
+            if (terminal.conductingEquipment.additionalEquipmentContainer.size) {
+              disconnectedTerminalCEs.push([terminal]);
+            }
+          } else if (wnFeeder.additionalGroupedEquipment.has(ce.mrid)) {
+            /** offene Verbindungen zu sich selbst */
+            if (!isSwitchObjectInArray(terminal as Terminal, disconnectedSelfTerminalCE)) disconnectedSelfTerminalCE.push([terminal]);
+          } else {
+            /** offenes Schaltalement,das zu keinem Abgang gehört */
+            if (terminal.conductingEquipment instanceof Switch) {
+              const swtch = terminal.conductingEquipment as Switch;
+              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.mrid !== terminal.mrid) {
+                    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 (isBelongingToFeeder(switchConnNodeUUID, cimModel.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.normalHeadTerminals.values()) {
+      outageNodes.push(headTerminal.connectivityNode);
+    }
+    for (const cn of wnFeeder.normalEnergizedConnectivityNodes.values()) {
+        let connectedACLineSegments = 0;
+        for (const terminal of cn.terminals.values()) {
+          if (terminal.isClosed() && terminal.conductingEquipment instanceof ACLineSegment) {
+            connectedACLineSegments++;
+          }
+        }
+        if (connectedACLineSegments > 2) outageNodes.push(cn);
+    }
+
+    // HeadTerminal-Ausfälle
+    const proceededContingencyNodes = [];
+    for (const outageSfCN of outageNodes) {
+      console.log(outageSfCN.name);
+      if (outageSfCN.name === '05966012-S-K-ST-00042')
+        console.log();
+      if (outageSfCN.mrid === '128a65ff-702d-47b2-8e7c-0be501740358')
+        console.log();
+      /** abgearbeitete Knoten überspringen. Tritt auf, wenn ein Feederknoten untergeklemmte Leitungen besitzt */
+      if (proceededContingencyNodes.indexOf(outageSfCN.mrid) !== -1) continue;
+
+      console.log('\tOutage ' + outageSfCN.mrid);
+
+      proceededContingencyNodes.push(outageSfCN.mrid);
+      const graphNode = graph.nodes.get(outageSfCN?.mrid);
+
+      if (graphNode) {
+        /** Als Ausfall markieren */
+        graphNode.inService = false
+
+        const outageResult: OutageResult = determineOutageAffectedSubstations(graph, [graphNode.uuid],
+                                                                              wnFeeder.normalEnergizedConnectivityNodes,
+                                                                              slackUUIDs);
+        /** 2 Schaltmaßnahmen */
+        const switchActionsFullyReenergised = [];
+        const switchActionsPartiallyReenergised = [];
+        /** Ausfall führt zum Zerfall des Netzes */
+        if (outageResult.outageStations.size) {
+          const a = [...outageResult.outageStations.values()];
+          /*          console.log('\toutageStations ' + a.map(elemt => {
+                      return elemt.map(e => e['uuid']);
+                    }));*/
+
+          /** Schaltmaßnahmen evaluieren */
+            // Schaltmaßnahmen von den CNs
+          const switchActionsTerminalsCN: SwitchEvalResult[] = evaluateSwitchActions(graphNode.uuid, outageResult.outageStations,
+            wnFeeder.normalEnergizedConnectivityNodes, graph,
+            disconnectedTerminalCNs, slackUUIDs);
+
+          const switchActionsSelfTerminalsCN: SwitchEvalResult[] = evaluateSwitchActions(graphNode.uuid, outageResult.outageStations,
+            wnFeeder.normalEnergizedConnectivityNodes, graph,
+            disconnectedSelfTerminalCN, slackUUIDs);
+
+          // Schaltmaßnahmen von den CEs
+          const switchActionsTerminalsCE: SwitchEvalResult[] = evaluateSwitchActions(graphNode.uuid, outageResult.outageStations,
+            wnFeeder.normalEnergizedConnectivityNodes, graph,
+            disconnectedTerminalCEs, slackUUIDs);
+
+          const switchActionsSelfTerminalsCE: SwitchEvalResult[] = evaluateSwitchActions(graphNode.uuid, outageResult.outageStations,
+            wnFeeder.normalEnergizedConnectivityNodes, graph,
+            disconnectedSelfTerminalCE, slackUUIDs);
+
+          // Schaltmaßnahmen von den Switches
+          const switchActionsSwitches: SwitchEvalResult[] = evaluateSwitchActions(graphNode.uuid, outageResult.outageStations,
+            wnFeeder.normalEnergizedConnectivityNodes, graph,
+            disconnectedSwitches, slackUUIDs);
+
+          const switchActionsPartially = [
+            ...switchActionsTerminalsCN.filter(elem => elem.type === 1),
+            ...switchActionsTerminalsCE.filter(elem => elem.type === 1),
+            ...switchActionsSwitches.filter(elem => elem.type === 1),
+            ...switchActionsSelfTerminalsCN.filter(elem => elem.type === 1),
+            ...switchActionsSelfTerminalsCE.filter(elem => elem.type === 1),
+          ];
+
+          switchActionsFullyReenergised.push(
+            ...switchActionsTerminalsCN.filter(elem => elem.type === 2),
+            ...switchActionsTerminalsCE.filter(elem => elem.type === 2),
+            ...switchActionsSwitches.filter(elem => elem.type === 2),
+            ...switchActionsSelfTerminalsCN.filter(elem => elem.type === 2),
+            ...switchActionsSelfTerminalsCE.filter(elem => elem.type === 2),
+            );
+
+          /** Wenn es mehr als eine Maßnahme mit partieller Wiederversorgung gibt,
+           * dann versuche eine Kombination zur vollständigen Wiederversorgung zu finden */
+          if (switchActionsPartially.length > 1) {
+            const combinedSwitchUUIDs: string[][] = [];
+            for (const currentSwitchAction of switchActionsPartially) {
+              /** key -> UUID des unversorgten (Teil-)Abgangs; value -> Schaltmaßnahmen zur Wiederversorgung 0...n */
+              const additionalSwitchActions = new Map<string, SwitchEvalResult[]>();
+
+              /** Ausgefalle Stationen dieser Maßnahme */
+              const currentOutageSubstations: Map<string, Node[]> = currentSwitchAction.outageResult.outageStations;
+
+              /** Iteriere über zerfallene Teilangänge der aktuellen Maßnahme.
+               * für jeden zerfallenen Teilabgang muss eine schaltmaßnahme gefunden werden  */
+              for (const entry of currentOutageSubstations.entries()) {
+                const outageNodesToRepair = entry[1];
+                if (outageNodesToRepair.length) {
+                  /** Bestimme Maßnahmen zur Wiederversorgung der Stationen dieses Teilabgangs */
+                  const repairActions: SwitchEvalResult[] = getPartiallySwitchingActionForSubstations(outageNodesToRepair, switchActionsPartially);
+                  /*        /!** Wenn keine Schaltmaßnahme gefunden werden konnte, dann bereche ab, da der Abgang nicht vollständig wiederversorgt werden kann *!/
+                          if (!switchActions?.length) break;*/
+                  if (repairActions?.length) {
+                    additionalSwitchActions.set(entry[0], repairActions);
+                  }
+                }
+              }
+
+              /** IDs der SwitchObjekte als 2D array anlegen,
+               * um alle Kombinatonen zu bestimmen */
+              /** Erste Maßnahme ist currentSwitchAction */
+              const switchingAction = [];
+              switchingAction.push([currentSwitchAction]);
+              for (const repairActions of additionalSwitchActions.values()) {
+                switchingAction.push(repairActions);
+              }
+              const results: string[][] = [];
+              getArrayCombination(0, 0, switchingAction, [], results);
+              sort2DArray(results);
+              addNewRepairActions(combinedSwitchUUIDs, results);
+              // console.log(combinedSwitchUUIDs);
+
+            }
+            const combinedSwitchActions = [];
+            for (const combinedSwitchesUUID of combinedSwitchUUIDs) {
+              const combinedSwitches = combinedSwitchesUUID.map(element => {
+                return cimModel.getObject(element)
+              });
+              combinedSwitchActions.push(combinedSwitches);
+            }
+            /** Kombinierte Maßnahmen testen */
+            const switchEvalResults: SwitchEvalResult[] = evaluateSwitchActions(graphNode.uuid, outageResult.outageStations,
+              wnFeeder.normalEnergizedConnectivityNodes, graph,
+              combinedSwitchActions, slackUUIDs);
+            switchActionsFullyReenergised.push(...switchEvalResults.filter(elem => elem.type === 2));
+
+          }
+
+        }
+
+        for (const action of switchActionsFullyReenergised) {
+          console.log('\tActions ' + action.switchObjects);
+          const outageObjects: string[] = action.outageResult.outageObjects;
+          if (outageObjects.length) {
+            const faultCN = cimModel.getConnectivityNode(outageObjects[0]) as unknown as WNConnectivityNode;
+
+            const outageNew = new WNOutage(generateUUID(), `Ausfall-${faultCN.name}`, `${wnFeeder.shortName}`, '', wnFeeder.baseIRI);
+            insertSPARQL.push(outageNew.createNewStatementSPARQL());
+            /** Equipments */
+            for (const object of wnFeeder.additionalGroupedEquipment.values()) {
+              if (object instanceof ConductingEquipment) {
+                insertSPARQL.push(outageNew.addOutageIsolationEquipment(object as ConductingEquipment));
+
+              } else if (object instanceof WNConnectivityNode) {
+                insertSPARQL.push(outageNew.addOutageIsolationConnectivityNodes(object as WNConnectivityNode));
+              } else if (object instanceof EVTerminal) {
+                // TBD
+              }
+            }
+
+            /** WNConnectivityNodes */
+            for (const object of wnFeeder.normalEnergizedConnectivityNodes.values()) {
+              insertSPARQL.push(outageNew.addOutageIsolationConnectivityNodes(object));
+            }
+            /** Fault */
+            const cnFaultNew = new WNFaultConnectivityNode(generateUUID(), `Ausfall-${faultCN.name}`, '', '', wnFeeder.baseIRI);
+            insertSPARQL.push(cnFaultNew.createNewStatementSPARQL());
+
+            insertSPARQL.push(cnFaultNew.setConnectivityNode(faultCN));
+            insertSPARQL.push(cnFaultNew.setOutage(outageNew));
+
+            /** SwitchingPlan */
+            // de-energise
+/*            const switchingPlanDeEnergise = createSwitchingPlan(generateUUID(), wnFeeder.baseIRI, `Schaltmaßnahme-Ausfall`, -1, 'de-energise', outageNew, insertSPARQL);
+            const switchingActionDeEnergise = createTerminalAction(generateUUID(), wnFeeder.baseIRI, `Schaltung-Ausfall`, SwitchActionKind.open, switchingPlanDeEnergise, insertSPARQL);
+            insertSPARQL.push(switchingActionDeEnergise.addTerminal(headTerminal as EVTerminal));
+            //restore
+            const switchingPlanRestore = createSwitchingPlan(generateUUID(), wnFeeder.baseIRI, `Schaltmaßnahme-Restore`, 0, 'restore', outageNew, insertSPARQL);
+            const switchingActionRestore = createTerminalAction(generateUUID(), wnFeeder.baseIRI, `Schaltung-Restore`, SwitchActionKind.close, switchingPlanRestore, insertSPARQL);
+            insertSPARQL.push(switchingActionRestore.addTerminal(headTerminal as EVTerminal));*/
+          }
+
+        }
+
+        graphNode.inService = true;
+      }
+      /** 2 Schaltmaßnahmen */
+
+      //Lege einen N-1 Fall an, wenn es Schaltmaßnahmen exisitieren
+
+/*      for (const aa of switchActionsFullyReenergised) {
+
+      }
+      if (disconnectedTerminalCNs.length || disconnectedTerminalCEs.length) {
+        const faultCN = headTerminal.connectivityNode as WNConnectivityNode;
+        const outageNew = new WNOutage(generateUUID(), `Ausfall-${faultCN.name}`, `${wnFeeder.shortName}`, '', wnFeeder.baseIRI);
+        insertSPARQL.push(outageNew.createNewStatementSPARQL());
+
+        /!** Equipments *!/
+        for (const object of wnFeeder.additionalGroupedEquipment.values()) {
+          if (object instanceof ConductingEquipment) {
+            insertSPARQL.push(outageNew.addOutageIsolationEquipment(object as ConductingEquipment));
+
+          } else if (object instanceof WNConnectivityNode) {
+            insertSPARQL.push(outageNew.addOutageIsolationConnectivityNodes(object as WNConnectivityNode));
+          } else if (object instanceof EVTerminal) {
+            // TBD
+          }
+        }
+        /!** WNConnectivityNodes *!/
+        for (const object of wnFeeder.normalEnergizedConnectivityNodes.values()) {
+          insertSPARQL.push(outageNew.addOutageIsolationConnectivityNodes(object));
+        }
+        //Fault
+        const cnFaultNew = new WNFaultConnectivityNode(generateUUID(), `Ausfall-${faultCN.name}`, '', '', wnFeeder.baseIRI);
+        insertSPARQL.push(cnFaultNew.createNewStatementSPARQL());
+
+        insertSPARQL.push(cnFaultNew.setConnectivityNode(faultCN));
+        insertSPARQL.push(cnFaultNew.setOutage(outageNew));
+
+
+        //SwitchingPlan
+        // de-energise
+        const switchingPlanDeEnergise = createSwitchingPlan(generateUUID(), wnFeeder.baseIRI, `Schaltmaßnahme-Ausfall`, -1, 'de-energise', outageNew, insertSPARQL);
+        const switchingActionDeEnergise = createTerminalAction(generateUUID(), wnFeeder.baseIRI, `Schaltung-Ausfall`, SwitchActionKind.open, switchingPlanDeEnergise, insertSPARQL);
+        insertSPARQL.push(switchingActionDeEnergise.addTerminal(headTerminal as EVTerminal));
+        //restore
+        const switchingPlanRestore = createSwitchingPlan(generateUUID(), wnFeeder.baseIRI, `Schaltmaßnahme-Restore`, 0, 'restore', outageNew, insertSPARQL);
+        const switchingActionRestore = createTerminalAction(generateUUID(), wnFeeder.baseIRI, `Schaltung-Restore`, SwitchActionKind.close, switchingPlanRestore, insertSPARQL);
+        insertSPARQL.push(switchingActionRestore.addTerminal(headTerminal as EVTerminal));
+
+        // Schaltmaßnahmen von den CNs
+        for (let i = 0; i < disconnectedTerminalCNs.length; i++) {
+          const terminal = disconnectedTerminalCNs[i];
+          const switchingPlanEnergise = createSwitchingPlan(generateUUID(), wnFeeder.baseIRI, `Schaltmaßnahme-Energise`, (i + 1), 'energise', outageNew, insertSPARQL);
+          const switchingActionEnergise = createTerminalAction(generateUUID(), wnFeeder.baseIRI, `Schaltung-${terminal.connectivityNode.name}`, SwitchActionKind.close, switchingPlanEnergise, insertSPARQL);
+          insertSPARQL.push(switchingActionEnergise.addTerminal(terminal));
+        }
+
+        // Schaltmaßnahmen von den CEs
+        for (let i = 0; i < disconnectedTerminalCEs.length; i++) {
+          const terminal = disconnectedTerminalCEs[i];
+          const switchingPlanEnergise = createSwitchingPlan(generateUUID(), wnFeeder.baseIRI, `Schaltmaßnahme-Energise`, (i + 1), 'energise', outageNew, insertSPARQL);
+          const switchingActionEnergise = createTerminalAction(generateUUID(), wnFeeder.baseIRI, `Schaltung-${terminal.connectivityNode.name}`, SwitchActionKind.close, switchingPlanEnergise, insertSPARQL);
+          insertSPARQL.push(switchingActionEnergise.addTerminal(terminal));
+        }
+      }*/
+    }
+  }
+
+  return insertSPARQL;
+}
+
+export function createSwitchingPlan(uuid: string, baseIRI: string, name: string, rank: any, purpose: string, outage: IOutage, insertSPARQL: string[]): SwitchingPlan {
+  const switchingPlan = new 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;
+}
+
+export function createTerminalAction(uuid: string, baseIRI: string, name: string, kind: SwitchActionKind, switchingPlan: SwitchingPlan, insertSPARQL: string[]): EVTerminalAction {
+  const switchingActionNew = new EVTerminalAction(uuid, name, '', '', baseIRI);
+  insertSPARQL.push(switchingActionNew.createNewStatementSPARQL());
+  insertSPARQL.push(switchingActionNew.setKind(kind));
+  insertSPARQL.push(switchingActionNew.setSwitchingPlan(switchingPlan));
+  return switchingActionNew;
+}
+
+/** Bestimmt, ob aussgefallene substations durch die übergenen Maßnahmen wiederversorgt werden können */
+export function getPartiallySwitchingActionForSubstations(substations: Node[], partiallySwitchActions: SwitchEvalResult[]): SwitchEvalResult[] {
+  return partiallySwitchActions.filter(elem => {
+    const feededSubstations: Map<string, Node[]> = elem.outageResult.feededStations;
+    for (const feededNodes of feededSubstations.values()) {
+      if (feededNodes.indexOf(substations[0]) !== -1) {
+        return elem;
+      }
+    }
+  });
+}
+
+
+export function getArrayCombination(row: number, col: number, data: SwitchEvalResult[][], oldCombination: string[], results: string[][]) {
+  const newCombination = [...oldCombination, ...data[row][col].switchObjects];
+
+  if (row === data.length - 1) {
+    //console.log(newCombination);
+    results.push(newCombination)
+  }
+
+  if (row < data.length - 1) {
+    getArrayCombination(row + 1, 0, data, newCombination, results);
+  }
+
+  if (col < data[row].length - 1) {
+    getArrayCombination(row, col + 1, data, oldCombination, results);
+  }
+}
+
+export function addNewRepairActions(repairActions: string[][], newRepairActions: string[][]) {
+
+  for (const newRepairAction of newRepairActions) {
+    if (!arrayContains(repairActions, newRepairAction)) {
+      repairActions.push(newRepairAction);
+    }
+  }
+}
+
+
+function arrayContains(arrays: string[][], b: string[]) {
+  for (const a of arrays) {
+    if (arraysEqual(a, b)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function arraysEqual(a: string[], b: string[]): boolean {
+  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: ITerminal, trm2: ITerminal, swtch: Switch): IdentifiedObject[] {
+  const switchArray = [];
+  if (!trm1.isClosed()) switchArray.push(trm1);
+  if (!swtch.isClosed()) switchArray.push(swtch);
+  if (!trm2.isClosed()) switchArray.push(trm2);
+  return switchArray;
+}
+
+export function sort2DArray(array: string[][]) {
+  for (let _i = 0; _i < array.length; _i++) {
+    array[_i].sort();
+  }
+}

package/src/graph/Types.ts

@@ -0,0 +1,7 @@
+import { ConductingEquipment } from '../model/core/ConductingEquipment';
+
+export enum Type {
+  ExternalNetworkinjection ='ExternalNetworkinjection',
+  Switch = 'Switch',
+  ConductingEquipment = 'ConductingEquipment',
+}

package/src/graph/connections/connection.ts

@@ -0,0 +1,29 @@
+import { Edge } from '../edges/edge';
+import { Node } from '../nodes/Node';
+
+export class Connection {
+  uuid: string;
+  connected: boolean;
+  node: Node;
+  edge: Edge;
+  visited: boolean = false;
+
+  constructor(uuid: string, connected: boolean, node: Node, edge: Edge) {
+    this.uuid = uuid;
+    this.connected = connected;
+    this.node = node;
+    this.edge = edge;
+  }
+
+  canPassThrough(): boolean {
+    return this.connected;
+  }
+
+/*  isSlackReachable() {
+    if (this.connected && !this.visited) {
+      this.visited = true;
+      this.node.isSlackReachable();
+      this.edge.isSlackReachable();
+    }
+  }*/
+}

package/src/graph/edges/edge.ts

@@ -0,0 +1,27 @@
+import { Type } from '../Types';
+import { GraphObject } from '../nodes/node';
+
+export class Edge extends GraphObject {
+  type: Type;
+  open: boolean;
+
+  constructor(uuid: string, type: Type, open: boolean) {
+    super(uuid);
+    this.type = type;
+    this.open = open;
+  }
+
+  canPassThrough(): boolean {
+    return this.open === true ? false : true;
+  }
+
+/*  isSlackReachable() {
+    if (this.closed && !this.visited) {
+      this.visited = true;
+      for (const term of this.terminals.values()) {
+        term.isSlackReachable();
+      }
+    }
+  }*/
+
+}

package/src/graph/graph-interfaces.ts

@@ -0,0 +1,21 @@
+import { Node } from './nodes/node';
+
+export interface ResultBFS {
+  found: boolean;
+  nodesVisited: Node [];
+}
+
+export interface SwitchEvalResult {
+  switchObjects: string []; // ID des Schaltobjektes
+  /** 0 -> keine Wiederversorgung
+   * 1 -> partielle Wiederversorgung
+   * 2 -> vollständige Wiederversorgung */
+  type: number;
+  outageResult: OutageResult, // Ergebnis mit durchgefühter Schaltmaßnahme
+}
+
+export interface OutageResult {
+  outageObjects: string []; // IDs der Ausfallobjekte (z.B. Trennschalter und Station)
+  outageStations: Map<string, Node[]>; // nicht versorgte Stationen
+  feededStations: Map<string, Node[]>; // versorgte Stationen
+}