@enervance/insight-cim-model 0.0.1

package/src/model/core/Equipment.ts

@@ -0,0 +1,184 @@
+import { EquipmentContainer } from './EquipmentContainer';
+import { PowerSystemResource } from './PowerSystemResource';
+import { Model } from '../model/Model';
+import { OperationalLimitSet } from '../operationallimits/OperationalLimitSet';
+import { CurrentLimit } from '../operationallimits/CurrentLimit';
+import { BaseVoltage } from './BaseVoltage';
+import { VoltageLevel } from './VoltageLevel';
+import { Bay } from './Bay';
+import { getValue, parseCsvLineIntoArray, writeElement, writeElementAttribute } from '../../util/utils';
+import { convertValue, toBoolean } from '../../util/datatype-converter';
+import { RDF_XML } from '../../constants/rdf-xml';
+import XMLWriter from 'xml-writer';
+import { IEquipmentContainer } from '../../interfaces/model/core/IEquipmentContainer';
+
+export class Equipment extends PowerSystemResource {
+
+  equipmentContainer: EquipmentContainer | undefined;
+  equipmentContainerUUID: string | undefined;
+
+  aggregate: boolean;
+  operationalLimitSets: OperationalLimitSet[];
+
+  additionalEquipmentContainer: Map<string, IEquipmentContainer>;
+  additionalEquipmentContainerUUIDs: string[];
+
+  constructor(uuid?: string, name?: string, shortName?: string, description?: string, aggregate?: boolean) {
+    super(uuid, name, shortName, description);
+    this.aggregate = aggregate ?? true;
+    this.operationalLimitSets = [];
+
+    this.additionalEquipmentContainer = new Map();
+    this.additionalEquipmentContainerUUIDs = [];
+
+    this.prop2namespacePrefix.set('aggregate', 'cim'); // zur Generierung der Insert-Statements
+    this.prop2Class.set('aggregate', 'Equipment');
+    this.prop2Datatype.set('aggregate', 'boolean');
+
+  }
+
+
+  public addOperationalLimitSet(operationalLimitSet: OperationalLimitSet) {
+    if (operationalLimitSet && this.operationalLimitSets.indexOf(operationalLimitSet) === -1)
+      this.operationalLimitSets.push(operationalLimitSet);
+  }
+
+  public addAdditionalEquipmentContainer(equipmentContainer: IEquipmentContainer) {
+    this.additionalEquipmentContainer.set(equipmentContainer.getUUID(), equipmentContainer);
+    return this.getAssociationSparqlTriple(this.baseIRI, this.mrid, 'cim', 'Equipment', 'AdditionalEquipmentContainer', equipmentContainer.mrid);
+
+  }
+
+  /** Gibt zur übergebenen UUID das EquipmentContainer-Objekt zurück
+   *  Wenn keine UUID übergeben wird, dann wird das erste Mapelement zurückgegeben. */
+  public getAdditionalEquipmentContainer(uuid?: string): IEquipmentContainer | undefined {
+    if (uuid) {
+      return this.additionalEquipmentContainer.get(uuid);
+    } else if (this.additionalEquipmentContainer.size) {
+      for (const value of this.additionalEquipmentContainer.values()) {
+        return value;
+      }
+    }
+    return;
+  }
+
+  protected resolveAttributesFusekiJSON(value: any) {
+    super.resolveAttributesFusekiJSON(value);
+    this.aggregate = toBoolean(getValue(value, 'aggregate'));
+    this.equipmentContainerUUID = getValue(value, 'equipmentContainerUUID');
+
+    // AdditionalEquipmentContainer
+    this.additionalEquipmentContainerUUIDs = parseCsvLineIntoArray(getValue(value, 'additionalEquipmentContainerUUIDs'), ',');
+  }
+
+  public resolveParsedAssociations(cimModel: Model) {
+    super.resolveParsedAssociations(cimModel);
+
+    this.equipmentContainer = cimModel.getEquipmentContainer(this.equipmentContainerUUID || '');
+
+    if (this.equipmentContainer) {
+      this.equipmentContainer.addEquipment(this);
+    } else {
+      // console.log(this.constructor.name + ' ' + this.mrid + ' hat keine equipmentContainerInstanz ' + this.equipmentContainerUUID);
+    }
+
+    for (const aecUUID of this.additionalEquipmentContainerUUIDs) {
+      if (cimModel.feeders.has(aecUUID)) {
+        const additionalEquipmentContainer = cimModel.getFeeder(aecUUID) as unknown as EquipmentContainer;
+        this.additionalEquipmentContainer.set(additionalEquipmentContainer.getUUID(), additionalEquipmentContainer);
+        additionalEquipmentContainer.addAdditionalGroupedEquipment(this);
+      } else {
+        console.log(this.constructor.name + ' ' + this.mrid + ' hat keine additionalEquipmentContainer ' + aecUUID);
+      }
+    }
+  }
+
+  public toJSONAttributes() {
+    super.toJSONAttributes();
+    this.json['aggregate'] = this.aggregate;
+  }
+
+  public toJSONAssociations() {
+    super.toJSONAssociations();
+    this.json['equipmentContainer'] = this.equipmentContainerUUID;
+    this.json['additionalEquipmentContainers'] = [...this.additionalEquipmentContainerUUIDs];
+  }
+
+  public getCurrentLimit(): number {
+    return this.getLimitValue(this.operationalLimitSets);
+  }
+
+  protected getLimitValue(operationalLimitSets: OperationalLimitSet[]): number {
+    let limit: number = 0;
+    for (let i = 0; i < operationalLimitSets.length; i++) {
+      const operationalLimitSet = operationalLimitSets[i];
+      if (operationalLimitSet.operationalLimits.length > 0) {
+        for (let j = 0; j < operationalLimitSet.operationalLimits.length; j++) {
+          const operationalLimit = operationalLimitSet.operationalLimits[j];
+          if (operationalLimit.constructor.name === 'CurrentLimit') {
+            const limitNew = (operationalLimit as CurrentLimit).value.value;
+            if (limitNew > limit) {
+              limit = limitNew;
+            }
+          }
+        }
+      }
+    }
+    return limit;
+  }
+
+
+  public getBaseVoltage(): BaseVoltage {
+    if (this.equipmentContainer instanceof VoltageLevel) {
+      return (this.equipmentContainer as VoltageLevel).baseVoltage;
+    } else if (this.equipmentContainer instanceof Bay) {
+      return (this.equipmentContainer as Bay).getBaseVoltage();
+    }
+  }
+
+
+  protected toCIMXMLAttributes(xmlWriter: XMLWriter, profile: string) {
+    super.toCIMXMLAttributes(xmlWriter, profile);
+    if (profile === RDF_XML.PROFILE_EQ) {
+      writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:Equipment.aggregate`, this.aggregate);
+    }
+  }
+
+  protected toCIMXMLAssociations(xmlWriter: XMLWriter, profile: string) {
+    super.toCIMXMLAssociations(xmlWriter, profile);
+    if (profile === RDF_XML.PROFILE_EQ) {
+      if (this.equipmentContainer) {
+        xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'Equipment.EquipmentContainer', RDF_XML.CIM_NS_16);
+        writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.HASH_UNDERSCORE}${this.equipmentContainer.mrid}`);
+        xmlWriter.endElement();
+      } else if (this.equipmentContainerUUID) {
+        xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'Equipment.EquipmentContainer', RDF_XML.CIM_NS_16);
+        writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.HASH_UNDERSCORE}${this.equipmentContainerUUID}`);
+        xmlWriter.endElement();
+      } else {
+        xmlWriter.writeComment('EquipmentContainer is not defined');
+      }
+    }
+  }
+
+
+  public resolveAttributesRDFXML(className: string, attrName: string, value: string) {
+    if (className === 'Equipment') {
+      const dataType = this.prop2Datatype.get(attrName);
+      this[attrName] = convertValue(dataType, value);
+    } else {
+      super.resolveAttributesRDFXML(className, attrName, value);
+    }
+  }
+
+  public resolveAssociationRDFXML(className: string, resourceName: string, resourceUUID: string) {
+    if (className === 'Equipment') {
+      if (resourceName === 'EquipmentContainer') {
+        this.equipmentContainerUUID = resourceUUID;
+      }
+    } else {
+      super.resolveAssociationRDFXML(className, resourceName, resourceUUID);
+    }
+  }
+}
+

package/src/model/core/EquipmentContainer.ts

@@ -0,0 +1,40 @@
+import { ConnectivityNodeContainer } from '../core/ConnectivityNodeContainer';
+import { Equipment } from '../core/Equipment';
+import { Substation } from './Substation';
+import { IEquipmentContainer } from '../../interfaces/model/core/IEquipmentContainer';
+
+export class EquipmentContainer extends ConnectivityNodeContainer implements IEquipmentContainer {
+
+  equipments: Equipment[];
+
+  additionalGroupedEquipment: Map<string, Equipment>;
+
+  constructor(mrid?: string, name?: string, shortName?: string, description?: string) {
+    super(mrid, name, shortName, description);
+    this.equipments = [];
+    this.additionalGroupedEquipment = new Map();
+  }
+
+  public addEquipment(equipment: Equipment) {
+    if (this.equipments.indexOf(equipment) === -1) {
+      this.equipments.push(equipment);
+    } else {
+      console.log(`EquipmentContainer ${this.constructor.name} ${this.mrid} already contains equipment ${equipment?.mrid}`);
+    }
+  }
+
+  public addAdditionalGroupedEquipment(equipment: Equipment) {
+    this.additionalGroupedEquipment.set(equipment.getUUID(), equipment);
+  }
+
+  public getSubstation(): Substation | undefined {
+    return;
+  }
+
+  /** ------------------ insight JSON Serialisierung ------------------*/
+  public toJSONAssociations(){
+    super.toJSONAssociations();
+    this.json['additionalGroupedEquipment'] = [...this.additionalGroupedEquipment.keys()];
+  }
+
+}

package/src/model/core/Feeder.ts

@@ -0,0 +1,186 @@
+import {EquipmentContainer} from './EquipmentContainer';
+import {Substation} from './Substation';
+import { RDF_XML, Model, ITerminal } from '../..';
+import {getValue, parseCsvLineIntoArray, writeElementAttribute} from '../../util/utils';
+import XMLWriter from 'xml-writer';
+import { IFeeder } from '../../interfaces/model/core/IFeeder';
+
+export class Feeder extends EquipmentContainer implements IFeeder {
+
+  /** The substation that nominally energizes the feeder. */
+  normalEnergizingSubstation: Substation;
+  normalEnergizingSubstationUUID: string;
+
+  /** The substations that are normally energized by the feeder. */
+  normalEnergizedSubstations: Map<string, Substation>;
+  normalEnergizedSubstationUUIDs: string[] = [];
+
+
+  /** The normal head terminal or terminals of the feeder. */
+  normalHeadTerminals: Map<string, ITerminal>;
+
+  constructor(uuid?: string, name?: string, shortName?: string, description?: string){
+    super(uuid, name, shortName, description);
+    this.normalEnergizedSubstations = new Map();
+    this.normalHeadTerminals = new Map();
+  }
+
+  setNormalEnergizingSubstation(substation: Substation): string {
+    this.normalEnergizingSubstation = substation;
+    return this.getAssociationSparqlTriple(this.baseIRI, this.mrid, 'cim', 'Feeder', 'NormalEnergizingSubstation', substation.mrid);
+  }
+
+  addNormalEnergizedSubstation(substation: Substation) {
+    this.normalEnergizedSubstations.set(substation.getUUID(), substation);
+  }
+
+  addNormalHeadTerminal(terminal: ITerminal) {
+    this.normalHeadTerminals.set(terminal.getUUID(), terminal);
+  }
+
+  /** ------------------ insight JSON Serialisierung ------------------*/
+  public toJSON(){
+    super.toJSON();
+    this.toJSONAttributes();
+    this.toJSONAssociations();
+    return this.json;
+  }
+
+  public toJSONAttributes(){
+    super.toJSONAttributes();
+  }
+
+  public toJSONAssociations(){
+    super.toJSONAssociations();
+    this.json['normalEnergizedSubstation'] = [...this.normalEnergizedSubstations.keys()];
+    this.json['normalEnergizingSubstation'] = this.normalEnergizingSubstation ? this.normalEnergizingSubstation.mrid : undefined;
+  }
+
+
+  /** ------------------ CIM RDF/XML Parser ------------------*/
+  public static resolveClassRDFXML(uuid: string, cimModel: Model): Feeder | undefined {
+    const newClass = new Feeder(uuid);
+    cimModel.addFeeder(newClass);
+    return newClass;
+  }
+  public resolveAttributesRDFXML(className: string, attrName: string, value: string){
+    if(className === 'Feeder') {
+
+    } else {
+      super.resolveAttributesRDFXML(className, attrName, value);
+    }
+  }
+  public resolveAssociationRDFXML(className: string, resourceName: string, resourceUUID: string){}
+
+  /** ------------------ CIM RDF/XML Serialisierung ------------------*/
+  public toCIMXML(xmlWriter: XMLWriter, profile: string) {
+    xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'Feeder', RDF_XML.CIM_NS_16);
+    writeElementAttribute(xmlWriter, RDF_XML.RDF_ID, `${RDF_XML.UNDERSCORE}${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(this.normalEnergizingSubstation) {
+      xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'Feeder.NormalEnergizingSubstation', RDF_XML.CIM_NS_16);
+      writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.HASH_UNDERSCORE}${this.normalEnergizingSubstation.mrid}`);
+      xmlWriter.endElement();
+    }
+
+    for (const substation of this.normalEnergizedSubstations.values()) {
+      xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'Feeder.NormalEnergizedSubstation', RDF_XML.CIM_NS_16);
+      writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.HASH_UNDERSCORE}${substation.mrid}`);
+      xmlWriter.endElement();
+    }
+  }
+
+  /** ------------------ Fuseki Schnittstelle ------------------*/
+
+  /** ------------------ Fuseki Persistierung ------------------*/
+
+  public createNewStatementSPARQL(): string {
+    return `
+            <${this.baseIRI}${this.mrid}>
+            a   cim:Feeder ;
+                cim:IdentifiedObject.name "Feeder" .
+        `;
+  }
+
+  /** ------------------ Fuseki Parser ------------------------*/
+  /** Parst und initialisiert das Objekt aus Fuseki JSON Daten  */
+  public static resolveClassFusekiJSON(data: any, cimModel: Model){
+    data.results.bindings.forEach((value: any) => {
+      const newClass = new Feeder();
+      newClass.resolveAttributesFusekiJSON(value);
+      cimModel.addFeeder(newClass);
+    });
+  }
+
+  /** Parst die Attributs- und Assoziationsinformationen aus Fuseki JSON Daten */
+  protected resolveAttributesFusekiJSON(value: any){
+    super.resolveAttributesFusekiJSON(value);
+    this.normalEnergizedSubstationUUIDs =  parseCsvLineIntoArray(getValue(value, 'energizedSubstationUUIDs'), ',');
+    this.normalEnergizingSubstationUUID = getValue(value, 'normalEnergizingSubstationUUID');
+  }
+
+  /** Initialisiert Assoziationen aus geparsten Daten
+   *  Fuseki und XML Daten */
+  public resolveParsedAssociations(cimModel: Model){
+    super.resolveParsedAssociations(cimModel);
+    /** Substations parsen */
+    for (const subUUID of this.normalEnergizedSubstationUUIDs) {
+      if (cimModel.substations.has(subUUID)) {
+        const substation = cimModel.getSubstation(subUUID);
+        this.normalEnergizedSubstations.set(subUUID, substation);
+        substation.addNormalEnergizedFeeder(this);
+      }
+    }
+    this.normalEnergizedSubstationUUIDs = [];
+    if (cimModel.substations.has(this.normalEnergizingSubstationUUID)) {
+      const substation = cimModel.getSubstation(this.normalEnergizingSubstationUUID);
+      this.normalEnergizingSubstation = substation;
+      substation.addNormalEnergizingFeeder(this);
+    }
+  }
+
+  public static getQuerySPARQL(graphURI: string): string{
+    if(graphURI.length > 0){
+      return Feeder.sparqlQuery.replace('<http://default/>', graphURI);
+    }
+    return Feeder.sparqlQuery;
+  }
+
+  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(?fUUID), "#"), "_") AS ?uuid) 
+        (CONCAT(STRBEFORE(str(?fUUID), '#_'), '#_') AS ?baseIRI) 
+        ?name ?shortName ?description
+        (STRAFTER(str(?negsUUID), '#_') AS ?normalEnergizingSubstationUUID) 
+        (group_concat(STRAFTER(str(?nedsUUIDs), '#_');separator=',') as ?energizedSubstationUUIDs)
+        WHERE { 
+            GRAPH <http://default/>{
+            
+                ?fUUID rdf:type cim:Feeder .
+                OPTIONAL{?fUUID cim:IdentifiedObject.name ?name .}
+                OPTIONAL{?fUUID entsoe:IdentifiedObject.shortName ?shortName .}
+                OPTIONAL{?fUUID cim:IdentifiedObject.description ?description .}
+                OPTIONAL{?fUUID cim:Feeder.NormalEnergizingSubstation ?negsUUID .}
+                OPTIONAL{?fUUID cim:Feeder.NormalEnergizedSubstation ?nedsUUIDs . }
+            }
+        }
+        GROUP BY ?fUUID ?baseIRI ?name ?shortName ?description ?negsUUID
+    `
+}

package/src/model/core/GeographicalRegion.ts

@@ -0,0 +1,34 @@
+import { IdentifiedObject } from './IdentifiedObject';
+import { SubGeographicalRegion } from './SubGeographicalRegion';
+import { Substation } from './Substation';
+import { RDF_XML } from '../../constants/rdf-xml';
+import { writeElementAttribute } from '../../util/utils';
+import XMLWriter from 'xml-writer';
+
+export class GeographicalRegion extends IdentifiedObject {
+
+    regions: SubGeographicalRegion[] = [];
+
+    constructor(mrid?: string, name?: string, shortName?: string, description?: string, sequenceNumber?: number){
+        super(mrid, name, shortName, description);
+    }
+
+    addSubGeographicalRegion(subGeographicalRegion: SubGeographicalRegion) {
+        if (this.regions.indexOf(subGeographicalRegion) === -1) {
+            this.regions.push(subGeographicalRegion);
+        }
+    }
+
+    /** 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();
+        }
+    }
+}