@enervance/insight-cim-model 0.0.12 → 0.0.14

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

@@ -1,188 +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 { EVTerminal } from '../model/extensions/enervance/core/EVTerminal';
-import { WNOutage } from '../model/extensions/neplan-westnetz/operations/WNOutage';
-import { generateUUID } from '../util/utils';
-import { WNFaultConnectivityNode } from '../model/extensions/neplan-westnetz/faults/WNFaultConnectivityNode';
-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';
-
-export function performContingencyAnalysis(cimModel: Model): string[] {
-
-  /** 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 = [];
-  const graph = new Graph();
-
-  for (const feeder of cimModel.feeders.values()) {
-    const wnFeeder = feeder as WNFeeder;
-    const disconnectedTerminalCNs = []; // nicht verbundene Knoten zu anderen Abgängen
-    const disconnectedTerminalCEs = []; // nicht verbundene leitende Equipments
-
-    const disconnectedSwitches = []; // nicht verbundene Schaltelemente
-    const disconnectedTerminal = []; // nicht verbundene Knoten zum gleichen Abgang
-
-    /** 1.1 / 1.2) nicht verbundene Knoten und Switches bestimmen */
-    for (const equip of wnFeeder.additionalGroupedEquipment.values()) {
-      if (equip instanceof ConductingEquipment) {
-        const ce = equip as ConductingEquipment;
-        // Bestimme nicht verbundene CNs
-        for (const terminal of ce.terminals.values()) {
-
-          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);
-              }
-            } else if (wnFeeder.normalEnergizedConnectivityNodes.has(terminal.connectivityNode.mrid)) {
-              /** offene Verbindungen zu sich selbst */
-              if (!disconnectedTerminal.includes(terminal)) disconnectedTerminal.push(terminal);
-            }
-          }
-        }
-
-        // Prüfen, ob es um einen offen Switch handelt
-        if (ce instanceof Switch) {
-          const swtch = ce as Switch;
-          if (swtch.open === true) {
-            disconnectedSwitches.push(swtch);
-          }
-        }
-      }
-    }
-
-    /** 1.1 / 1.2) nicht verbundene leitende Elemente bestimmen */
-    for (const cn of wnFeeder.normalEnergizedConnectivityNodes.values()) {
-      // Bestimme nicht verbundene CNs
-      for (const terminal of cn.terminals.values()) {
-
-        if (!terminal.isClosed()) {
-          /** ist offen und gehört zu einem anderen Abgang */
-          if (!wnFeeder.additionalGroupedEquipment.has(terminal.conductingEquipment.mrid)) {
-            if (terminal.conductingEquipment.additionalEquipmentContainer.size) {
-              disconnectedTerminalCEs.push(terminal);
-            }
-          } else if (wnFeeder.additionalGroupedEquipment.has(terminal.conductingEquipment.mrid)) {
-            /** offene Verbindungen zu sich selbst */
-            if (!disconnectedTerminal.includes(terminal)) disconnectedTerminal.push(terminal);
-          }
-        }
-      }
-    }
-
-    /** 2 Schaltmaßnahmen */
-    //Ausfallasset: Headterminal
-    /*    console.log(feeder.shortName);
-        console.log('\tdisconnected CNs');
-        for (const terminal of disconnectedTerminalCNs) {
-          const wn = terminal.connectivityNode as WNConnectivityNode;
-          console.log('\t\t' + wn.additionalConnectivityNodeContainer.shortName + ' ' + wn.mrid + ' ');
-        }
-
-        console.log('\tdisconnected CEs');
-        for (const terminal of disconnectedTerminalCEs) {
-          console.log('\t\t' + terminal.conductingEquipment.getAdditionalEquipmentContainer()?.shortName + ' ' + terminal.conductingEquipment.mrid + ' ');
-        }
-
-        console.log('\topenswitches');
-        for (const swtch of disconnectedSwitches) {
-          console.log('\t\t' + swtch.additionalEquipmentContainer.shortName + ' ' + swtch.mrid + ' ');
-        }
-
-        console.log('\twnFeeder.additionalGroupedEquipment ' + wnFeeder.additionalGroupedEquipment.size);
-        console.log('\twnFeeder.normalEnergizedConnectivityNodes + ' + wnFeeder.normalEnergizedConnectivityNodes.size);*/
-
-    // Stationen mit mehr als einem Anbgang ausfallen lassen.
-
-    // Head TerminalAusfälle
-    for (const headTerminal of feeder.normalHeadTerminals.values()) {
-      //Lege einen N-1 Fall an, wenn es Schaltmaßnahmen exisitieren
-
-      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;
-}

