@enervance/insight-cim-model 0.0.12 → 0.0.14

package/src/util/util-topology.ts

@@ -1,175 +0,0 @@
-
-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';
-import { isInArray } from './utils';
-
-
-/** 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, 'ExternalNetworkInjection');
-    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[], startObjectName: string): IIdentifiedObject[][] {
-
-  const networkSlackElemenets: IIdentifiedObject[][] = [];
-  for (let i = 0; i < network.length; i++) {
-    const networkElement = network[i];
-    // Slack-Element bestimmen
-    if (networkElement.constructor.name === startObjectName) {
-      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, computableGridsSlackElements: IIdentifiedObject[][]): 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) {
-      /** In Neplan Netzen umfasst ein VoltageLevel alle elektrisch verbundene Elemente.
-       * Dieses Vorgehen bestimmt alle Elemente, die zur gegebenen Spannung gehören => eine Anlage */
-
-      const networkSlackElemenets: IIdentifiedObject[][] = determineNetworkSlackElements(cimModel, vl.equipments, 'BusbarSection');
-      for(const arraySlackNetz of networkSlackElemenets) {
-        for (const arraySlackElem of arraySlackNetz) {
-          if(!isInArray(arraySlackElem, computableGridsSlackElements)) {
-            substationElements.push(arraySlackElem);
-          }
-        }
-      }
-    }
-  }
-  resetMapCIM(cimModel.objects);
-  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;
-    }
-  }
-}

package/src/util/utils.ts

