@enervance/insight-cim-model 0.0.1 → 0.0.2

package/src/model/wires/SeriesCompensator.ts

@@ -1,12 +1,59 @@
 import { ConductingEquipment } from "../core/ConductingEquipment";
+import { Model } from '../model/Model';
+import { getValue, writeElement, writeElementAttribute } from '../../util/utils';
+import { toBoolean } from '../../util/datatype-converter';
+import { RDF_XML } from '../../constants/rdf-xml';
+import XMLWriter from 'xml-writer';
 
-export class SeriesCompensator extends ConductingEquipment{
+export class SeriesCompensator extends ConductingEquipment {
 
-    constructor(uuid: string, name: string, shortName : string, description : string){
-        super(uuid, name, shortName, description);
+  r: number; // Pflichtattr
+  x: number; // Pflichtattr
+  r0: number; // Pflichtattr
+  x0: number; // Pflichtattr
+
+  varistorPresent: boolean;
+  varistorRatedCurrent: number; // CurrentFlow Pflichtattr
+  varistorVoltageThreshold: number; // Voltage Pflichtattr
+
+  constructor(uuid?: string, name?: string, shortName?: string, description?: string) {
+    super(uuid, name, shortName, description);
+  }
+
+
+  public static resolveClassFusekiJSON(data: any, cimModel: Model){
+    data.results.bindings.forEach((value: any) => {
+      const seriesCompensator = new SeriesCompensator();
+      seriesCompensator.resolveAttributesFusekiJSON(value);
+      cimModel.addSeriesCompensator(seriesCompensator);
+    });
+  }
+
+  protected resolveAttributesFusekiJSON(value: any){
+    super.resolveAttributesFusekiJSON(value);
+    this.r = +getValue(value, 'r');
+    this.x = +getValue(value, 'x');
+    this.r0 = +getValue(value, 'r0');
+    this.x0 = +getValue(value, 'x0');
+
+    this.varistorPresent = toBoolean(getValue(value, 'varistorPresent'));
+    this.varistorRatedCurrent = +getValue(value, 'varistorRatedCurrent');
+    this.varistorVoltageThreshold = +getValue(value, 'varistorVoltageThreshold');
+
+  }
+
+  public resolveParsedAssociations(cimModel: Model){
+    super.resolveParsedAssociations(cimModel);
+  }
+
+  public static getQuerySPARQL(graphURI: string): string {
+    if (graphURI.length > 0) {
+      return SeriesCompensator.sparqlQuery.replace('<http://default/>', graphURI);
     }
+    return SeriesCompensator.sparqlQuery;
+  }
 
-    public static sparqlQuery : string = `
+  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#> 
@@ -15,26 +62,105 @@ export class SeriesCompensator extends ConductingEquipment{
         PREFIX apf:	 		<http://jena.hpl.hp.com/ARQ/property#>
         PREFIX afn:	 		<http://jena.apache.org/ARQ/function#>
         
-        SELECT  (strafter(strafter(str(?vlUUID), "#"), "_") AS ?uuid) ?name
-        
+        SELECT  (strafter(strafter(str(?MRID), "#"), "_") AS ?uuid) 
+        ?name shortName description r x r0 x0 varistorPresent varistorRatedCurrent varistorVoltageThreshold
+        (strafter(strafter(str(?bvUUID), '#'), '_') AS ?baseVoltageUUID) 
+        (strafter(strafter(str(?ptUUID), '#'), '_') AS ?psrTypeUUID) 
+        (strafter(strafter(str(?ecUUID), '#'), '_') AS ?equipmentContainerUUID)
         WHERE { 
             GRAPH <http://default/>{
-                ?vlUUID rdf:type cim:SeriesCompensator .
-                ?vlUUID cim:IdentifiedObject.name ?name .
+                ?MRID rdf:type cim:SeriesCompensator .
+                OPTIONAL{?MRID cim:IdentifiedObject.name ?name .}
+                OPTIONAL{?MRID entsoe:IdentifiedObject.shortName ?shortName .}
+                OPTIONAL{?MRID cim:IdentifiedObject.description ?description .}
+                OPTIONAL{?MRID cim:Equipment.aggregate ?aggregate .}
+                OPTIONAL{?MRID cim:SeriesCompensator.r ?r .}
+                OPTIONAL{?MRID cim:SeriesCompensator.x ?x .}
+                OPTIONAL{?MRID cim:SeriesCompensator.r0 ?r0 .}
+                OPTIONAL{?MRID cim:SeriesCompensator.x0 ?x0 .}
+                
+                OPTIONAL{?MRID cim:SeriesCompensator.varistorPresent ?varistorPresent .}
+                OPTIONAL{?MRID cim:SeriesCompensator.varistorRatedCurrent ?varistorRatedCurrent
+                OPTIONAL{?MRID cim:SeriesCompensator.varistorVoltageThreshold ?varistorVoltageThreshold .}
+                
+                OPTIONAL{?MRID cim:PowerSystemResource.PSRType ?ptUUID .}
+                OPTIONAL{?MRID cim:ConductingEquipment.BaseVoltage ?bvUUID .}
+                OPTIONAL{?MRID cim:Equipment.EquipmentContainer ?ecUUID .}
             }
         }
-    ` 
-    public static getQuerySPARQL(graphURI : string) : string{
-        if(graphURI.length > 0){
-            return SeriesCompensator.sparqlQuery.replace("<http://default/>", graphURI);
-        }
-        return SeriesCompensator.sparqlQuery;
+    `
+
+  public breadthFirstSearch(networkElements: any[]) {
+    if (!this.visited) {
+      this.addNetworkElement(networkElements);
+      super.breadthFirstSearch(networkElements);
     }
+  }
 
-    public breadthFirstSearch(networkElements: any[]){
-        if(!this.visited){
-            this.addNetworkElement(networkElements);
-            super.breadthFirstSearch(networkElements);
-        }
+  /** CIM RDF/XML Serialisierung */
+  public toCIMXML(xmlWriter: XMLWriter, profile: string) {
+    let defaultValues = '';
+    this.checkMandatoryAttributes(profile, defaultValues);
+    this.description += defaultValues;
+    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) {
+      writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:SeriesCompensator.r`, this.r);
+      writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:SeriesCompensator.x`, this.x);
+      writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:SeriesCompensator.r0`, this.r0);
+      writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:SeriesCompensator.x0`, this.x0);
+      writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:SeriesCompensator.varistorPresent`, this.varistorPresent);
+      writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:SeriesCompensator.varistorRatedCurrent`, this.varistorRatedCurrent);
+      writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:SeriesCompensator.varistorVoltageThreshold`, this.varistorVoltageThreshold);
+    }
+  }
+
+  protected toCIMXMLAssociations(xmlWriter: XMLWriter, profile: string) {
+    super.toCIMXMLAssociations(xmlWriter, profile);
+  }
+
+  checkMandatoryAttributes(profile: string, defaultValues: string) {
+    super.checkMandatoryAttributes(profile, defaultValues);
+    if (profile === RDF_XML.PROFILE_EQ) {
+      if (!this.r) {
+        this.r = 0;
+        defaultValues += 'r,'
+      }
+      if (!this.x) {
+        this.x = 0.1;
+        defaultValues += 'x,'
+      }
+      if (!this.r0) {
+        this.r0 = 0;
+        defaultValues += 'r0,'
+      }
+      if (!this.x0) {
+        this.x0 = 0.1;
+        defaultValues += 'x0,'
+      }
+      if (!this.varistorPresent) {
+        this.varistorPresent = false;
+        defaultValues += 'varistorPresent,'
+      }
+      if (!this.varistorRatedCurrent) {
+        this.varistorRatedCurrent = 100;
+        defaultValues += 'varistorRatedCurrent,'
+      }
+      if (!this.varistorVoltageThreshold) {
+        this.varistorVoltageThreshold = 0;
+        defaultValues += 'varistorVoltageThreshold,'
+      }
     }
+  }
 }

