@enervance/insight-cim-model 0.0.1

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

@@ -0,0 +1,864 @@
+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';
+
+describe('Apache Jena Fuseki Interface Neplan Test', () => {
+
+  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(async (done) => {
+    jasmine.DEFAULT_TIMEOUT_INTERVAL = 100000000;
+    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/neplan-eslohe/Eslohe_Rootnet_Area_1_EQ_V1.xml', 'utf8');
+        const dataDecimalEq = eq.replace(regexDecimal, `$1`);
+        const dataAdjustedEq = dataDecimalEq.replace(regexZeroScientific, `$1`);
+        await postNodeFetchData(fusekiGraphDataURI, 'post', dataAdjustedEq, {'Content-type': 'application/rdf+xml;charset=utf-8'});
+
+        const ssh = await fs.readFileSync('test/apache-jena-fuseki-interface/data/xml/neplan-eslohe/Eslohe_Rootnet_Area_1_SSH_V1.xml', 'utf8');
+        const dataDecimalSSH = ssh.replace(regexDecimal, `$1`);
+        const dataAdjustedSSH = dataDecimalSSH.replace(regexZeroScientific, `$1`);
+        await postNodeFetchData(fusekiGraphDataURI, 'post', dataAdjustedSSH, {'Content-type': 'application/rdf+xml;charset=utf-8'});
+
+        /** feeder lines */
+        /*        const eqExt = await fs.readFileSync('test/apache-jena-fuseki-interface/data/xml/neplan-eslohe/Eslohe_Rootnet_Area_1_EQ_V1_feeder_ext.xml', 'utf8');
+                await postNodeFetchData(fusekiGraphDataURI, 'post', eqExt, {'Content-type': 'application/rdf+xml;charset=utf-8'});*/
+        /** psrtypes */
+        const psrTypes = await fs.readFileSync('test/apache-jena-fuseki-interface/data/xml/PsrType.xml', 'utf8');
+        await postNodeFetchData(fusekiGraphDataURI, 'post', psrTypes, {'Content-type': 'application/rdf+xml;charset=utf-8'});
+
+        /** AssetOwner */
+        const ownershipData = await fs.readFileSync('test/apache-jena-fuseki-interface/data/xml/AssetOwner.xml', 'utf8');
+        await postNodeFetchData(fusekiGraphDataURI, 'post', ownershipData, {'Content-type': 'application/rdf+xml;charset=utf-8'});
+
+        /** S4/S6 Meldungen */
+        const assetHealthEvents = await fs.readFileSync('test/apache-jena-fuseki-interface/data/xml/AssetHealthEvent.xml', 'utf8');
+        await postNodeFetchData(fusekiGraphDataURI, 'post', assetHealthEvents, {'Content-type': 'application/rdf+xml;charset=utf-8'});
+
+        /** N-1, Outages, SwitchingPlans  */
+        const outageData = await fs.readFileSync('test/apache-jena-fuseki-interface/data/xml/Outages.xml', 'utf8');
+        await postNodeFetchData(fusekiGraphDataURI, 'post', outageData, {'Content-type': 'application/rdf+xml;charset=utf-8'});
+
+        done();
+      }
+    });
+  });
+
+  it('Apache Jena Fuseki Interface Neplan load and parse data test', async (done) => {
+    cimModel.purgeData();
+    /** configure query data */
+    const neplanClassDefinitions = getClassDefinitionMap();
+    const neplanLoadConfig = FUSEKI_LOAD_CONFIG_NEPLAN;
+
+    // const loadConfig = [CIM_CLASS_NAMES.WNFeeder, CIM_CLASS_NAMES.WNConnectivityNode, CIM_CLASS_NAMES.ACLineSegment];
+
+    /** query data */
+    const cimFusekiDataRaw = await Promise.all(neplanLoadConfig.map(async (className) => {
+
+      const sparqlQuery = neplanClassDefinitions.get(className).getQuerySPARQL(graphURI);
+      /*      console.log('className ' + className + ' ' + sparqlQuery);*/
+      const dataResponse = await fetch(`${fusekiURI}?query=${encodeURIComponent(sparqlQuery)}&format=json`);
+      return await dataResponse.json();
+    }));
+    /** parse queried data */
+
+    for (let i = 0; i < cimFusekiDataRaw.length; i++) {
+      const className = neplanLoadConfig[i];
+      const rawData = cimFusekiDataRaw[i];
+      // writeFile('C:\\Users\\seasmaie\\Desktop\\data\\powerGrid_name_' + className + '.txt', rawData);
+      /*  console.log('className ' + className);*/
+      neplanClassDefinitions.get(className).resolveClassFusekiJSON(rawData, cimModel);
+    }
+    /** die Assoziationen herstellen. */
+    cimModel.resolveParsedAssociations();
+
+    /*    expect(cimModel.feeders.size).toBe(1);
+        expect(cimModel.feeders.get('3b55fae2-02b8-4d3e-a009-35808d375a6c')).toBeDefined();*/
+
+    /*    const feeder = cimModel.feeders.get('3b55fae2-02b8-4d3e-a009-35808d375a6c') as WNFeeder;
+        expect(feeder.additionalConnectivityNodes.size).toBe(3);
+        expect(feeder.additionalGroupedEquipment.size).toBe(4);
+
+        const connectivityNode = cimModel.getConnectivityNode('136666a5-10df-42f8-ad7c-374a425b5680') as WNConnectivityNode;
+        expect(connectivityNode).toBeDefined();
+        expect(connectivityNode.switchable).toBeTrue();
+        expect(connectivityNode.additionalConnectivityNodeContainer.mrid).toBe('3b55fae2-02b8-4d3e-a009-35808d375a6c');*/
+
+    /** AssetHealthEvent */
+    const assetHealthEvent = cimModel.getAssetHealthEvent('0e2e9147-44cb-4714-9f11-e3a99aac1e62');
+    expect(assetHealthEvent).toBeDefined();
+
+    /** AsserOwner */
+    expect(cimModel.assetOwners.size).toBeGreaterThanOrEqual(3);
+
+    /** PSRType */
+    const psrType = cimModel.getPsrType('c159f529-3291-41e0-a55a-0d4365bae08c');
+    expect(psrType).toBeDefined();
+
+    /** N-1 */
+
+    /** CN Fault*/
+    expect(cimModel.customFaults.size).toBe(1);
+    const cnFault = cimModel.getCustomFault('7fdc56d5-ee93-497a-9d2b-7f595b3000b8') as WNFaultConnectivityNode;
+    expect(cnFault).toBeDefined();
+    expect(cnFault.connectivityNode).toBeDefined();
+    expect(cnFault.outage).toBeDefined();
+
+    /** Outage */
+    expect(cimModel.outages.size).toBe(1);
+    const wnOutage = cimModel.outages.get('dd343038-0ed0-4d78-9907-dd9f9d092652') as WNOutage;
+    expect(wnOutage).toBeDefined();
+    expect(wnOutage.outageIsolationEquipment.size).toBe(2);
+    expect(wnOutage.outageIsolationConnectivityNodes.size).toBe(1);
+
+    /** SwitchingPlan */
+    expect(cimModel.switchingPlans.size).toBe(3);
+    const switchingPlan1 = cimModel.switchingPlans.get('d48ee5cf-9a01-4413-9973-49fec584edce');
+    expect(switchingPlan1).toBeDefined();
+    expect(switchingPlan1.rank).toBe(-1);
+    expect(switchingPlan1.purpose).toBe('de-energise');
+    expect(switchingPlan1.outage).toBeDefined()
+
+    /** SwitchingActions */
+    expect(cimModel.switchingActions.size).toBe(3);
+    const switchingAction = cimModel.switchingActions.get('81d43de7-9298-4bfe-b81e-65f2933d8fbb') as EVTerminalAction;
+    expect(switchingAction).toBeDefined();
+
+    expect(switchingAction.kind).toBe(SwitchActionKind.open);
+    expect(switchingAction.switchingPlan).toBeDefined();
+    expect(switchingAction.terminals.size).toBe(1);
+
+
+    /** ETL */
+    const createFacilitySPARQL = [];
+    const addCnSPARQL = [];
+    for (const cn of cimModel.connectivityNodes.values()) {
+      const facility = new WNFacility(generateUUID(), 'Facility', '', '', cn.baseIRI);
+      createFacilitySPARQL.push(facility.createNewStatementSPARQL());
+      addCnSPARQL.push(facility.addConnectivityNode(cn));
+      break;
+    }
+
+    const queryCreate = `
+                          PREFIX rdf:             <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+                          PREFIX cim:             <http://iec.ch/TC57/2013/CIM-schema-cim16#>
+                          PREFIX westnetzneplan:  <http://westnetzneplan.de/CIM/Extensions#>
+                          INSERT DATA{
+                              GRAPH <${graphURI}> {
+                                   ${createFacilitySPARQL.join(' ')}
+                                   ${addCnSPARQL.join(' ')}
+                              }
+                          }
+      `;
+    await postNodeFetchData(fusekiUpdateURI, 'post', queryCreate, {'Content-type': 'application/sparql-update'});
+
+    done();
+  });
+  it('Apache Jena Fuseki Interface Neplan ETL add Facilities test', async (done) => {
+    cimModel.purgeData();
+    /** configure query data */
+    const neplanClassDefinitions = getClassDefinitionMap();
+
+    const loadConfig = [CIM_CLASS_NAMES.WNConnectivityNode];
+    /** query data */
+    const cimFusekiDataRaw = await loadFusekiData(fusekiURI, graphURI, loadConfig, neplanClassDefinitions);
+    /** parse queried data */
+    parseFusekiData(cimModel, cimFusekiDataRaw, loadConfig, neplanClassDefinitions);
+
+    /** ETL */
+    /** ----------------Facilities hinzufügen--------------------- */
+    const addFacilitiesSPARQL = addNeplanFacilities(cimModel, graphURI);
+    /** Facilities speichern */
+    await postNodeFetchData(fusekiUpdateURI, 'post', addFacilitiesSPARQL, {'Content-type': 'application/sparql-update'});
+
+    const sparqlQueryFacility = neplanClassDefinitions.get(CIM_CLASS_NAMES.WNFacility).getQuerySPARQL(graphURI);
+    const dataResponseFacility = await fetch(`${fusekiURI}?query=${encodeURIComponent(sparqlQueryFacility)}&format=json`);
+    const rawDataFacility = await dataResponseFacility.json();
+    neplanClassDefinitions.get(CIM_CLASS_NAMES.WNFacility).resolveClassFusekiJSON(rawDataFacility, cimModel);
+
+    const sparqlQueryImportanceScore = neplanClassDefinitions.get(CIM_CLASS_NAMES.EVImportanceScore).getQuerySPARQL(graphURI);
+    const dataResponseImportanceScore = await fetch(`${fusekiURI}?query=${encodeURIComponent(sparqlQueryImportanceScore)}&format=json`);
+    const rawDataImportanceScore = await dataResponseImportanceScore.json();
+    neplanClassDefinitions.get(CIM_CLASS_NAMES.EVImportanceScore).resolveClassFusekiJSON(rawDataImportanceScore, cimModel);
+
+    /** die Assoziationen herstellen. */
+    cimModel.resolveParsedAssociations();
+
+    /** Jeder ConnectivityNode soll mit je ein Instanz von WNFacility assoziiert sein. */
+    for (const icn of cimModel.connectivityNodes.values()) {
+      const cn = icn as WNConnectivityNode;
+      expect(cn.assets.size).toBe(1);
+    }
+    for (const ifa of cimModel.facilities.values()) {
+      const fa = ifa as WNFacility;
+      if (fa.connectivityNodes.size === 0) console.log('----------- ' + fa.name);
+      expect(fa.connectivityNodes.size).toBe(1);
+      expect(fa.getImportanceScore()).toBeDefined();
+      expect(fa.analyticScores.size).toBe(1);
+      // console.log('----------- getImportanceScore ' + fa.getImportanceScore().value);
+    }
+
+    done();
+  });
+  it('Apache Jena Fuseki Interface Neplan ETL consolidate EnergyConsumers test', async (done) => {
+    cimModel.purgeData();
+    /** configure query data */
+    const neplanClassDefinitions = getClassDefinitionMap();
+
+    const loadConfig = [CIM_CLASS_NAMES.WNEnergyConsumer, CIM_CLASS_NAMES.Terminal];
+    /** query data */
+    const cimFusekiDataRaw = await loadFusekiData(fusekiURI, graphURI, loadConfig, neplanClassDefinitions);
+    /** parse queried data */
+    parseFusekiData(cimModel, cimFusekiDataRaw, loadConfig, neplanClassDefinitions);
+    cimModel.resolveParsedAssociations();
+
+
+    /** ETL */
+    /** ----------------EnergyConsumers konsolidieren --------------------- */
+    const updateSPARQL = transformEnergyConsumers(cimModel, graphURI);
+    /** konsolodierte EnergyConsumer speichern */
+    await postNodeFetchData(fusekiUpdateURI, 'post', updateSPARQL, {'Content-type': 'application/sparql-update'});
+
+    cimModel.purgeData();
+
+    const loadConfigEC = [CIM_CLASS_NAMES.WNEnergyConsumer];
+    /** query data */
+    const cimFusekiDataRawEC = await loadFusekiData(fusekiURI, graphURI, loadConfigEC, neplanClassDefinitions);
+    /** parse queried data */
+    parseFusekiData(cimModel, cimFusekiDataRawEC, loadConfigEC, neplanClassDefinitions);
+
+    /** Tests */
+    /** V 1.2996/0.629425 */
+    /** M 0.533700/0.258482 */
+    const energyConsumer = getEnergyConsumerByName(cimModel, '05966020-S-K-ST-00024') as WNEnergyConsumer;
+    expect(energyConsumer).toBeDefined();
+
+    expect(energyConsumer.contractualP).toBe(1.2996);
+    expect(energyConsumer.contractualQ).toBe(0.629425);
+
+    expect(energyConsumer.measuredP).toBe(0.5337);
+    expect(energyConsumer.measuredQ).toBe(0.258482);
+
+    // Unterlagerte Lasten
+    const energyConsumerUnterlagert = getEnergyConsumerByName(cimModel, '05154032-S-K-ST-00223') as WNEnergyConsumer;
+    expect(energyConsumerUnterlagert).toBeDefined();
+
+    // Test: Umrechnung kVA in MVA
+    expect(energyConsumerUnterlagert.p).toBeCloseTo(0);
+    expect(energyConsumerUnterlagert.q).toBeCloseTo(0);
+
+    expect(energyConsumerUnterlagert.subContractualP).toBeCloseTo(0.28099);
+    expect(energyConsumerUnterlagert.subContractualQ).toBeCloseTo(0.13609, 3);
+
+    expect(energyConsumerUnterlagert.subMeasuredP).toBeCloseTo(0.28099);
+    expect(energyConsumerUnterlagert.subMeasuredQ).toBeCloseTo(0.13609, 3);
+
+    expect(energyConsumerUnterlagert.contractualP).toBe(0);
+    expect(energyConsumerUnterlagert.contractualQ).toBe(0);
+
+    expect(energyConsumerUnterlagert.measuredP).toBe(0.001);
+    expect(energyConsumerUnterlagert.measuredQ).toBe(0);
+
+    // energyConsumerUnterlagert.cosPhi.toFixed(3)
+    done();
+
+  });
+/*  it('Apache Jena Fuseki Interface Neplan ETL consolidate EnergyConsumers test', async (done) => {
+    cimModel.purgeData();
+    /!** configure query data *!/
+    const neplanClassDefinitions = getClassDefinitionMap();
+
+    const loadConfig = [CIM_CLASS_NAMES.WNEnergyConsumer, CIM_CLASS_NAMES.Terminal];
+    /!** query data *!/
+    const cimFusekiDataRaw = await loadFusekiData(fusekiURI, graphURI, loadConfig, neplanClassDefinitions);
+    /!** parse queried data *!/
+    parseFusekiData(cimModel, cimFusekiDataRaw, loadConfig, neplanClassDefinitions);
+    cimModel.resolveParsedAssociations();
+
+
+    /!** ETL *!/
+    /!** ----------------EnergyConsumers konsolidieren --------------------- *!/
+    const updateSPARQL = transformEnergyConsumers(cimModel, graphURI);
+    /!** konsolodierte EnergyConsumer speichern *!/
+    await postNodeFetchData(fusekiUpdateURI, 'post', updateSPARQL, {'Content-type': 'application/sparql-update'});
+
+    cimModel.purgeData();
+
+    const loadConfigEC = [CIM_CLASS_NAMES.WNEnergyConsumer];
+    /!** query data *!/
+    const cimFusekiDataRawEC = await loadFusekiData(fusekiURI, graphURI, loadConfigEC, neplanClassDefinitions);
+    /!** parse queried data *!/
+    parseFusekiData(cimModel, cimFusekiDataRawEC, loadConfigEC, neplanClassDefinitions);
+
+    /!** Tests *!/
+    /!** V 1.2996/0.629425 *!/
+    /!** M 0.533700/0.258482 *!/
+    const energyConsumer = getEnergyConsumerByName(cimModel, '05966020-S-K-ST-00024') as WNEnergyConsumer;
+    expect(energyConsumer).toBeDefined();
+
+    expect(energyConsumer.contractualP).toBe(1.2996);
+    expect(energyConsumer.contractualQ).toBe(0.629425);
+
+    expect(energyConsumer.measuredP).toBe(0.5337);
+    expect(energyConsumer.measuredQ).toBe(0.258482);
+
+    // Unterlagerte Lasten
+    const energyConsumerUnterlagert = getEnergyConsumerByName(cimModel, '05154032-S-K-ST-00223') as WNEnergyConsumer;
+    expect(energyConsumerUnterlagert).toBeDefined();
+
+    // Test: Umrechnung kVA in MVA
+    expect(energyConsumerUnterlagert.p).toBeCloseTo(0.28099);
+    expect(energyConsumerUnterlagert.q).toBeCloseTo(0.13609, 3);
+
+    expect(energyConsumerUnterlagert.subContractualP).toBeCloseTo(0.28099);
+    expect(energyConsumerUnterlagert.subContractualQ).toBeCloseTo(0.13609, 3);
+
+    expect(energyConsumerUnterlagert.subMeasuredP).toBeCloseTo(0.28099);
+    expect(energyConsumerUnterlagert.subMeasuredQ).toBeCloseTo(0.13609, 3);
+
+    expect(energyConsumerUnterlagert.contractualP).toBe(0);
+    expect(energyConsumerUnterlagert.contractualQ).toBe(0);
+
+    expect(energyConsumerUnterlagert.measuredP).toBe(0.001);
+    expect(energyConsumerUnterlagert.measuredQ).toBe(0);
+
+
+    expect(Math.floor(energyConsumerUnterlagert.cosPhi * 100) / 100).toBeCloseTo(0.89, 2);
+    // energyConsumerUnterlagert.cosPhi.toFixed(3)
+    done();
+
+  });*/
+  it('Apache Jena Fuseki Interface Neplan ETL add Faults, Outages, SwitchActions', async (done) => {
+    cimModel.purgeData();
+    /** configure query data */
+    const neplanClassDefinitions = getClassDefinitionMap();
+
+    let loadConfig = [CIM_CLASS_NAMES.WNConnectivityNode,
+      CIM_CLASS_NAMES.EVTerminal,
+      CIM_CLASS_NAMES.WNEnergyConsumer,
+      CIM_CLASS_NAMES.ACLineSegment
+    ];
+    /** query data */
+    let cimFusekiDataRaw = await loadFusekiData(fusekiURI, graphURI, loadConfig, neplanClassDefinitions);
+    /** parse queried data */
+    parseFusekiData(cimModel, cimFusekiDataRaw, loadConfig, neplanClassDefinitions);
+
+    const failureCN = cimModel.getConnectivityNode('b36b88d6-df2d-48b6-908f-15fa2d21aa19') as WNConnectivityNode;
+    const switchTerminal = cimModel.getTerminal('d343e428-31a3-4ef8-879d-b8e08f3af1fa') as EVTerminal;
+
+    /** Objekte erzeugen */
+    const baseIRI = failureCN.baseIRI;
+    const createN_1SPARQL = [];
+    const addN_1SPARQL = [];
+
+    //Outage
+    const outageNew = new WNOutage('df9dffd9-6bda-4e49-aa86-71d01449a48e', 'OutageNew', '', '', baseIRI);
+    const isolatedEQ = cimModel.getEnergyConsumer('785349c5-83e3-4846-81f3-de0886ac8dbc');
+    const isolatedCN1 = cimModel.getConnectivityNode('f554c420-b13f-442e-85a2-fc26df46d8ca') as WNConnectivityNode;
+    const isolatedCN2 = cimModel.getConnectivityNode('1a689b75-0ffe-4087-8806-38c4cacce4c6') as WNConnectivityNode;
+
+    createN_1SPARQL.push(outageNew.createNewStatementSPARQL());
+    addN_1SPARQL.push(outageNew.addOutageIsolationEquipment(isolatedEQ));
+    addN_1SPARQL.push(outageNew.addOutageIsolationConnectivityNodes(isolatedCN1));
+    addN_1SPARQL.push(outageNew.addOutageIsolationConnectivityNodes(isolatedCN2));
+
+
+    //Fault
+    const cnFaultNew = new WNFaultConnectivityNode('677af82b-98ca-47eb-8e4b-5249abb0978a', 'WNFaultCN', '', '', baseIRI);
+
+    createN_1SPARQL.push(cnFaultNew.createNewStatementSPARQL());
+    addN_1SPARQL.push(cnFaultNew.setConnectivityNode(failureCN));
+    addN_1SPARQL.push(cnFaultNew.setOutage(outageNew));
+
+    //SwitchingPlan
+    const switchingPlanNew = new SwitchingPlan('26e10a1a-63ba-44b7-8126-4f698df94995', 'SwitchingPlanNew', '', '', baseIRI);
+    createN_1SPARQL.push(switchingPlanNew.createNewStatementSPARQL());
+    addN_1SPARQL.push(switchingPlanNew.setOutage(outageNew));
+
+    const switchingActionNew = new EVTerminalAction('aa281d4c-6442-49d4-b9e4-a6ac8e94c322', 'TerminalAction', '', '', baseIRI);
+    createN_1SPARQL.push(switchingActionNew.createNewStatementSPARQL());
+    addN_1SPARQL.push(switchingActionNew.setSwitchingPlan(switchingPlanNew));
+    addN_1SPARQL.push(switchingActionNew.addTerminal(switchTerminal));
+
+    const queryCreateOutageSwitch = `
+                        PREFIX rdf:             <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+                        PREFIX cim:             <http://iec.ch/TC57/2013/CIM-schema-cim16#>
+                        PREFIX westnetzneplan:  <http://westnetzneplan.de/CIM/Extensions#>
+                        PREFIX enervance:           <http://enervance.com/CIM/Extensions#> 
+                        INSERT DATA{
+                            GRAPH ${graphURI} {
+                                 ${createN_1SPARQL.join(' ')}
+                                 ${addN_1SPARQL.join(' ')}
+                            }
+                        }
+    `;
+    console.log('queryCreateOutageSwitch');
+    console.log(queryCreateOutageSwitch);
+    await postNodeFetchData(fusekiUpdateURI, 'post', queryCreateOutageSwitch, {'Content-type': 'application/sparql-update'});
+
+    cimModel.purgeData();
+
+    // Laden und testen
+    loadConfig = [CIM_CLASS_NAMES.WNConnectivityNode,
+      CIM_CLASS_NAMES.EVTerminal,
+      CIM_CLASS_NAMES.SwitchingPlan,
+      CIM_CLASS_NAMES.WNOutage,
+      CIM_CLASS_NAMES.WNFaultConnectivityNode,
+      CIM_CLASS_NAMES.WNEnergyConsumer,
+      CIM_CLASS_NAMES.EVTerminalAction
+    ];
+    /** query data */
+    cimFusekiDataRaw = await loadFusekiData(fusekiURI, graphURI, loadConfig, neplanClassDefinitions);
+    /** parse queried data */
+    parseFusekiData(cimModel, cimFusekiDataRaw, loadConfig, neplanClassDefinitions);
+    cimModel.resolveParsedAssociations();
+
+    expect(cimModel.outages.size).toBe(2);
+
+
+    const outage = cimModel.getOutage('df9dffd9-6bda-4e49-aa86-71d01449a48e') as WNOutage;
+    expect(outage).toBeDefined();
+    expect(outage.outageIsolationEquipment.size).toBe(1);
+    expect(outage.outageIsolationConnectivityNodes.size).toBe(2);
+
+    const fault = cimModel.getCustomFault('677af82b-98ca-47eb-8e4b-5249abb0978a') as WNFaultConnectivityNode;
+    expect(fault).toBeDefined();
+    expect(fault.connectivityNode).toBeDefined();
+    expect(fault.connectivityNode.mrid).toBe('b36b88d6-df2d-48b6-908f-15fa2d21aa19');
+
+    expect(fault.outage).toBeDefined();
+    expect(fault.outage.mrid).toBe('df9dffd9-6bda-4e49-aa86-71d01449a48e');
+
+    const switchingPlan = cimModel.getSwitchingPlan('26e10a1a-63ba-44b7-8126-4f698df94995');
+    expect(switchingPlan).toBeDefined();
+    expect(switchingPlan.outage).toBeDefined();
+    expect(switchingPlan.outage.mrid).toBe('df9dffd9-6bda-4e49-aa86-71d01449a48e');
+
+    const switchingAction = cimModel.getSwitchingAction('aa281d4c-6442-49d4-b9e4-a6ac8e94c322') as EVTerminalAction;
+    expect(switchingAction).toBeDefined();
+    expect(switchingAction.switchingPlan).toBeDefined();
+    expect(switchingAction.switchingPlan.mrid).toBe('26e10a1a-63ba-44b7-8126-4f698df94995');
+
+    expect(switchingAction.terminals.size).toBe(1);
+    expect(switchingAction.terminals.get('d343e428-31a3-4ef8-879d-b8e08f3af1fa')).toBeDefined();
+
+    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.getSubstation('0b053582-c951-4ff7-a1d6-be179b582804');
+    const baseIRI = defaultSubstation.baseIRI;
+
+    /** Objekte erzeugen */
+    const insertObjectSPARQL = createFeederLines(cimModel, baseIRI);
+
+    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 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();
+  });
+  it('Apache Jena Fuseki Interface Neplan Set&Get test', async (done) => {
+    cimModel.purgeData();
+    /** configure query data */
+    const neplanClassDefinitions = getClassDefinitionMap();
+
+    const loadConfig = [CIM_CLASS_NAMES.WNEnergyConsumer,
+      CIM_CLASS_NAMES.WNConnectivityNode,
+      CIM_CLASS_NAMES.ACLineSegment,
+      CIM_CLASS_NAMES.PSRType,
+      CIM_CLASS_NAMES.WNFacility,
+      CIM_CLASS_NAMES.AssetHealthEvent,
+      CIM_CLASS_NAMES.AssetOwner];
+    /** query data */
+    const cimFusekiDataRaw = await loadFusekiData(fusekiURI, graphURI, loadConfig, neplanClassDefinitions);
+    /** parse queried data */
+    parseFusekiData(cimModel, cimFusekiDataRaw, loadConfig, neplanClassDefinitions);
+    cimModel.resolveParsedAssociations();
+    /** ImportData */
+    const data = fs.readFileSync('test/apache-jena-fuseki-interface/data/json/PersistData.json', 'utf8');
+
+    const importData: { uuid: string, propName: string, propValue: string }[] = JSON.parse(data);
+    const deleteData = [];
+    const insertData = [];
+    for (const newData of importData) {
+      const instance = cimModel.getObject(newData.uuid);
+      const propHandler = PROPERTY_HANDLER_WESTNETZNEPLAN_CONFIG[newData.propName];
+      if (instance) {
+        if (propHandler) {
+          const tripleData = propHandler.cb(cimModel, instance, newData);
+          deleteData.push(tripleData.oldTriple);
+          insertData.push(tripleData.newTriple);
+        } else {
+          const tripleData = instance.setProperty(newData.propName, newData.propValue);
+          deleteData.push(tripleData.oldTriple);
+          insertData.push(tripleData.newTriple);
+        }
+      } else {
+        console.log(`${newData.uuid} keine Instanz vorhanden.`);
+      }
+    }
+
+    const updateSPARQL = `
+                          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#>
+
+                          DELETE DATA {
+                              GRAPH ${graphURI}{
+                                  ${deleteData.join(' ')}
+                              }
+                          };
+                          INSERT DATA{
+                              GRAPH ${graphURI} {
+                                  ${insertData.join(' ')}
+                              }
+                          }
+                `;
+    /** konsolodierte EnergyConsumer speichern */
+    await postNodeFetchData(fusekiUpdateURI, 'post', updateSPARQL, {'Content-type': 'application/sparql-update'});
+
+    cimModel.purgeData();
+
+    const loadConfigEC = [CIM_CLASS_NAMES.WNEnergyConsumer,
+      CIM_CLASS_NAMES.WNConnectivityNode,
+      CIM_CLASS_NAMES.ACLineSegment,
+      CIM_CLASS_NAMES.PSRType,
+      CIM_CLASS_NAMES.WNFacility,
+      CIM_CLASS_NAMES.AssetHealthEvent,
+      CIM_CLASS_NAMES.AssetOwner];
+    /** query data */
+    const cimFusekiDataRawEC = await loadFusekiData(fusekiURI, graphURI, loadConfigEC, neplanClassDefinitions);
+    /** parse queried data */
+    parseFusekiData(cimModel, cimFusekiDataRawEC, loadConfigEC, neplanClassDefinitions);
+    cimModel.resolveParsedAssociations();
+
+    /** Tests */
+    /** EnergyConsumer Callbacks */
+    /** "precision" parameter specifies the number of decimal places that the matcher will check precision at, with rounding. */
+      // const energyConsumer = cimModel.getObject('84a4df06-0bba-421f-8803-bce94a1ba189') as WNEnergyConsumer;
+    const energyConsumer = getEnergyConsumerByName(cimModel, '05966020-S-K-ST-00024') as WNEnergyConsumer;
+
+    expect(energyConsumer).toBeDefined();
+
+/*    expect(energyConsumer.p).toBeCloseTo(0.96);
+    expect(energyConsumer.q).toBeCloseTo(0.72);
+    expect(energyConsumer.cosPhi).toBeCloseTo(0.8);*/
+
+/*    expect(energyConsumer.contractualP).toBeCloseTo(1.299, 2);
+    expect(energyConsumer.contractualQ).toBeCloseTo(0.629425);
+
+    expect(energyConsumer.measuredP).toBeCloseTo(0.53, 2);
+    expect(energyConsumer.measuredQ).toBeCloseTo(0.25, 1);
+
+    expect(energyConsumer.selectedLoad).toBe('wn_energyconsumer_contractual');
+
+
+    expect(energyConsumer.customMultiplier).toBe(2);
+
+    expect(energyConsumer.getApparentPower()).toBe(1.4);
+    expect(energyConsumer.getTypedApparentPower()).toBe(1.2);
+    expect(energyConsumer.getTypedApparentPower('wn_energyconsumer_measured')).toBe(1.6);
+
+    // Unterlagerte
+    const energyConsumerUnterlagert = getEnergyConsumerByName(cimModel, '05154032-S-K-ST-00223') as WNEnergyConsumer;
+
+    expect(energyConsumerUnterlagert.subMeasuredP).toBeCloseTo(1.28, 2);
+    expect(energyConsumerUnterlagert.subMeasuredQ).toBeCloseTo(0.96, 1);
+    expect(energyConsumerUnterlagert.subContractualP).toBeCloseTo(1.28, 2);
+    expect(energyConsumerUnterlagert.subContractualQ).toBeCloseTo(0.96, 1);
+
+    expect(energyConsumerUnterlagert.powerTransfomer1P).toBeCloseTo(1.28, 2);
+    expect(energyConsumerUnterlagert.powerTransfomer1Q).toBeCloseTo(0.96, 1);
+
+    expect(energyConsumerUnterlagert.powerTransfomer2P).toBeCloseTo(1.28, 2);
+    expect(energyConsumerUnterlagert.powerTransfomer2Q).toBeCloseTo(0.96, 1);*/
+
+    /** ConnectivityNode.switchable / description / Art-Kind */
+    const cnTrue = cimModel.getObject('45fe3ffd-2db5-476e-a867-e291a4514736') as WNConnectivityNode;
+    expect(cnTrue).toBeDefined();
+    expect(cnTrue.switchable).toBeTrue();
+    expect(cnTrue.description).toBe('Test-Str-1');
+    expect(cnTrue.assets.size).toBe(1);
+
+    for (const asset of cnTrue.assets.values()) {
+      const facility = asset as WNFacility;
+      expect(facility.kind).toBe('DIGI-ONS');
+      expect(facility.type).toBe('C-Station');
+      /** S Meldungen */
+      expect(facility.activityRecords.size).toBe(2);
+      const s4 = getActivityRecordEventByTypeName(facility.activityRecords, 'Prio 1', 'S4');
+      const s6 = getActivityRecordEventByTypeName(facility.activityRecords, 'Prio 3', 'S6');
+      expect(s4).toBeDefined();
+      expect(s6).toBeDefined();
+      /** AssetOwner */
+      expect(facility.organisationRoles.size).toBe(1);
+      const assetOwner = getObjectByProperty(facility.organisationRoles, 'name', 'Kundenstation');
+      expect(assetOwner).toBeDefined();
+
+    }
+
+
+    const cnFalse = cimModel.getObject('36eb94ab-4a24-4f56-ac11-957a545ac19b') as WNConnectivityNode;
+    expect(cnFalse).toBeDefined();
+    expect(cnFalse.switchable).toBeFalse();
+    expect(cnFalse.assets.size).toBe(1);
+    for (const asset of cnFalse.assets.values()) {
+      const facility = asset as WNFacility;
+      expect(facility.type).toBe('Schaltschrank');
+
+      /** AssetOwner */
+      expect(facility.organisationRoles.size).toBe(1);
+      const assetOwner = getObjectByProperty(facility.organisationRoles, 'name', 'Ortsnetzstation');
+      expect(assetOwner).toBeDefined();
+    }
+
+    const cnDescrp = cimModel.getObject('c0973783-3ebb-494b-bfdb-c6d0596634dd') as WNConnectivityNode;
+    expect(cnDescrp).toBeDefined();
+    expect(cnDescrp.description).toBe('Test-Str-2');
+    expect(cnDescrp.assets.size).toBe(1);
+    for (const asset of cnDescrp.assets.values()) {
+      const facility = asset as WNFacility;
+      expect(facility.type).toBe('Maststat');
+    }
+
+    /** ACLineSegment PSRType */
+    const stkFl = cimModel.getObject('8ead1023-f8d4-4653-be8f-6bfd53f26ac4') as ACLineSegment;
+    expect(stkFl).toBeDefined();
+    expect(stkFl.psrType).toBeDefined();
+    expect(stkFl.psrType.name).toBe('Freileitung');
+
+    const stkKb = cimModel.getObject('19755e75-6f37-4de3-8a76-e2b6f8bca7c7') as ACLineSegment;
+    expect(stkKb).toBeDefined();
+    expect(stkKb.psrType).toBeDefined();
+    expect(stkKb.psrType.name).toBe('Kabel');
+
+    const stkReSet = cimModel.getObject('b26e7cde-b330-49d2-b471-38c95663d561') as ACLineSegment;
+    expect(stkReSet).toBeDefined();
+    expect(stkReSet.psrType).toBeDefined();
+    expect(stkReSet.psrType.name).toBe('Freileitung');
+
+
+    done();
+
+  });
+
+  /*  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, {
+      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);
+    }
+  });
+}