@enervance/insight-cim-model 0.0.1

package/src/model/wires/SynchronousMachine.ts

@@ -0,0 +1,267 @@
+import { RotatingMachine } from './RotatingMachine';
+import {
+    RDF_XML,
+    ConnectivityNode,
+    IdentifiedObject,
+    Model,
+    ReactiveCapabilityCurve,
+    ShortCircuitRotorKind,
+    SynchronousMachineKind, IConnectivityNode, RegulatingControlModeKind
+} from '../..';
+import { getValue, writeElement, writeElementAttribute } from "../../util/utils";
+import XMLWriter from 'xml-writer';
+import { TripleData } from '../../interfaces/persistence-interfaces';
+import { SynchronousMachineOperatingMode } from './SynchronousMachineOperatingMode';
+import { toBoolean } from '../../util/datatype-converter';
+
+export class SynchronousMachine extends RotatingMachine {
+
+    type: SynchronousMachineKind;
+    referencePriority: number;
+    maxQ: number;
+    minQ: number;
+    maxU: number;
+    minU: number;
+    qPercent: number;
+
+    earthing: boolean;
+    earthingStarPointR: number;
+    earthingStarPointX: number;
+    ikk: number;
+    mu: number;
+    r: number;
+    r0: number;
+    r2: number;
+    satDirectSubtransX: number;
+    satDirectSyncX: number;
+    satDirectTransX: number;
+    shortCircuitRotorType: ShortCircuitRotorKind;
+    voltageRegulationRange: number;
+    x0: number;
+    x2: number;
+
+    operatingMode: SynchronousMachineOperatingMode;
+
+    initialReactiveCapabilityCurve: ReactiveCapabilityCurve;
+    initialReactiveCapabilityCurveUUID: string;
+
+    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 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(?eneUUID), '#'), '_') AS ?uuid) 
+                (CONCAT(STRBEFORE(str(?eneUUID), '#_'), '#_') AS ?baseIRI) 
+                ?name ?shortName ?description 
+                ?controlEnabled ?ratedS ?p ?q ?maxU ?maxQ ?minU ?minQ
+                ?earthing ?qPercent ?ratedPowerFactor
+                ?referencePriority ?r
+                ?satDirectSubtransX ?satDirectTransX ?voltageRegulationRange
+                (strafter(strafter(str(?typeEnum), '#'), '.') AS ?type) 
+                (strafter(strafter(str(?operatingModeEnum), '#'), '.') AS ?operatingMode) 
+                (strafter(strafter(str(?guUUID), '#'), '_') AS ?generatingUnitUUID) 
+                        
+        WHERE {
+            GRAPH <http://default/>{
+                ?eneUUID rdf:type cim:SynchronousMachine .
+                OPTIONAL{?eneUUID cim:IdentifiedObject.name ?name .}
+                OPTIONAL{?eneUUID entsoe:IdentifiedObject.shortName ?shortName .}
+                OPTIONAL{?eneUUID cim:IdentifiedObject.description ?description .}
+                OPTIONAL{?eneUUID cim:RegulatingCondEq.controlEnabled ?controlEnabled .}
+                
+                OPTIONAL{?eneUUID cim:RotatingMachine.ratedS ?ratedS .}
+                OPTIONAL{?eneUUID cim:RotatingMachine.p ?p .}
+                OPTIONAL{?eneUUID cim:RotatingMachine.q ?q .}
+                OPTIONAL{?eneUUID cim:SynchronousMachine.ratedPowerFactor ?ratedPowerFactor .}
+                              
+                OPTIONAL{?eneUUID cim:SynchronousMachine.maxU ?maxU .}
+                OPTIONAL{?eneUUID cim:SynchronousMachine.maxQ ?maxQ .}
+
+                OPTIONAL{?eneUUID cim:SynchronousMachine.minU ?minU .}
+                OPTIONAL{?eneUUID cim:SynchronousMachine.minQ ?minQ .}
+                        
+                OPTIONAL{?eneUUID cim:SynchronousMachine.earthing ?earthing .}
+                OPTIONAL{?eneUUID cim:SynchronousMachine.qPercent ?qPercent .}
+                
+                OPTIONAL{?eneUUID cim:SynchronousMachine.earthing ?referencePriority .}
+                OPTIONAL{?eneUUID cim:SynchronousMachine.qPercent ?r .}
+                OPTIONAL{?eneUUID cim:SynchronousMachine.satDirectSubtransX ?satDirectSubtransX .}
+                OPTIONAL{?eneUUID cim:SynchronousMachine.satDirectTransX ?satDirectTransX .}
+                
+                OPTIONAL{?eneUUID cim:SynchronousMachine.voltageRegulationRange ?voltageRegulationRange .}
+                
+                
+                OPTIONAL{?eneUUID cim:SynchronousMachine.type ?typeEnum .}
+                OPTIONAL{?eneUUID cim:SynchronousMachine.operatingMode ?operatingModeEnum .}
+                OPTIONAL{?eneUUID cim:RotatingMachine.GeneratingUnit ?guUUID .}
+                
+                
+            }
+        }
+    `
+    public static getQuerySPARQL(graphURI : string) : string{
+        if(graphURI.length > 0){
+            return SynchronousMachine.sparqlQuery.replace('<http://default/>', graphURI);
+        }
+        return SynchronousMachine.sparqlQuery;
+    }
+
+    public static resolveClassFusekiJSON(data: any, cimModel: Model){
+        data.results.bindings.forEach((value: any) => {
+            const newClass = new SynchronousMachine();
+            newClass.resolveAttributesFusekiJSON(value);
+            cimModel.addSynchronousMachine(newClass);
+        });
+    }
+
+    protected resolveAttributesFusekiJSON(value: any){
+        super.resolveAttributesFusekiJSON(value);
+
+        this.minU = +getValue(value, 'minU');
+        this.maxU = +getValue(value, 'maxU');
+
+        this.minQ = +getValue(value, 'minQ');
+        this.maxQ = +getValue(value, 'maxQ');
+
+        this.qPercent = +getValue(value, 'qPercent');
+
+        this.earthing = toBoolean(getValue(value, 'earthing'));
+
+        this.referencePriority = +getValue(value, 'referencePriority');
+        this.r = +getValue(value, 'r');
+
+        this.satDirectSubtransX = +getValue(value, 'satDirectSubtransX');
+        this.satDirectTransX = +getValue(value, 'satDirectTransX');
+        this.voltageRegulationRange = +getValue(value, 'voltageRegulationRange');
+
+        this.type = SynchronousMachineKind[getValue(value, 'type')];
+        this.operatingMode = SynchronousMachineOperatingMode[getValue(value, 'operatingMode')];
+
+    }
+    public resolveParsedAssociations(cimModel: Model){
+        super.resolveParsedAssociations(cimModel);
+    }
+
+    public toJSON(){
+        super.toJSON();
+        this.toJSONAttributes();
+        this.toJSONAssociations();
+        return this.json;
+    }
+
+
+    public toJSONAttributes(){
+        super.toJSONAttributes();
+        this.json['p'] = this.p;
+        this.json['q'] = this.q;
+        this.json['referencePriority'] = this.referencePriority;
+        this.json['type'] = this.type;
+        this.json['operatingMode'] = this.operatingMode;
+    }
+
+    public toJSONAssociations(){
+        super.toJSONAssociations();
+    }
+
+    /* Graphalgorithmen */
+    public determineGridIslands(networkElements: any[]){
+        super.determineGridIslands(networkElements);
+    }
+
+    public breadthFirstSearch(networkElements: any[]){
+        if(!this.visited){
+            //console.log(this.constructor.name + ' ' + this.mrid)
+            this.addNetworkElement(networkElements);
+            super.breadthFirstSearch(networkElements);
+        }
+    }
+
+    //hier endet der Aufruf
+    public determineTopologicalNodes(connNodes: IConnectivityNode[]){
+        return;
+    }
+
+    /* Bestimmt alle zum Slack gehörende Netzelemente (CN, Terminals Sammelschienen, Trafos)*/
+    public determineSlackNodes(slackElemenets: IdentifiedObject[]){
+        if(!this.visited) {
+            this.addNetworkElement(slackElemenets);
+            // 0 = key, 1 = value
+            for (const entry of this.terminals.entries()){
+                const value = entry[1];
+                value.determineSlackNodes(slackElemenets);
+            }
+        }
+    }
+
+    public isLoadOrFeed(): boolean{
+        return true;
+    }
+
+    /** die Methode bestimmen den Datentyp, konvertiert und weist den Wert zu */
+/*    public setProperty(cimModel: Model, propName: string, propertyValue: any){
+
+    }*/
+
+    public setProperty(propName: string, propertyValue: any): TripleData {
+        return { oldTriple: '', newTriple: ''};
+    }
+
+
+    /** 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);
+        /*<cim:SynchronousMachine.type rdf:resource="http://iec.ch/TC57/2013/CIM-schema-cim16#SynchronousMachineKind.generator"/>*/
+        if(profile === RDF_XML.PROFILE_EQ) {
+            xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'SynchronousMachine.type', RDF_XML.CIM_NS_16);
+            writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.CIM_NS_16}SynchronousMachineKind.${this.type}`);
+            xmlWriter.endElement();
+
+            writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:SynchronousMachine.maxQ`, this.maxQ);
+            writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:SynchronousMachine.minQ`, this.minQ);
+            writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:SynchronousMachine.qPercent`, this.qPercent);
+            writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:SynchronousMachine.satDirectSubtransX`, this.satDirectSubtransX);
+            writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:SynchronousMachine.earthing`, this.earthing);
+            writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:SynchronousMachine.r`, this.r);
+            writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:SynchronousMachine.r0`, this.r0);
+            writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:SynchronousMachine.r2`, this.r2);
+            writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:SynchronousMachine.x0`, this.x0);
+            writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:SynchronousMachine.x2`, this.x2);
+        }
+    }
+    protected toCIMXMLAssociations(xmlWriter: XMLWriter, profile: string) {
+        super.toCIMXMLAssociations(xmlWriter, profile);
+        if(profile === RDF_XML.PROFILE_EQ) {
+            /*<cim:SynchronousMachine.InitialReactiveCapabilityCurve rdf:resource="#_c27d5861-d731-4a0b-bf9e-c060f714bdd6"/>*/
+            if (this.initialReactiveCapabilityCurve) {
+                xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'SynchronousMachine.InitialReactiveCapabilityCurve', RDF_XML.CIM_NS_16);
+                writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.HASH_UNDERSCORE}${this.initialReactiveCapabilityCurve.mrid}`);
+                xmlWriter.endElement();
+            } else if (this.initialReactiveCapabilityCurveUUID) {
+                xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'SynchronousMachine.InitialReactiveCapabilityCurve', RDF_XML.CIM_NS_16);
+                writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.HASH_UNDERSCORE}${this.initialReactiveCapabilityCurveUUID}`);
+                xmlWriter.endElement();
+            }
+        }
+    }
+
+}

