@enervance/insight-cim-model 0.0.1

package/src/model/core/Terminal.ts

@@ -0,0 +1,413 @@
+import { ACDCTerminal } from './ACDCTerminal';
+
+import { ConductingEquipment } from './ConductingEquipment'
+import { SvPowerFlow } from '../statevariables/SvPowerFlow';
+import { TopologicalNode } from '../topology/TopologicalNode';
+import { Model } from '../model/Model';
+import { TransformerEnd } from '../wires/TransformerEnd';
+
+import { OperationalLimitSet } from '../operationallimits/OperationalLimitSet';
+import { getValue, isInArray, writeElement, writeElementAttribute } from '../../util/utils';
+import { RegulatingControl } from '../wires/RegulatingControl';
+import XMLWriter from 'xml-writer';
+import { RDF_XML } from '../../constants/rdf-xml';
+import { PhaseCode } from './PhaseCode';
+import { IConnectivityNode } from '../../interfaces/model/core/IConnectivityNode';
+import { IIdentifiedObject } from '../../interfaces/model/core/IIdentifiedObject';
+import { IdentifiedObject } from './IdentifiedObject';
+import { ITerminal } from '../../interfaces/model/core/ITerminal';
+import { ISvPowerFlow } from '../../interfaces/model/statevariables/ISvPowerFlow';
+import { IFeeder } from '../../interfaces/model/core/IFeeder';
+
+export class Terminal extends ACDCTerminal implements ITerminal {
+
+  connectivityNode: IConnectivityNode;
+  connectivityNodeUUID: string;
+
+  conductingEquipment: ConductingEquipment;
+  conductingEquipmentUUID: string;
+
+  topologicalNode: TopologicalNode;
+  topologicalNodeUUID: string;
+
+  operationalLimitSets: OperationalLimitSet[];
+
+  phases: PhaseCode;
+  transformerEnds: TransformerEnd[];
+
+  svPowerFlow: ISvPowerFlow;
+
+  regulatingControl: Map<string, RegulatingControl>;
+
+  /** The feeder that this terminal normally feeds.  Only specified for the terminals at head of feeders.*/
+  normalHeadFeeder: IFeeder;
+  normalHeadFeederUUID: string;
+
+  constructor(uuid?: string, name?: string, shortName?: string, description?: string, sequenceNumber?: number) {
+    super(uuid, name, shortName, description, sequenceNumber);
+    this.transformerEnds = [];
+    this.operationalLimitSets = [];
+    this.regulatingControl = new Map();
+  }
+
+
+  public static getQuerySPARQL(graphURI: string): string {
+    if (graphURI.length > 0) {
+      return Terminal.sparqlQuery.replace('<http://default/>', graphURI);
+    }
+    return Terminal.sparqlQuery;
+  }
+
+  public getConnectivityNode(): IConnectivityNode {
+    return this.connectivityNode;
+  }
+
+  public setConnectivityNode(connectivityNode: IConnectivityNode) {
+    this.connectivityNode = connectivityNode;
+  }
+
+  public setNormalHeadFeeder(feeder: IFeeder): string {
+    this.normalHeadFeeder = feeder;
+    return this.getAssociationSparqlTriple(this.baseIRI, this.mrid, 'cim', 'Terminal', 'NormalHeadFeeder', feeder.mrid);
+  }
+
+  public getConnectivityNodeUUID(): string {
+    return this.connectivityNodeUUID;
+  }
+
+  public setConnectivityNodeUUID(connectivityNodeUUID: string) {
+    this.connectivityNodeUUID = connectivityNodeUUID;
+  }
+
+  public getConductingEquipment(): ConductingEquipment {
+    return this.conductingEquipment;
+  }
+
+  public setConductingEquipment(conductingEquipment: ConductingEquipment) {
+    this.conductingEquipment = conductingEquipment;
+  }
+
+  public getConductingEquipmentUUID(): string {
+    return this.conductingEquipmentUUID;
+  }
+
+  public setConductingEquipmentUUID(conductingEquipmentUUID: string) {
+    this.conductingEquipmentUUID = conductingEquipmentUUID;
+  }
+
+  public getSvPowerFlow(): ISvPowerFlow {
+    return this.svPowerFlow;
+  }
+
+  public setSvPowerFlow(value: ISvPowerFlow) {
+    this.svPowerFlow = value;
+  }
+
+  public getTransformerEnd(uuid: string): TransformerEnd | undefined {
+    // 0 = key, 1 = value
+    for (const entry of this.transformerEnds.entries()) {
+      const value = entry[1];
+      if (value.getUUID() === uuid) {
+        return value;
+      }
+    }
+    /*        this.transformerEnds.forEach(element => {
+                if(element.getUUID() === uuid){
+                    return element;
+                }
+            });*/
+    return;
+  }
+
+  public getTransformerEnds(): TransformerEnd[] {
+    return this.transformerEnds;
+  }
+
+  public addTransformerEnd(transformerEnd: TransformerEnd) {
+    if (transformerEnd && this.transformerEnds.indexOf(transformerEnd) == -1)
+      this.transformerEnds.push(transformerEnd);
+  }
+
+  public addRegulatingControl(regulatingControl: RegulatingControl) {
+    this.regulatingControl.set(regulatingControl.mrid, regulatingControl);
+  }
+
+  public addOperationalLimitSet(operationalLimitSet: OperationalLimitSet) {
+    if (operationalLimitSet && this.operationalLimitSets.indexOf(operationalLimitSet) == -1)
+      this.operationalLimitSets.push(operationalLimitSet);
+  }
+
+
+  public getTopologicalNode(): TopologicalNode {
+    return this.topologicalNode;
+  }
+
+  public setTopologicalNode(value: TopologicalNode) {
+    this.topologicalNode = value;
+  }
+
+  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 amp:	 		<http://amprion.net/2018/cim_extensions#>
+        PREFIX apf:	 		<http://jena.hpl.hp.com/ARQ/property#>
+        PREFIX afn:	 		<http://jena.apache.org/ARQ/function#>
+
+        SELECT  (strafter(strafter(str(?terminalUUID), '#'), '_') AS ?uuid)
+                (CONCAT(STRBEFORE(STR(?terminalUUID), '#_'), '#_') AS ?baseIRI) 
+                ?name ?shortName ?connected ?sequenceNumber
+                (strafter(strafter(str(?cnUUID), '#'), '_') AS ?connectivityNodeUUID)
+                (strafter(strafter(str(?ceUUID), '#'), '_') AS ?conductingEquipmentUUID)
+                (strafter(strafter(str(?tpUUID), '#'), '_') AS ?topologicalNodeUUID)
+                (strafter(strafter(str(?nhFeederUUID), '#'), '_') AS ?normalHeadFeederUUID)
+
+        WHERE {
+            GRAPH <http://default/>{
+                ?terminalUUID rdf:type cim:Terminal .
+                OPTIONAL {?terminalUUID cim:IdentifiedObject.name ?name .}
+                OPTIONAL {?terminalUUID entsoe:IdentifiedObject.shortName ?shortName .}
+                OPTIONAL {?terminalUUID cim:ACDCTerminal.connected ?connected .}
+                OPTIONAL {?terminalUUID cim:ACDCTerminal.sequenceNumber ?sequenceNumber .}
+                OPTIONAL {?terminalUUID cim:Terminal.ConnectivityNode ?cnUUID .}
+                OPTIONAL {?terminalUUID cim:Terminal.ConductingEquipment ?ceUUID .}
+                OPTIONAL {?terminalUUID cim:Terminal.TopologicalNode ?tpUUID .}
+                OPTIONAL {?terminalUUID cim:Terminal.NormalHeadFeeder ?nhFeederUUID .}
+            }
+        }
+    `
+
+  public static resolveClassFusekiJSON(data: any, cimModel: Model) {
+    data.results.bindings.forEach((value: any) => {
+      const newClass = new Terminal();
+      newClass.resolveAttributesFusekiJSON(value);
+      cimModel.addTerminal(newClass);
+    });
+  }
+
+  protected resolveAttributesFusekiJSON(value: any) {
+    super.resolveAttributesFusekiJSON(value);
+
+    this.connectivityNodeUUID = getValue(value, 'connectivityNodeUUID');
+    this.conductingEquipmentUUID = getValue(value, 'conductingEquipmentUUID');
+    this.topologicalNodeUUID = getValue(value, 'topologicalNodeUUID');
+    this.normalHeadFeederUUID = getValue(value, 'normalHeadFeederUUID');
+  }
+
+  public resolveParsedAssociations(cimModel: Model) {
+    super.resolveParsedAssociations(cimModel);
+    //connectivityNode
+    this.connectivityNode = cimModel.getConnectivityNode(this.connectivityNodeUUID) as IConnectivityNode;
+    if (this.connectivityNode) this.connectivityNode.addTerminal(this);
+    // else console.log(this.constructor.name + ' ' + this.mrid + ' hat keine connectivityNodeInstanz ' + this.connectivityNodeUUID);
+
+    //conductingEquipment
+    this.conductingEquipment = cimModel.getConductingEquipment(this.conductingEquipmentUUID);
+
+    if (this.conductingEquipment) this.conductingEquipment.addTerminal(this);
+    // else console.log(this.constructor.name + ' ' + this.mrid + ' hat keine conductingEquipmentInstanz ' + this.conductingEquipmentUUID);
+
+    //topologicalNode
+    this.topologicalNode = cimModel.getTopologicalNode(this.topologicalNodeUUID);
+    if (this.topologicalNode) this.topologicalNode.addTerminal(this);
+    // else console.log(this.constructor.name + ' ' + this.mrid + ' hat keine topologicalNodeInstanz ' + this.topologicalNodeUUID);
+
+    // Feeder
+    this.normalHeadFeeder = cimModel.getFeeder(this.normalHeadFeederUUID);
+    if (this.normalHeadFeeder) {
+      this.normalHeadFeeder.addNormalHeadTerminal(this);
+
+    }
+  }
+
+
+  /* Graphalgorithmen  */
+  public determineGridIslands(networkElements: any []) {
+    if (this.conductingEquipment && this.conductingEquipment.constructor.name === 'EnergySource')
+
+    if (!this.visited) {
+      this.addNetworkElement(networkElements);
+      if (this.connectivityNode) {
+        this.connectivityNode.determineGridIslands(networkElements);
+      }
+      // if(this.topologicalNode){
+      //     this.topologicalNode.determineGridIslands(networkElements);
+      // }
+      if (this.conductingEquipment) {
+        this.conductingEquipment.determineGridIslands(networkElements);
+      }
+    }
+  }
+
+
+  public breadthFirstSearch(networkElements: any[]) {
+    if (!this.visited && this.isClosed()) {
+      //console.log(this.constructor.name + ' ' + this.mrid)
+      this.addNetworkElement(networkElements);
+      if (this.connectivityNode) {
+        this.connectivityNode.breadthFirstSearch(networkElements);
+      }
+      // if(this.topologicalNode){
+      //     this.topologicalNode.breadthFirstSearch(networkElements);
+      // }
+      if (this.conductingEquipment) {
+        this.conductingEquipment.breadthFirstSearch(networkElements);
+      }
+    }
+  }
+
+  public determineTopologicalNodes(connNodes: IConnectivityNode[]) {
+    if (!this.visited && this.isClosed()) {
+      this.visited = true;
+      if (this.connectivityNode) {
+        this.connectivityNode.determineTopologicalNodes(connNodes);
+      }
+      if (this.conductingEquipment) {
+        this.conductingEquipment.determineTopologicalNodes(connNodes);
+      }
+    }
+  }
+
+  public isClosed(): boolean {
+    let proceed: boolean = true;
+    if (this.connected !== undefined && this.connected !== null) {
+      if (!this.connected) {
+        proceed = false; //Wenn das Attributt 'connected' definiert und false ist, fahre nicht mehr fort
+      }
+    }
+    return proceed;
+  }
+
+  /** wenn der angeschlossene ConnectivityNode schaltbar ist (mit und ohne assoziiertem SwitchDevice),
+   * dann fungiert der Terminal als schaltbarer logischer Schalter */
+  public isSwitchable(): boolean {
+    if (this.connectivityNode) {
+      return this.connectivityNode.isSwitchable();
+    }
+    return false;
+  }
+
+  public determineLoadNFeeder(loadsNfeeders: Map<string, IIdentifiedObject[]>) {
+    if (this.conductingEquipment && this.conductingEquipment.isLoadOrFeed()) {
+      const ceName = this.conductingEquipment.constructor.name;
+      let data: IIdentifiedObject[] = loadsNfeeders.get(ceName);
+      if (!(loadsNfeeders.has(ceName))) {
+        data = [];
+        loadsNfeeders.set(ceName, data);
+      }
+      data.push(this.conductingEquipment);
+    }
+  }
+
+
+  /* Bestimmt alle zum Slack gehörende Netzelemente (CN, Terminals Sammelschienen, Trafos)*/
+  public determineSlackNodes(slackElemenets: IIdentifiedObject[]) {
+    if (!this.visited) {
+      this.addNetworkElement(slackElemenets);
+
+      if (this.conductingEquipment && this.conductingEquipment.constructor.name !== 'ACLineSegment') {
+        this.conductingEquipment.determineSlackNodes(slackElemenets);
+      }
+
+      if (this.connectivityNode) {
+        this.connectivityNode.determineSlackNodes(slackElemenets);
+      }
+    }
+  }
+
+  public determineMidVoltageLineElements(feederLineElemenets: IIdentifiedObject[], slackSubstationElements: IIdentifiedObject[][]) {
+    if (!this.visited && this.isClosed() && !isInArray(this, slackSubstationElements)) {
+      this.addNetworkElement(feederLineElemenets);
+
+      if (this.conductingEquipment) {
+        this.conductingEquipment.determineMidVoltageLineElements(feederLineElemenets, slackSubstationElements);
+      }
+
+      if (this.connectivityNode) {
+        this.connectivityNode.determineMidVoltageLineElements(feederLineElemenets, slackSubstationElements);
+      }
+    }
+  }
+
+  /** CIM RDF/XML Serialisierung */
+  public toCIMXML(xmlWriter: XMLWriter, profile: string) {
+    if (profile === RDF_XML.PROFILE_EQ || profile === RDF_XML.PROFILE_SSH) {
+      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);
+    if (profile === RDF_XML.PROFILE_EQ) {
+      xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'Terminal.phases', RDF_XML.CIM_NS_16);
+      writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.CIM_NS_16}PhaseCode.${this.phases}`);
+      xmlWriter.endElement();
+    }
+  }
+
+  protected toCIMXMLAssociations(xmlWriter: XMLWriter, profile: string) {
+    super.toCIMXMLAssociations(xmlWriter, profile);
+    /*<cim:VoltageLevel.Substation rdf:resource="#_1be806f9-0316-4bb8-b350-f54a292353f1"/>*/
+    if (profile === RDF_XML.PROFILE_EQ) {
+      if (this.conductingEquipment) {
+        xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'Terminal.ConductingEquipment', RDF_XML.CIM_NS_16);
+        writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.HASH_UNDERSCORE}${this.conductingEquipment.mrid}`);
+        xmlWriter.endElement();
+      } else if (this.conductingEquipmentUUID) { // Workaround I7 Exporter
+        xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'Terminal.ConductingEquipment', RDF_XML.CIM_NS_16);
+        writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.HASH_UNDERSCORE}${this.conductingEquipmentUUID}`);
+        xmlWriter.endElement();
+      } else {
+        xmlWriter.writeComment('ConductingEquipment is not defined');
+      }
+      if (this.connectivityNode) {
+        xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'Terminal.ConnectivityNode', RDF_XML.CIM_NS_16);
+        writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.HASH_UNDERSCORE}${this.connectivityNode.mrid}`);
+        xmlWriter.endElement();
+      } else if (this.connectivityNodeUUID) { // Workaround I7 Exporter
+        xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'Terminal.ConnectivityNode', RDF_XML.CIM_NS_16);
+        writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.HASH_UNDERSCORE}${this.connectivityNodeUUID}`);
+        xmlWriter.endElement();
+      } else {
+        xmlWriter.writeComment('ConnectivityNode is not defined');
+      }
+    }
+  }
+
+
+  /** ------------------ CIM RDF/XML Parser ------------------*/
+  public static resolveClassRDFXML(uuid: string, cimModel: Model): IdentifiedObject | undefined {
+    const newClass = new Terminal(uuid);
+    cimModel.addTerminal(newClass);
+    return newClass;
+  }
+
+  public resolveAttributesRDFXML(className: string, attrName: string, value: string) {
+    if (className === 'Terminal') {
+
+    } else {
+      super.resolveAttributesRDFXML(className, attrName, value);
+    }
+  }
+
+  public resolveAssociationRDFXML(className: string, resourceName: string, resourceUUID: string) {
+    if (className === 'Terminal') {
+      if (resourceName === 'ConductingEquipment') {
+        this.conductingEquipmentUUID = resourceUUID;
+      } else if (resourceName === 'ConnectivityNode') {
+        this.connectivityNodeUUID = resourceUUID;
+      } else if (resourceName === 'phases') {
+        this.phases = PhaseCode[resourceUUID];
+      }
+    } else {
+      super.resolveAssociationRDFXML(className, resourceName, resourceUUID);
+    }
+  }
+}

