@enervance/insight-cim-model 0.0.1

package/src/model/core/IdentifiedObject.ts

@@ -0,0 +1,393 @@
+
+import { DiagramObject } from '../diagram/DiagramObject';
+import { Model } from '../model/Model';
+import { IObserver } from '../../interfaces/observable/IObserver';
+import { IObservable} from '../../interfaces/observable/IObservable';
+import { ISchemaSettings} from '../../interfaces/schema-settings/ShapeInfos';
+
+import { convertValue } from '../../util/datatype-converter';
+import { checkName, getValue, writeElement } from '../../util/utils';
+import XMLWriter from 'xml-writer';
+import { RDF_XML } from '../../constants/rdf-xml';
+import { IIdentifiedObject } from '../../interfaces/model/core/IIdentifiedObject';
+import { CIM_CLASS_NAMES } from '../../constants/cim-class-names';
+import { TripleData } from '../../interfaces/persistence-interfaces';
+import { IConnectivityNode } from '../../interfaces/model/core/IConnectivityNode';
+
+export abstract class IdentifiedObject implements IObservable, IIdentifiedObject {
+    mrid: string;
+    name: string;
+    shortName: string;
+    description: string;
+
+    observers: IObserver[];
+
+    /** Namespace aus Fuseki
+     *  Er unterscheidet sich von der GraphURI!
+     *  z.B. <http://localhost:3007/enerVance/data?graph=http://c7a56c4b-3f81-48d2-b764-99dee6b60692/data/Netz1# */
+    baseIRI: string;
+
+    diagramObjects: DiagramObject[];
+
+
+    /* Serialisierung: property -> Class
+     * z.B. name -> IdentifiedObject */
+    prop2Class: Map<string, string>;
+
+    /* Serialisierung: property -> namespace präfix
+    *  z.B. name -> cim, switchable -> enervance */
+    prop2namespacePrefix: Map<string, string>;
+    /* Serialisierung: property -> datentyp */
+    prop2Datatype: Map<string, string>;
+
+    /* PropertyName -> Propertty type z.B. psrType -> attr, assoc*/
+    property2type: Map<string, 'property' | 'association'>;
+
+
+    /* Graph variables */
+    visited: boolean = false;
+    id: number = 0;
+
+    installation: number;
+
+
+    /* JSON Object*/
+    protected json: any;
+
+    protected constructor(mrid?: string, name?: string, shortName?: string, description?: string){
+        this.mrid = mrid || '';
+        this.name = name;
+        this.shortName = shortName || '';
+        this.description = description || '';
+
+        this.diagramObjects = [];
+        this.observers= [];
+
+        this.prop2namespacePrefix = new Map();
+
+        this.prop2namespacePrefix.set('name', 'cim'); // zur Generierung der Insert-Statements
+        this.prop2namespacePrefix.set('description', 'cim'); // zur Generierung der Insert-Statements
+        this.prop2namespacePrefix.set('installation', 'enervance'); // zur Generierung der Insert-Statements
+
+        this.prop2Datatype = new Map();
+        this.prop2Datatype.set('name', 'string');
+        this.prop2Datatype.set('description', 'string');
+        this.prop2Datatype.set('installation', 'number');
+
+        this.prop2Class = new Map();
+        this.prop2Class.set('name', 'IdentifiedObject');
+        this.prop2Class.set('description', 'IdentifiedObject');
+        this.prop2Class.set('installation', 'IdentifiedObject');
+
+        this.property2type = new Map();
+        this.property2type.set('name', 'property');
+        this.property2type.set('description', 'property');
+        this.property2type.set('installation', 'property');
+    }
+
+
+
+    hasSwitchAssociation(): boolean {
+        return false;
+    }
+
+
+    public print(){
+        console.log(this.constructor.name + ' ' + this.mrid + ' ' + this.name);
+    }
+
+    public getUUID(): string {
+        return this.mrid;
+    }
+
+    public getDiagramObjects(): DiagramObject[] {
+        return this.diagramObjects;
+    }
+    public addDiagramObject(diagramObject: DiagramObject) {
+        this.diagramObjects.push(diagramObject);
+    }
+
+    public registerObserver(observer : IObserver){
+        if(this.observers.indexOf(observer) === -1){
+            this.observers.push(observer);
+        }
+    }
+
+    public removeObserver(observer: IObserver): void {
+
+        for (let i = 0; i < this.observers.length; i++) {
+            if (this.observers[i] === observer) {
+                this.observers.splice(i,1);
+            }
+        }
+    }
+
+    public notifyObservers() {
+        for (let i = 0; i < this.observers.length; i++) {
+            this.observers[i].receiveNotification(this);
+        }
+    }
+
+    /**gibt ein DiagramObject zum aktuellen Diagram
+     * Objekte koennen in mehreren Diagrammen enthalten sein
+     */
+    public getDiagramObject(diagramUUID: string): DiagramObject | undefined{
+
+        for (const diagramObject of this.diagramObjects) {
+            if(diagramObject.getDiagramUUID() === diagramUUID){
+                return diagramObject;
+            }
+        }
+        return;
+    }
+
+
+    public computeBounds(profile: string, schemaSettings: ISchemaSettings, diagramObject?: DiagramObject): any{}
+
+    /** Methode zur Netzbereinigung
+     *@param networkElements Liste zum Speichern der Elemente des aktuellen Teilnetzes
+     *Der Schaltzustand des Netzes wird nicht berücksichtigt */
+    public determineGridIslands(networkElements: any[]){}
+
+    /** Methode zum Breitendurchlauf
+      *@param networkElements Liste zum Speichern der Elemente des aktuellen Teilnetzes
+      *Der Schaltzustand des Netzes wird berücksichtigt */
+    public breadthFirstSearch(networkElements: any[]){}
+
+    /** Bestimmt TopopogicalNode für die Erstellung des Knoten-Kanten-Modells */
+    public determineTopologicalNodes(connNodes: IConnectivityNode[]){}
+
+    /** Bestimmt alle zum Slack gehörende Netzelemente (CN, Terminals Sammelschienen, Trafos)
+     * Relevant für Mittelspannungsnetze */
+    public determineSlackNodes(slackElemenets: IdentifiedObject[]){}
+
+
+
+    public addNetworkElement(networkElements: any[]) {
+        networkElements.push(this);
+        this.visited = true;
+    }
+
+/*    /!** die Methode gibt basierend auf der aktuellen Ausprägung des übergebenen Property
+     * ein SPARQL-INSERT Statemant zurück.
+     * 2 Szearien:
+     *      Löschen der aktuellen Ausprägung -> wird im DELETE DATA Block platziert.
+     *      Einfügen der aktuellen Ausprägung -> wird im INSERT DATA Block platziert. *!/
+    public getUpdateSPARQL (className: string, propName: string): string {
+        return;
+    }*/
+
+    /** Das Element kann schaltbar sein, wenn kein Schaltelement im Netzmodell vorhanden ist.
+     * Dieses Attribut wird von Benutzer eingepflegt.
+     * Implementierung s. Kindklassen */
+    public isSwitchable(): boolean {
+        return false;
+    }
+
+
+    /** Bestimmt alle zum Strang gehörende Netzelemente
+     * Mittelspannungsnetze*/
+    public determineMidVoltageLineElements(feederLineElemenets: IIdentifiedObject[], slackSubstationElements: IIdentifiedObject[][]){}
+
+
+    /** ------------------ insight JSON Serialisierung ------------------*/
+    public toJSON() {
+        this.json = {};
+    }
+
+    public toJSONAttributes() {
+        this.json['uuid'] = this.mrid;
+        this.json['name'] = this.name;
+        this.json['shortName'] = this.shortName;
+        this.json['description'] = this.description;
+        this.json['installation'] = this.installation;
+    }
+
+    /** ------------------ insight GeoJSON Interface  ------------------*/
+    /** ------------------ Schema  ------------------*/
+    public toJSONAssociations(){}
+
+    public getGeoJSON(profile: string, schemaSettings: ISchemaSettings): any {
+        return;
+    }
+    public toGeoJSON (geoJSON: any, profile: string, schemaSettings: ISchemaSettings, diagramObject?: DiagramObject) {
+        geoJSON['type'] = 'Feature';
+        geoJSON['id'] = this.mrid;
+    }
+
+    /** ------------------ Karte  ------------------*/
+    public toMapGeoJSON(): any {
+       return;
+    }
+
+    /** ------------------ CIM RDF/XML Serialisierung ------------------*/
+    public toCIMXML(xmlWriter: XMLWriter, profile: string) {}
+
+    protected toCIMXMLAttributes(xmlWriter: XMLWriter, profile: string) {
+        if(!profile || profile === RDF_XML.PROFILE_EQ || profile === RDF_XML.PROFILE_DL) {
+            writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:IdentifiedObject.name`, checkName(this.name, 'name'));
+            writeElement(xmlWriter, `${RDF_XML.ENTSOE_NS_PREFIX}:IdentifiedObject.shortName`, checkName(this.shortName, 'shortName'));
+            writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:IdentifiedObject.description`, checkName(this.description, 'description'));
+        }
+    }
+    protected toCIMXMLAssociations(xmlWriter: XMLWriter, profile: string) {}
+
+    protected getSuffixID(profile: string): string {
+        if (!profile || profile === '' || profile === RDF_XML.PROFILE_EQ || profile === RDF_XML.PROFILE_GL) {
+            return RDF_XML.RDF_ID;
+        } else {
+            return RDF_XML.RDF_ABOUT;
+        }
+    }
+    protected getPrefixUUID(suffixID: string): string {
+        if (suffixID === RDF_XML.RDF_ID) {
+            return RDF_XML.UNDERSCORE;
+        } else {
+            return RDF_XML.HASH_UNDERSCORE;
+        }
+    }
+
+
+
+    /** ------------------ CIM RDF/XML Parser ------------------*/
+    /** Implementierung: Klassen in der Hierarchie */
+    public static resolveClassRDFXML(uuid: string, cimModel: Model): IdentifiedObject | undefined {
+        return;
+    }
+
+    public resolveAttributesRDFXML(className: string, attrName: string, value: string){
+        if (className === 'IdentifiedObject') {
+            if (attrName === 'name') {
+                this.name = value;
+            } else if (attrName === 'shortName') {
+                this.shortName = value;
+            } else if (attrName === 'description') {
+                this.description = value;
+            }
+        }
+    }
+    public resolveAssociationRDFXML(className: string, resourceName: string, resourceUUID: string){}
+
+    /** ------------------ Fuseki Schnittstelle ------------------*/
+
+    /** Implementierung: Klassen in der Hierarchie */
+    public static getQuerySPARQL(graphURI: string): string{
+        return '';
+    }
+
+    /** ------------------ Fuseki Parser ------------------------*/
+    /** Parst und initialisiert das Objekt aus Fuseki JSON Daten  */
+    public static resolveClassFusekiJSON(data: any, cimModel: Model){}
+
+    /** Parst die Attributs- und Assoziationsinformationen aus Fuseki JSON Daten */
+    protected resolveAttributesFusekiJSON(value: any){
+        this.mrid = getValue(value, 'uuid');
+        this.baseIRI = getValue(value, 'baseIRI');
+        this.name = getValue(value, 'name');
+        this.shortName = getValue(value, 'shortName');
+        this.description = getValue(value, 'description');
+        this.installation = +getValue(value, 'installation');
+    }
+    /** Initialisiert Assoziationen aus geparsten Daten
+     *  Fuseki und XML Daten */
+    public resolveParsedAssociations(cimModel: Model){}
+
+
+    /** Löscht alle Tripel */
+    public createDeleteStatementSPARQL(graphURI: string): string {
+        return `
+                PREFIX rdf:<http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+                PREFIX cim:<http://iec.ch/TC57/2013/CIM-schema-cim16#>
+                PREFIX entsoe: <http://entsoe.eu/CIM/SchemaExtension/3/1#>
+                PREFIX enervance: <http://enervance.com/CIM/Extensions#>
+                 
+                 WITH ${graphURI}
+                 DELETE {
+                  ?s ?p ?o .
+                 }
+                 WHERE {
+                  ?s ?p ?o .
+                  FILTER(strafter(strafter(str(?s), '#'), '_') = '${this.mrid}')
+                 }`;
+    }
+
+    /*    public createSPARQLStatement(ns: string, className: string, propName: string, propValue: string, attribute: boolean): string {
+        if(attribute) {
+            return `<${this.baseIRI}${this.mrid}> ${ns}:${className}.${propName} ${propValue} . `;
+        } else {
+            return `<${this.baseIRI}${this.mrid}> ${ns}:${className}.${propName} <${this.baseIRI}${propValue}> . `;
+        }
+    }*/
+
+    /** Erstellt ein neues Tripel */
+    public createNewStatementSPARQL(): string {
+        return '';
+    }
+
+    /** Zuweiseung von neuen Assoziation und/oder Attributen
+     * @param propName Name der Assoziation bzw. des Attributes
+     * @param propertyValue eine neuer Wert
+     * @return Triple-Objekt zur Persistierung der geänderten Assoziationen/Attribute */
+    public setProperty(propName: string, propertyValue: any): TripleData {
+        const className = this.prop2Class.get(propName);
+        const dataType = this.prop2Datatype.get(propName);
+        const propertyType = this.property2type.get(propName);
+        const propertyNs = this.prop2namespacePrefix.get(propName);
+        if(propertyType === 'property') { // primitiver Datentyp
+            return this.setAttribute(className, propName, propertyValue, dataType, propertyNs);
+        } else { // komplexer Datentyp
+            //return this.setAssociation(cimModel, propName, propertyValue, dataType);
+        }
+        return { oldTriple: '', newTriple: ''};
+    }
+
+
+
+    /** Setzt einen neuen Wert für ein Property
+     * @param propName Name des Attributes
+     * @param propertyValue der neue Wert
+     * @param dataType der Datentyp des Attributes.
+     * @return das alte und das neue Triple */
+    public setAttribute(className:string, propName: string, propertyValue: any, dataType: string, namespace: string): TripleData {
+        const oldTriple = this.getPropertySparqlTriple(this.baseIRI, this.mrid, namespace, className, propName, this[propName]);
+        this[propName] = convertValue(dataType, propertyValue);
+        const newTriple = this.getPropertySparqlTriple(this.baseIRI, this.mrid, namespace, className, propName, this[propName]);
+        return {oldTriple, newTriple};
+    }
+    public getPropertySparqlTriple(baseIRI: string, mrid: string, namespace: string, className: string, propName, propValue: string): string {
+        return `<${baseIRI}${mrid}> ${namespace}:${className}.${propName} '${propValue}' . `;
+    }
+    /**
+     * @param associationName Klasse-Assoziationsname z.B. 'psrType' !== SPARQL-Assoziationsname z.B. PSRType => Datentyp
+     * @param relationObject (Assoziations-)Objekt
+     * @return TripleData alte und neue Assoziation als Triple
+     * */
+    public setAssociation(className: string, associationName: string, relationObject: any, dataType: string, namespace: string): TripleData {
+        const currentAssociationValue = this[associationName] ? this[associationName]['mrid'] : undefined;
+        const oldTriple = currentAssociationValue ?
+                          this.getAssociationSparqlTriple(this.baseIRI, this.mrid, namespace, className, dataType, currentAssociationValue)
+                          : '';
+        this[associationName] = relationObject;
+        const newTriple = this.getAssociationSparqlTriple(this.baseIRI, this.mrid, namespace, className, dataType, this[associationName]['mrid']);
+        return { oldTriple, newTriple };
+        // return { oldTriple: '', newTriple: ''};
+    }
+
+    getAssociationSparqlTriple(baseIRI: string, mrid: string, namespace: string, className: string, propName, propValueMrid: string): string {
+        return `<${baseIRI}${mrid}> ${namespace}:${className}.${propName} <${baseIRI}${propValueMrid}> . `;
+    }
+
+    /** Überprüft die Instanz auf verpflichtende CGMES-Attribute.
+     * Bei nicht Vorhandensein eines verpflichtenden Attributes,
+     * wird ein Defaultwert gesetzt
+     * @return Eine Zeichenkette mit den gesetzen Defaultwerten.
+     * */
+    checkMandatoryAttributes(profile: string, defaultValues: string) {
+        if (profile === RDF_XML.PROFILE_EQ) {
+            if (!this.name) {
+                this.name = 'name';
+                defaultValues += 'name,'
+            }
+        }
+    }
+}