package/src/model/wires/SynchronousMachineKind.ts

@@ -0,0 +1,9 @@
+export enum SynchronousMachineKind {
+    generator = 'generator',
+    condenser = 'condenser',
+    generatorOrCondenser = 'generatorOrCondenser',
+    motor = 'motor',
+    generatorOrMotor = 'generatorOrMotor',
+    motorOrCondenser = 'motorOrCondenser',
+    generatorOrCondenserOrMotor = 'generatorOrCondenserOrMotor',
+}

package/src/model/wires/SynchronousMachineOperatingMode.ts

@@ -0,0 +1,5 @@
+export enum SynchronousMachineOperatingMode {
+  generator = 'generator',
+  condenser = 'condenser',
+  motor = 'motor',
+}

package/src/model/wires/TapChanger.ts

@@ -0,0 +1,55 @@
+import { RDF_XML, PowerSystemResource } from '../..';
+import { TapChangerControl } from './TapChangerControl';
+import { SvTapStep } from "../statevariables/SvTapStep";
+import XMLWriter from 'xml-writer';
+import { writeElement, writeElementAttribute } from '../../util/utils';
+
+
+export class TapChanger extends PowerSystemResource {
+
+  highStep: number;
+  lowStep: number;
+  ltcFlag: boolean;
+  neutralStep: number;
+  neutralU: number;
+  normalStep: number;
+
+  tapChangerControl: TapChangerControl;
+  tapChangerControlUUID: string;
+
+  svTapStep: SvTapStep;
+  svTapStepUUID: string;
+  constructor(mrid?: string, name?: string, shortName?: string, description?: string) {
+    super(mrid, name, shortName, description);
+  }
+
+  protected toCIMXMLAttributes(xmlWriter: XMLWriter, profile: string) {
+    super.toCIMXMLAttributes(xmlWriter, profile);
+    if (profile === RDF_XML.PROFILE_EQ) {
+      writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:TapChanger.highStep`, String(this.highStep));
+      writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:TapChanger.lowStep`, String(this.lowStep));
+      writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:TapChanger.ltcFlag`, String(this.ltcFlag));
+      writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:TapChanger.neutralStep`, String(this.neutralStep));
+      writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:TapChanger.neutralU`, String(this.neutralU));
+      writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:TapChanger.normalStep`, String(this.normalStep));
+    }
+  }
+
+  protected toCIMXMLAssociations(xmlWriter: XMLWriter, profile: string) {
+    super.toCIMXMLAssociations(xmlWriter, profile);
+    if (profile === RDF_XML.PROFILE_EQ) {
+      if (this.tapChangerControl) {
+        xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'TapChanger.TapChangerControl', RDF_XML.CIM_NS_16);
+        writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.HASH_UNDERSCORE}${this.tapChangerControl.mrid}`);
+        xmlWriter.endElement();
+      } else if (this.tapChangerControlUUID) {
+          xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'TapChanger.TapChangerControl', RDF_XML.CIM_NS_16);
+          writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.HASH_UNDERSCORE}${this.tapChangerControlUUID}`);
+          xmlWriter.endElement();
+      } else {
+        xmlWriter.writeComment('ConductingEquipment is not defined');
+      }
+    }
+  }
+
+}

