@enervance/insight-cim-model 0.0.1

package/src/model/core/Bay.ts

@@ -0,0 +1,178 @@
+import { EquipmentContainer } from '../core/EquipmentContainer';
+import { VoltageLevel } from '../core/VoltageLevel';
+import { Substation } from './Substation';
+import { BaseVoltage } from './BaseVoltage';
+import XMLWriter from 'xml-writer';
+import { getValue, writeElementAttribute, writeStartElement } from '../../util/utils';
+import { RDF_XML } from '../../constants/rdf-xml';
+import { DiagramObject, ISchemaSettings, Model } from "../..";
+
+export class Bay extends EquipmentContainer {
+
+  voltageLevel: VoltageLevel | undefined;
+  voltageLevelUUID: string | undefined;
+
+  constructor(uuid?: string, name?: string, shortName?: string, description?: string) {
+    super(uuid, name, shortName, description);
+  }
+
+  public static sparqlQuery: string = `
+        PREFIX cim:	 		<http://iec.ch/TC57/2013/CIM-schema-cim16#> 
+        PREFIX enervance:	<http://enervance.com/CIM/Extensions#> 
+        PREFIX entsoe:	 	<http://entsoe.eu/CIM/SchemaExtension/3/1#> 
+        PREFIX rdf:	 		<http://www.w3.org/1999/02/22-rdf-syntax-ns#> 
+        PREFIX apf:	 		<http://jena.hpl.hp.com/ARQ/property#>
+        PREFIX afn:	 		<http://jena.apache.org/ARQ/function#>
+        
+        SELECT  (strafter(strafter(str(?bayUUID), '#'), '_') AS ?uuid) 
+                 (CONCAT(STRBEFORE(str(?bayUUID), '#_'), '#_') AS ?baseIRI) 
+                 ?name ?shortName ?description 
+                 (strafter(strafter(str(?vlUUID), '#'), '_') AS ?voltageLevelUUID)
+        WHERE { 
+            GRAPH <http://default/>{
+                ?bayUUID rdf:type cim:Bay .
+                OPTIONAL {?bayUUID cim:IdentifiedObject.name ?name . }
+                OPTIONAL {?bayUUID entsoe:IdentifiedObject.shortName ?shortName .}
+                OPTIONAL {?bayUUID cim:IdentifiedObject.description ?description .}
+  
+                OPTIONAL {?bayUUID cim:Bay.VoltageLevel ?vlUUID}
+            }
+        }
+    `
+
+
+  public static getQuerySPARQL(graphURI: string): string {
+    if (graphURI.length > 0) {
+      return Bay.sparqlQuery.replace('<http://default/>', graphURI);
+    }
+    return Bay.sparqlQuery;
+  }
+
+  public static resolveClassFusekiJSON(data: any, cimModel: Model) {
+    data.results.bindings.forEach((value: any) => {
+      const bay = new Bay();
+      bay.resolveAttributesFusekiJSON(value)
+      cimModel.addBay(bay);
+    });
+  }
+
+  protected resolveAttributesFusekiJSON(value: any) {
+    super.resolveAttributesFusekiJSON(value);
+    this.voltageLevelUUID = getValue(value, 'voltageLevelUUID');
+  }
+
+  public resolveParsedAssociations(cimModel: Model) {
+    super.resolveParsedAssociations(cimModel);
+    //Substation
+    this.voltageLevel = cimModel.getVoltageLevel(this.voltageLevelUUID);
+    if (this.voltageLevel) this.voltageLevel.addBay(this);
+    else console.log(this.constructor.name + ' ' + this.mrid + ' hat keine VoltageLevel ' + this.voltageLevelUUID);
+  }
+
+  public toJSON() {
+    super.toJSON();
+    this.toJSONAttributes();
+    this.toJSONAssociations();
+    return this.json;
+  }
+
+  public toJSONAttributes() {
+    super.toJSONAttributes();
+  }
+
+  public toJSONAssociations() {
+    super.toJSONAssociations();
+    this.json['voltageLevelUUID'] = this.voltageLevel ? this.voltageLevel.mrid : this.voltageLevelUUID;
+  }
+
+  public getBaseVoltageAsNumber(): number {
+    if (this.voltageLevel) {
+      return this.voltageLevel.getBaseVoltageAsNumber();
+    }
+    return 0;
+  }
+
+  public getBaseVoltage(): BaseVoltage {
+    if (this.voltageLevel) {
+      return this.voltageLevel.baseVoltage;
+    }
+  }
+
+  public getVoltageLevel(): VoltageLevel {
+    return this.voltageLevel;
+  }
+
+  public getSubstation(): Substation | undefined {
+    if (this.voltageLevel) {
+      return this.voltageLevel.getSubstation();
+    }
+    return;
+  }
+
+  /** CIM RDF/XML Serialisierung */
+  public toCIMXML(xmlWriter: XMLWriter, profile: string) {
+    if (profile === RDF_XML.PROFILE_EQ) {
+      const suffixID = this.getSuffixID(profile);
+      const prefixUUID = this.getPrefixUUID(suffixID);
+      xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, this.constructor.name, RDF_XML.CIM_NS_16);
+      writeElementAttribute(xmlWriter, suffixID, `${prefixUUID}${this.mrid}`);
+      this.toCIMXMLAttributes(xmlWriter, profile);
+      this.toCIMXMLAssociations(xmlWriter, profile);
+      xmlWriter.endElement();
+    }
+  }
+
+  protected toCIMXMLAttributes(xmlWriter: XMLWriter, profile: string) {
+    super.toCIMXMLAttributes(xmlWriter, profile);
+  }
+
+  protected toCIMXMLAssociations(xmlWriter: XMLWriter, profile: string) {
+    super.toCIMXMLAssociations(xmlWriter, profile);
+    if (profile === RDF_XML.PROFILE_EQ) {
+      if (this.voltageLevel) {
+        xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'Bay.VoltageLevel', RDF_XML.CIM_NS_16);
+        writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.HASH_UNDERSCORE}${this.voltageLevel.mrid}`);
+        xmlWriter.endElement();
+      } else if (this.voltageLevelUUID) {
+        xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'Bay.VoltageLevel', RDF_XML.CIM_NS_16);
+        writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.HASH_UNDERSCORE}${this.voltageLevelUUID}`);
+        xmlWriter.endElement();
+      } else {
+        xmlWriter.writeComment('VoltageLevel is not defined');
+      }
+    }
+  }
+
+  public toGeoJSON(geoJSON: any, profile: string, schemaSettings: ISchemaSettings, diagramObject?: DiagramObject): any {
+    if (diagramObject) {
+      super.toGeoJSON(geoJSON, profile, schemaSettings, diagramObject);
+
+      const cimPoints = diagramObject.diagramObjectPoints;
+      const points: number[][] = [];
+      if (cimPoints.length === 7) {
+        points.push([cimPoints[5].xPosition, -cimPoints[5].yPosition]);
+        points.push([cimPoints[6].xPosition, -cimPoints[6].yPosition]);
+      }
+      /*          for (const doPoint of cimPoints) {
+                    points.push([doPoint.xPosition, -doPoint.yPosition]);
+                }*/
+      const pointsPolygon: number[][][] = [];
+      pointsPolygon.push(points);
+
+      geoJSON['geometry'] = {
+        type: 'Polygon',
+        coordinates: pointsPolygon
+      };
+      geoJSON['properties'] = {
+        diagramObjectUUID: diagramObject.mrid,
+        objectType: this.constructor.name,
+        width: 0,
+        height: 0,
+        offsetX: 0,
+        offsetY: 0,
+        fill: undefined,
+      }
+    }
+    return geoJSON;
+  }
+}