package/src/etl-neplan/etl-neplan-feederline.ts

@@ -1,229 +0,0 @@
-/** */
-import { IIdentifiedObject } from '../interfaces/model/core/IIdentifiedObject';
-import {
-  determineComputableGrid,
-  determineNetworksSlackElements, determineSubstations,
-  determineTopologicalIslands, resetMapCIM
-} from '../util/util-topology';
-import { Model } from '../model/model/Model';
-import { WNFeeder } from '../model/extensions/neplan-westnetz/core/WNFeeder';
-import { IConnectivityNode } from '../interfaces/model/core/IConnectivityNode';
-import { ACLineSegment } from '../model/wires/ACLineSegment';
-import { generateUUID, isInArray } from '../util/utils';
-import { Equipment } from '../model/core/Equipment';
-import { WNConnectivityNode } from '../model/extensions/neplan-westnetz/core/WNConnectivityNode';
-import { EVTerminal } from '../model/extensions/enervance/core/EVTerminal';
-import { ITerminal } from '../interfaces/model/core/ITerminal';
-import { ConductingEquipment } from '../model/core/ConductingEquipment';
-import { VoltageLevel } from '../model/core/VoltageLevel';
-import { Bay } from '../model/core/Bay';
-import { ExternalNetworkInjection } from '../model/wires/ExternalNetworkInjection';
-
-/**
- * Erzeugung von Abgängen
- * @param cimModel das CIM Modellinstanz
- * @param baseIRI IRI (Internationalized Resource Identifier) des RDF-Stores
- * return SPARQL Insert Statements
- * */
-export function createFeederLines(cimModel: Model, basiIRI: string): 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);
-
-  const computableGridsSlackElementsForFeeder = [...computableGridsSlackElements, substationElements]
-
-
-
-  const insertObjectSPARQL = [];
-  /** bestimmt ALLE elektrisch zusammenhängende Abgänge (eine Art Stromkreis für Mittelspannungsnetze) */
-  for (const grid of computableGrids) {
-    /** Für das Netz die elektrisch zusammenhängenden Abgänge bestimmen (bestehend aus allen Elementen ) */
-    const networkFeederElements: IIdentifiedObject[][] = determineFeederLinesElements(cimModel, grid, computableGridsSlackElementsForFeeder);
-
-    /** Erstellen der FeederLine Objekte */
-    for (const feederObjects of networkFeederElements) {
-
-      const headTerminals = determineHeadTerminals(feederObjects, computableGridsSlackElements, substationElements);
-
-      const headTerminalsMulti = determineMultiStartHeadTerminals(headTerminals, substationElements);
-      const headTerminal = headTerminalsMulti[0];
-      const startCN = headTerminal?.connectivityNode;
-      console.log(startCN.name);
-      const substation = startCN?.getVoltageLevel()?.getSubstation();
-
-      if (substation && startCN) {
-        const nameLenght = startCN.name?.length; // 05958016-S-H-ST-06736-K0-007
-        const feeder = new WNFeeder(generateUUID(), startCN.name, startCN.name?.substr(nameLenght - 3, nameLenght), '', basiIRI);
-        //feeder.number = startCN.name?.substr(nameLenght - 3, nameLenght);
-        insertObjectSPARQL.push(feeder.createNewStatementSPARQL());
-        insertObjectSPARQL.push(feeder.setNumber(startCN.name?.substr(nameLenght - 3, nameLenght)));
-        //additionalGroupedEquipment
-        for (const object of feederObjects) {
-          if (object instanceof Equipment) {
-            const equip = object as Equipment;
-            feeder.addAdditionalGroupedEquipment(equip);
-            insertObjectSPARQL.push(equip.addAdditionalEquipmentContainer(feeder));
-
-          } else if (object instanceof WNConnectivityNode) {
-            const wnCN = object as WNConnectivityNode;
-            feeder.addEnergizedConnectivityNode(wnCN)
-            insertObjectSPARQL.push(wnCN.addAdditionalConnectivityNodeContainer(feeder));
-          } else if (object instanceof EVTerminal) {
-            // TBD
-          }
-        }
-
-        // Substion
-        insertObjectSPARQL.push(feeder.setNormalEnergizingSubstation(substation));
-        substation.addNormalEnergizingFeeder(feeder);
-        // HeadTerminal setzen
-
-        for (const hTerminal of headTerminalsMulti) {
-          feeder.addNormalHeadTerminal(hTerminal);
-          insertObjectSPARQL.push(hTerminal.setNormalHeadFeeder(feeder));
-        }
-        cimModel.addFeeder(feeder);
-
-      } else {
-        console.log(`Der StartConnNode oder die Substion für Feeder konnte nicht bestimmt werden`);
-        console.log(substation + ' ' + startCN);
-      }
-    }
-
-  }
-  return insertObjectSPARQL;
-}
-
-/**Es wird ein FeederLine-Objekt bestimmt
- * Ausgehend von Stromkreisabschnitten alle zusammenhende Netzelemente bestimmen und zu einem Abgang zusammenfassen.
- * ???Trafos gehören immer zu einer Umspannanlage und können nicht zu einem Angang gehören???.
- depricated Hinweis: der Algorythmus setzt varaus, dass Slackelemente vorher bestimmt wurden.
- D.h. sie sind als 'visited' markiert. */
-export function determineFeederLinesElements(cimModel: Model, grid: IIdentifiedObject[],
-                                             slackSubstationElements: IIdentifiedObject[][]): IIdentifiedObject[][] {
-
-  const networkFeederLineElements: IIdentifiedObject[][] = [];
-  for (let i = 0; i < grid.length; i++) {
-    const gridElement = grid[i];
-    if (gridElement instanceof ConductingEquipment && gridElement.constructor.name.includes('ACLineSegment')|| gridElement.constructor.name === 'PowerTransformer') {
-      const feederLineElements: IIdentifiedObject[] = [];
-      gridElement.determineMidVoltageLineElements(feederLineElements, slackSubstationElements);
-      if (feederLineElements.length > 0) {
-        networkFeederLineElements.push(feederLineElements)
-      }
-    }
-  }
-  resetMapCIM(cimModel.objects);
-  return networkFeederLineElements;
-}
-
-/** Den Anfang eines Abgangs bestimmen - ConnectivityNode */
-/** prüft, ob ein Netzelement zur Slack-UA gehört
- * die Methode wird nur von der Terminal-Klasse implementiert,
- * da sie ConductingElements mit den ConnectivityNodes verbindet.
- * Gesucht ist ein ConnectivityNode der nicht Teil des Abgangs ist.
- * Die Bedingung ist erfüllt, wenn der ConnectivityNode nicht
- * im Array gridElements enthalten ist. */
-export function determineHeadTerminals(gridElements: IIdentifiedObject[],
-                                       slackSubstationElements: IIdentifiedObject[][],
-                                       additionalslackSubstationElements: IIdentifiedObject[]): ITerminal[] {
-  const headTerminals = [];
-  for (const object of gridElements) {
-    /*if (object.constructor.name.includes('ACLineSegment')) {*/
-    if (object instanceof ConductingEquipment) {
-      const ce = object as unknown as ConductingEquipment;
-
-      //_9fafa042-b9d1-4052-ace2-9bfbefeb0134
-      //_59f7d40a-36c9-4b39-95e4-657976e50b12
-      for (const terminal of ce.terminals.values()) {
-
-        if (isInArray(terminal.connectivityNode, slackSubstationElements)) { /** gehört der CN zur Substation mit Slack */
-           headTerminals.push(terminal);
-        } else if (additionalslackSubstationElements.indexOf(terminal.connectivityNode) != null) {  /** gehört der CN zur (Schwerpunkt-)Substation ohne Slack */
-          headTerminals.push(terminal);
-        }
-/*        if (terminal.isClosed()) { /!** ist elektrisch angeschlossen. *!/
-          if (gridElements.indexOf(terminal.connectivityNode) === -1) { /!** ist CN Teil des Abgabgs und ist mit einem ConductEquip verbunden? *!/
-          headTerminals.push(terminal);
-          }
-        }*/
-      }
-    }
-  }
-  return headTerminals;
-}
-
-/** HeadTerminal bestimmen
- * HeadTerminal gehört zu der Station mit dem Slack
- * falls der 2 Headterminals mit je einem Slack existieren, wird das erste Element als Head festgelegt*/
-export function determineStartHeadTerminals(terminals: ITerminal[], additionalslackSubstationElements: IIdentifiedObject[]): ITerminal {
-  for (const terminal of terminals) {
-    const cnc = terminal.connectivityNode.connectivityNodeContainer;
-    let voltageLevel;
-    if (cnc instanceof VoltageLevel) {
-      voltageLevel = cnc as VoltageLevel;
-    } else if (cnc instanceof Bay) {
-      voltageLevel = (cnc as Bay).voltageLevel;
-    }
-    for (const equip of voltageLevel?.equipments) {
-      if (equip instanceof ExternalNetworkInjection) {
-        return terminal;
-      }
-    }
-  }
-}
-
-  /** HeadTerminals bestimmen
-   * HeadTerminal gehört zu der Station mit dem Slack
-   * falls der 2 Headterminals mit je einem Slack existieren, werden alle Instanzen als Head festgelegt */
-  export function determineMultiStartHeadTerminals(terminals: ITerminal[], additionalslackSubstationElements: IIdentifiedObject[]): ITerminal[] {
-    const headTerminals = [];
-    const headNodes = [];
-    for (const terminal of terminals) {
-      const cnc = terminal.connectivityNode.connectivityNodeContainer;
-      let voltageLevel;
-      if (cnc instanceof VoltageLevel) {
-        voltageLevel = cnc as VoltageLevel;
-      } else if (cnc instanceof Bay) {
-        voltageLevel = (cnc as Bay).voltageLevel;
-      }
-      for (const equip of voltageLevel?.equipments) {
-        if (equip instanceof ExternalNetworkInjection) {
-          if (headNodes.indexOf(terminal.connectivityNode) === -1) {
-            headTerminals.push(terminal);
-            headNodes.push(terminal.connectivityNode);
-          }
-        }
-      }
-    }
-
-  /** Wenn keine Kriterien erfüllt werden,
-   * dann überprüfe additionalslackSubstationElements */
-  if (!headTerminals.length) {
-    const trm = determineStartHeadTerminalsTemporary(terminals, additionalslackSubstationElements);
-    if(trm) headTerminals.push(trm);
-  }
-
-  return headTerminals;
-}
-
-/** Übergangslösung, Schwerpunktstationen ohne Slack */
-export function determineStartHeadTerminalsTemporary(terminals: ITerminal[], additionalslackSubstationElements: IIdentifiedObject[]): ITerminal {
-  for (const terminal of terminals) {
-    if (additionalslackSubstationElements.indexOf(terminal.connectivityNode) !==-1) {
-      return terminal;
-    }
-  }
-  /** Wenn keine Kriterien erfüllt werden,
-   * dann nehme den ersten Terminal*/
-  return terminals[0];
-}