package/src/model/wires/TapChangerControl.ts

@@ -0,0 +1,32 @@
+import { RegulatingControl } from './RegulatingControl';
+import { TapChanger } from './TapChanger';
+import { RDF_XML } from '../..';
+import { writeElementAttribute } from '../../util/utils';
+import XMLWriter from 'xml-writer';
+
+export class TapChangerControl extends RegulatingControl{
+
+    tapChanger: TapChanger[] = [];
+
+    constructor(mrid?: string, name?: string, shortName?: string, description?: string){
+        super(mrid, name, shortName, description);
+    }
+
+    public addTapChanger(tapChanger: TapChanger){
+        this.tapChanger.push(tapChanger);
+    }
+
+
+    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();
+        }
+    }
+
+}

package/src/model/wires/TapChangerTablePoint.ts

@@ -0,0 +1,41 @@
+import { RDF_XML } from '../..';
+import { writeElement } from '../../util/utils';
+import XMLWriter from 'xml-writer';
+
+export class TapChangerTablePoint {
+    mrid: string;
+
+    b: number; // %
+    g: number; // %
+    r: number; // %
+    x: number; // %
+    ratio: number;
+    step: number;
+
+    constructor(mrid?: string){
+        this.mrid = mrid;
+    }
+
+    protected toCIMXMLAttributes(xmlWriter: XMLWriter, profile: string) {
+        if(profile === RDF_XML.PROFILE_EQ) {
+            if(this.b) {
+                writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:TapChangerTablePoint.b`, this.b);
+            }
+            if(this.g) {
+                writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:TapChangerTablePoint.g`, this.g);
+            }
+            if(this.r) {
+                writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:TapChangerTablePoint.r`, this.r);
+            }
+            if(this.x) {
+                writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:TapChangerTablePoint.x`, this.x);
+            }
+            if(this.ratio) {
+                writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:TapChangerTablePoint.ratio`, this.ratio);
+            }
+            if(this.step) {
+                writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:TapChangerTablePoint.step`, this.step);
+            }
+        }
+    }
+}

