@enervance/insight-cim-model 0.0.1

package/src/model/extensions/neplan-westnetz/wires/WNEnergyConsumer.ts

@@ -0,0 +1,451 @@
+import { EnergyConsumer } from '../../../wires/EnergyConsumer';
+import { Model } from '../../../model/Model';
+import { getNumberValue, getValue } from '../../../../util/utils';
+
+import { IEnergyConsumer } from '../../../../interfaces/model/wires/IEnergyConsumer';
+import { TripleData } from '../../../../interfaces/persistence-interfaces';
+
+export class WNEnergyConsumer extends EnergyConsumer implements IEnergyConsumer {
+
+  cosPhi: number;
+
+  /** vetragliche Wirklast */
+  contractualP: number;
+  /** vetragliche Blindlast */
+  contractualQ: number;
+
+  /** gemessene Wirklast */
+  measuredP: number;
+  /** gemessene Blindlast */
+  measuredQ: number;
+
+  /** unterlagerte vetragliche Wirklast */
+  subContractualP: number;
+  /** unterlagerte ragliche Blindlast */
+  subContractualQ: number;
+
+  /** unterlagerte gemessene Wirklast */
+  subMeasuredP: number;
+  /** unterlagerte gemessene Blindlast */
+  subMeasuredQ: number;
+
+  /** Trafoleistung Wirklast */
+  powerTransfomer1P: number;
+  /** Trafoleistung Blindlast */
+  powerTransfomer1Q: number;
+
+  /** Trafoleistung Wirklast */
+  powerTransfomer2P: number;
+  /** Trafoleistung Blindlast */
+  powerTransfomer2Q: number;
+
+  /** die selektierte Lastangabe (wn_energyconsumer_installed, wn_energyconsumer_contractual, wn_energyconsumer_measured, trafo) */
+  selectedLoad: string;
+
+  /** Ein benutzerdefinierter Skalierungsfaktor. */
+  customMultiplier: number;
+
+  /**
+   *  VB – vertragliche Last der angeschlossenen Niederspannungskunden
+      MB – gemessene Last der angeschlossenen Niederspannungskunden
+      V – vertragliche Last des Mittelspannungskunden
+      M – gemessene Last des Mittelspannungskunden
+      T – Trafo-Leistung
+   * */
+  constructor(uuid?: string, name?: string, shortName?: string, description?: string){
+    super(uuid, name, shortName, description);
+
+
+    this.prop2namespacePrefix.set('contractualP', 'westnetzneplan'); // zur Generierung der Insert-Statements
+    this.prop2Class.set('contractualP', 'WNEnergyConsumer');
+    this.prop2Datatype.set('contractualP', 'number');
+    this.property2type.set('contractualP', 'property');
+
+    this.prop2namespacePrefix.set('contractualQ', 'westnetzneplan'); // zur Generierung der Insert-Statements
+    this.prop2Class.set('contractualQ', 'WNEnergyConsumer');
+    this.prop2Datatype.set('contractualQ', 'number');
+    this.property2type.set('contractualQ', 'property');
+
+    this.prop2namespacePrefix.set('measuredP', 'westnetzneplan'); // zur Generierung der Insert-Statements
+    this.prop2Class.set('measuredP', 'WNEnergyConsumer');
+    this.prop2Datatype.set('measuredP', 'number');
+    this.property2type.set('measuredP', 'property');
+
+    this.prop2namespacePrefix.set('measuredQ', 'westnetzneplan'); // zur Generierung der Insert-Statements
+    this.prop2Class.set('measuredQ', 'WNEnergyConsumer');
+    this.prop2Datatype.set('measuredQ', 'number');
+    this.property2type.set('measuredQ', 'property');
+
+    this.prop2namespacePrefix.set('subContractualP', 'westnetzneplan'); // zur Generierung der Insert-Statements
+    this.prop2Class.set('subContractualP', 'WNEnergyConsumer');
+    this.prop2Datatype.set('subContractualP', 'number');
+    this.property2type.set('subContractualP', 'property');
+
+    this.prop2namespacePrefix.set('subContractualQ', 'westnetzneplan'); // zur Generierung der Insert-Statements
+    this.prop2Class.set('subContractualQ', 'WNEnergyConsumer');
+    this.prop2Datatype.set('subContractualQ', 'number');
+    this.property2type.set('subContractualQ', 'property');
+
+    this.prop2namespacePrefix.set('subMeasuredP', 'westnetzneplan'); // zur Generierung der Insert-Statements
+    this.prop2Class.set('subMeasuredP', 'WNEnergyConsumer');
+    this.prop2Datatype.set('subMeasuredP', 'number');
+    this.property2type.set('subMeasuredP', 'property');
+
+    this.prop2namespacePrefix.set('subMeasuredQ', 'westnetzneplan'); // zur Generierung der Insert-Statements
+    this.prop2Class.set('subMeasuredQ', 'WNEnergyConsumer');
+    this.prop2Datatype.set('subMeasuredQ', 'number');
+    this.property2type.set('subMeasuredQ', 'property');
+
+    this.prop2namespacePrefix.set('powerTransfomer1P', 'westnetzneplan'); // zur Generierung der Insert-Statements
+    this.prop2Class.set('powerTransfomer1P', 'WNEnergyConsumer');
+    this.prop2Datatype.set('powerTransfomer1P', 'number');
+    this.property2type.set('powerTransfomer1P', 'property');
+
+    this.prop2namespacePrefix.set('powerTransfomer1Q', 'westnetzneplan'); // zur Generierung der Insert-Statements
+    this.prop2Class.set('powerTransfomer1Q', 'WNEnergyConsumer');
+    this.prop2Datatype.set('powerTransfomer1Q', 'number');
+    this.property2type.set('powerTransfomer1Q', 'property');
+
+    this.prop2namespacePrefix.set('powerTransfomer2P', 'westnetzneplan'); // zur Generierung der Insert-Statements
+    this.prop2Class.set('powerTransfomer2P', 'WNEnergyConsumer');
+    this.prop2Datatype.set('powerTransfomer2P', 'number');
+    this.property2type.set('powerTransfomer2P', 'property');
+
+    this.prop2namespacePrefix.set('powerTransfomer2Q', 'westnetzneplan'); // zur Generierung der Insert-Statements
+    this.prop2Class.set('powerTransfomer2Q', 'WNEnergyConsumer');
+    this.prop2Datatype.set('powerTransfomer2Q', 'number');
+    this.property2type.set('powerTransfomer2Q', 'property');
+
+
+    this.prop2namespacePrefix.set('selectedLoad', 'westnetzneplan'); // zur Generierung der Insert-Statements
+    this.prop2Class.set('selectedLoad', 'WNEnergyConsumer');
+    this.prop2Datatype.set('selectedLoad', 'string');
+    this.property2type.set('selectedLoad', 'property');
+
+    this.prop2namespacePrefix.set('cosPhi', 'westnetzneplan'); // zur Generierung der Insert-Statements
+    this.prop2Class.set('cosPhi', 'WNEnergyConsumer');
+    this.prop2Datatype.set('cosPhi', 'number');
+    this.property2type.set('cosPhi', 'property');
+
+    this.prop2namespacePrefix.set('customMultiplier', 'westnetzneplan'); // zur Generierung der Insert-Statements
+    this.prop2Class.set('customMultiplier', 'WNEnergyConsumer');
+    this.prop2Datatype.set('customMultiplier', 'number');
+    this.property2type.set('customMultiplier', 'property');
+
+  }
+
+
+  public static sparqlQuery : string = `
+        PREFIX cim:	 		            <http://iec.ch/TC57/2013/CIM-schema-cim16#> 
+        PREFIX westnetzneplan:	    <http://westnetzneplan.de/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(?econUUID), '#'), '_') AS ?uuid)  
+        (CONCAT(STRBEFORE(STR(?econUUID), '#_'), '#_') AS ?baseIRI) 
+        ?name ?shortName ?description ?aggregate ?p ?q 
+        ?contractualP ?contractualQ 
+        ?measuredP ?measuredQ 
+        
+        ?subContractualP ?subContractualQ
+        ?subMeasuredP ?subMeasuredQ
+        
+        ?powerTransfomer1P ?powerTransfomer1Q 
+        ?powerTransfomer2P ?powerTransfomer2Q
+        ?selectedLoad  ?cosPhi ?customMultiplier
+        (strafter(strafter(str(?ecUUID), '#'), '_') AS ?equipmentContainerUUID)  
+        (strafter(strafter(str(?ptUUID), '#'), '_') AS ?psrTypeUUID)      
+        (group_concat(STRAFTER(str(?aecUUIDs), '#_');separator=',') as ?additionalEquipmentContainerUUIDs)         
+        WHERE {
+            GRAPH <http://default/>{
+                ?econUUID rdf:type cim:EnergyConsumer . 
+                OPTIONAL{?econUUID cim:IdentifiedObject.name ?name .}
+                OPTIONAL{?econUUID entsoe:IdentifiedObject.shortName ?shortName .}
+                OPTIONAL{?econUUID cim:IdentifiedObject.description ?description .}
+                OPTIONAL{?econUUID cim:EnergyConsumer.p ?p .}
+                OPTIONAL{?econUUID cim:EnergyConsumer.q ?q .}
+                
+                OPTIONAL{?econUUID westnetzneplan:WNEnergyConsumer.contractualP ?contractualP .}
+                OPTIONAL{?econUUID westnetzneplan:WNEnergyConsumer.contractualQ ?contractualQ .}
+                
+                OPTIONAL{?econUUID westnetzneplan:WNEnergyConsumer.measuredP ?measuredP .}
+                OPTIONAL{?econUUID westnetzneplan:WNEnergyConsumer.measuredQ ?measuredQ .}
+                
+                OPTIONAL{?econUUID westnetzneplan:WNEnergyConsumer.subContractualP ?subContractualP .}
+                OPTIONAL{?econUUID westnetzneplan:WNEnergyConsumer.subContractualQ ?subContractualQ .}
+                  
+                OPTIONAL{?econUUID westnetzneplan:WNEnergyConsumer.subMeasuredP ?subMeasuredP .}
+                OPTIONAL{?econUUID westnetzneplan:WNEnergyConsumer.subMeasuredQ ?subMeasuredQ .}
+              
+                OPTIONAL{?econUUID westnetzneplan:WNEnergyConsumer.powerTransfomer1P ?powerTransfomer1P .}
+                OPTIONAL{?econUUID westnetzneplan:WNEnergyConsumer.powerTransfomer1Q ?powerTransfomer1Q .}
+  
+                OPTIONAL{?econUUID westnetzneplan:WNEnergyConsumer.powerTransfomer2P ?powerTransfomer2P .}
+                OPTIONAL{?econUUID westnetzneplan:WNEnergyConsumer.powerTransfomer2Q ?powerTransfomer2Q .}
+              
+                OPTIONAL{?econUUID westnetzneplan:WNEnergyConsumer.selectedLoad ?selectedLoad .}
+                 
+                OPTIONAL{?econUUID westnetzneplan:WNEnergyConsumer.cosPhi ?cosPhi .}
+                OPTIONAL{?econUUID westnetzneplan:WNEnergyConsumer.customMultiplier ?customMultiplier .}
+                                
+                OPTIONAL{?econUUID cim:Equipment.aggregate ?aggregate .}
+                OPTIONAL{?econUUID cim:Equipment.EquipmentContainer ?ecUUID .}
+                OPTIONAL{?econUUID cim:PowerSystemResource.PSRType ?ptUUID .}
+                OPTIONAL{?econUUID cim:Equipment.AdditionalEquipmentContainer ?aecUUIDs .}
+            }
+        }
+       GROUP BY ?econUUID ?baseIRI ?name ?shortName ?description ?aggregate ?p ?q 
+        ?contractualP ?contractualQ 
+        ?measuredP ?measuredQ 
+        
+        ?subContractualP ?subContractualQ
+        ?subMeasuredP ?subMeasuredQ
+        
+        ?powerTransfomer1P ?powerTransfomer1Q 
+        ?powerTransfomer2P ?powerTransfomer2Q
+        ?selectedLoad  ?cosPhi ?customMultiplier
+        ?ecUUID ?ptUUID
+    `
+  public static getQuerySPARQL(graphURI: string): string{
+    if(graphURI.length > 0){
+      return WNEnergyConsumer.sparqlQuery.replace('<http://default/>', graphURI);
+    }
+    return WNEnergyConsumer.sparqlQuery;
+  }
+  public static resolveClassFusekiJSON(data: any, cimModel: Model){
+    data.results.bindings.forEach((value: any) => {
+      const newClass = new WNEnergyConsumer();
+      newClass.resolveAttributesFusekiJSON(value);
+      cimModel.addEnergyConsumer(newClass);
+    });
+  }
+
+  protected resolveAttributesFusekiJSON(value: any){
+    super.resolveAttributesFusekiJSON(value);
+
+    this.contractualP = +getNumberValue(value, 'contractualP');
+    this.contractualQ = +getNumberValue(value, 'contractualQ');
+
+    this.measuredP = +getNumberValue(value, 'measuredP');
+    this.measuredQ = +getNumberValue(value, 'measuredQ');
+
+
+    this.subContractualP = +getNumberValue(value, 'subContractualP');
+    this.subContractualQ = +getNumberValue(value, 'subContractualQ');
+
+    this.subMeasuredP = +getNumberValue(value, 'subMeasuredP');
+    this.subMeasuredQ = +getNumberValue(value, 'subMeasuredQ');
+
+    this.powerTransfomer1P = +getNumberValue(value, 'powerTransfomer1P');
+    this.powerTransfomer1Q = +getNumberValue(value, 'powerTransfomer1Q');
+
+    this.powerTransfomer2P = +getNumberValue(value, 'powerTransfomer2P');
+    this.powerTransfomer2Q = +getNumberValue(value, 'powerTransfomer2Q');
+
+    this.selectedLoad = getValue(value, 'selectedLoad');
+
+    this.cosPhi = +getNumberValue(value, 'cosPhi');
+    this.customMultiplier = +getNumberValue(value, 'customMultiplier');
+  }
+
+  public toJSON(){
+    super.toJSON();
+    this.toJSONAttributes();
+    this.toJSONAssociations();
+    return this.json;
+  }
+
+  public toJSONAttributes(){
+    super.toJSONAttributes();
+
+    this.json['wn_energyconsumer_installed'] = this.getTypedApparentPower('wn_energyconsumer_installed');
+    this.json['wn_energyconsumer_contractual'] = this.getTypedApparentPower('wn_energyconsumer_contractual');
+    this.json['wn_energyconsumer_measured'] = this.getTypedApparentPower('wn_energyconsumer_measured');
+
+    this.json['wn_energyconsumer_sub_measured'] = this.getTypedApparentPower('wn_energyconsumer_sub_measured');
+    this.json['wn_energyconsumer_sub_contractual'] = this.getTypedApparentPower('wn_energyconsumer_sub_contractual');
+
+    this.json['wn_energyconsumer_trafo1'] = this.getTypedApparentPower('wn_energyconsumer_trafo1');
+    this.json['wn_energyconsumer_trafo2'] = this.getTypedApparentPower('wn_energyconsumer_trafo2');
+
+    this.json['selectedLoad'] = this.selectedLoad;
+    this.json['cosPhi'] = this.getCosPhi();
+    this.json['customMultiplier'] = this.customMultiplier;
+  }
+
+  public getApparentPower(): number {
+    return this.getTypedApparentPower(this.selectedLoad);
+  }
+
+  public getTypedApparentPower(loadType?: string): number {
+
+    switch (loadType) {
+      case 'wn_energyconsumer_contractual': {
+        return Math.sqrt(Math.pow(this.contractualP, 2) + Math.pow(this.contractualQ, 2));
+      }
+      case 'wn_energyconsumer_measured': {
+        return Math.sqrt(Math.pow(this.measuredP, 2) + Math.pow(this.measuredQ, 2));
+      }
+      case 'wn_energyconsumer_sub_measured': {
+        return Math.sqrt(Math.pow(this.subMeasuredP, 2) + Math.pow(this.subMeasuredQ, 2));
+      }
+      case 'wn_energyconsumer_sub_contractual': {
+        return Math.sqrt(Math.pow(this.subContractualP, 2) + Math.pow(this.subContractualQ, 2));
+      }
+      case 'wn_energyconsumer_trafo1': {
+        return Math.sqrt(Math.pow(this.powerTransfomer1P, 2) + Math.pow(this.powerTransfomer1Q, 2));
+      }
+      case 'wn_energyconsumer_trafo2': {
+        return Math.sqrt(Math.pow(this.powerTransfomer2P, 2) + Math.pow(this.powerTransfomer2Q, 2));
+      }
+      default: {
+        return super.getApparentPower();
+      }
+    }
+  }
+
+  public getP(): number {
+    switch (this.selectedLoad) {
+      case 'wn_energyconsumer_contractual': {
+        return isNaN(this.contractualP) ? 0 : this.contractualP;
+      }
+      case 'wn_energyconsumer_measured': {
+        return isNaN(this.measuredP) ? 0 : this.measuredP;
+      }
+      case 'wn_energyconsumer_sub_measured': {
+        return isNaN(this.subMeasuredP) ? 0 : this.subMeasuredP;
+      }
+      case 'wn_energyconsumer_sub_contractual': {
+        return isNaN(this.subContractualP) ? 0 : this.subContractualP;
+      }
+      case 'wn_energyconsumer_trafo1': {
+        return isNaN(this.powerTransfomer1P) ? 0 : this.powerTransfomer1P;
+      }
+      case 'wn_energyconsumer_trafo2': {
+        return isNaN(this.powerTransfomer2P) ? 0 : this.powerTransfomer2P;
+      }
+      default: {
+        return super.getP();
+      }
+    }
+  }
+
+  public getQ(): number {
+    switch (this.selectedLoad) {
+      case 'wn_energyconsumer_contractual': {
+        return isNaN(this.contractualQ) ? 0 : this.contractualQ;
+      }
+      case 'wn_energyconsumer_measured': {
+        return isNaN(this.measuredQ) ? 0 : this.measuredQ;
+      }
+      case 'wn_energyconsumer_sub_measured': {
+        return isNaN(this.subMeasuredQ) ? 0 : this.subMeasuredQ;
+      }
+      case 'wn_energyconsumer_sub_contractual': {
+        return isNaN(this.subContractualQ) ? 0 : this.subContractualQ;
+      }
+      case 'wn_energyconsumer_trafo1': {
+        return isNaN(this.powerTransfomer1Q) ? 0 : this.powerTransfomer1Q;
+      }
+      case 'wn_energyconsumer_trafo2': {
+        return isNaN(this.powerTransfomer2Q) ? 0 : this.powerTransfomer2Q;
+      }
+      default: {
+        return super.getQ();
+      }
+    }
+  }
+
+  public setActiveReactivePower(apparentPower: number, loadType?: string): TripleData {
+    const activepower = apparentPower * this.getCosPhi();
+    const ractivePower = Math.sqrt(Math.pow(apparentPower, 2) - Math.pow(activepower, 2));
+
+    const sparqlOldValue = [];
+    const sparqlNewValue = [];
+    switch (loadType) {
+      case 'contractual': {
+/*        sparqlOldValue.push(this.setProperty(undefined, 'contractualP', this.contractualP));
+        sparqlOldValue.push(this.setProperty(undefined, 'contractualQ', this.contractualQ));
+        sparqlNewValue.push(this.setProperty(undefined, 'contractualP', activepower));
+        sparqlNewValue.push(this.setProperty(undefined, 'contractualQ', ractivePower));*/
+        break;
+      }
+      case 'measured': {
+/*        sparqlOldValue.push(this.setProperty(undefined, 'measuredP', this.measuredP));
+        sparqlOldValue.push(this.setProperty(undefined, 'measuredQ', this.measuredQ));
+        sparqlNewValue.push(this.setProperty(undefined, 'measuredP', activepower));
+        sparqlNewValue.push(this.setProperty(undefined, 'measuredQ', ractivePower));*/
+        break;
+      }
+      case 'installed': {
+/*        sparqlOldValue.push(this.setProperty(undefined, 'p', this.p));
+        sparqlOldValue.push(this.setProperty(undefined, 'q', this.q));
+        sparqlNewValue.push(this.setProperty(undefined, 'p', activepower));
+        sparqlNewValue.push(this.setProperty(undefined, 'q', ractivePower));*/
+        break;
+      }
+
+    }
+    return {
+      oldTriple: sparqlOldValue.join(' '),
+      newTriple: sparqlNewValue.join(' ')
+    };
+  }
+
+
+  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: ''};
+  }
+
+  /*    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 setAssociation(className: string, associationName: string, relationObject: any, dataType: string, namespace: string): TripleData {
+    const currentAssociationValue = this[associationName] ? this[associationName]['mrid'] : undefined;
+    const oldTriple = currentAssociationValue ?
+      this.getAsssociationSparqlTriple(this.baseIRI, this.mrid, namespace, className, dataType, currentAssociationValue) :
+      '';
+    this[associationName] = currentAssociationValue;
+    const newAssociationValue = this[associationName] ? this[associationName]['mrid'] : undefined;
+    const newTriple = currentAssociationValue ?
+      this.getAsssociationSparqlTriple(this.baseIRI, this.mrid, namespace, className, dataType, newAssociationValue) :
+      '';
+    return { oldTriple, newTriple };
+  }*/
+
+
+
+  public getCosPhi(): number {
+    return isNaN(this.cosPhi) ? 1 : this.cosPhi;
+  }
+
+  public setCosPhi(cosPhi: number): TripleData {
+/*    const sparqlOldValue = this.setProperty(undefined, 'cosPhi', this.cosPhi);
+    const sparqlNewValue = this.setProperty(undefined, 'cosPhi', cosPhi);*/
+    return {
+      oldTriple: '',
+      newTriple: ''
+    };
+  }
+
+}