package/src/util/util-create.ts

@@ -10,6 +10,8 @@ import {
 
 } from '..';
 import { getUUID } from './utils';
+import { convertValue } from './datatype-converter';
+
 
 export function createGeoregion(uuid: string, name: string, shortName: string, description: string, cimModel: Model): GeographicalRegion {
   const region = new GeographicalRegion(getUUID(uuid), name, shortName, description);

package/src/util/util-topology.ts

@@ -8,6 +8,7 @@ import { ExternalNetworkInjection } from '../model/wires/ExternalNetworkInjectio
 import { ACLineSegment } from '../model/wires/ACLineSegment';
 import { PowerTransformer } from '../model/wires/PowerTransformer';
 import { Switch } from '../model/wires/Switch';
+import { isInArray } from './utils';
 
 
 /** bestimmt alle elektrisch zusammenhängende Knoten/Nodes in eimen Teilnetz.
@@ -48,7 +49,7 @@ export function determineNetworksSlackElements(cimModel: Model, networks: IIdent
 
   for (let i = 0; i < networks.length; i++) {
     const network: IIdentifiedObject[] = networks[i];
-    const networkSlackElemenets: IIdentifiedObject[][] = determineNetworkSlackElements(cimModel, network);
+    const networkSlackElemenets: IIdentifiedObject[][] = determineNetworkSlackElements(cimModel, network, 'ExternalNetworkInjection');
     for(const arraySlackElem of networkSlackElemenets) {
       networksSlackElements.push(arraySlackElem);
     }
@@ -58,13 +59,13 @@ export function determineNetworksSlackElements(cimModel: Model, networks: IIdent
 }
 
 /**  Es werden Netzelemente bestimmt, die im übergebenen Netz mit dem Slack direkt verbunden sind. */
-export function determineNetworkSlackElements(cimModel: Model, network: IIdentifiedObject[]): IIdentifiedObject[][] {
+export function determineNetworkSlackElements(cimModel: Model, network: IIdentifiedObject[], startObjectName: string): IIdentifiedObject[][] {
 
   const networkSlackElemenets: IIdentifiedObject[][] = [];
   for (let i = 0; i < network.length; i++) {
     const networkElement = network[i];
     // Slack-Element bestimmen
-    if (networkElement.constructor.name === 'ExternalNetworkInjection') {
+    if (networkElement.constructor.name === startObjectName) {
       if(!networkElement.visited) {
         const slackElemenets: IIdentifiedObject[] = [];
         networkElement.determineSlackNodes(slackElemenets);
@@ -77,7 +78,7 @@ export function determineNetworkSlackElements(cimModel: Model, network: IIdentif
 }
 
 /** Kruecke für NEPLAN-Netze. Bestimme Umspannstationen, die als Anlagen modelliert sind. */
-export function determineSubstations(cimModel: Model): IIdentifiedObject[] {
+export function determineSubstations(cimModel: Model, computableGridsSlackElements: IIdentifiedObject[][]): IIdentifiedObject[] {
   const substationElements: IIdentifiedObject[] = [];
 
   for (const vl of cimModel.voltageLevels.values()) {
@@ -90,13 +91,23 @@ export function determineSubstations(cimModel: Model): IIdentifiedObject[] {
       }
     }
     if(counter > 9) {
-      substationElements.push(...vl.equipments);
-      substationElements.push(...vl.connectivityNodes.values());
+      /** In Neplan Netzen umfasst ein VoltageLevel alle elektrisch verbundene Elemente.
+       * Dieses Vorgehen bestimmt alle Elemente, die zur gegebenen Spannung gehören => eine Anlage */
+
+      const networkSlackElemenets: IIdentifiedObject[][] = determineNetworkSlackElements(cimModel, vl.equipments, 'BusbarSection');
+      for(const arraySlackNetz of networkSlackElemenets) {
+        for (const arraySlackElem of arraySlackNetz) {
+          if(!isInArray(arraySlackElem, computableGridsSlackElements)) {
+            substationElements.push(arraySlackElem);
+          }
+        }
+      }
     }
   }
-
+  resetMapCIM(cimModel.objects);
   return substationElements;
 }
+
 //Prüft, ob das Netz rechenfähig ist.
 export function isComputable(network: IIdentifiedObject[]): boolean{
   if(isGeneratorsExists(network)){

package/test/apache-jena-fuseki-interface/{apache-jena-fuseki-neplan.tests.spec.ts → apache-jena-fuseki-neplan-1.tests.sp-ec.ts}

@@ -792,32 +792,6 @@ describe('Apache Jena Fuseki Interface Neplan Test', () => {
 
   });
 
-  /*  it('Apache Jena Fuseki Interface RegExTest', async(done) => {
-      cimModel.purgeData();
-
-      const regexTrafo = /-T\d*!/;
-      // exec return mathed string
-      const keyA = '05154032-S-K-ST-00442-VB';
-      const keyB = '05154032-S-K-ST-00442-T';
-      const keyC = '05154032-S-K-ST-00443-T1';
-      const keyD = '05154032-S-K-ST-00442-T2';
-      const keyE = '05154032-S-K-ST-00442-T3';
-
-      expect(regexTrafo.test(keyA)).toBeFalse();
-      expect(regexTrafo.test(keyB)).toBeTrue()
-      expect(regexTrafo.test(keyC)).toBeTrue();
-      expect(regexTrafo.test(keyD)).toBeTrue();
-      expect(regexTrafo.test(keyE)).toBeTrue();
-
-      //[ '-T', index: 21, input: '05154032-S-K-ST-00442-T', groups: undefined ]
-  /!*    expect(regexTrafo.exec(keyB)).toBe('-T')
-      expect(regexTrafo.exec(keyC)[0]).toBe('-T1')
-      expect(regexTrafo.exec(keyD)[0]).toBe('-T2')
-      expect(regexTrafo.exec(keyE)[0]).toBe('-T3')*!/
-
-      done();
-    });*/
-
   afterAll(async (done) => {
 
     await fetch(fusekiURI, {

package/test/apache-jena-fuseki-interface/apache-jena-fuseki-neplan-2.tests.spec.ts

@@ -0,0 +1,255 @@
+import * as fetch from 'node-fetch';
+import fs from "fs";
+
+import * as childProcess from 'child_process';
+import {
+  ACLineSegment,
+  addNeplanFacilities,
+  CIM_CLASS_NAMES,
+  EVTerminal,
+  EVTerminalAction,
+  FUSEKI_LOAD_CONFIG_NEPLAN, generateUUID, getActivityRecordEventByTypeName,
+  getClassDefinitionMap,
+  getEnergyConsumerByName,
+  getObjectByProperty,
+  IConnectivityNode,
+  Model, PROPERTY_HANDLER_WESTNETZNEPLAN_CONFIG,
+  SwitchActionKind,
+  SwitchingPlan,
+  transformEnergyConsumers,
+  WNConnectivityNode, WNFacility,
+  WNFaultConnectivityNode,
+  WNFeeder
+} from "../../src";
+import { loadFusekiData, parseFusekiData } from '../../src/etl-neplan/etl-neplan';
+import { postNodeFetchData } from '../../src/util/utils';
+import { createFeederLines } from '../../src/etl-neplan/etl-neplan-feederline';
+import { performContingencyAnalysis } from '../../src/etl-neplan/etl-neplan-contingency-analysis';
+import { WNOutage } from '../../src/model/extensions/neplan-westnetz/operations/WNOutage';
+import { WNEnergyConsumer } from '../../src/model/extensions/neplan-westnetz/wires/WNEnergyConsumer';
+import { determineSubstations } from '../../src/util/util-topology';
+import { performContingencyAnalysisV2 } from '../../src/etl-neplan/neplan-contingency-analysis';
+
+describe('Apache Jena Fuseki Interface Neplan Test', () => {
+  jasmine.DEFAULT_TIMEOUT_INTERVAL =  2147483633;
+  const FUSEKI_PORT = 3010;
+  const FUSEKI_TBD_NAME = 'test';
+
+  const fusekiURI = `http://127.0.0.1:${FUSEKI_PORT}/${FUSEKI_TBD_NAME}`;
+  const graphURL = 'http://test/data';
+  const graphURI = `<${graphURL}>`;
+
+  /** Endpunkt: Aktualisieren der Daten*/
+  const fusekiUpdateURI = `${fusekiURI}/update`;
+
+  /** Endpunkt: Abfrage der Daten*/
+  const fusekiQueryURI = `${fusekiURI}/query`;
+
+  /** Endpunkt: Datenimport */
+  const fusekiDataURI = `${fusekiURI}/data`;
+
+  /** Endpunkt: GraphURI-basierter Datenimport */
+  const fusekiGraphDataURI = `${fusekiURI}/data?graph=${graphURL}`;
+
+  let childRef;
+
+
+  const cimModel = new Model();
+
+  beforeAll((done) => {
+
+    childRef = childProcess.spawn('fuseki-server', [`--port=${FUSEKI_PORT}`, '--update'], {
+      cwd: process.cwd() + '\\test\\apache-jena-fuseki-interface\\data\\apache-jena-fuseki-3.12.0\\',
+      shell: true,
+      /*detached: true,*/
+    });
+    childRef.stdout.on('data', async (code) => {
+      /** auf die Ausgabe warten, wenn der Server gestartet ist */
+      const consolePrint = code.toString();
+      //console.log(consolePrint);
+      if (consolePrint.includes('Started') && consolePrint.includes('on port')) {
+        console.log('Fuseki started');
+
+        /** Mit RegEx Zahlen prüfen: nullen und Dezmaltrennzeichen abschneiden */
+        /** 0.081510 -> 0.08151, 0. -> 0, 10.00 -> 10*/
+        const regexDecimal = /(?:(\.\d*?[1-9]+)|\.)0*(?=<)/gm;
+        /** 0e+000 -> 0*/
+        const regexZeroScientific = /(>\d+(?=e[+-]0+))e[+-]0+/gm;
+
+
+        /** load testdata */
+        const eq = await fs.readFileSync('test/apache-jena-fuseki-interface/data/xml/finnentrop/Finnentrop_Rootnet_Area 1_EQ_V1.xml', 'utf8');
+        const dataDecimalEq = eq.replace(regexDecimal, `$1`);
+        const dataAdjustedEq = dataDecimalEq.replace(regexZeroScientific, `$1`);
+
+        const ssh = await fs.readFileSync('test/apache-jena-fuseki-interface/data/xml/finnentrop/Finnentrop_Rootnet_Area 1_SSH_V1.xml', 'utf8');
+        const dataDecimalSSH = ssh.replace(regexDecimal, `$1`);
+        const dataAdjustedSSH = dataDecimalSSH.replace(regexZeroScientific, `$1`);
+        /** feeder lines */
+        /** psrtypes */
+        const psrTypes = await fs.readFileSync('test/apache-jena-fuseki-interface/data/xml/PsrType.xml', 'utf8');
+
+        Promise.all([ postNodeFetchData(fusekiGraphDataURI, 'post', dataAdjustedEq, {'Content-type': 'application/rdf+xml;charset=utf-8'}),
+                            postNodeFetchData(fusekiGraphDataURI, 'post', dataAdjustedSSH, {'Content-type': 'application/rdf+xml;charset=utf-8'}),
+                            postNodeFetchData(fusekiGraphDataURI, 'post', psrTypes, {'Content-type': 'application/rdf+xml;charset=utf-8'})
+        ]).then((values: any[]) => {
+          done();
+        });
+      }
+    });
+  });
+
+  it('Apache Jena Fuseki Interface Neplan ETL add Feeder&SwitchActions', async (done) => {
+    cimModel.purgeData();
+    /** configure query data */
+    const neplanClassDefinitions = getClassDefinitionMap();
+
+    /** query data */
+    let cimFusekiDataRaw = await loadFusekiData(fusekiURI, graphURI, FUSEKI_LOAD_CONFIG_NEPLAN, neplanClassDefinitions);
+    /** parse queried data */
+    parseFusekiData(cimModel, cimFusekiDataRaw, FUSEKI_LOAD_CONFIG_NEPLAN, neplanClassDefinitions);
+    cimModel.resolveParsedAssociations();
+
+    const defaultSubstation = cimModel.getObjectByName('DefaultSubstation');
+    const baseIRI = defaultSubstation.baseIRI;
+
+    /** Objekte erzeugen */
+    const insertObjectSPARQL = createFeederLines(cimModel, baseIRI);
+
+    console.log('Feeders');
+    for (const feeder of cimModel.feeders.values()) {
+      const wnFeeder = feeder as WNFeeder;
+      console.log('\t' + wnFeeder.name);
+      for (const trm of wnFeeder.normalHeadTerminals.values()) {
+        console.log('\t\t' + trm.connectivityNode.name + ' - ' + wnFeeder.normalEnergizedConnectivityNodes.size);
+      }
+/*      for (const cn of wnFeeder.normalEnergizedConnectivityNodes.values()) {
+        console.log('\t\t' + cn.name);
+      }*/
+    }
+    const queryCreateFeedersSwitch = `
+                        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 westnetzneplan:  <http://westnetzneplan.de/CIM/Extensions#>
+                        PREFIX enervance:           <http://enervance.com/CIM/Extensions#> 
+                        INSERT DATA{
+                            GRAPH ${graphURI} {
+                                 ${insertObjectSPARQL.join(' ')}
+                            }
+                        }
+    `;
+
+    await postNodeFetchData(fusekiUpdateURI, 'post', queryCreateFeedersSwitch, {'Content-type': 'application/sparql-update'});
+
+    expect(defaultSubstation).toBeDefined();
+    expect(baseIRI).toBeDefined();
+
+    // SwitchActions
+    // const insertSPARQL = performContingencyAnalysis(cimModel);
+    const insertSPARQL = performContingencyAnalysisV2(cimModel);
+    const queryCreateSwitchActions = `
+                        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 westnetzneplan:  <http://westnetzneplan.de/CIM/Extensions#>
+                        PREFIX enervance:           <http://enervance.com/CIM/Extensions#> 
+                        INSERT DATA{
+                            GRAPH ${graphURI} {
+                                 ${insertSPARQL.join(' ')}
+                            }
+                        }
+    `;
+    await postNodeFetchData(fusekiUpdateURI, 'post', queryCreateSwitchActions, {'Content-type': 'application/sparql-update'});
+    cimModel.purgeData();
+
+    /** query data */
+    const cimFusekiDataRawNew = await loadFusekiData(fusekiURI, graphURI, FUSEKI_LOAD_CONFIG_NEPLAN, neplanClassDefinitions);
+    /** parse queried data */
+    parseFusekiData(cimModel, cimFusekiDataRawNew, FUSEKI_LOAD_CONFIG_NEPLAN, neplanClassDefinitions);
+    cimModel.resolveParsedAssociations();
+
+    expect(cimModel.feeders.size).toBe(10);
+
+    // Head Terminals
+    for (const feeder of cimModel.feeders.values()) {
+      /** Jeder Abgang hat mind. eine assozierte Head-Terminal Instanz */
+      expect(feeder.normalHeadTerminals.size).toBe(1);
+      /** NEPLAN Spezifisch: jeder Abgang hat im Esloh-Netz mind. einen versorgten ConnectivityNode */
+      expect((feeder as WNFeeder).normalEnergizedConnectivityNodes.size).toBeGreaterThan(0);
+
+      // contingency analysis result
+      for (const headTerminal of feeder.normalHeadTerminals.values()) {
+        /** Der Kopf-Knoten -> Schaltfeld-Ersatz */
+        const headCN = headTerminal.connectivityNode as WNConnectivityNode;
+        expect(headCN).toBeDefined();
+
+        /** Schaltfeld-Ersatz-> Ausfall-Simumation */
+        const faultCN = headCN.fault;
+        expect(faultCN).toBeDefined();
+
+        /** Netzausfall-Instanz */
+        const outage = faultCN.outage as WNOutage;
+        expect(outage).toBeDefined();
+
+        expect(outage.outageIsolationEquipment.size).toBeGreaterThan(0);
+        expect(outage.outageIsolationConnectivityNodes.size).toBeGreaterThan(0);
+
+        expect(outage.switchingPlans.size).toBeGreaterThan(0);
+      }
+    }
+
+/*    performContingencyAnalysis(cimModel);
+    //CN
+    const wnCN = getObjectByProperty(cimModel.connectivityNodes, 'name', '05958016-S-K-ST-00056') as WNConnectivityNode;
+    expect(wnCN).toBeDefined();
+    expect(wnCN.additionalConnectivityNodeContainer).toBeDefined()*/;
+
+    done();
+  });
+
+
+  afterAll(async (done) => {
+
+    await fetch(fusekiURI, {
+      method: 'post',
+      body: `DROP GRAPH ${graphURI}`,
+      headers: {'Content-type': 'application/sparql-update'},
+    });
+    console.log(`Graph ${graphURI} dropped`);
+    console.log('Fuseki childRef PID ' + childRef.pid);
+
+    const childRefPort = childProcess.spawn(`echo off & (for /f \"tokens=5\" %a in (\'netstat -aon ^| findstr ${FUSEKI_PORT}\') do tasklist /NH /FO \"csv\" /FI \"PID eq %a\") & echo on`, {
+      shell: true,
+    });
+    childRefPort.stdout.on('data', (code) => {
+      try {
+        const arrayData = code.toString().split(',');
+        const appName = arrayData[0];
+        const pid = arrayData[1];
+        if (appName.includes('java')) {
+          const cildRefKill = childProcess.exec(`taskkill /PID ${pid} /F`, (error, stdout, stderr) => {
+          });
+          cildRefKill.stdout.on('data', (code) => {
+            console.log('Kill Fuseki Server');
+            console.log(code.toString());
+          });
+        }
+      } catch (e) {
+      } finally {
+        //TODO
+      }
+      done();
+    });
+  });
+});
+
+
+/** Methode zum Schreiben der Daten in eine Datei */
+export function writeFile(filePath: string, data: any) {
+  fs.writeFile(filePath, JSON.stringify(data), function (err) {
+    if (err) {
+      console.log(err);
+    }
+  });
+}