package/src/model/wires/TransformerControlMode.ts

@@ -0,0 +1,4 @@
+export enum TransformerControlMode {
+    volt = 'volt',
+    reactive = 'reactive',
+}

package/src/model/wires/TransformerEnd.ts

@@ -0,0 +1,143 @@
+import { IdentifiedObject } from '../core/IdentifiedObject';
+import { BaseVoltage } from '../core/BaseVoltage';
+import { Terminal } from '../core/Terminal';
+import { Model } from '../model/Model';
+import { getValue, writeElement, writeElementAttribute } from '../../util/utils';
+import XMLWriter from 'xml-writer';
+import { RDF_XML } from '../../constants/rdf-xml';
+import { RatioTapChanger } from './RatioTapChanger';
+import { ITerminal } from '../../interfaces/model/core/ITerminal';
+
+export class TransformerEnd extends IdentifiedObject {
+
+  endNumber: number;
+
+  baseVoltage: BaseVoltage;
+  baseVoltageUUID: string;
+
+  terminal: ITerminal;
+  terminalUUID: string;
+
+  ratioTapChanger: RatioTapChanger;
+  ratioTapChangerUUID: string;
+
+  constructor(uuid: string, name: string, shortName: string, description: string, endNumber: number) {
+    super(uuid, name, shortName, description);
+    this.endNumber = endNumber;
+  }
+
+  public getTerminal(): ITerminal {
+    return this.terminal;
+  }
+
+  public setTerminal(value: Terminal) {
+    this.terminal = value;
+  }
+
+  public getEndNumber(): number {
+    return this.endNumber;
+  }
+
+  public setEndNumber(value: number) {
+    this.endNumber = value;
+  }
+
+
+  public getBaseVoltage(): BaseVoltage {
+    return this.baseVoltage;
+  }
+
+  public setBaseVoltage(baseVoltage: BaseVoltage) {
+    this.baseVoltage = baseVoltage;
+  }
+
+  public getTerminalUUID(): string {
+    return this.terminalUUID;
+  }
+
+  public setTerminalUUID(terminalUUID: string) {
+    this.terminalUUID = terminalUUID;
+  }
+
+  protected resolveAttributesFusekiJSON(value: any) {
+    super.resolveAttributesFusekiJSON(value);
+    this.endNumber = +getValue(value, 'endNumber');
+    this.baseVoltageUUID = getValue(value, 'baseVoltageUUID');
+    this.terminalUUID = getValue(value, 'terminalUUID');
+
+  }
+
+  public resolveParsedAssociations(cimModel: Model) {
+    super.resolveParsedAssociations(cimModel);
+
+    this.baseVoltage = cimModel.getBaseVoltageByUUID(this.baseVoltageUUID);
+    if (!this.baseVoltage) console.log(this.constructor.name + ' ' + this.mrid + ' hat keine BaseVoltageInstanz ' + this.baseVoltageUUID);
+
+    //Terminal
+    this.terminal = cimModel.getTerminal(this.terminalUUID);
+    if (this.terminal) this.terminal.addTransformerEnd(this);
+    else console.log(this.constructor.name + ' ' + this.mrid + ' hat keine TerminalInstanz ' + this.terminalUUID);
+
+  }
+
+  // public toJSON(){
+  // super.toJSON();
+  // this.toJSONAttributes();
+  // this.toJSONAssociations();
+  // return this.json;
+  // }
+
+  public toJSONAttributes() {
+    super.toJSONAttributes();
+    this.json['endNumber'] = +this.endNumber;
+  }
+
+  public toJSONAssociations() {
+    super.toJSONAssociations();
+    if (this.baseVoltage) {
+      this.json['baseVoltageUUID'] = this.baseVoltage.mrid;
+    }
+    if (this.terminal) {
+      this.json['terminalUUID'] = this.terminal.mrid;
+    }
+  }
+
+  protected toCIMXMLAttributes(xmlWriter: XMLWriter, profile: string) {
+    super.toCIMXMLAttributes(xmlWriter, profile);
+    if (profile === RDF_XML.PROFILE_EQ) {
+      writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:TransformerEnd.endNumber`, this.endNumber);
+      writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:TransformerEnd.rground`, 0);
+      writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:TransformerEnd.xground`, 0);
+      writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:TransformerEnd.grounded`, 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, `TransformerEnd.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, `TransformerEnd.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');
+      }
+
+      if (this.terminal) {
+        xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, `TransformerEnd.Terminal`, RDF_XML.CIM_NS_16);
+        writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.HASH_UNDERSCORE}${this.terminal.mrid}`);
+        xmlWriter.endElement();
+      } else if (this.terminalUUID) {
+        xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, `TransformerEnd.Terminal`, RDF_XML.CIM_NS_16);
+        writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.HASH_UNDERSCORE}${this.terminalUUID}`);
+        xmlWriter.endElement();
+      } else {
+        xmlWriter.writeComment('Terminal is not defined');
+      }
+    }
+  }
+}

