@enervance/insight-cim-model 0.0.12 → 0.0.14

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

@@ -1,571 +0,0 @@
-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';
-import { SwitchAction } from '../model/operations/SwitchAction';
-
-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));
-      }
-    }
-  }
-
-  /** Konnektivität durch terminals herstellen */
-  for (const terminal of terminals) {
-    if (!terminal.connectivityNode) {
-      console.log(`Terminal ${terminal.mrid} hat keinen CN`);
-    }
-    if (!terminal.conductingEquipment) {
-      console.log(`Terminal ${terminal.mrid} hat keinen CE`);
-    }
-
-    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 (!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);
-    }
-
-    // Ausfälle
-    const proceededContingencyNodes = [];
-    for (const outageSfCN of outageNodes) {
-      console.log(outageSfCN.name);
-
-      /** 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 bestimmen */
-        const switchActionsFullyReenergised = [];
-        const switchActionsPartiallyReenergised = [];
-        /** Ausfall führt zum Zerfall des Netzes */
-        if (outageResult.outageStations.size) {
-          /** 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));
-
-          }
-
-        }
-
-        /** 2 Schaltmaßnahmen Modell erstellen und speichern */
-        if (switchActionsFullyReenergised.length) {
-          //Ausfallschaltmaßnahme anlegen
-          const faultCN = outageSfCN 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);
-          /** SwitchingAction de-energise*/
-          const switchingActionDeEnergise = createTerminalAction(generateUUID(), wnFeeder.baseIRI, `Schaltung-Ausfall`, SwitchActionKind.open, switchingPlanDeEnergise, insertSPARQL);
-          // Alle terminals des Ausfallknotens
-          for (const terminal of faultCN.terminals.values()) {
-            insertSPARQL.push(switchingActionDeEnergise.addTerminal(terminal as EVTerminal));
-          }
-
-          /** SwitchingPlan restore*/
-          const switchingPlanRestore = createSwitchingPlan(generateUUID(), wnFeeder.baseIRI, `Schaltmaßnahme-Restore`, 0, 'restore', outageNew, insertSPARQL);
-          /** SwitchingAction de-energise*/
-          const switchingActionRestore = createTerminalAction(generateUUID(), wnFeeder.baseIRI, `Schaltung-Restore`, SwitchActionKind.close, switchingPlanRestore, insertSPARQL);
-          // Alle terminals des Ausfallknotens
-          for (const terminal of faultCN.terminals.values()) {
-            insertSPARQL.push(switchingActionRestore.addTerminal(terminal as EVTerminal));
-          }
-
-          //Wiederversorgungsmaßnahmen
-          for (let i = 0; i < switchActionsFullyReenergised.length; i++) {
-            const switchAction = switchActionsFullyReenergised[i];
-            console.log('\tActions ' + switchAction.switchObjects);
-            /** SwitchingPlan restore*/
-            const switchingPlanRestore = createSwitchingPlan(generateUUID(), wnFeeder.baseIRI, `Schaltmaßnahme-Restore`, (i + 1), 'energise', outageNew, insertSPARQL);
-            /** SwitchingAction restore*/
-            for (const switchObjectUUID of switchAction.switchObjects) {
-              const cimSwitchObject = cimModel.getObject(switchObjectUUID);
-
-              if(cimSwitchObject) {
-                if (cimSwitchObject instanceof Terminal) {
-                  const switchingActionRestore = createTerminalAction(generateUUID(), wnFeeder.baseIRI, `Schaltung-Restore`, SwitchActionKind.close, switchingPlanRestore, insertSPARQL);
-                  insertSPARQL.push(switchingActionRestore.addTerminal(cimSwitchObject as EVTerminal));
-                }
-                else if (cimSwitchObject instanceof Switch) {
-                  const switchingActionRestore = createSwitchAction(generateUUID(), wnFeeder.baseIRI, `Schaltung-Restore`, SwitchActionKind.close, switchingPlanRestore, insertSPARQL);
-                  insertSPARQL.push(switchingActionRestore.setSwitch(cimSwitchObject as Switch));
-                }
-              }
-            }
-          }
-        }
-
-        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;
-}
-
-export function createSwitchAction(uuid: string, baseIRI: string, name: string, kind: SwitchActionKind, switchingPlan: SwitchingPlan, insertSPARQL: string[]): SwitchAction {
-  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 */
-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

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

package/src/graph/connections/connection.ts

@@ -1,29 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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
-}