@enervance/insight-cim-model 0.0.1

package/src/model/extensions/neplan-westnetz/core/WNConnectivityNode.ts

@@ -0,0 +1,344 @@
+import {ConnectivityNode} from "../../../core/ConnectivityNode";
+import {Asset} from "../../../assets/Asset";
+import { WNFacility } from '../assets/WNFacility';
+import { WNFeeder } from './WNFeeder';
+import { Model } from '../../../model/Model';
+import { toBoolean } from '../../../../util/datatype-converter';
+import { getValue } from '../../../../util/utils';
+import { IFacility } from '../../../../interfaces/model/assets/IFacility';
+import { AssetOwner } from '../../../assets/AssetOwner';
+import { Facility } from '../../../assets/Facility';
+import { IRectangleShapeInfo, ISchemaSettings } from '../../../../interfaces/schema-settings/ShapeInfos';
+import { DiagramObject } from '../../../diagram/DiagramObject';
+import { HealthScore } from '../../../assets/HealthScore';
+import { EVImportanceScore } from '../../enervance/assets/EVImportanceScore';
+import { WNFaultConnectivityNode } from '../faults/WNFaultConnectivityNode';
+import { WNOutage } from '../operations/WNOutage';
+import { IOutage } from '../../../../interfaces/model/operations/IOutage';
+import { IEquipmentContainer } from '../../../../interfaces/model/core/IEquipmentContainer';
+
+/** Wenstnezu Neplan Erweiterung */
+export class WNConnectivityNode extends ConnectivityNode {
+
+  /** Schaltbarkeit von Stationen */
+  switchable: boolean;
+
+  /** Assoziation zu Facility, da ConnectivityNode im Standardmodell nicht mit Asset assoziiert ist */
+  assets: Map<string, WNFacility>;
+
+  /** Abgabgszugehörigkeit */
+  additionalConnectivityNodeContainer: WNFeeder;
+  additionalConnectivityNodeContainerUUID: string;
+
+  /** N-1 Ausfallobjekt: dieses Objekt fällt aus */
+  fault: WNFaultConnectivityNode;
+
+  /** N-1 Objekt dieses Objekt ist von einem (Asset-) Ausfall betroffen */
+  outages: Map<string, WNOutage>;
+
+  constructor(uuid?: string, name?: string, shortName?: string, description?: string){
+    super(uuid, name, shortName, description);
+    this.assets = new Map();
+    this.outages = new Map();
+
+    this.prop2Datatype.set('switchable', 'boolean');
+    this.property2type.set('switchable', 'property');
+    this.prop2namespacePrefix.set('switchable', 'westnetzneplan'); // zur Generierung der Insert-Statements
+    this.prop2Class.set('switchable', 'WNConnectivityNode');
+
+  }
+
+  addOutage(outage: WNOutage) {
+    this.outages.set(outage.mrid, outage);
+  }
+  public toJSONAttributes(){
+    super.toJSONAttributes();
+    this.json['switchable'] = this.switchable;
+    for (const asset of this.assets.values()) {
+      // S4-S6 Meldungen
+      for (const activityRecord of asset.activityRecords.values()) {
+        if(activityRecord.type === 'S4') {
+          this.json['wn_connectivity_node_s4'] = activityRecord.name;
+        } else if (activityRecord.type === 'S6') {
+          this.json['wn_connectivity_node_s6'] = activityRecord.name;
+        }
+      }
+      for (const organisationRole of asset.organisationRoles.values()) {
+        if(organisationRole instanceof AssetOwner) {
+          this.json['wn_connectivity_node_assetowner'] = organisationRole.name;
+        }
+      }
+
+      for (const analyticScore of asset.analyticScores.values()) {
+        if(analyticScore instanceof HealthScore) {
+          this.json['wn_connectivity_node_health_score'] = analyticScore.value;
+        } else if (analyticScore instanceof EVImportanceScore) {
+          this.json['wn_connectivity_node_importance_score'] = analyticScore.value;
+        }
+      }
+
+      this.json['wn_connectivity_node_type'] = (asset as Facility).kind;
+      this.json['wn_connectivity_node_kind'] = asset.type;
+    }
+  }
+
+  public toJSONAssociations() {
+    super.toJSONAssociations();
+    this.json['additionalConnectivityNodeContainer'] = this.additionalConnectivityNodeContainerUUID;
+  }
+
+  /** Das Element kann schaltbar sein, wenn kein Schaltelement im Netzmodell vorhanden ist.
+   * Dieses Attribut wird von Benutzer eingepflegt. */
+  public isSwitchable(): boolean {
+    if(this.switchable === true) { // das Attribut kann u.U. undefined sein!
+      return true;
+    }
+    return false;
+  }
+
+  public toGeoJSON(geoJSON: any, profile: string, schemaSettings: ISchemaSettings, diagramObject: DiagramObject): any {
+
+    const coordinates : number[] = diagramObject.computeRectBounds(diagramObject);
+    const shapeInfos: IRectangleShapeInfo = schemaSettings.getRectangleShapeInfo(profile);
+
+    let x = coordinates[0];
+    let y = coordinates[1];
+    let offsetX = 0;
+    let offsetY = 0;
+
+    let width: number = coordinates[2];
+    let height: number = coordinates[3];
+    const stationsTyp = this.getType();
+
+    /* Shape besteht nur aus einer Koordinate */
+    if (shapeInfos && width === 1 && height === 1) {
+
+      width = +shapeInfos.width ?? 0;
+      height = +shapeInfos.height;
+      offsetX = +width/2;
+      offsetY = +height/2;
+    }
+
+    /* bei Kompakt- und Maststationen muss im Neplan-Fall kein Offset berücksichtigt werden,
+     * da das Shape aufgrund des C- bzw. M-Buchstabens doppel so groß ist */
+    if(stationsTyp === 'C-Station') {
+      offsetX = -width/4;
+      offsetY = -height/4;
+    } else if(stationsTyp === 'Maststat') {
+      offsetX = -width/2;
+      offsetY = -height/2;
+    } /*else if(stationsTyp === 'Muffe') {
+            //TODO überarbeiten muffen in Settgins breite 3px, Höhe 3px
+            width = 3;
+            height = 3;
+            offsetX = 1.5;
+            offsetY = 1.5;
+        }*/
+
+    if(x != 0 && y != 0 && width != 0 && height != 0) {
+      super.toGeoJSON(geoJSON, profile, schemaSettings, diagramObject);
+
+      if (profile === 'Integral 7_') {
+        let xx = coordinates[0];
+        let yy = coordinates[1] * -1;
+
+        let offsetXX = width/2;
+        let offsetYY = height/2;
+
+        //Als Raute
+        const pointsPolygon: number[][][] = /*stationsTyp === 'Muffe' ? [[[x , -y]]] :*/ [
+          [
+            [xx, yy + offsetYY], // oben
+            [xx + offsetXX , yy], // rechts
+            [xx, yy - offsetYY], // unten
+            [xx - offsetXX, yy],
+            [xx, yy + offsetYY]
+          ]
+        ];
+
+        geoJSON['geometry'] = {
+          type: 'Polygon',
+          coordinates: pointsPolygon
+        };
+
+        geoJSON['properties'] = {
+          diagramObjectUUID: diagramObject.mrid,
+          objectType: this.constructor.name,
+          width: width,
+          height: height,
+          offsetX: offsetXX,
+          offsetY: offsetYY,
+          fill: undefined,
+        }
+      } else {
+        const xOff = x - offsetX;
+        const yOff = y - offsetY;
+        let fill = stationsTyp === 'Schaltschrank' ? 'white' : undefined;
+
+
+        let pointsPolygon: number[][][] = /*stationsTyp === 'Muffe' ? [[[x , -y]]] :*/ [
+          [
+            [xOff, yOff * -1],
+            [xOff + width , yOff * -1],
+            [xOff + width, (yOff + height) * -1],
+            [xOff, (yOff + height) * -1],
+            [xOff, yOff * -1]
+          ]
+        ];
+        // Typ der Station (Westnetz)
+        for (const asset of this.assets.values()) {
+          for (const organisationRole of asset.organisationRoles.values()) {
+            if(organisationRole.name === 'Ortsnetzstation') {
+              pointsPolygon.push(       [
+                [xOff, (yOff + height) * -1],
+                [xOff + width , yOff * -1],
+              ]);
+              fill = 'white';
+            } else if (organisationRole.name === 'Kundenstation') {
+              pointsPolygon.push(       [
+                [xOff, (yOff + height) * -1],
+                [xOff + width , yOff * -1],
+              ]);
+              pointsPolygon.push(       [
+                [xOff, yOff * -1],
+                [xOff + width, (yOff + height) * -1],
+              ]);
+              fill = 'white';
+            } else if (organisationRole.name === 'Gemischte Station') {
+              pointsPolygon.push(       [
+                [xOff, (yOff + height) * -1],
+                [xOff + width , yOff * -1],
+              ]);
+              pointsPolygon.push(       [
+                [xOff, yOff * -1],
+                [xOff + width/2, (yOff + height/2) * -1],
+              ]);
+              fill = 'white';
+            }
+          }
+          // Kompaktstationen, Muffen, Schaltschrank
+        }
+        if(stationsTyp === 'Muffe') {
+          geoJSON['geometry'] = {
+            type: 'Point',
+            coordinates: [x, -y], // Y Umkehren
+          }
+        } else {
+          geoJSON['geometry'] = {
+            type: 'Polygon',
+            coordinates: pointsPolygon
+          }
+        }
+
+
+        geoJSON['properties'] = {
+          diagramObjectUUID: diagramObject.mrid,
+          objectType: this.constructor.name,
+          width: width,
+          height: height,
+          offsetX: offsetX,
+          offsetY: offsetY,
+          fill: fill,
+          radius: 1.5
+        }
+      }
+    }
+    return geoJSON;
+  }
+
+  public deleteAsset(facility: IFacility): string {
+    const asset = facility as WNFacility;
+    if(this.assets.has(asset.mrid)) {
+      this.assets.delete(asset.mrid);
+      return this.getAssociationSparqlTriple(this.baseIRI, this.mrid, 'westnetzneplan', 'WNConnectivityNode', 'Assets',  asset.mrid);
+    } else {
+      console.log(`WNConnectivityNode ${this.mrid} delete: WNFacility ${asset.mrid} does not exists.`);
+    }
+    return '';
+  }
+
+  public addAsset(facility: IFacility): string {
+    const asset = facility as WNFacility;
+    if(!this.assets.has(asset.mrid)) {
+      this.assets.set(asset.mrid, asset);
+      return this.getAssociationSparqlTriple(this.baseIRI, this.mrid, 'westnetzneplan', 'WNConnectivityNode', 'Assets',  asset.mrid);
+    } else {
+      console.log(`WNConnectivityNode ${this.mrid} add: WNFacility ${asset.mrid} already exists.`);
+    }
+    return '';
+  }
+
+
+  public addAdditionalConnectivityNodeContainer(eqConatiner: IEquipmentContainer): string {
+    this.additionalConnectivityNodeContainer = eqConatiner as WNFeeder;
+    return this.getAssociationSparqlTriple(this.baseIRI, this.mrid, 'westnetzneplan', 'WNConnectivityNode', 'AdditionalConnectivityNodeContainer', eqConatiner.mrid);
+  }
+
+  public static resolveClassFusekiJSON(data: any, cimModel: Model){
+    data?.results?.bindings?.forEach((value: any) => {
+      const newClass = new WNConnectivityNode();
+      newClass.resolveAttributesFusekiJSON(value);
+      cimModel.addConnectivityNode(newClass);
+    });
+  }
+
+  public resolveAttributesFusekiJSON(value: any){
+    super.resolveAttributesFusekiJSON(value);
+    this.switchable = toBoolean(getValue(value, 'switchable'));
+    this.additionalConnectivityNodeContainerUUID = getValue(value, 'additionalConnectivityNodeContainerUUID');
+  }
+  public resolveParsedAssociations(cimModel: Model){
+    super.resolveParsedAssociations(cimModel);
+    if (cimModel.objects.has(this.additionalConnectivityNodeContainerUUID)) {
+      this.additionalConnectivityNodeContainer = cimModel.getObject(this.additionalConnectivityNodeContainerUUID) as WNFeeder;
+      this.additionalConnectivityNodeContainer.addEnergizedConnectivityNode(this);
+    } else {
+      //console.log(this.constructor.name + ' ' + this.mrid + ' hat keinen Feeder ' + this.additionalConnectivityNodeContainerUUID);
+    }
+  }
+
+  public static getQuerySPARQL(graphURI: string): string {
+    if(graphURI.length > 0){
+      return WNConnectivityNode.sparqlQuery.replace('<http://default/>', graphURI);
+    }
+    return WNConnectivityNode.sparqlQuery;
+  }
+
+  private getType(): string {
+    for (const asset of this.assets.values()) {
+      return asset.type;
+    }
+    return undefined;
+  }
+
+  public static sparqlQuery: string = `
+        PREFIX cim:	 		            <http://iec.ch/TC57/2013/CIM-schema-cim16#> 
+        PREFIX enervance:           <http://enervance.com/CIM/Extensions#> 
+        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/Extensions#> 
+        PREFIX apf:	 		            <http://jena.hpl.hp.com/ARQ/property#>
+        PREFIX afn:	 		            <http://jena.apache.org/ARQ/function#>
+        
+        SELECT  (STRAFTER(str(?MRID), '#_') AS ?uuid)  
+                (CONCAT(STRBEFORE(str(?MRID), '#_'), '#_') AS ?baseIRI) 
+                ?name ?shortName ?description ?switchable
+                (STRAFTER(str(?cncUUID), '#_') AS ?connectivityNodeContainerUUID)
+                (STRAFTER(str(?acncUUID), '#_') AS ?additionalConnectivityNodeContainerUUID)
+        
+        WHERE { 
+            GRAPH <http://default/>{
+                ?MRID rdf:type cim:ConnectivityNode .
+                OPTIONAL {?MRID cim:IdentifiedObject.name ?name .}
+                OPTIONAL {?MRID entsoe:IdentifiedObject.shortName ?shortName .}
+                OPTIONAL {?MRID cim:IdentifiedObject.description ?description .}
+                OPTIONAL {?MRID westnetzneplan:WNConnectivityNode.switchable ?switchable .}
+                OPTIONAL {?MRID cim:ConnectivityNode.ConnectivityNodeContainer ?cncUUID .}
+                OPTIONAL {?MRID westnetzneplan:WNConnectivityNode.AdditionalConnectivityNodeContainer ?acncUUID .}
+            }
+        }
+    `;
+
+
+}