package/src/model/wires/WindingConnection.ts

@@ -0,0 +1,9 @@
+export enum WindingConnection {
+    D = 'D',
+    Y = 'Y',
+    Z = 'Z',
+    Yn = 'Yn',
+    Zn = 'Zn',
+    A = 'A',
+    I = 'I',
+}

package/src/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "insight-cim-model",
+  "version": "1.0.0",
+  "description": "cim data model",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "rimraf dist && tsc && copyfiles -f src/package.json dist",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {},
+  "devDependencies": {}
+}

package/src/util/datatype-converter.ts

@@ -0,0 +1,48 @@
+
+export function convertValue(toDataType, propertyValue) {
+    switch(toDataType){
+        case 'boolean':
+            return toBoolean(propertyValue);
+        case 'number':
+            return +propertyValue;
+        default:
+            return String(propertyValue);
+    }
+}
+
+export function toBoolean(value){
+    switch(value){
+        case true:
+            return true;
+        case "true":
+            return true;
+        case "on":
+            return true;
+        case "ja":
+            return true;
+        case "yes":
+            return true;
+
+        case false:
+            return false;
+        case "false":
+            return false;
+        case "off":
+            return false;
+        case "nein":
+            return false;
+        case "no":
+            return false;
+
+        default:
+            return false;
+    }
+}
+
+export function getFormattedNumber(value) {
+    if(!isNaN(value)) {
+        return value;
+    }
+    return 0;
+}
+

