@enervance/insight-cim-model 0.0.1

package/src/util/sparql/sparql-utils.ts

@@ -0,0 +1,150 @@
+
+import {
+    BaseVoltage,
+    Substation,
+    VoltageLevel,
+    Bay,
+    Junction,
+    Ground,
+    GroundDisconnector,
+    Breaker,
+    Recloser,
+    SeriesCompensator,
+    Clamp,
+    ConnectivityNode,
+    ACLineSegment,
+    Line,
+    Terminal,
+    BusbarSection,
+    Switch,
+    Disconnector,
+    LoadBreakSwitch,
+    PowerTransformer,
+    PowerTransformerEnd,
+    SvPowerFlow,
+    SvVoltage,
+    TopologicalIsland,
+    TopologicalNode,
+    EnergySource,
+    EnergyConsumer,
+    ExternalNetworkInjection,
+    Diagram,
+    DiagramObject,
+    DiagramObjectPoint,
+    IdentifiedObject,
+    OperationalLimitSet,
+    OperationalLimitType,
+    CurrentLimit,
+    Facility,
+    AssetDeployment,
+    AssetHealthEvent,
+    HealthScore,
+    NS_PREFIX_RDF,
+    NS_PREFIX_CIM,
+    AssetOwner,
+    WNConnectivityNode, WNFacility, WNFeeder, NS_PREFIX_ENERVANCE
+} from '../..';
+import { PSRType } from '../../model/core/PSRType';
+import { CIM_CLASS_NAMES } from '../../constants/cim-class-names';
+import { RegulatingControl } from '../../model/wires/RegulatingControl';
+import { NS_PREFIX_WN } from './sparql-building-block';
+
+/** erstellt eine Map Klassname zu Klassdefinition
+ * Wird für abfragen und datenparsen benutzt */
+/*export function getMapClassName2Class(): any {
+    const cimClassName2Class = new Map();
+
+    cimClassName2Class.set(CIM_CLASS_NAMES.BaseVoltage.toLowerCase(), BaseVoltage);
+    cimClassName2Class.set(CIM_CLASS_NAMES.PSRType.toLowerCase(), PSRType);
+    //EQ
+    cimClassName2Class.set(CIM_CLASS_NAMES.Substation.toLowerCase(), Substation);
+    cimClassName2Class.set(CIM_CLASS_NAMES.VoltageLevel.toLowerCase(), VoltageLevel);
+    cimClassName2Class.set(CIM_CLASS_NAMES.Bay.toLowerCase(), Bay);
+    cimClassName2Class.set(CIM_CLASS_NAMES.Line.toLowerCase(), Line);
+    //ConductingEquipment
+    cimClassName2Class.set(CIM_CLASS_NAMES.ACLineSegment.toLowerCase(), ACLineSegment);
+    cimClassName2Class.set(CIM_CLASS_NAMES.PowerTransformer.toLowerCase(), PowerTransformer);
+    cimClassName2Class.set(CIM_CLASS_NAMES.PowerTransformerEnd.toLowerCase(), PowerTransformerEnd);
+    cimClassName2Class.set(CIM_CLASS_NAMES.BusbarSection.toLowerCase(), BusbarSection);
+    cimClassName2Class.set(CIM_CLASS_NAMES.Junction.toLowerCase(), Junction);
+    cimClassName2Class.set(CIM_CLASS_NAMES.Ground.toLowerCase(), Ground);
+    cimClassName2Class.set(CIM_CLASS_NAMES.GroundDisconnector.toLowerCase(), GroundDisconnector);
+    cimClassName2Class.set(CIM_CLASS_NAMES.Disconnector.toLowerCase(), Disconnector);
+    cimClassName2Class.set(CIM_CLASS_NAMES.Switch.toLowerCase(), Switch);
+    cimClassName2Class.set(CIM_CLASS_NAMES.Breaker.toLowerCase(), Breaker);
+    cimClassName2Class.set(CIM_CLASS_NAMES.LoadBreakSwitch.toLowerCase(), LoadBreakSwitch);
+    cimClassName2Class.set(CIM_CLASS_NAMES.Recloser.toLowerCase(), Recloser);
+    cimClassName2Class.set(CIM_CLASS_NAMES.SeriesCompensator.toLowerCase(), SeriesCompensator);
+    cimClassName2Class.set(CIM_CLASS_NAMES.Clamp.toLowerCase(), Clamp);
+    cimClassName2Class.set(CIM_CLASS_NAMES.EnergySource.toLowerCase(), EnergySource);
+    cimClassName2Class.set(CIM_CLASS_NAMES.EnergyConsumer.toLowerCase(), EnergyConsumer);
+
+    //RegulatingConductingEquipment
+    cimClassName2Class.set(CIM_CLASS_NAMES.ExternalNetworkInjection.toLowerCase(), ExternalNetworkInjection);
+    cimClassName2Class.set(CIM_CLASS_NAMES.RegulatingControl.toLowerCase(), RegulatingControl);
+    //OperationalLimits
+    cimClassName2Class.set(CIM_CLASS_NAMES.OperationalLimitSet.toLowerCase(), OperationalLimitSet);
+    cimClassName2Class.set(CIM_CLASS_NAMES.OperationalLimitType.toLowerCase(), OperationalLimitType);
+    cimClassName2Class.set(CIM_CLASS_NAMES.CurrentLimit.toLowerCase(), CurrentLimit);
+
+    //Topology
+    cimClassName2Class.set(CIM_CLASS_NAMES.ConnectivityNode.toLowerCase(), ConnectivityNode);
+    cimClassName2Class.set(CIM_CLASS_NAMES.Terminal.toLowerCase(), Terminal);
+    cimClassName2Class.set(CIM_CLASS_NAMES.TopologicalIsland.toLowerCase(), TopologicalIsland);
+    cimClassName2Class.set(CIM_CLASS_NAMES.TopologicalNode.toLowerCase(), TopologicalNode);
+    //SV
+    cimClassName2Class.set(CIM_CLASS_NAMES.SvPowerFlow.toLowerCase(), SvPowerFlow);
+    cimClassName2Class.set(CIM_CLASS_NAMES.SvVoltage.toLowerCase(), SvVoltage);
+    //Diagram
+    cimClassName2Class.set(CIM_CLASS_NAMES.Diagram.toLowerCase(), Diagram);
+    cimClassName2Class.set(CIM_CLASS_NAMES.DiagramObject.toLowerCase(), DiagramObject);
+    cimClassName2Class.set(CIM_CLASS_NAMES.DiagramObjectPoint.toLowerCase(), DiagramObjectPoint);
+
+    //Assets
+    cimClassName2Class.set(CIM_CLASS_NAMES.Facility.toLowerCase(), Facility);
+    cimClassName2Class.set(CIM_CLASS_NAMES.AssetDeployment.toLowerCase(), AssetDeployment);
+    cimClassName2Class.set(CIM_CLASS_NAMES.AssetHealthEvent.toLowerCase(), AssetHealthEvent);
+
+    //Analytics
+    cimClassName2Class.set(CIM_CLASS_NAMES.HealthScore.toLowerCase(), HealthScore);
+    cimClassName2Class.set(CIM_CLASS_NAMES.ImportanceScore.toLowerCase(), ImportanceScore);
+
+    // Roles
+    cimClassName2Class.set(CIM_CLASS_NAMES.AssetOwner.xml.toLowerCase(), AssetOwner.xml);
+
+    // Neplan Erweiterungen
+    cimClassName2Class.set(CIM_CLASS_NAMES.WNConnectivityNode.toLowerCase(), WNConnectivityNode);
+    cimClassName2Class.set(CIM_CLASS_NAMES.WNFacility.toLowerCase(), WNFacility);
+    cimClassName2Class.set(CIM_CLASS_NAMES.WNFeeder.toLowerCase(), WNFeeder);
+
+    return cimClassName2Class;
+}*/
+
+export function getNewInsertSPARQL(className: string, uuid: string, baseIRI: string, graphURI: string) {
+    return `
+            ${NS_PREFIX_RDF}
+            ${NS_PREFIX_CIM}
+             INSERT DATA
+             {
+                GRAPH ${graphURI}
+                {
+                   <${baseIRI}${uuid}>
+                    a   cim:${className} ;
+                }
+             }
+    `;
+}
+
+export function getSparqlTriple4Property(baseIRI: string, mrid: string, namespace: string,
+                                         className: string, propName, propValue: string) {
+    return `<${baseIRI}${mrid}> ${namespace}:${className}.${propName} <${this.baseIRI}${propValue}> . `;
+}
+
+export function getSparqlTriple4Asssociation(baseIRI: string, mrid: string, namespace: string,
+                                             className: string, propName, propValueMrid: string) {
+    return `<${baseIRI}${mrid}> ${namespace}:${className}.${propName} <${this.baseIRI}${propValueMrid}> . `;
+}
+
+
+
+