package/src/model/extensions/neplan-westnetz/core/WNFeeder.ts

@@ -0,0 +1,115 @@
+import { Feeder } from '../../../core/Feeder';
+import { WNConnectivityNode } from './WNConnectivityNode';
+import { Model } from '../../../model/Model';
+import { getValue } from '../../../../util/utils';
+
+/** Wenstnezu Neplan Erweiterung */
+export class WNFeeder extends Feeder {
+
+  number: string;
+  /** ConnectivityNodes that are normally energized by the feeder. */
+  normalEnergizedConnectivityNodes: Map<string, WNConnectivityNode>;
+
+  constructor(uuid?: string, name?: string, shortName?: string, description?: string, baseIRI?: string){
+    super(uuid, name, shortName, description);
+    this.baseIRI = baseIRI;
+    this.normalEnergizedConnectivityNodes = new Map();
+  }
+
+  public addEnergizedConnectivityNode(connectivityNode: WNConnectivityNode) {
+    this.normalEnergizedConnectivityNodes.set(connectivityNode.getUUID(), connectivityNode);
+  }
+
+  setNumber(number: string) {
+    this.number = number;
+    return this.getPropertySparqlTriple(this.baseIRI, this.mrid, 'westnetzneplan', 'WNFeeder', 'number', this.number);
+  }
+
+  /** ------------------ JSON------------------------*/
+
+  public toJSON(){
+    super.toJSON();
+    this.toJSONAttributes();
+    this.toJSONAssociations();
+    return this.json;
+  }
+
+  public toJSONAttributes(){
+    super.toJSONAttributes();
+    this.json['number'] = this.number;
+  }
+
+  public toJSONAssociations(){
+    super.toJSONAssociations();
+    this.json['normalEnergizedConnectivityNodes'] = [...this.normalEnergizedConnectivityNodes.keys()];
+  }
+
+  /** ------------------ Fuseki Parser ------------------------*/
+  /** Parst und initialisiert das Objekt aus Fuseki JSON Daten  */
+  public static resolveClassFusekiJSON(data: any, cimModel: Model){
+    data?.results?.bindings?.forEach((value: any) => {
+      const newClass = new WNFeeder();
+      newClass.resolveAttributesFusekiJSON(value);
+      cimModel.addFeeder(newClass);
+    });
+  }
+
+  /** Parst die Attributs- und Assoziationsinformationen aus Fuseki JSON Daten */
+  protected resolveAttributesFusekiJSON(value: any){
+    super.resolveAttributesFusekiJSON(value);
+    this.number = getValue(value, 'number');
+
+  }
+
+  /** Initialisiert Assoziationen aus geparsten Daten
+   *  Fuseki und XML Daten */
+  public resolveParsedAssociations(cimModel: Model){
+    super.resolveParsedAssociations(cimModel);
+  }
+
+  public static getQuerySPARQL(graphURI: string): string{
+    if(graphURI.length > 0){
+      return WNFeeder.sparqlQuery.replace('<http://default/>', graphURI);
+    }
+    return WNFeeder.sparqlQuery;
+  }
+
+
+
+  public createNewStatementSPARQL(): string {
+    return `
+            <${this.baseIRI}${this.mrid}>
+            a   cim:Feeder ;
+                cim:IdentifiedObject.name '${this.name}' ;
+                entsoe:IdentifiedObject.shortName '${this.number}' .
+        `;
+  }
+  public static sparqlQuery : string = `
+        PREFIX cim:	 		<http://iec.ch/TC57/2013/CIM-schema-cim16#> 
+        PREFIX enervance:	<http://enervance.com/CIM/Extensions#> 
+        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 apf:	 		<http://jena.hpl.hp.com/ARQ/property#>
+        PREFIX afn:	 		<http://jena.apache.org/ARQ/function#>
+        
+        SELECT  (strafter(strafter(str(?fUUID), "#"), "_") AS ?uuid) 
+        (CONCAT(STRBEFORE(str(?fUUID), '#_'), '#_') AS ?baseIRI) 
+        ?name ?shortName ?description ?number 
+        (STRAFTER(str(?negsUUID), '#_') AS ?normalEnergizingSubstationUUID) 
+        (group_concat(STRAFTER(str(?nedsUUIDs), '#_');separator=',') as ?energizedSubstationUUIDs)
+        WHERE { 
+            GRAPH <http://default/>{
+            
+                ?fUUID rdf:type cim:Feeder .
+                OPTIONAL{?fUUID cim:IdentifiedObject.name ?name .}
+                OPTIONAL{?fUUID entsoe:IdentifiedObject.shortName ?shortName .}
+                OPTIONAL{?fUUID cim:IdentifiedObject.description ?description .}
+                OPTIONAL{?fUUID westnetzneplan:WNFeeder.number ?number .}
+                OPTIONAL{?fUUID cim:Feeder.NormalEnergizingSubstation ?negsUUID .}
+                OPTIONAL{?fUUID cim:Feeder.NormalEnergizedSubstation ?nedsUUIDs . }
+            }
+        }
+        GROUP BY ?fUUID ?baseIRI ?name ?shortName ?description ?number  ?negsUUID
+    `
+}