@@ -1,255 +0,0 @@
-/* Liest aus einem Objekt die Ausprägung des Attributes */
-import {
-  BaseVoltage, createGeoregion, createSubgeoregion, GeographicalRegion, getGeoregionByName, getSubgeoregionByName,
-  IdentifiedObject, IIdentifiedObject, Model,
-  PowerTransformer,
-  PowerTransformerEnd, PSRType, SubGeographicalRegion,
-  Substation,
-  Terminal,
-  Voltage, VoltageLevel
-} from '..';
-import { ISchemaSettings } from '../interfaces/schema-settings/ShapeInfos';
-import { UnitMultiplier } from '../model/domain/UnitMultiplier';
-import { UnitSymbol } from '../model/domain/UnitSymbol';
-import * as fetch from 'node-fetch';
-import uuid from 'uuid-random';
-import XMLWriter from 'xml-writer';
-
-/** Fuseki Data */
-export function getValue(data: any, attributeName: any): string | undefined {
-  if (data.hasOwnProperty(attributeName)) {
-    return data[attributeName].value;
-  }
-  return;
-}
-
-/** Fuseki Data */
-export function getNumberValue(data: any, attributeName: any): number {
-  if (data.hasOwnProperty(attributeName)) {
-    const value = +data[attributeName].value;
-    return (isNaN(value) ? undefined : value);
-  }
-  return undefined;
-}
-
-export function getEnumValue(data: any, attributeName: any): string | undefined {
-  if (data.hasOwnProperty(attributeName)) {
-    return data[attributeName].value;
-  }
-  return;
-}
-
-export function isTerminalsAssociatedWith(terminals: Map<string, Terminal>, equipmentName: string): boolean {
-  // 0 = key, 1 = value
-  for (const entry of terminals.entries()) {
-    const value = entry[1];
-    if (value.conductingEquipment && value.conductingEquipment.constructor.name === equipmentName) {
-      return true;
-    }
-  }
-  return false;
-}
-
-
-export function getColorFromBaseVoltage(baseVoltage: BaseVoltage, schemaSettings: ISchemaSettings) {
-  if (baseVoltage) {
-    const voltage = this.getBaseVoltage().nominalVoltage;
-    if (voltage && voltage.value) {
-      return schemaSettings.getVoltageColor(voltage.value);
-    }
-  }
-  return '#7b7d7d'; // wenn keine Spannungsebene übergeben, dann default value grau
-}
-
-/** prüft, ob ein Netzelement im Array vorhanden ist */
-export function isInArray(element: IIdentifiedObject, slackSubstationElements: IIdentifiedObject[][]): boolean {
-  for (const slackSubstationElement of slackSubstationElements) {
-    if (slackSubstationElement.indexOf(element) !== -1) {
-      return true
-    }
-  }
-  return false;
-}
-
-export function createDummyPowerTransformer(substation: Substation, unHv: number, unLv: number): PowerTransformer {
-  const powerTransformer = new PowerTransformer('e4e161eb-8b16-482d-9bca-33347cef63e6');
-  //30kV  x = 7.2000000000 ratedS = 10 ratedU = 30
-  //10kV  x = 7.2000000000 ratedS = 10 ratedU = 10.5
-  const baseVoltageHv = createBaseVoltage(unHv);
-  const powerTransformerEndHv = createDummyPowerTransformerEnd('6b5dab07-fdb4-49c7-a63c-91b60e062182', baseVoltageHv,
-    10, unHv, 7.2, powerTransformer);
-  const baseVoltageLv = createBaseVoltage(unLv);
-  const powerTransformerEndLv = createDummyPowerTransformerEnd('8e59f450-e5e2-4d47-bebd-1655f75bfb95', baseVoltageLv,
-    10, unLv, 0, powerTransformer);
-
-  powerTransformer.equipmentContainer = substation;
-  substation.addEquipment(powerTransformer);
-  return powerTransformer;
-}
-
-export function createDummyPowerTransformerEnd(uuid: string, baseVoltage: BaseVoltage, ratedS: number, ratedU: number,
-                                               x: number, trafo: PowerTransformer): PowerTransformerEnd {
-  const powerTransformerEnd = new PowerTransformerEnd();
-  powerTransformerEnd.x = x;
-  powerTransformerEnd.ratedS = ratedS;
-  powerTransformerEnd.ratedU = ratedU;
-  powerTransformerEnd.baseVoltage = baseVoltage;
-  powerTransformerEnd.powerTransformer = trafo;
-  trafo.addPowerTransformerEnd(powerTransformerEnd);
-
-  return powerTransformerEnd;
-}
-
-export function createVoltageLevel(substation: Substation, bv: BaseVoltage) {
-  const vl = new VoltageLevel('8e59f450-e5e2-4d47-bebd-1655f75bfb95');
-  vl.baseVoltage = bv;
-  vl.substation = substation;
-  substation.addVoltageLevel(vl);
-  return vl;
-}
-
-function createBaseVoltage(value: number) {
-  const voltage = new Voltage(value, UnitMultiplier.k, UnitSymbol.V);
-  const baseVoltage = new BaseVoltage('57a46509-b66e-42d8-947a-1b1fd15b273c');
-  baseVoltage.nominalVoltage = voltage
-  return baseVoltage;
-}
-
-// napespace prefix, name, uri
-export function writeStartElement(xmlWriter: XMLWriter, prefix: string, className: string, uri: string) {
-  // xmlWriter.startElementNS('cim', 'Substation', 'http://iec.ch/TC57/2013/CIM-schema-cim16#');
-  xmlWriter.startElementNS(prefix, className, uri);
-}
-
-export function writeElementAttribute(xmlWriter: XMLWriter, tag: string, value: string) {
-  // xmlWriter.writeAttribute('rdf:ID', this.mrid);
-  xmlWriter.writeAttribute(tag, value);
-}
-
-export function writeElement(xmlWriter: XMLWriter, tag: string, value: any) {
-  // xmlWriter.writeElement('md:Model.version', '1');
-  // leere Attribute werden ignoriert
-  if (value !== undefined && value !== null && String(value).length > 0) {
-    xmlWriter.writeElement(tag, String(value));
-  }
-}
-
-
-/** generiert eine UUID
- * @return UUID-Value
- * */
-export function generateUUID(): string {
-  return uuid();
-}
-
-/**
- * Prüft, formamiert und ggf. erzeugt die ausgelesenen UUID-Werte (XWL, CSV, ...).
- *
- * @param value geparsed uuid value
- * @return UUID-Value*/
-export function getUUID(value: string | undefined): string {
-  if (value && value.length >= 36) {
-    if (value.length === 36) {
-      return value;
-    } else if (value.length === 37) {
-      return value.substr(1); // underscore abschneiden
-    }
-  }
-  return generateUUID();
-}
-
-export function resolveClassFusekiJSON(classDef: any, data: any, cimModel: Model) {
-  classDef.resolveClassFusekiJSON(data, cimModel);
-}
-
-export function parseCsvLineIntoArray(data: string, delimiter: string): string[] {
-  if (data && data.length > 0) {
-    return data.split(delimiter);
-  }
-  return [];
-}
-
-
-export function createIfNotExitsGeoregionByName(cimModel: Model, name: string): GeographicalRegion {
-  let region = getGeoregionByName(cimModel, name);
-  if (!region) {
-    region = createGeoregion(generateUUID(), 'ENTSO-E', 'ENTSO-E', 'Default GeographicalRegion', cimModel);
-  }
-  return region;
-}
-
-export function createIfNotExitsSubGeoregionByName(cimModel: Model, name: string, region: GeographicalRegion): SubGeographicalRegion {
-  let subregion = getSubgeoregionByName(cimModel, name);
-  if (!subregion) {
-    subregion = createSubgeoregion(generateUUID(), 'Deutschland', 'DE', 'Default SubGeographicalRegion', region, cimModel);
-  }
-  return subregion;
-}
-
-export function createIfNotExitsPSRType(cimModel: Model, name: string): PSRType {
-  let psrType = cimModel.getPsrTypeAtName(name);
-  if (!psrType) {
-    psrType = new PSRType(generateUUID(), name);
-    cimModel.addPsrType(psrType);
-  }
-  return psrType;
-}
-
-/** Methode zum Abfragen der Daten */
-export async function postNodeFetchData(url: string, method: string, body: string, headers: any): Promise<Response> {
-  return fetch(url, {
-    method,
-    body,
-    headers,
-  });
-}
-
-/**
- * Prüft und ggf. ergänzt die Form des Graphnamens
- *
- * */
-export function checkGraphName(graphName: string): string {
-  let checkedGraphName = graphName.trim();
-  if (!checkedGraphName.startsWith('<')) {
-    checkedGraphName = '<' + checkedGraphName
-  }
-  if (!graphName.endsWith('>')) {
-    checkedGraphName = checkedGraphName + '>';
-  }
-  return checkedGraphName;
-}
-
-/**
- * Prüft das Attribut auf die Längenbeschränkungen
- *
- * */
-export function checkName(value: string, attributeName: string): string {
-
-  switch (attributeName) {
-    case 'name': {
-      if(value) {
-        if (value.length > 32) return value.substr(0, 32);
-        else return value;
-      } else {
-        return 'name'
-      }
-    }
-    case 'shortName': {
-      if(value) {
-        if (value.length > 12) return value.substr(0, 12);
-        else return value;
-      }
-      break;
-    }
-    case 'description': {
-      if(value) {
-        if (value.length > 256) return value.substr(0, 256);
-        else return value;
-      }
-      break;
-    }
-    default: {
-      return value;
-    }
-  }
-}