package/src/model/core/PSRType.ts

@@ -0,0 +1,167 @@
+import { IdentifiedObject } from '../core/IdentifiedObject';
+import { Model } from '../model/Model';
+import { Bay } from './Bay';
+import { PowerSystemResource } from './PowerSystemResource';
+import {
+    IDENTIFIED_OBJECT_PROP_SELECT, IDENTIFIED_OBJECT_PROP_WHERE, NS_PREFIX_AFN, NS_PREFIX_APF,
+    NS_PREFIX_CIM, NS_PREFIX_ENERVANCE, NS_PREFIX_ENTSOE,
+    NS_PREFIX_RDF, PROP_MRID
+} from '../../util/sparql/sparql-building-block';
+import { RDF_XML } from '../../constants/rdf-xml';
+import { writeElementAttribute } from '../../util/utils';
+import XMLWriter from 'xml-writer';
+
+export class PSRType extends IdentifiedObject{
+    /**
+     * Photovoltaik Gebäude - nicht EEG subventioniert
+     * Photovoltaik Gebäude - EEG subventioniert
+     * Photovoltaik Freiflächen - nicht EEG subventioniert
+     * Photovoltaik Freiflächen - EEG subventioniert
+     * Elektrostraßenfahrzeuge
+     * Verkehr
+     * Gwerbe, Handel, Dienstleistung
+     * Industrie
+     * Private Haushalte
+     * Wasserkraft
+     * Windkraft
+     * Bio
+     * */
+    powerSystemResources: PowerSystemResource[];
+
+    constructor(mrid?: string, name?: string, shortName?: string, description?: string){
+        super(mrid, name, shortName, description);
+        this.powerSystemResources = [];
+    }
+
+    protected resolveAttributesFusekiJSON(value: any){
+        super.resolveAttributesFusekiJSON(value);
+    }
+    public resolveParsedAssociations(cimModel: Model){
+        super.resolveParsedAssociations(cimModel);
+    }
+
+    public addPowerSystemResource(psr: PowerSystemResource){
+        if(this.powerSystemResources.indexOf(psr) === -1) {
+            this.powerSystemResources.push(psr);
+        }
+    }
+    public toJSON(){
+        super.toJSON();
+        this.toJSONAttributes();
+        this.toJSONAssociations();
+        return this.json;
+    }
+
+    public toJSONAttributes(){
+        super.toJSONAttributes();
+    }
+
+    public toJSONAssociations(){
+        super.toJSONAssociations();
+    }
+
+/*    public getUpdateSPARQL(className: string, propName: string): string  {
+        if(this.constructor.name === className) {
+            const propValue = String(this[propName]); // aktuelle Ausprägung auslesen
+
+            const propNS = this.prop2namespacePrefix.get(String(propName));
+            const propClassName = this.prop2Class.get(String(propName));
+            if(propNS) {
+                return `<${this.baseIRI}${this.mrid}> ${propNS}:${propClassName}.${propName} \'${propValue}\' . `;
+            }
+        } else {
+            //TODO überarbeiten murks
+            //return super.getUpdateSPARQL(className, propName);
+        }
+        return;
+    }*/
+
+    public static resolveClassFusekiJSON(data: any, cimModel: Model){
+
+        data.results.bindings.forEach((value: any) => {
+            const psrType = new PSRType();
+            psrType.resolveAttributesFusekiJSON(value)
+            cimModel.addPsrType(psrType);
+        });
+    }
+
+    public static sparqlQuery : string = `
+        ${NS_PREFIX_CIM}
+        ${NS_PREFIX_ENERVANCE}
+        ${NS_PREFIX_RDF}
+        ${NS_PREFIX_APF}
+        ${NS_PREFIX_AFN}
+        ${NS_PREFIX_ENTSOE}
+         SELECT
+        ${IDENTIFIED_OBJECT_PROP_SELECT}
+        
+        WHERE { 
+            GRAPH <http://default/>{
+                ${PROP_MRID} rdf:type cim:PSRType . 
+                ${IDENTIFIED_OBJECT_PROP_WHERE}
+            }
+        }
+    `;
+
+    // depricated
+    public static sparqlInsert(baseIRI: string, graphURI: string) {
+        return `
+        ${NS_PREFIX_RDF}
+        ${NS_PREFIX_CIM}
+        ${NS_PREFIX_ENERVANCE}
+        INSERT DATA
+        {GRAPH ${graphURI} 
+            { 
+            #Leitungen
+            #Freileitung
+            <${baseIRI}4b9d56ff-2dfe-45c7-bd30-b327220b5333> 
+            a   cim:PSRType ;
+                cim:IdentifiedObject.name "Freileitung" .
+            <${baseIRI}d7fd2f5c-7ad4-400f-bcfe-3667520d4991> 
+            a   cim:PSRType ;
+                cim:IdentifiedObject.name "Kabel" .
+            
+            #Stationen
+            <${baseIRI}8f3de582-ad66-4d8a-bed4-a8f80036acf4> 
+            a   cim:PSRType ;
+                cim:IdentifiedObject.name "Abzweigpunkt" .
+            <${baseIRI}2701d754-2130-496f-8437-be593efb1ee6> 
+            a   cim:PSRType ;
+                cim:IdentifiedObject.name "Kundenstation" .
+            <${baseIRI}836564cc-5116-46ca-894f-ea360b80b15b> 
+            a   cim:PSRType ;
+                cim:IdentifiedObject.name "Kompaktstation" .
+        }
+}`
+    }
+
+    public static getQuerySPARQL(graphURI: string) : string{
+        if(graphURI.length > 0){
+            return PSRType.sparqlQuery.replace('<http://default/>', graphURI);
+        }
+        return PSRType.sparqlQuery;
+    }
+
+    /** CIM RDF/XML Serialisierung */
+    public toCIMXML(xmlWriter: XMLWriter, profile: string) {
+        if(!profile || profile === '') {
+            xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'PSRType', 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);
+    }
+
+    protected getSuffixID(profile: string): string {
+        return RDF_XML.RDF_ID
+    }
+}