package/src/model/core/ConductingEquipment.ts

@@ -0,0 +1,182 @@
+import { Terminal } from './Terminal';
+import { BaseVoltage } from './BaseVoltage';
+import { Model } from '../model/Model';
+import { Equipment } from './Equipment';
+import { getValue, isInArray, writeElementAttribute } from '../../util/utils';
+import { RDF_XML } from '../../constants/rdf-xml';
+import XMLWriter from 'xml-writer';
+import { SvStatus } from '../statevariables/SvStatus';
+import { IIdentifiedObject } from '../../interfaces/model/core/IIdentifiedObject';
+import { IConnectivityNode } from '../../interfaces/model/core/IConnectivityNode';
+import { Outage } from '../operations/Outage';
+import { IOutage } from '../../interfaces/model/operations/IOutage';
+import { IConductingEquipment } from '../../interfaces/model/core/IConductingEquipment';
+import { ITerminal } from '../../interfaces/model/core/ITerminal';
+
+export class ConductingEquipment extends Equipment implements IConductingEquipment {
+
+  terminals: Map<string, ITerminal>;
+  terminalsUUIDs: string[] = [];
+
+  baseVoltage: BaseVoltage | undefined;
+  baseVoltageUUID: string | undefined;
+
+  svStatus: SvStatus;
+  svStatusUUID: string | undefined;
+
+  /** Abweichend vom CIM Model: statt 0..1, 0..n Kardinalität!*/
+  outages: Map<string, IOutage>;
+
+  constructor(uuid?: string, name?: string, shortName?: string, description?: string, aggregate?: boolean) {
+    super(uuid, name, shortName, description, aggregate);
+    this.terminals = new Map();
+    this.outages = new Map();
+  }
+
+  public addTerminal(terminal: Terminal) {
+    this.terminals.set(terminal.getUUID(), terminal);
+  }
+
+  public getTerminal(uuid: string): ITerminal | undefined {
+    return this.terminals.get(uuid);
+  }
+
+  protected resolveAttributesFusekiJSON(value: any) {
+    super.resolveAttributesFusekiJSON(value);
+    this.baseVoltageUUID = getValue(value, 'baseVoltageUUID');
+    // this.outageUUID = getValue(value, 'outageUUID');
+  }
+
+  public resolveParsedAssociations(cimModel: Model) {
+    super.resolveParsedAssociations(cimModel);
+    this.baseVoltage = cimModel.getBaseVoltageByUUID(this.baseVoltageUUID || '');
+    if (this.constructor.name === 'ACLineSegment' && !this.baseVoltage) {
+      // console.log(this.constructor.name + ' ' + this.mrid + ' hat keine BaseVoltage ' + this.baseVoltageUUID);
+    }
+  }
+
+  public toJSONAttributes() {
+    super.toJSONAttributes();
+    // this.json['baseVoltageUUID'] = this.baseVoltage.nominalVoltage.value;
+    // this.json['un'] = (this.baseVoltage ? this.baseVoltage.nominalVoltage.value : 0)
+  }
+
+  public determineGridIslands(networkElements: any []) {
+    if (!this.visited) {
+      this.addNetworkElement(networkElements);
+      // 0 = key, 1 = value
+      for (const entry of this.terminals.entries()) {
+        const value = entry[1];
+        value.determineGridIslands(networkElements);
+      }
+    }
+  }
+
+  public breadthFirstSearch(networkElements: any[]) {
+    // 0 = key, 1 = value
+    for (const entry of this.terminals.entries()) {
+      const value = entry[1];
+      value.breadthFirstSearch(networkElements);
+    }
+  }
+
+  /* Bestimmt alle zum Slack gehörende Netzelemente (CN, Terminals Sammelschienen, Trafos)*/
+  public determineSlackNodes(slackElemenets: IIdentifiedObject[]) {
+    if (!this.visited) {
+      this.addNetworkElement(slackElemenets);
+      // 0 = key, 1 = value
+      for (const entry of this.terminals.entries()) {
+        const value = entry[1];
+        value.determineSlackNodes(slackElemenets);
+      }
+    }
+  }
+
+  /** für Switches separate Implementierung, da der Schaltzustand berücksichtigt werden muss. */
+  public determineMidVoltageLineElements(feederLineElemenets: IIdentifiedObject[], slackSubstationElements: IIdentifiedObject[][]) {
+    if (!this.visited && !isInArray(this, slackSubstationElements)) {
+      this.addNetworkElement(feederLineElemenets);
+      // 0 = key, 1 = value
+      for (const entry of this.terminals.entries()) {
+        const value = entry[1];
+        value.determineMidVoltageLineElements(feederLineElemenets, slackSubstationElements);
+      }
+    }
+  }
+
+  public determineTopologicalNodes(connNodes: IConnectivityNode[]) {
+    // 0 = key, 1 = value
+    for (const entry of this.terminals.entries()) {
+      const value = entry[1];
+      value.determineTopologicalNodes(connNodes);
+    }
+  }
+
+  public getBusConnections(): IIdentifiedObject[] {
+    const connections: IIdentifiedObject[] = [];
+    // 0 = key, 1 = value
+    for (const value of this.terminals.values()) {
+      connections.push(value.connectivityNode);
+    }
+    return connections;
+  }
+
+  /*
+      die Methode prüft, ob die Terminals im Geschlossenenzustand sind;
+  */
+  public isConnected(): boolean {
+    let connected = true;
+    for (const value of this.terminals.values()) {
+      if (!value.isClosed() && connected) {
+        connected = false;
+      }
+    }
+    return connected;
+  }
+
+  public getCurrentLimit(): number {
+    let limit: number = 0;
+    for (const entry of this.terminals.entries()) {
+      const value = entry[1];
+      if (value && value.operationalLimitSets.length > 0) {
+        const limitNew = this.getLimitValue(value.operationalLimitSets);
+        if (limitNew > limit) {
+          limit = limitNew;
+        }
+      }
+    }
+    //OperationalLimitSet ist direkt mit Equipment verknüpft
+    if (limit === 0) {
+      limit = super.getCurrentLimit();
+    }
+    return limit;
+  }
+
+  //
+  public isLoadOrFeed(): boolean {
+    return false;
+  }
+
+  protected toCIMXMLAssociations(xmlWriter: XMLWriter, profile: string) {
+    super.toCIMXMLAssociations(xmlWriter, profile);
+    if (profile === RDF_XML.PROFILE_EQ) {
+      if (this.baseVoltage) {
+        xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'ConductingEquipment.BaseVoltage', RDF_XML.CIM_NS_16);
+        writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.HASH_UNDERSCORE}${this.baseVoltage.mrid}`);
+        xmlWriter.endElement();
+      } else if (this.baseVoltageUUID) {
+        xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'ConductingEquipment.BaseVoltage', RDF_XML.CIM_NS_16);
+        writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.HASH_UNDERSCORE}${this.baseVoltageUUID}`);
+        xmlWriter.endElement();
+      } else {
+        if (this.constructor.name === 'ACLineSegment') {
+          xmlWriter.writeComment('BaseVoltage is not defined');
+        }
+      }
+    }
+  }
+
+  addOutage(outage: IOutage) {
+    this.outages.set(outage.mrid, outage);
+  }
+}