package/src/model/core/VoltageLevel.ts

@@ -0,0 +1,193 @@
+import { EquipmentContainer } from '../core/EquipmentContainer';
+import { Substation } from '../core/Substation';
+import { BaseVoltage } from './BaseVoltage';
+import { Bay } from './Bay';
+import { Model } from '../model/Model';
+import { generateUUID, getValue, writeElement, writeElementAttribute, writeStartElement } from '../../util/utils';
+import XMLWriter from 'xml-writer';
+import { RDF_XML } from '../../constants/rdf-xml';
+
+export class VoltageLevel extends EquipmentContainer {
+
+  substation: Substation;
+  substationUUID: string;
+
+  baseVoltage: BaseVoltage;
+  baseVoltageUUID: string;
+
+  bays: Bay[];
+
+  highVoltageLimit: number;
+  lowVoltageLimit: number;
+
+  constructor(uuid?: string, name?: string, shortName?: string, description?: string) {
+    super(uuid, name, shortName, description);
+    this.bays = [];
+  }
+
+
+  public getSubstationUUID(): string {
+    if (this.substationUUID) {
+      return this.substationUUID;
+    } else if (this.substation) {
+      return this.substation.getUUID();
+    }
+    return '';
+  }
+
+  public setSubstationUUID(substationUUID: string) {
+    this.substationUUID = substationUUID;
+  }
+
+  public getBaseVoltageUUID(): string {
+    if (this.baseVoltageUUID != null) {
+      return this.baseVoltageUUID;
+    } else if (this.baseVoltage != null) {
+      return this.baseVoltage.getUUID();
+    }
+    return '';
+  }
+
+  public setBaseVoltageUUID(baseVoltageUUID: string) {
+    this.baseVoltageUUID = baseVoltageUUID;
+  }
+
+  public addBay(bay: Bay) {
+    this.bays.push(bay);
+  }
+
+  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 amp:	 		<http://amprion.net/2018/cim_extensions#> 
+        PREFIX apf:	 		<http://jena.hpl.hp.com/ARQ/property#>
+        PREFIX afn:	 		<http://jena.apache.org/ARQ/function#>
+        
+        SELECT  (STRAFTER(str(?vlUUID), '#_') AS ?uuid)  
+                (CONCAT(STRBEFORE(str(?vlUUID), '#_'), '#_') AS ?baseIRI) 
+                ?name (STRAFTER(str(?sUUID), '#_') AS ?substationUUID) (STRAFTER(str(?bvUUID), '#_') AS ?baseVoltageUUID)
+        
+        WHERE { 
+            GRAPH <http://default/>{
+                OPTIONAL{?vlUUID rdf:type cim:VoltageLevel .}
+                OPTIONAL{?vlUUID cim:IdentifiedObject.name ?name .}
+                OPTIONAL{?vlUUID cim:VoltageLevel.Substation ?sUUID .}
+                OPTIONAL{?vlUUID cim:VoltageLevel.BaseVoltage ?bvUUID .}
+            }
+        }
+    `
+
+  public static getQuerySPARQL(graphURI: string): string {
+    if (graphURI.length > 0) {
+      return VoltageLevel.sparqlQuery.replace('<http://default/>', graphURI);
+    }
+    return VoltageLevel.sparqlQuery;
+  }
+
+  public static resolveClassFusekiJSON(data: any, cimModel: Model) {
+    data.results.bindings.forEach((value: any) => {
+      const voltageLevel = new VoltageLevel();
+      voltageLevel.resolveAttributesFusekiJSON(value)
+      cimModel.addVoltageLevel(voltageLevel);
+    });
+  }
+
+  protected resolveAttributesFusekiJSON(value: any) {
+    super.resolveAttributesFusekiJSON(value);
+    //BaseVoltage
+    this.baseVoltageUUID = getValue(value, 'baseVoltageUUID');
+    //substation
+    this.substationUUID = getValue(value, 'substationUUID');
+  }
+
+  public resolveParsedAssociations(cimModel: Model) {
+    super.resolveParsedAssociations(cimModel);
+    //Substation
+    this.substation = cimModel.getSubstation(this.substationUUID);
+    if (this.substation) this.substation.addVoltageLevel(this);
+    else console.log(this.constructor.name + ' ' + this.mrid + ' hat keine SubstationInstanz ' + this.substationUUID);
+
+    //baseVoltageUUID
+    this.baseVoltage = cimModel.getBaseVoltageByUUID(this.baseVoltageUUID);
+    if (!this.baseVoltage) console.log(this.constructor.name + ' ' + this.mrid + ' hat keine BaseVoltageInstanz ' + this.baseVoltageUUID);
+  }
+
+
+  public toJSON() {
+    super.toJSON();
+    this.toJSONAttributes();
+    this.toJSONAssociations();
+    return this.json;
+  }
+
+  public toJSONAttributes() {
+    super.toJSONAttributes();
+
+  }
+
+  public toJSONAssociations() {
+    super.toJSONAssociations();
+    this.json['substationUUID'] = this.substation ? this.substation.mrid : this.substationUUID;
+    this.json['baseVoltageUUID'] = this.baseVoltage ? this.baseVoltage.mrid : this.baseVoltageUUID;
+  }
+
+  public getBaseVoltageAsNumber(): number {
+    if (this.baseVoltage) {
+      return this.baseVoltage.nominalVoltageValue
+    }
+    return 0;
+  }
+
+  /** 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);
+    writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:VoltageLevel.highVoltageLimit`, this.highVoltageLimit);
+    writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:VoltageLevel.lowVoltageLimit`, this.lowVoltageLimit);
+  }
+
+  protected toCIMXMLAssociations(xmlWriter: XMLWriter, profile: string) {
+    super.toCIMXMLAssociations(xmlWriter, profile);
+    if (profile === RDF_XML.PROFILE_EQ) {
+      if (this.substation) {
+        xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'VoltageLevel.Substation', RDF_XML.CIM_NS_16);
+        writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.HASH_UNDERSCORE}${this.substation.mrid}`);
+        xmlWriter.endElement();
+      } else if (this.substationUUID) {
+        xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'VoltageLevel.Substation', RDF_XML.CIM_NS_16);
+        writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.HASH_UNDERSCORE}${this.substationUUID}`);
+        xmlWriter.endElement();
+      } else {
+        xmlWriter.writeComment('Substation is not defined');
+      }
+      if (this.baseVoltage) {
+        xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'VoltageLevel.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, 'VoltageLevel.BaseVoltage', RDF_XML.CIM_NS_16);
+          writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.HASH_UNDERSCORE}${this.baseVoltageUUID}`);
+          xmlWriter.endElement();
+      } else {
+        xmlWriter.writeComment('BaseVoltage is not defined');
+      }
+    }
+  }
+
+  public getSubstation(): Substation | undefined {
+    return this.substation;
+  }
+}