package/src/model/faults/EquipmentFault.ts

@@ -0,0 +1,9 @@
+import { Fault } from './Fault';
+
+export class EquipmentFault extends Fault {
+
+  protected constructor(mrid?: string, name?: string, shortName?: string, description?: string){
+    super(mrid, name, shortName, description);
+  }
+
+}

package/src/model/faults/Fault.ts

@@ -0,0 +1,41 @@
+import { IdentifiedObject } from '../core/IdentifiedObject';
+
+import { IOutage } from '../../interfaces/model/operations/IOutage';
+import { Model } from '../model/Model';
+import { IIdentifiedObject } from '../../interfaces/model/core/IIdentifiedObject';
+
+export class Fault extends IdentifiedObject {
+
+  outage: IOutage;
+  outageUUID: string;
+
+  constructor(mrid?: string, name?: string, shortName?: string, description?: string){
+    super(mrid, name, shortName, description);
+  }
+
+  getFaultEquipment(): IIdentifiedObject {
+    return;
+  }
+  setOutage(outage: IOutage): string {
+    this.outage = outage;
+    this.outage.addFault(this);
+    return this.getAssociationSparqlTriple(this.baseIRI, this.mrid, 'cim', 'Fault', 'Outage', outage.mrid);
+  }
+  /** ------------------ JSON------------------------*/
+  public toJSONAssociations(){
+    super.toJSONAssociations();
+    this.json['outageUUID'] = this.outageUUID;
+  }
+
+  /** ------------------ Fuseki Parser ------------------------*/
+  public resolveParsedAssociations(cimModel: Model){
+    super.resolveParsedAssociations(cimModel);
+    if (cimModel.outages.has(this.outageUUID)) {
+      this.outage = cimModel.getOutage(this.outageUUID);
+    } else {
+      //console.log(this.constructor.name + ' ' + this.mrid + ' hat keine Outage ' + this.outageUUID);
+    }
+  }
+
+
+}