package/src/util/util-create.ts

@@ -0,0 +1,146 @@
+import {
+  BaseVoltage,
+  ConductingEquipment, ConnectivityNode,
+  generateUUID,
+  GeographicalRegion, IdentifiedObject,
+  Model, PhaseCode,
+  SubGeographicalRegion,
+  SvStatus, Terminal, UnitMultiplier, UnitSymbol,
+  RatioTapChangerTable, RatioTapChangerTablePoint, NS_PREFIX_RDF, NS_PREFIX_CIM, IConnectivityNode
+
+} from '..';
+import { getUUID } from './utils';
+
+export function createGeoregion(uuid: string, name: string, shortName: string, description: string, cimModel: Model): GeographicalRegion {
+  const region = new GeographicalRegion(getUUID(uuid), name, shortName, description);
+  cimModel.addGeographicalRegion(region);
+  return region;
+}
+
+export function createSubgeoregion(uuid: string, name: string, shortName: string, description: string, region: GeographicalRegion, cimModel: Model): SubGeographicalRegion {
+  const subregion = new SubGeographicalRegion(getUUID(uuid), name, shortName, description);
+  subregion.region = region;
+  region.addSubGeographicalRegion(subregion);
+  cimModel.addSubGeographicalRegion(subregion);
+  return subregion;
+}
+
+export function getGeoregionByName(cimModel: Model, name: string): GeographicalRegion {
+  for (const region of cimModel.geographicalRegions.values()) {
+    if (region.name === name) {
+      return region;
+    }
+  }
+  return;
+}
+
+export function getSubgeoregionByName(cimModel: Model, name: string): SubGeographicalRegion {
+  for (const region of cimModel.subgeographicalRegions.values()) {
+    if (region.name === name) {
+      return region;
+    }
+  }
+  return;
+}
+
+/*export function getBaseVoltage(cimModel: Model, un: number) {
+    let baseVoltage = cimModel.getBaseVoltage(un);
+    if(!baseVoltage) {
+        baseVoltage = createBaseVoltage(cimModel, un);
+    }
+    return baseVoltage;
+}*/
+
+export function createSvStatus(cimModel: Model, inBetrieb: boolean, conductingEquipment: ConductingEquipment) {
+  const svStatus = new SvStatus(generateUUID());
+  svStatus.inService = inBetrieb;
+  svStatus.conductingEquipmentUUID = conductingEquipment.mrid;
+  // conductingEquipment.svStatus = svStatus;
+  cimModel.addSvStatus(svStatus);
+  return svStatus;
+}
+
+export function createBaseVoltageIfNotExists(cimModel: Model, nominalVoltage: number): BaseVoltage {
+  let baseVoltage = cimModel.getBaseVoltage(nominalVoltage);
+  if (!baseVoltage) {
+    baseVoltage = new BaseVoltage(generateUUID(), String(nominalVoltage) + UnitMultiplier.k + UnitSymbol.V);
+    baseVoltage.nominalVoltage = cimModel.getVoltage(nominalVoltage);
+    cimModel.addBaseVoltage(baseVoltage);
+  }
+  return baseVoltage;
+}
+
+
+export function createConnection(cimModel: Model, conductingEquipment: ConductingEquipment,
+                                 object: IdentifiedObject | IConnectivityNode, phase: PhaseCode, sequenceNumber?: number): Terminal | undefined {
+  // console.log(`${conductingEquipment.description} start ${object.constructor.name} ${object instanceof ConnectivityNode} / ${object instanceof Terminal}`);
+  let terminal;
+  if (object instanceof ConnectivityNode) {
+    const cn = object as ConnectivityNode;
+    terminal = new Terminal(generateUUID(), 'T');
+
+    terminal.connectivityNodeUUID = cn.mrid;
+    // Damit Obejekt nicht nach de, Rausschreiben nicht im Speicher verbleibt,
+    // wird es nicht der CN-Instanz hinzugefügt
+    // cn.addTerminal(terminal);
+
+    cimModel.addTerminal(terminal);
+  } else if (object instanceof Terminal) { // eine Schlaufe/KnotenZw
+    // es wird keine neue Terminalinstanz erzeugt, da bereits existiert
+    terminal = object as Terminal;
+  }
+  if (terminal) {
+    terminal.phases = phase;
+    terminal.conductingEquipmentUUID = conductingEquipment.mrid;
+    
+    conductingEquipment.terminalsUUIDs.push(terminal.mrid);
+    // Damit Obejekt nicht nach de, Rausschreiben nicht im Speicher verbleibt,
+    // wird es nicht der CN-Instanz hinzugefügt
+    // conductingEquipment.addTerminal(terminal);
+
+    if (sequenceNumber) {
+      terminal.sequenceNumber = sequenceNumber;
+    }
+  }
+  // console.log(`\t  ${terminal.mrid} ${terminal.conductingEquipment.mrid}`);
+  return terminal;
+}
+
+export function createRatioTapChanger() {
+
+}
+
+export function createRatioTapChangerTablePoint(ratioTapChangerTable: RatioTapChangerTable, step: number, ratio: number): RatioTapChangerTablePoint {
+  const ratioTapChangerTablePoint = new RatioTapChangerTablePoint(generateUUID());
+  ratioTapChangerTablePoint.step = step;
+  ratioTapChangerTablePoint.ratio = ratio;
+  ratioTapChangerTablePoint.ratioTapChangerTableUUID = ratioTapChangerTable.mrid;
+  ratioTapChangerTable.addTapChangerTablePoint(ratioTapChangerTablePoint);
+  return ratioTapChangerTablePoint;
+}
+
+
+export function createNewFacilityStatement(baseIRI: string, graphURI: string): string {
+
+  const insertStatement = `
+            ${NS_PREFIX_RDF}
+            ${NS_PREFIX_CIM}
+             INSERT DATA
+             {
+                GRAPH <${graphURI}>
+                {
+                   <${baseIRI}${this.mrid}>
+                    a   cim:Facility ;
+                        cim:IdentifiedObject.name "Facility" ;
+                        cim:Asset.lifecycleDate 
+                        [
+                            a   cim:LifecycleDate ;
+                            cim:LifecycleDate.manufacturedDate "" ;
+                            cim:LifecycleDate.purchaseDate "" 
+                        ] .
+                }
+             }
+        `;
+  return insertStatement;
+}
+