package/src/model/core/PhaseCode.ts

@@ -0,0 +1,23 @@
+export enum PhaseCode {
+    ABCN = 'ABCN',
+    ABC = 'ABC',
+    ABN = 'ABN',
+    ACN = 'ACN',
+    BCN = 'BCN',
+    AB = 'AB',
+    AC = 'AC',
+    BC = 'BC',
+    AN = 'AN',
+    BN = 'BN',
+    CN = 'CN',
+    A = 'A',
+    B = 'B',
+    C = 'C',
+    N = 'N',
+    s1N = 's1N',
+    s2N = 's2N',
+    s12N = 's12N',
+    s1 = 's1',
+    s2 = 's2',
+    s12 = 's12'
+}

package/src/model/core/PowerSystemResource.ts

@@ -0,0 +1,113 @@
+
+import { Model } from '../model/Model';
+import { PSRType } from './PSRType';
+import { getValue, writeElementAttribute } from '../../util/utils';
+import XMLWriter from 'xml-writer';
+import { RDF_XML } from '../../constants/rdf-xml';
+import { Asset } from '../assets/Asset';
+import { AssetInfo, IdentifiedObject, Location } from '../..';
+import { IPowerSystemResource } from '../../interfaces/model/core/IPowerSystemResource';
+import { TripleData } from '../../interfaces/persistence-interfaces';
+
+export class PowerSystemResource extends IdentifiedObject implements IPowerSystemResource {
+
+    psrType: PSRType;
+    psrTypeUUID: string; // für Parser
+
+    /** In CgmesRdfXml ist die Assoziation umgedreht!*/
+    location: Location;
+    locationUUID: string;
+
+    assetDataSheet: AssetInfo;
+    assetDataSheetUUID: string;
+
+    assets: Map<string, Asset> = new Map();
+
+    constructor(mrid?: string, name?: string, shortName?: string, description?: string){
+        super(mrid, name, shortName, description);
+
+        this.prop2namespacePrefix.set('psrType', 'cim'); // zur Generierung der Insert-Statements
+        this.prop2Class.set('psrType', 'PowerSystemResource');
+        this.prop2Datatype.set('psrType', 'PSRType');
+        this.property2type.set('psrType', 'association');
+
+    }
+
+    protected resolveAttributesFusekiJSON(value: any){
+        super.resolveAttributesFusekiJSON(value);
+        //PowerSystemResource Type
+        this.psrTypeUUID = getValue(value, 'psrTypeUUID');
+    }
+
+    public resolveParsedAssociations(cimModel: Model){
+        this.psrType = cimModel.getPsrType(this.psrTypeUUID);
+    }
+
+    addAsset(asset: Asset) {
+        this.assets.set(asset.mrid, asset);
+    }
+
+    public toJSON(){
+        super.toJSON();
+        this.toJSONAttributes();
+        this.toJSONAssociations();
+        return this.json;
+    }
+
+    public toJSONAttributes(){
+        super.toJSONAttributes();
+    }
+
+    public toJSONAssociations(){
+        super.toJSONAssociations();
+        this.json['psrType'] = this.psrType ? this.psrType.name : undefined;
+    }
+
+    /** CIM RDF/XML Serialisierung */
+
+    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 && profile !== RDF_XML.PROFILE_DL && profile !== RDF_XML.PROFILE_GL &&
+          profile !== RDF_XML.PROFILE_SSH && profile !== RDF_XML.PROFILE_SV && profile !== RDF_XML.PROFILE_TP) {
+            if(this.psrType) {
+                xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'PowerSystemResource.PSRType', RDF_XML.CIM_NS_16);
+                writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.HASH_UNDERSCORE}${this.psrType.mrid}`);
+                xmlWriter.endElement();
+            } else if(this.psrTypeUUID) {
+                xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'PowerSystemResource.PSRType', RDF_XML.CIM_NS_16);
+                writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.HASH_UNDERSCORE}${this.psrTypeUUID}`);
+                xmlWriter.endElement();
+            }
+        }
+    }
+
+
+    public setProperty(propName: string, propertyValue: any): TripleData {
+        if (this.prop2Class.has(propName)) {
+            const className = this.prop2Class.get(propName);
+            const dataType = this.prop2Datatype.get(propName);
+            const propertyType = this.property2type.get(propName);
+            const propertyNs = this.prop2namespacePrefix.get(propName);
+
+            if(propertyType === 'property') { // primitiver Datentyp
+                return this.setAttribute(className, propName, propertyValue, dataType, propertyNs);
+            } else { // komplexer Datentyp
+                return this.setAssociation(className, propName, propertyValue, dataType, propertyNs);
+            }
+        }
+
+        return { oldTriple: '', newTriple: ''};
+    }
+
+
+    setPsrType(psrType: PSRType | undefined): string {
+        this.psrType = psrType;
+        if(psrType) {
+            return this.getAssociationSparqlTriple(this.baseIRI, this.mrid, 'cim', 'PowerSystemResource', 'PSRType',  psrType.mrid);
+        } else {
+            return '';
+        }
+
+    }
+}