package/src/model/extensions/neplan-westnetz/faults/WNFaultConnectivityNode.ts

@@ -0,0 +1,113 @@
+import { Fault } from '../../../faults/Fault';
+import { WNConnectivityNode } from '../core/WNConnectivityNode';
+import { Model } from '../../../model/Model';
+import { toBoolean } from '../../../../util/datatype-converter';
+import { getValue } from '../../../../util/utils';
+import { WNFeeder } from '../core/WNFeeder';
+import { IIdentifiedObject } from '../../../../interfaces/model/core/IIdentifiedObject';
+
+export class WNFaultConnectivityNode extends Fault {
+
+  connectivityNode: WNConnectivityNode;
+  connectivityNodeUUID: string;
+
+  constructor(mrid?: string, name?: string, shortName?: string, description?: string, baseIRI?: string){
+    super(mrid, name, shortName, description);
+    this.baseIRI = baseIRI;
+  }
+
+
+  getFaultEquipment(): IIdentifiedObject {
+    return this.connectivityNode;
+  }
+
+  /** ------------------ JSON------------------------*/
+  public toJSON(){
+    super.toJSON();
+    this.toJSONAttributes();
+    this.toJSONAssociations();
+    return this.json;
+  }
+
+  public toJSONAttributes(){
+    super.toJSONAttributes();
+  }
+
+  public toJSONAssociations(){
+    super.toJSONAssociations();
+    this.json['connectivityNodeUUID'] = this.connectivityNodeUUID;
+
+  }
+
+  /** ------------------ Fuseki Parser ------------------------*/
+  public static resolveClassFusekiJSON(data: any, cimModel: Model){
+    data?.results?.bindings?.forEach((value: any) => {
+      const newClass = new WNFaultConnectivityNode();
+      newClass.resolveAttributesFusekiJSON(value);
+      cimModel.addCustomFault(newClass);
+    });
+  }
+
+  public resolveAttributesFusekiJSON(value: any){
+    super.resolveAttributesFusekiJSON(value);
+    this.connectivityNodeUUID = getValue(value, 'connectivityNodeUUID');
+    this.outageUUID = getValue(value, 'outageUUID');
+  }
+
+  public resolveParsedAssociations(cimModel: Model){
+    super.resolveParsedAssociations(cimModel);
+    if (cimModel.connectivityNodes.has(this.connectivityNodeUUID)) {
+      this.connectivityNode = cimModel.getConnectivityNode(this.connectivityNodeUUID) as WNConnectivityNode;
+      this.connectivityNode.fault = this;
+    } else {
+      //console.log(this.constructor.name + ' ' + this.mrid + ' hat keinen Feeder ' + this.additionalConnectivityNodeContainerUUID);
+    }
+  }
+  public static getQuerySPARQL(graphURI: string): string {
+    if(graphURI.length > 0){
+      return WNFaultConnectivityNode.sparqlQuery.replace('<http://default/>', graphURI);
+    }
+    return WNFaultConnectivityNode.sparqlQuery;
+  }
+
+  public static sparqlQuery: string = `
+        PREFIX cim:	 		            <http://iec.ch/TC57/2013/CIM-schema-cim16#> 
+        PREFIX enervance:           <http://enervance.com/CIM/Extensions#> 
+        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 apf:	 		<http://jena.hpl.hp.com/ARQ/property#>
+        PREFIX afn:	 		<http://jena.apache.org/ARQ/function#>
+        
+        SELECT  (STRAFTER(str(?MRID), '#_') AS ?uuid)  
+                (CONCAT(STRBEFORE(str(?MRID), '#_'), '#_') AS ?baseIRI) 
+                ?name ?shortName ?description ?switchable
+                (STRAFTER(str(?cnUUID), '#_') AS ?connectivityNodeUUID)
+                (STRAFTER(str(?oUUID), '#_') AS ?outageUUID)
+        
+        WHERE { 
+            GRAPH <http://default/>{
+                ?MRID rdf:type cim:Fault .
+                OPTIONAL {?MRID cim:IdentifiedObject.name ?name .}
+                OPTIONAL {?MRID entsoe:IdentifiedObject.shortName ?shortName .}
+                OPTIONAL {?MRID cim:IdentifiedObject.description ?description .}
+                OPTIONAL {?MRID westnetzneplan:WNFaultConnectivityNode.ConnectivityNode ?cnUUID .}
+                OPTIONAL {?MRID cim:Fault.Outage ?oUUID .}
+            }
+        }
+    `;
+
+  setConnectivityNode(cn: WNConnectivityNode): string {
+    this.connectivityNode = cn;
+    cn.fault = this;
+    return this.getAssociationSparqlTriple(this.baseIRI, this.mrid, 'westnetzneplan', 'WNFaultConnectivityNode', 'ConnectivityNode', cn.mrid);
+  }
+
+  public createNewStatementSPARQL(): string {
+    return `
+            <${this.baseIRI}${this.mrid}>
+            a   cim:Fault ;
+                cim:IdentifiedObject.name "CNFault" .
+        `;
+  }
+}