package/src/util/util-search.ts

@@ -0,0 +1,40 @@
+import { ActivityRecord } from '../model/common/ActivityRecord';
+import { IdentifiedObject } from '../model/core/IdentifiedObject';
+import { Model } from '../model/model/Model';
+import { IEnergyConsumer } from '../interfaces/model/wires/IEnergyConsumer';
+
+export function getActivityRecordEventByTypeName(map: Map<string, ActivityRecord>, name?: string, type?: string): ActivityRecord | undefined {
+  for (const object of map.values()) {
+    if (object.type == type && object.name === name) {
+      return object;
+    } else if (!name && object.type === type) {
+      return object;
+    }
+  }
+  return;
+}
+
+export function getEnergyConsumerByName(cimModel: Model, name: string): IEnergyConsumer | undefined {
+  for (const value of cimModel.energyConsumers.values()){
+    if(value.name === name) {
+      return value;
+    }
+  }
+  return;
+}
+
+export function getObjectByProperty(dataMap: Map<string, any>, propertyName: string, propertyValue: string): IdentifiedObject | undefined {
+  for (const value of dataMap.values()) {
+    if (value[propertyName] === propertyValue) {
+      return value;
+    }
+  }
+}
+
+export function getObjectByClass(dataMap: Map<string, any>, classType: any): IdentifiedObject | undefined {
+  for (const value of dataMap.values()) {
+    if (value instanceof classType) {
+      return value;
+    }
+  }
+}