package/src/util/sparql/sparql-building-block.ts

@@ -0,0 +1,43 @@
+
+export const NS_PREFIX_CIM = 'PREFIX cim: <http://iec.ch/TC57/2013/CIM-schema-cim16#> ';
+export const NS_PREFIX_WN = 'PREFIX westnetzneplan: <http://westnetzneplan.de/CIM/Extensions#>  ';
+export const NS_PREFIX_ENERVANCE = 'PREFIX enervance: <http://enervance.com/CIM/Extensions#> ';
+export const NS_PREFIX_AMPRION = 'PREFIX amp: <http://amprion.net/CIM/2018/Extensions#> ';
+export const NS_PREFIX_ENTSOE = 'PREFIX entsoe: <http://entsoe.eu/CIM/SchemaExtension/3/1#> ';
+export const NS_PREFIX_RDF = 'PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> ';
+export const NS_PREFIX_APF = 'PREFIX apf: <http://jena.hpl.hp.com/ARQ/property#> ';
+export const NS_PREFIX_AFN = 'PREFIX afn: <http://jena.apache.org/ARQ/function#> ';
+
+export const PROP_MRID = '?MRID';
+
+
+export const PROP_CONNECTIVITY_NODE_CONTAINER_UUID = '?cncUUID ';
+export const PROP_CONNECTIVITY_NODE_SWITCHABLE = '?switchable ';
+export const IDENTIFIED_OBJECT_PROP_SELECT =
+    `(STRAFTER(STR(${PROP_MRID}), \'#_\') AS ?uuid) 
+     (CONCAT(STRBEFORE(STR(${PROP_MRID}), \'#_\'), \'#_\') AS ?baseIRI) 
+     ?name 
+     ?shortName 
+     ?description  
+     ?installation `;
+
+
+export const CONNECTIVITY_NODE_SELECT =
+    ` ${PROP_CONNECTIVITY_NODE_SWITCHABLE}
+    (STRAFTER(STR(${PROP_CONNECTIVITY_NODE_CONTAINER_UUID}), \'#_\') AS ?connectivityNodeContainerUUID) `;
+
+
+export const CONNECTIVITY_NODE_WHERE = `
+    OPTIONAL {${PROP_MRID} enervance:ConnectivityNode.switchable ${PROP_CONNECTIVITY_NODE_SWITCHABLE} .} 
+    OPTIONAL {${PROP_MRID} cim:ConnectivityNode.ConnectivityNodeContainer ${PROP_CONNECTIVITY_NODE_CONTAINER_UUID} .} `;
+
+
+
+
+export const IDENTIFIED_OBJECT_PROP_WHERE = `
+    OPTIONAL {${PROP_MRID} cim:IdentifiedObject.name ?name .} 
+    OPTIONAL {${PROP_MRID} entsoe:IdentifiedObject.shortName ?shortName .} 
+    OPTIONAL {${PROP_MRID} cim:IdentifiedObject.description ?description .} 
+    OPTIONAL {${PROP_MRID} enervance:IdentifiedObject.installation ?installation .} `;
+
+