package/src/model/extensions/neplan-westnetz/operations/WNOutage.ts

@@ -0,0 +1,111 @@
+import { Outage } from '../../../operations/Outage';
+import { WNConnectivityNode } from '../core/WNConnectivityNode';
+import { getValue, parseCsvLineIntoArray } from '../../../../util/utils';
+import { Model } from '../../../model/Model';
+
+export class WNOutage extends Outage {
+
+
+  /** Von einem N-1 Fall betroffene ConnectivityNodes  */
+  outageIsolationConnectivityNodes: Map<string, WNConnectivityNode>;
+  outageIsolationConnectivityNodesUUIDs: string[];
+
+  constructor(mrid?: string, name?: string, shortName?: string, description?: string, baseIRI?: string) {
+    super(mrid, name, shortName, description);
+    this.outageIsolationConnectivityNodes = new Map();
+    this.baseIRI = baseIRI;
+  }
+
+  addOutageIsolationConnectivityNodes(cn: WNConnectivityNode): string {
+    if (!this.outageIsolationConnectivityNodes.has(cn.mrid)) {
+      this.outageIsolationConnectivityNodes.set(cn.mrid, cn);
+      cn.addOutage(this);
+      return this.getAssociationSparqlTriple(this.baseIRI, this.mrid, 'westnetzneplan', 'WNOutage', 'OutageIsolationConnectivityNodes', cn.mrid);
+    } else {
+      console.log(`Outage ${this.mrid} add: OutageIsolationEquipment ${cn.mrid} already exists.`);
+    }
+    return '';
+  }
+
+  /** ------------------ JSON------------------------*/
+  public toJSON(){
+    super.toJSON();
+    this.toJSONAttributes();
+    this.toJSONAssociations();
+    return this.json;
+  }
+
+  public toJSONAttributes(){
+    super.toJSONAttributes();
+  }
+
+  public toJSONAssociations(){
+    super.toJSONAssociations();
+  }
+
+  /** ------------------ Fuseki Parser ------------------------*/
+  public static resolveClassFusekiJSON(data: any, cimModel: Model){
+    data?.results?.bindings?.forEach((value: any) => {
+      const newClass = new WNOutage();
+      newClass.resolveAttributesFusekiJSON(value);
+      cimModel.addOutage(newClass);
+    });
+  }
+
+  protected resolveAttributesFusekiJSON(value: any) {
+    super.resolveAttributesFusekiJSON(value);
+    this.outageIsolationConnectivityNodesUUIDs = parseCsvLineIntoArray(getValue(value, 'outageIsolationConnectivityNodes'), ',');
+  }
+
+  public resolveParsedAssociations(cimModel: Model) {
+    super.resolveParsedAssociations(cimModel);
+    /** connectivityModes parsen */
+    for (const cnUUID of this.outageIsolationConnectivityNodesUUIDs) {
+      const cn = cimModel.getObject(cnUUID);
+      if (cn && cn instanceof WNConnectivityNode) {
+        this.outageIsolationConnectivityNodes.set(cn.mrid, cn);
+        cn.outages.set(this.mrid, this);
+      }
+    }
+    this.outageIsolationConnectivityNodesUUIDs.length = 0;
+  }
+
+  public static getQuerySPARQL(graphURI: string): string {
+    if(graphURI.length > 0){
+      return WNOutage.sparqlQuery.replace('<http://default/>', graphURI);
+    }
+    return WNOutage.sparqlQuery;
+  }
+  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 apf:	 		    <http://jena.hpl.hp.com/ARQ/property#>
+        PREFIX afn:	 		    <http://jena.apache.org/ARQ/function#>
+    
+        SELECT  (STRAFTER(str(?MRID), '#_') AS ?uuid)
+                (CONCAT(STRBEFORE(str(?MRID), '#_'), '#_') AS ?baseIRI) 
+                ?name
+                (group_concat(STRAFTER(str(?oieUUIDs), '#_');separator=',') as ?outageIsolationEquipments)
+                (group_concat(STRAFTER(str(?oicnUUIDs), '#_');separator=',') as ?outageIsolationConnectivityNodes)
+    
+        WHERE {
+            GRAPH <http://default/>{
+                ?MRID rdf:type cim:Outage .
+                OPTIONAL {?MRID cim:IdentifiedObject.name ?name .}
+                OPTIONAL {?MRID cim:Outage.OutageIsolationEquipment ?oieUUIDs .}
+                OPTIONAL {?MRID westnetzneplan:WNOutage.OutageIsolationConnectivityNodes ?oicnUUIDs .}
+            }
+        }
+        GROUP BY ?MRID ?baseIRI ?name `;
+
+  public createNewStatementSPARQL(): string {
+
+    return `
+            <${this.baseIRI}${this.mrid}>
+            a   cim:Outage ;
+                cim:IdentifiedObject.name "WNOutage" .
+        `;
+  }
+}