package/src/util/util-topology.ts

@@ -0,0 +1,164 @@
+
+import { IdentifiedObject } from '../model/core/IdentifiedObject';
+import { Model } from '../model/model/Model';
+import { IIdentifiedObject } from '../interfaces/model/core/IIdentifiedObject';
+import { EnergySource } from '../model/wires/EnergySource';
+import { EnergyConsumer } from '../model/wires/EnergyConsumer';
+import { ExternalNetworkInjection } from '../model/wires/ExternalNetworkInjection';
+import { ACLineSegment } from '../model/wires/ACLineSegment';
+import { PowerTransformer } from '../model/wires/PowerTransformer';
+import { Switch } from '../model/wires/Switch';
+
+
+/** bestimmt alle elektrisch zusammenhängende Knoten/Nodes in eimen Teilnetz.
+ Der Schaltzustand findet Berücksichtigung.
+ Im Ergebnis werden für alle zusammenhängende Knoten ein TopologicalNode erstellt.
+ enerVance.planing bestimmeVerbundeneSammelschienen */
+export function determineTopologicalIslands(cimModel: Model): IdentifiedObject[][]{
+  const networks: IdentifiedObject[][] = [];
+  // 0 = key, 1 = value
+  for (const entry of cimModel.externalNetworkInjections.entries()){
+    const value = entry[1];
+    if(value) {
+      const networkElements: IdentifiedObject[] = [];
+      value.breadthFirstSearch(networkElements);
+      if(networkElements.length > 0) {
+        networks.push(networkElements);
+      }
+    }
+  }
+  resetMapCIM(cimModel.objects);
+  return networks;
+}
+
+export function determineComputableGrid(networks: IIdentifiedObject[][]): IIdentifiedObject[][] {
+  const computableNetworks: IIdentifiedObject[][] = [];
+  for (let i = 0; i < networks.length; i++){
+    const network = networks[i];
+    if(isComputable(network)) {
+      computableNetworks.push(network);
+    }
+  }
+  return computableNetworks;
+}
+
+/**  Es werden Netzelemente bestimmt, die im übergebenenen Netzen mit dem Slack direkt verbunden sind. */
+export function determineNetworksSlackElements(cimModel: Model, networks: IIdentifiedObject[][]): IIdentifiedObject[][] {
+  const networksSlackElements: IIdentifiedObject[][] = [];
+
+  for (let i = 0; i < networks.length; i++) {
+    const network: IIdentifiedObject[] = networks[i];
+    const networkSlackElemenets: IIdentifiedObject[][] = determineNetworkSlackElements(cimModel, network);
+    for(const arraySlackElem of networkSlackElemenets) {
+      networksSlackElements.push(arraySlackElem);
+    }
+
+  }
+  return networksSlackElements;
+}
+
+/**  Es werden Netzelemente bestimmt, die im übergebenen Netz mit dem Slack direkt verbunden sind. */
+export function determineNetworkSlackElements(cimModel: Model, network: IIdentifiedObject[]): IIdentifiedObject[][] {
+
+  const networkSlackElemenets: IIdentifiedObject[][] = [];
+  for (let i = 0; i < network.length; i++) {
+    const networkElement = network[i];
+    // Slack-Element bestimmen
+    if (networkElement.constructor.name === 'ExternalNetworkInjection') {
+      if(!networkElement.visited) {
+        const slackElemenets: IIdentifiedObject[] = [];
+        networkElement.determineSlackNodes(slackElemenets);
+        networkSlackElemenets.push(slackElemenets)
+      }
+    }
+  }
+  resetMapCIM(cimModel.objects);
+  return networkSlackElemenets;
+}
+
+/** Kruecke für NEPLAN-Netze. Bestimme Umspannstationen, die als Anlagen modelliert sind. */
+export function determineSubstations(cimModel: Model): IIdentifiedObject[] {
+  const substationElements: IIdentifiedObject[] = [];
+
+  for (const vl of cimModel.voltageLevels.values()) {
+    let counter = 0;
+    for (const equip of vl.equipments) {
+      if(equip instanceof Switch) {
+        counter += 1;
+      } else if (equip instanceof ExternalNetworkInjection) {
+        counter = 10;
+      }
+    }
+    if(counter > 9) {
+      substationElements.push(...vl.equipments);
+      substationElements.push(...vl.connectivityNodes.values());
+    }
+  }
+
+  return substationElements;
+}
+//Prüft, ob das Netz rechenfähig ist.
+export function isComputable(network: IIdentifiedObject[]): boolean{
+  if(isGeneratorsExists(network)){
+    if(isEnergySourcesConsumersExists(network)){
+      if(isBranchExists(network)){
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+//Prüft, ob im Teilnetz Netzlasten/-einspeisungen vorhanden sind
+export function isEnergySourcesConsumersExists(network: IIdentifiedObject[]): boolean{
+  for (let i = 0; i < network.length; i++) {
+    if(network[i] instanceof EnergySource) return true;
+    if(network[i] instanceof EnergyConsumer) return true;
+  }
+  return false;
+}
+
+//Prüft, ob im Teilnetz eine Slacks/Generators vorhanden sind
+export function isGeneratorsExists(network: IIdentifiedObject[]): boolean{
+  for (let i = 0; i < network.length; i++) {
+    if(network[i] instanceof ExternalNetworkInjection){
+      return true;
+    }
+  }
+  return false;
+}
+//Prüft, ob im Teilnetz eine Slacks/Generators vorhanden sind
+export function isBranchExists(network: IIdentifiedObject[]): boolean{
+  for (let i = 0; i < network.length; i++) {
+    if(network[i] instanceof ACLineSegment){
+      return true;
+    }
+    else
+    if(network[i] instanceof PowerTransformer){
+      return true;
+    }
+  }
+  return false;
+}
+/** setzt Attr. visited auf false */
+export function resetMapCIM(objects: Map<string, IIdentifiedObject>){
+  // 0 = key, 1 = value
+  for (const entry of objects.entries()){
+    const value = entry[1];
+    if(value) {
+      value.visited = false;
+      // value.switchDistance = 0;
+      // value.notSwitchableInRow = false;
+    }
+  }
+}
+
+/** setzt Attr. visited auf false */
+export function resetArrayCIM(objects: IIdentifiedObject[]){
+  // 0 = key, 1 = value
+  for (const object of objects){
+    if(object) {
+      object.visited = false;
+    }
+  }
+}