package/src/util/xml/utils.parser.ts

@@ -1,29 +0,0 @@
-import {SaxesAttributeNS, SaxesTag} from "saxes";
-
-export function getRdfID(nsAttribute: SaxesAttributeNS): string {
-    const value = nsAttribute.value;
-    if(value.charAt(0) === '_') {
-        return value.substr(1, value.length);
-    }  else if (value.startsWith('urn:uuid:')) {
-        return value.substr(9, value.length);
-    } else if (value.startsWith('#_')) {
-        return value.substr(2, value.length);
-    } else if (value.startsWith('http://')) {
-        try {
-            const enumValue = value.split('#')[1]; // uri#PhaseCode.abc
-            return enumValue.split('.')[1]; // enum value PhaseCode.ABC
-        } catch (e) {}
-
-
-    }
-}
-
-
-export function getClassDefinition(className: string, cimClassName2ClassDef: Map<string, any>): any {
-    const classDef = cimClassName2ClassDef.get(className.toLowerCase());
-    if (!classDef) {
-        console.log(`Unknown Class ${className}`);
-    }
-    return classDef;
-}
-

package/src/util/xml/xml.parser.ts

@@ -1,107 +0,0 @@
-import {IdentifiedObject, Model} from "../..";
-
-import {EVENTS, SaxesAttributeNS, SaxesParser, SaxesTag} from 'saxes';
-import {getClassDefinition, getRdfID} from "./utils.parser";
-export class RdfXmlParser {
-
-    cimModel: Model
-    cimClassName2ClassDef: Map<string, any>;
-
-    currentObject: IdentifiedObject | any;
-    currentClassName;
-    currentAttrName;
-
-    saxesParser: SaxesParser;
-
-    constructor(cimClassName2ClassDef: Map<string, any>) {
-        this.cimModel = new Model();
-        this.cimClassName2ClassDef = cimClassName2ClassDef;
-        this.saxesParser = new SaxesParser({xmlns: true});
-    }
-
-    resolveClassRDFXML(xmlData: string, ) {
-        const start = Date.now();
-        this.saxesParser.on("opentag", (node: SaxesTag) => {
-            const classNameLocal: string = node.local;
-            const isSelfClosing = node.isSelfClosing;
-
-            if (!classNameLocal.includes('.')) { // Start 'BaseVoltage',
-                this.readClass(node, classNameLocal);
-            } else {
-                const pos = classNameLocal.indexOf('.');
-                this.currentClassName = classNameLocal.substr(0, pos);
-                this.currentAttrName = classNameLocal.substr(pos + 1, classNameLocal.length);
-
-                if(isSelfClosing) { // resource <cim:OrganisationRole.Organisation rdf:resource="#_c365e60e-2913-459f-af79-cf5a62d173c8" />
-                    this.readResource(node, classNameLocal);
-                }
-            }
-        });
-
-        this.saxesParser.on("text", (text) =>  {
-            this.readAttribute(text);
-        });
-
-        this.saxesParser.write(xmlData);
-        this.saxesParser.close();
-        console.log(`Parsing time: ${Date.now() - start}`);
-    }
-
-    readClass(node: SaxesTag, classNameLocal: string) {
-        const classDef = getClassDefinition(classNameLocal.toLowerCase(), this.cimClassName2ClassDef);
-        if (classDef) {
-            for (const [key, value] of Object.entries(node.attributes)) {
-                switch (key) {
-                    case 'rdf:ID': {
-                        const uuid = getRdfID(value);
-                        this.currentObject = classDef.resolveClassRDFXML(uuid, this.cimModel);
-                        console.log(`class parsed ${this.currentObject.constructor.name} ${this.currentObject.mrid}` );
-                        break;
-                    }
-                    case 'rdf:about': {
-                        const uuid = getRdfID(value);
-                        this.readAbout(uuid);
-                        break;
-                    }
-                    default: {
-                        console.log(`Parse Class unknown property ${key} with value ${value}`);
-                    }
-                }
-            }
-        } else {
-            console.log('no class def ');
-        }
-    }
-
-    readResource(node: SaxesTag, classNameLocal: string) {
-        const classDef = getClassDefinition(classNameLocal.toLowerCase(),this.cimClassName2ClassDef);
-        const attribute = node.attributes['rdf:resource'] as SaxesAttributeNS;
-        if (attribute && !classDef && this.currentObject && this.currentClassName && this.currentAttrName) {
-            if(attribute) {
-                const uuidEnum = getRdfID(attribute);
-                this.currentObject.fromRDFXMLAssociation(this.currentClassName, this.currentAttrName, uuidEnum);
-            }
-        } else {
-            console.log(`Can't parse rdf:resource ${this.currentClassName}/${this.currentAttrName}/${JSON.stringify(node)}`);
-        }
-        this.currentClassName = undefined;
-        this.currentAttrName  = undefined;
-    }
-
-    readAbout(uuid: string) {
-        if (this.cimModel.objects.has(uuid)) {
-            this.currentObject = this.cimModel.getObject(uuid);
-        } else {
-            console.log(`readAbout there is no Object with ${uuid}`);
-        }
-    }
-    readAttribute(value: string) {
-        if (this.currentObject && this.currentClassName && this.currentAttrName) {
-            this.currentObject.resolveAttributesRDFXML(this.currentClassName, this.currentAttrName, value);
-        } else {
-            console.log(`Can't parse Attribute ${this.currentClassName}/${this.currentAttrName}/${value}`);
-        }
-        this.currentClassName = undefined;
-        this.currentAttrName  = undefined;
-    }
-}