package/src/model/faults/LineFault.ts

@@ -0,0 +1,10 @@
+import { IdentifiedObject } from '../core/IdentifiedObject';
+import { Fault } from './Fault';
+
+export class LineFault extends Fault {
+
+  protected constructor(mrid?: string, name?: string, shortName?: string, description?: string){
+    super(mrid, name, shortName, description);
+  }
+
+}

package/src/model/generation/FossilFuel.ts

@@ -0,0 +1,53 @@
+import { IdentifiedObject } from '../..';
+import { ThermalGeneratingUnit } from './ThermalGeneratingUnit';
+import { FuelType } from './FuelType';
+import { RDF_XML } from '../../constants/rdf-xml';
+import XMLWriter from 'xml-writer';
+import { writeElementAttribute } from "../../util/utils";
+
+export class FossilFuel extends IdentifiedObject {
+
+  thermalGeneratingUnit: ThermalGeneratingUnit;
+  fossilFuelType: FuelType;
+
+  constructor(uuid?: string, name?: string, shortName?: string, description?: string, type?: FuelType) {
+    super(uuid, name, shortName, description);
+    this.fossilFuelType = type;
+  }
+
+  /** 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);
+    if (profile === RDF_XML.PROFILE_EQ) {
+      /*<cim:SynchronousMachine.type rdf:resource="http://iec.ch/TC57/2013/CIM-schema-cim16#SynchronousMachineKind.generator"/>*/
+      xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'FossilFuel.fossilFuelType', RDF_XML.CIM_NS_16);
+      writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.CIM_NS_16}FuelType.${this.fossilFuelType}`);
+      xmlWriter.endElement();
+    }
+  }
+
+  protected toCIMXMLAssociations(xmlWriter: XMLWriter, profile: string) {
+    super.toCIMXMLAssociations(xmlWriter, profile);
+    if (profile === RDF_XML.PROFILE_EQ) {
+      if (this.thermalGeneratingUnit) {
+        xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'FossilFuel.ThermalGeneratingUnit', RDF_XML.CIM_NS_16);
+        writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.HASH_UNDERSCORE}${this.thermalGeneratingUnit.mrid}`);
+        xmlWriter.endElement();
+      } else {
+        xmlWriter.writeComment('ConductingEquipment is not defined');
+      }
+    }
+  }
+}

package/src/model/generation/FuelType.ts

@@ -0,0 +1,8 @@
+export enum FuelType {
+    coal = 'coal',
+    oil = 'oil',
+    gas = 'gas',
+    lignite = 'lignite',
+    hardCoal = 'hardCoal',
+    oilShale = 'oilShale',
+}