@enervance/insight-cim-model 0.0.1

package/src/etl-neplan/etl-neplan-contingency-analysis.ts

@@ -0,0 +1,170 @@
+import { Model } from '../model/model/Model';
+import { WNFeeder } from '../model/extensions/neplan-westnetz/core/WNFeeder';
+import { Equipment } from '../model/core/Equipment';
+import { WNConnectivityNode } from '../model/extensions/neplan-westnetz/core/WNConnectivityNode';
+import { ConductingEquipment } from '../model/core/ConductingEquipment';
+import { Switch } from '../model/wires/Switch';
+import { EVTerminal } from '../model/extensions/enervance/core/EVTerminal';
+import { WNOutage } from '../model/extensions/neplan-westnetz/operations/WNOutage';
+import { generateUUID } from '../util/utils';
+import { WNFaultConnectivityNode } from '../model/extensions/neplan-westnetz/faults/WNFaultConnectivityNode';
+import { SwitchingPlan } from '../model/operations/SwitchingPlan';
+import { EVTerminalAction } from '../model/extensions/enervance/operations/EVTerminalAction';
+import { SwitchActionKind } from '../model/operations/SwitchActionKind';
+import { IOutage } from '../interfaces/model/operations/IOutage';
+import { ITerminal } from '../interfaces/model/core/ITerminal';
+
+export function performContingencyAnalysis(cimModel: Model): string[] {
+
+  /** 1.1 Bestimme pro Abgang alle elektrisch nicht verbundene Elemente (Knoten und ConductingEquipments) und bbfs. offene Switches */
+  /** 1.2 Überrpüfe nicht verbundene Elemente auf die Abgangszugehörigkeit zu anderen Abgängen */
+  /** 2 Erstelle für jedes nicht verbundenes Element, das zu einem anderen Abgang gehört, eine Schaltmaßname. */
+
+  const insertSPARQL = [];
+  for (const feeder of cimModel.feeders.values()) {
+    const wnFeeder = feeder as WNFeeder;
+    const disconnectedTerminalCNs = []; // nicht verbundene Knoten
+    const disconnectedSwitches = []; // nicht verbundene Schaltelemente
+    const disconnectedTerminalCEs = []; // nicht verbundene leitende Equipments
+
+    /** 1.1 / 1.2) nicht verbundene Knoten und Switches bestimmen */
+    for (const equip of wnFeeder.additionalGroupedEquipment.values()) {
+      if (equip instanceof ConductingEquipment) {
+        const ce = equip as ConductingEquipment;
+        // Bestimme nicht verbundene CNs
+        for (const terminal of ce.terminals.values()) {
+          if (!terminal.isClosed() && !wnFeeder.normalEnergizedConnectivityNodes.has(terminal.connectivityNode.mrid)) {
+            if (terminal.connectivityNode && (terminal.connectivityNode as WNConnectivityNode).additionalConnectivityNodeContainer) {
+              disconnectedTerminalCNs.push(terminal);
+            }
+          }
+        }
+
+        // Prüfen, ob es um einen offen Switch handelt
+        if (ce instanceof Switch) {
+          const swtch = ce as Switch;
+          if (swtch.open === true) {
+            disconnectedSwitches.push(swtch);
+          }
+        }
+      }
+    }
+
+
+    /** 1.1 / 1.2) nicht verbundene leitende Elemente bestimmen */
+    for (const cn of wnFeeder.normalEnergizedConnectivityNodes.values()) {
+      // Bestimme nicht verbundene CNs
+      for (const terminal of cn.terminals.values()) {
+        /** ist offen und gehört zu einem anderen Abgang */
+        if (!terminal.isClosed() && !wnFeeder.additionalGroupedEquipment.has(terminal.conductingEquipment.mrid)) {
+          if (terminal.conductingEquipment.additionalEquipmentContainer.size) {
+            disconnectedTerminalCEs.push(terminal);
+          }
+        }
+      }
+    }
+
+    /** 2 Schaltmaßnahmen */
+    //Ausfallasset: Headterminal
+    /*    console.log(feeder.shortName);
+        console.log('\tdisconnected CNs');
+        for (const terminal of disconnectedTerminalCNs) {
+          const wn = terminal.connectivityNode as WNConnectivityNode;
+          console.log('\t\t' + wn.additionalConnectivityNodeContainer.shortName + ' ' + wn.mrid + ' ');
+        }
+
+        console.log('\tdisconnected CEs');
+        for (const terminal of disconnectedTerminalCEs) {
+          console.log('\t\t' + terminal.conductingEquipment.getAdditionalEquipmentContainer()?.shortName + ' ' + terminal.conductingEquipment.mrid + ' ');
+        }
+
+        console.log('\topenswitches');
+        for (const swtch of disconnectedSwitches) {
+          console.log('\t\t' + swtch.additionalEquipmentContainer.shortName + ' ' + swtch.mrid + ' ');
+        }
+
+        console.log('\twnFeeder.additionalGroupedEquipment ' + wnFeeder.additionalGroupedEquipment.size);
+        console.log('\twnFeeder.normalEnergizedConnectivityNodes + ' + wnFeeder.normalEnergizedConnectivityNodes.size);*/
+
+    for (const headTerminal of feeder.normalHeadTerminals.values()) {
+      //Lege einen N-1 Fall an, wenn es Schaltmaßnahmen exisitieren
+
+      if (disconnectedTerminalCNs.length || disconnectedTerminalCEs.length) {
+        const faultCN = headTerminal.connectivityNode as WNConnectivityNode;
+        const outageNew = new WNOutage(generateUUID(), `Ausfall-${faultCN.name}`, `${wnFeeder.shortName}`, '', wnFeeder.baseIRI);
+        insertSPARQL.push(outageNew.createNewStatementSPARQL());
+
+        /** Equipments */
+        for (const object of wnFeeder.additionalGroupedEquipment.values()) {
+          if (object instanceof ConductingEquipment) {
+            insertSPARQL.push(outageNew.addOutageIsolationEquipment(object as ConductingEquipment));
+
+          } else if (object instanceof WNConnectivityNode) {
+            insertSPARQL.push(outageNew.addOutageIsolationConnectivityNodes(object as WNConnectivityNode));
+          } else if (object instanceof EVTerminal) {
+            // TBD
+          }
+        }
+        /** WNConnectivityNodes */
+        for (const object of wnFeeder.normalEnergizedConnectivityNodes.values()) {
+          insertSPARQL.push(outageNew.addOutageIsolationConnectivityNodes(object));
+        }
+        //Fault
+        const cnFaultNew = new WNFaultConnectivityNode(generateUUID(), `Ausfall-${faultCN.name}`, '', '', wnFeeder.baseIRI);
+        insertSPARQL.push(cnFaultNew.createNewStatementSPARQL());
+
+        insertSPARQL.push(cnFaultNew.setConnectivityNode(faultCN));
+        insertSPARQL.push(cnFaultNew.setOutage(outageNew));
+
+
+        //SwitchingPlan
+        // de-energise
+        const switchingPlanDeEnergise = createSwitchingPlan(generateUUID(), wnFeeder.baseIRI, `Schaltmaßnahme-Ausfall`, -1, 'de-energise', outageNew, insertSPARQL);
+        const switchingActionDeEnergise = createTerminalAction(generateUUID(), wnFeeder.baseIRI, `Schaltung-Ausfall`, SwitchActionKind.open, switchingPlanDeEnergise, insertSPARQL);
+        insertSPARQL.push(switchingActionDeEnergise.addTerminal(headTerminal as EVTerminal));
+        //restore
+        const switchingPlanRestore = createSwitchingPlan(generateUUID(), wnFeeder.baseIRI, `Schaltmaßnahme-Restore`, 0, 'restore', outageNew, insertSPARQL);
+        const switchingActionRestore = createTerminalAction(generateUUID(), wnFeeder.baseIRI, `Schaltung-Restore`, SwitchActionKind.close, switchingPlanRestore, insertSPARQL);
+        insertSPARQL.push(switchingActionRestore.addTerminal(headTerminal as EVTerminal));
+
+        // Schaltmaßnahmen von den CNs
+        for (let i = 0; i < disconnectedTerminalCNs.length; i++) {
+          const terminal = disconnectedTerminalCNs[i];
+          const switchingPlanEnergise = createSwitchingPlan(generateUUID(), wnFeeder.baseIRI, `Schaltmaßnahme-Energise`, (i + 1), 'energise', outageNew, insertSPARQL);
+          const switchingActionEnergise = createTerminalAction(generateUUID(), wnFeeder.baseIRI, `Schaltung-${terminal.connectivityNode.name}`, SwitchActionKind.close, switchingPlanEnergise, insertSPARQL);
+          insertSPARQL.push(switchingActionEnergise.addTerminal(terminal));
+        }
+
+        // Schaltmaßnahmen von den CEs
+        for (let i = 0; i < disconnectedTerminalCEs.length; i++) {
+          const terminal = disconnectedTerminalCEs[i];
+          const switchingPlanEnergise = createSwitchingPlan(generateUUID(), wnFeeder.baseIRI, `Schaltmaßnahme-Energise`, (i + 1), 'energise', outageNew, insertSPARQL);
+          const switchingActionEnergise = createTerminalAction(generateUUID(), wnFeeder.baseIRI, `Schaltung-${terminal.connectivityNode.name}`, SwitchActionKind.close, switchingPlanEnergise, insertSPARQL);
+          insertSPARQL.push(switchingActionEnergise.addTerminal(terminal));
+        }
+      }
+    }
+  }
+
+  return insertSPARQL;
+}
+
+export function createSwitchingPlan(uuid: string, baseIRI: string, name: string, rank: any, purpose: string, outage: IOutage, insertSPARQL: string[]): SwitchingPlan {
+  const switchingPlan = new SwitchingPlan(uuid, name, '', '', baseIRI);
+  // switchingPlanNew.rank undefined
+  // console.log(switchingPlan.createNewStatementSPARQL());
+  insertSPARQL.push(switchingPlan.createNewStatementSPARQL());
+  if (rank) insertSPARQL.push(switchingPlan.setRank(rank));
+  if (purpose) insertSPARQL.push(switchingPlan.setPurpose(purpose));
+  insertSPARQL.push(switchingPlan.setOutage(outage));
+
+  return switchingPlan;
+}
+
+export function createTerminalAction(uuid: string, baseIRI: string, name: string, kind: SwitchActionKind, switchingPlan: SwitchingPlan, insertSPARQL: string[]): EVTerminalAction {
+  const switchingActionNew = new EVTerminalAction(uuid, name, '', '', baseIRI);
+  insertSPARQL.push(switchingActionNew.createNewStatementSPARQL());
+  insertSPARQL.push(switchingActionNew.setKind(kind));
+  insertSPARQL.push(switchingActionNew.setSwitchingPlan(switchingPlan));
+  return switchingActionNew;
+}

package/src/etl-neplan/etl-neplan-feederline.ts

@@ -0,0 +1,138 @@
+/** */
+import { IIdentifiedObject } from '../interfaces/model/core/IIdentifiedObject';
+import {
+  determineComputableGrid,
+  determineNetworksSlackElements, determineSubstations,
+  determineTopologicalIslands, resetMapCIM
+} from '../util/util-topology';
+import { Model } from '../model/model/Model';
+import { WNFeeder } from '../model/extensions/neplan-westnetz/core/WNFeeder';
+import { IConnectivityNode } from '../interfaces/model/core/IConnectivityNode';
+import { ACLineSegment } from '../model/wires/ACLineSegment';
+import { generateUUID } from '../util/utils';
+import { Equipment } from '../model/core/Equipment';
+import { WNConnectivityNode } from '../model/extensions/neplan-westnetz/core/WNConnectivityNode';
+import { EVTerminal } from '../model/extensions/enervance/core/EVTerminal';
+import { ITerminal } from '../interfaces/model/core/ITerminal';
+import { ConductingEquipment } from '../model/core/ConductingEquipment';
+
+/**
+ * Erzeugung von Abgängen
+ * @param cimModel das CIM Modellinstanz
+ * @param baseIRI IRI (Internationalized Resource Identifier) des RDF-Stores
+ * return SPARQL Insert Statements
+ * */
+export function createFeederLines(cimModel: Model, basiIRI: string): string [] {
+  /** alle elektrisch zusammenhängende Teilnetze bestimmen mit Berücksichtigung des Schaltzustandes */
+  const networks: IIdentifiedObject[][] = determineTopologicalIslands(cimModel);
+
+  /** rechenbare Netze bestimmen */
+  const computableGrids: IIdentifiedObject[][] = determineComputableGrid(networks);
+
+  /** Slackelemente für rechenbare Netze, unabhängig vom Schaltzustand */
+  /** Key Netzindex, Value alle vom Slack aus erreichbare Elemente (ACLineSegments trennen Slack-UAs) */
+  const computableGridsSlackElements: IIdentifiedObject[][] = determineNetworksSlackElements(cimModel, computableGrids);
+
+  /** KRUECKE Anlagen mit mehr als 10 Switchelementen und Slacks werden als Umspannanlagen markiert. */
+  const substationElements = determineSubstations(cimModel);
+  computableGridsSlackElements.push(substationElements);
+
+  const insertObjectSPARQL = [];
+  /** bestimmt ALLE elektrisch zusammenhängende Abgänge (eine Art Stromkreis für Mittelspannungsnetze) */
+  for (const grid of computableGrids) {
+    /** Für das Netz die elektrisch zusammenhängenden Abgänge bestimmen (bestehend aus allen Elementen ) */
+    const networkFeederElements: IIdentifiedObject[][] = determineFeederLinesElements(cimModel, grid, computableGridsSlackElements);
+
+
+    /** Erstellen der FeederLine Objekte */
+    for (const feederObjects of networkFeederElements) {
+      const headTerminal = determineHeadTerminal(feederObjects);
+      const startCN = headTerminal?.connectivityNode;
+      const substation = startCN?.getVoltageLevel()?.getSubstation();
+
+      if (substation && startCN) {
+        const nameLenght = startCN.name?.length; // 05958016-S-H-ST-06736-K0-007
+        const feeder = new WNFeeder(generateUUID(), startCN.name, startCN.name?.substr(nameLenght - 3, nameLenght), '', basiIRI);
+        //feeder.number = startCN.name?.substr(nameLenght - 3, nameLenght);
+        insertObjectSPARQL.push(feeder.createNewStatementSPARQL());
+        insertObjectSPARQL.push(feeder.setNumber(startCN.name?.substr(nameLenght - 3, nameLenght)));
+        //additionalGroupedEquipment
+        for (const object of feederObjects) {
+          if (object instanceof Equipment) {
+            const equip = object as Equipment;
+            feeder.addAdditionalGroupedEquipment(equip);
+            insertObjectSPARQL.push(equip.addAdditionalEquipmentContainer(feeder));
+
+          } else if (object instanceof WNConnectivityNode) {
+            const wnCN = object as WNConnectivityNode;
+            feeder.addEnergizedConnectivityNode(wnCN)
+            insertObjectSPARQL.push(wnCN.addAdditionalConnectivityNodeContainer(feeder));
+          } else if (object instanceof EVTerminal) {
+            // TBD
+          }
+        }
+
+        // Substion
+        insertObjectSPARQL.push(feeder.setNormalEnergizingSubstation(substation));
+        substation.addNormalEnergizingFeeder(feeder);
+        // HeadTerminal setzen
+        feeder.addNormalHeadTerminal(headTerminal);
+        insertObjectSPARQL.push(headTerminal.setNormalHeadFeeder(feeder));
+
+        cimModel.addFeeder(feeder);
+      } else {
+        console.log(`Der StartConnNode oder die Substion für Feeder konnte nicht bestimmt werden`);
+        console.log(substation + ' ' + startCN);
+      }
+    }
+    return insertObjectSPARQL;
+  }
+
+
+}
+
+/**Es wird ein FeederLine-Objekt bestimmt
+ * Ausgehend von Stromkreisabschnitten alle zusammenhende Netzelemente bestimmen und zu einem Abgang zusammenfassen.
+ * ???Trafos gehören immer zu einer Umspannanlage und können nicht zu einem Angang gehören???.
+ depricated Hinweis: der Algorythmus setzt varaus, dass Slackelemente vorher bestimmt wurden.
+ D.h. sie sind als 'visited' markiert. */
+export function determineFeederLinesElements(cimModel: Model, grid: IIdentifiedObject[], slackSubstationElements: IIdentifiedObject[][]): IIdentifiedObject[][] {
+
+  const networkFeederLineElements: IIdentifiedObject[][] = [];
+  for (let i = 0; i < grid.length; i++) {
+    const gridElement = grid[i];
+    if (gridElement instanceof ConductingEquipment /*gridElement.constructor.name.includes('ACLineSegment')|| networkElement.constructor.name === 'PowerTransformer'*/) {
+      const feederLineElements: IIdentifiedObject[] = [];
+      gridElement.determineMidVoltageLineElements(feederLineElements, slackSubstationElements);
+      if (feederLineElements.length > 0) {
+        networkFeederLineElements.push(feederLineElements)
+      }
+    }
+  }
+  resetMapCIM(cimModel.objects);
+  return networkFeederLineElements;
+}
+
+/** Den Anfang eines Abgangs bestimmen - ConnectivityNode */
+/** prüft, ob ein Netzelement zur Slack-UA gehört
+ * die Methode wird nur von der Terminal-Klasse implementiert,
+ * da sie ConductingElements mit den ConnectivityNodes verbindet.
+ * Gesucht ist ein ConnectivityNode der nicht Teil des Abgangs ist.
+ * Die Bedingung ist erfüllt, wenn der ConnectivityNode nicht
+ * im Array gridElements enthalten ist. */
+export function determineHeadTerminal(gridElements: IIdentifiedObject[]): ITerminal {
+  for (const object of gridElements) {
+    if (object.constructor.name.includes('ACLineSegment')) {
+      const acLineSegment = object as unknown as ACLineSegment;
+
+      for (const terminal of acLineSegment.terminals.values()) {
+        if (terminal.isClosed()) { /** ist elektrisch angeschlossen. */
+          if (gridElements.indexOf(terminal.connectivityNode) === -1) { /** ist CN Teil des Abgabgs und ist mit einem ConductEquip verbunden? */
+            return terminal;
+          }
+        }
+      }
+    }
+  }
+  return;
+}

package/src/etl-neplan/etl-neplan.ts

@@ -0,0 +1,343 @@
+import * as fetch from 'node-fetch';
+import { EnergyConsumer, generateUUID, Model, WNFacility } from "../index";
+import { WNEnergyConsumer } from '../model/extensions/neplan-westnetz/wires/WNEnergyConsumer';
+import { IEnergyConsumer } from '../interfaces/model/wires/IEnergyConsumer';
+import { EVImportanceScore } from '../model/extensions/enervance/assets/EVImportanceScore';
+import { HealthScore } from '../model/assets/HealthScore';
+
+/** Erstellt pro ConnectivityNode eine WNFacility-Instanz und assoziiert sie mit dem CN */
+export function addNeplanFacilities(cimModel: Model, graphURI: string): string{
+    const createObjectsSPARQL = [];
+    const addReleationsSPARQL = [];
+    for (const cn of cimModel.connectivityNodes.values()) {
+        const facility = new WNFacility(generateUUID(), cn.mrid, '','', cn.baseIRI);
+        /** CN <-> Facility */
+        createObjectsSPARQL.push(facility.createNewStatementSPARQL());
+        addReleationsSPARQL.push(facility.addConnectivityNode(cn));
+
+        /** Facility <-> HealthScore/EVImportanceScore */
+        const healthScore = new HealthScore(generateUUID(), facility.mrid, '','', cn.baseIRI);
+        const importanceScore = new EVImportanceScore(generateUUID(), facility.mrid, '','', cn.baseIRI);
+
+        createObjectsSPARQL.push(healthScore.createNewStatementSPARQL());
+        createObjectsSPARQL.push(importanceScore.createNewStatementSPARQL());
+
+        addReleationsSPARQL.push(healthScore.setAsset(facility));
+        addReleationsSPARQL.push(importanceScore.setAsset(facility));
+    }
+    const createSPARQL = `
+                        PREFIX rdf:             <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+                        PREFIX enervance:   <http://enervance.com/CIM/Extensions#> 
+                        PREFIX cim:             <http://iec.ch/TC57/2013/CIM-schema-cim16#>
+                        PREFIX westnetzneplan:  <http://westnetzneplan.de/CIM/Extensions#>
+                        INSERT DATA{
+                            GRAPH ${graphURI} {
+                                 ${createObjectsSPARQL.join(' ')}
+                                 ${addReleationsSPARQL.join(' ')}
+                            }
+                        }
+    `;
+    return createSPARQL;
+}
+
+export function transformEnergyConsumers(cimModelXML: Model, graphURI: string): string {
+    const sparqlUpdates = [];
+    /** key unifiedName, Value -> EnergySourceArray*/
+    const tpEnergyConsumerMap = getUnifiedEnergyConsumersNames(cimModelXML);
+    if(tpEnergyConsumerMap.size > 1) {
+        for (const entry of tpEnergyConsumerMap.entries()) {
+            const unifiedName = entry[0];
+            const energyConsumers: WNEnergyConsumer[] = entry[1];
+
+            const energyConsumerUnified = determineMeasuredContractualPower(unifiedName, energyConsumers);
+
+            if(energyConsumerUnified.size > 0) {
+                /*const sparqlUpdate = getUpdateDeleteSPARQL(energyConsumerUnified, unifiedName, graphURI, energyConsumers);*/
+                const sparqlUpdate = getEtlSPARQL(energyConsumerUnified, unifiedName, graphURI);
+                if(sparqlUpdate) {
+                    sparqlUpdates.push(sparqlUpdate);
+                }
+            }
+        }
+    } else {
+        console.log(`tpEnergyConsumerMap.size ${tpEnergyConsumerMap.size}`);
+    }
+
+    return sparqlUpdates.join(';');
+}
+
+export function getUnifiedEnergyConsumersNames(cimModelXML: Model): Map<string, WNEnergyConsumer[]> {
+    const tpEnergyConsumerMap = new Map<string, WNEnergyConsumer[]>();
+
+    for (const ec of cimModelXML.energyConsumers.values()){
+
+        if (ec.name && ec.name.length >= 21) {
+            const unifiedName = ec.name.substr(0, 21);
+            let unifiedNameArray = tpEnergyConsumerMap.get(unifiedName);
+            if(!unifiedNameArray) {
+                unifiedNameArray = [];
+                tpEnergyConsumerMap.set(unifiedName, unifiedNameArray);
+            }
+            unifiedNameArray.push(ec as WNEnergyConsumer);
+        } else {
+            console.log(`EnergyConsumer ${ec.mrid} ${ec.name} has a short name/tp`);
+        }
+    }
+    return tpEnergyConsumerMap;
+}
+
+/*      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
+        */
+export function determineMeasuredContractualPower(unifiedName: string, energyConsumer: WNEnergyConsumer[]): Map<string, WNEnergyConsumer | WNEnergyConsumer[]> {
+    /** key consolidated | remove */
+    const result = new Map();
+    if(energyConsumer.length > 1) {
+        const energyConsumerMain = energyConsumer[0];
+        energyConsumerMain.cosPhi = energyConsumerMain.p / energyConsumerMain.getTypedApparentPower('default');
+
+        const ecToRemove = energyConsumer.filter(ec => ec.mrid !== energyConsumerMain.mrid);
+
+        result.set('consolidated', energyConsumerMain);
+        result.set('remove', ecToRemove);
+
+        for (const ec of energyConsumer) {
+            // Konsolidierte Objekte werden gelöscht!
+            if(ec.mrid !== energyConsumerMain.mrid) ecToRemove.push(ec);
+
+            const type = ec.name.substr(ec.name.length - 2, 2);
+            switch (type) {
+                case '-M': {
+                    energyConsumerMain.measuredP = ec.p;
+                    energyConsumerMain.measuredQ = ec.q;
+                    break;
+                }
+                case '-V': {
+                    energyConsumerMain.contractualP = ec.p;
+                    energyConsumerMain.contractualQ = ec.q;
+                    break;
+                }
+                case 'MB': {
+                    energyConsumerMain.subMeasuredP = ec.p / 1000; // da in Neplan kW -> Umrechnung in MW
+                    energyConsumerMain.subMeasuredQ = ec.q / 1000; // da in Neplan kVAr -> Umrechnung in MVAr
+                    break;
+                }
+                case 'VB': {
+                    energyConsumerMain.subContractualP = ec.p / 1000; // da in Neplan kW -> Umrechnung in MW
+                    energyConsumerMain.subContractualQ = ec.q / 1000; // da in Neplan kVAr -> Umrechnung in MVAr
+                    break;
+                }
+                case '-T': {
+                    energyConsumerMain.powerTransfomer1P = ec.p;
+                    energyConsumerMain.powerTransfomer1Q = ec.q;
+                    break;
+                }
+                case 'T1': {
+                    energyConsumerMain.powerTransfomer1P = ec.p;
+                    energyConsumerMain.powerTransfomer1Q = ec.q;
+                    break;
+                }
+                case 'T2': {
+                    energyConsumerMain.powerTransfomer2P = ec.p;
+                    energyConsumerMain.powerTransfomer2Q = ec.q;
+                    break;
+                }
+                default: {
+                    console.log(`Unbekannter Lasttyp ${type}`);
+                    break;
+                }
+            }
+        }
+    }
+    return result;
+    // const regexTrafo = /-T\d*/;
+}
+
+export function getEtlSPARQL(result: Map<string, WNEnergyConsumer | WNEnergyConsumer[]>, unifiedName: string, graphURI: string,): string {
+
+    const wnEnergyConsumerUnified = result.get('consolidated') as WNEnergyConsumer;
+    const deleteLoadObjects = result.get('remove') as WNEnergyConsumer[];
+
+    const insertQueries: string[] = [];
+    const deleteQueries: string[] = [];
+    const deleteObjectsQueries: string[] = [];
+    /** alten Namen löschen */
+    deleteQueries.push(wnEnergyConsumerUnified.getPropertySparqlTriple(wnEnergyConsumerUnified.baseIRI, wnEnergyConsumerUnified.mrid,
+                                                              'cim', 'IdentifiedObject',
+                                                              'name', wnEnergyConsumerUnified.name));
+
+    /** Die Alten Leistungsabgaben löschen und umgerechnete Persistieren */
+    const type = wnEnergyConsumerUnified.name.substr(wnEnergyConsumerUnified.name.length - 2, 2);
+    if(type === 'VB' || type === 'MB') {
+        const pNeu = wnEnergyConsumerUnified.p / 1000;
+        const qNeu = wnEnergyConsumerUnified.q / 1000;
+        deleteQueries.push(wnEnergyConsumerUnified.getPropertySparqlTriple(wnEnergyConsumerUnified.baseIRI, wnEnergyConsumerUnified.mrid, 'cim', 'EnergyConsumer', 'p', wnEnergyConsumerUnified.p+''));
+        deleteQueries.push(wnEnergyConsumerUnified.getPropertySparqlTriple(wnEnergyConsumerUnified.baseIRI, wnEnergyConsumerUnified.mrid, 'cim', 'EnergyConsumer', 'q', wnEnergyConsumerUnified.q+''));
+
+        /** Umgerechnete P und q Werte  */
+        wnEnergyConsumerUnified.p = isNaN(pNeu) ? 0 : pNeu;
+        wnEnergyConsumerUnified.q = isNaN(qNeu) ? 0 : qNeu;
+
+        insertQueries.push(wnEnergyConsumerUnified.getPropertySparqlTriple(wnEnergyConsumerUnified.baseIRI, wnEnergyConsumerUnified.mrid, 'cim', 'EnergyConsumer', 'p', wnEnergyConsumerUnified.p+''));
+        insertQueries.push(wnEnergyConsumerUnified.getPropertySparqlTriple(wnEnergyConsumerUnified.baseIRI, wnEnergyConsumerUnified.mrid, 'cim', 'EnergyConsumer', 'q', wnEnergyConsumerUnified.q+''));
+
+    }
+
+    /** neuen Namen einfügen*/
+
+    /** konsolidierte Leistungswerte einfügen */
+    wnEnergyConsumerUnified.name = unifiedName;
+    insertQueries.push(wnEnergyConsumerUnified.getPropertySparqlTriple(wnEnergyConsumerUnified.baseIRI, wnEnergyConsumerUnified.mrid, 'cim', 'IdentifiedObject', 'name', wnEnergyConsumerUnified.name));
+    insertQueries.push(wnEnergyConsumerUnified.getPropertySparqlTriple(wnEnergyConsumerUnified.baseIRI, wnEnergyConsumerUnified.mrid, 'westnetzneplan', 'WNEnergyConsumer', 'contractualP', wnEnergyConsumerUnified.contractualP +''));
+    insertQueries.push(wnEnergyConsumerUnified.getPropertySparqlTriple(wnEnergyConsumerUnified.baseIRI, wnEnergyConsumerUnified.mrid, 'westnetzneplan', 'WNEnergyConsumer', 'contractualQ', wnEnergyConsumerUnified.contractualQ +''));
+
+    insertQueries.push(wnEnergyConsumerUnified.getPropertySparqlTriple(wnEnergyConsumerUnified.baseIRI, wnEnergyConsumerUnified.mrid, 'westnetzneplan', 'WNEnergyConsumer', 'measuredP', wnEnergyConsumerUnified.measuredP +''));
+    insertQueries.push(wnEnergyConsumerUnified.getPropertySparqlTriple(wnEnergyConsumerUnified.baseIRI, wnEnergyConsumerUnified.mrid, 'westnetzneplan', 'WNEnergyConsumer', 'measuredQ', wnEnergyConsumerUnified.measuredQ +''));
+
+
+    insertQueries.push(wnEnergyConsumerUnified.getPropertySparqlTriple(wnEnergyConsumerUnified.baseIRI, wnEnergyConsumerUnified.mrid, 'westnetzneplan', 'WNEnergyConsumer', 'subContractualP', wnEnergyConsumerUnified.subContractualP +''));
+    insertQueries.push(wnEnergyConsumerUnified.getPropertySparqlTriple(wnEnergyConsumerUnified.baseIRI, wnEnergyConsumerUnified.mrid, 'westnetzneplan', 'WNEnergyConsumer', 'subContractualQ', wnEnergyConsumerUnified.subContractualQ +''));
+
+    insertQueries.push(wnEnergyConsumerUnified.getPropertySparqlTriple(wnEnergyConsumerUnified.baseIRI, wnEnergyConsumerUnified.mrid, 'westnetzneplan', 'WNEnergyConsumer', 'subMeasuredP', wnEnergyConsumerUnified.subMeasuredP +''));
+    insertQueries.push(wnEnergyConsumerUnified.getPropertySparqlTriple(wnEnergyConsumerUnified.baseIRI, wnEnergyConsumerUnified.mrid, 'westnetzneplan', 'WNEnergyConsumer', 'subMeasuredQ', wnEnergyConsumerUnified.subMeasuredQ +''));
+
+    insertQueries.push(wnEnergyConsumerUnified.getPropertySparqlTriple(wnEnergyConsumerUnified.baseIRI, wnEnergyConsumerUnified.mrid, 'westnetzneplan', 'WNEnergyConsumer', 'powerTransfomer1P', wnEnergyConsumerUnified.powerTransfomer1P +''));
+    insertQueries.push(wnEnergyConsumerUnified.getPropertySparqlTriple(wnEnergyConsumerUnified.baseIRI, wnEnergyConsumerUnified.mrid, 'westnetzneplan', 'WNEnergyConsumer', 'powerTransfomer1Q', wnEnergyConsumerUnified.powerTransfomer1Q +''));
+
+    insertQueries.push(wnEnergyConsumerUnified.getPropertySparqlTriple(wnEnergyConsumerUnified.baseIRI, wnEnergyConsumerUnified.mrid, 'westnetzneplan', 'WNEnergyConsumer', 'powerTransfomer2P', wnEnergyConsumerUnified.powerTransfomer2P +''));
+    insertQueries.push(wnEnergyConsumerUnified.getPropertySparqlTriple(wnEnergyConsumerUnified.baseIRI, wnEnergyConsumerUnified.mrid, 'westnetzneplan', 'WNEnergyConsumer', 'powerTransfomer2Q', wnEnergyConsumerUnified.powerTransfomer2Q +''));
+
+
+    insertQueries.push(wnEnergyConsumerUnified.getPropertySparqlTriple(wnEnergyConsumerUnified.baseIRI, wnEnergyConsumerUnified.mrid, 'westnetzneplan', 'WNEnergyConsumer', 'cosPhi', wnEnergyConsumerUnified.cosPhi +''));
+
+    /** alle anderen Lastobjekte löschen */
+    for (const delObject of deleteLoadObjects) {
+        deleteObjectsQueries.push(delObject.createDeleteStatementSPARQL(graphURI));
+        /** die assoziierten Terminals löschen */
+        for (const terminal of delObject.terminals.values()) {
+            deleteObjectsQueries.push(terminal.createDeleteStatementSPARQL(graphURI));
+        }
+    }
+
+    let deleteQuery = '';
+    if(deleteQueries.length > 0) {
+        deleteQuery = deleteQueries.join(' ');
+    }
+
+    let insertQuery = '';
+    if(insertQueries.length > 0) {
+        insertQuery = insertQueries.join(' ');
+    }
+
+    const updateQuery = `
+                        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}{
+                                ${deleteQuery}
+                            }
+                        };
+                        INSERT DATA{
+                            GRAPH ${graphURI} {
+                                ${insertQuery}
+                            }
+                        }
+              `;
+
+    return updateQuery + ';' + deleteObjectsQueries.join(';');
+
+}
+
+/*export function getUpdateDeleteSPARQL(energyConsumerUnified: EnergyConsumer, unifiedName: string, graphURI: string, energyConsumer: EnergyConsumer[]): string {
+
+    const wnEnergyConsumerUnified = energyConsumerUnified as WNEnergyConsumer
+    const insertQueries: string[] = [];
+    const deleteQueries: string[] = [];
+    const deleteObjectsQueries: string[] = [];
+
+    /!** alten Namen löschen *!/
+    // deleteQueries.push(energyConsumerUnified.getUpdateSPARQL(energyConsumerUnified.constructor.name, 'name'));
+    //getPropertySparqlTriple(baseIRI: string, mrid: string, namespace: string, className: string, propName, propValue: string)
+    deleteQueries.push(wnEnergyConsumerUnified.getPropertySparqlTriple(wnEnergyConsumerUnified.baseIRI, wnEnergyConsumerUnified.mrid,
+                                                                    'cim', 'IdentifiedObject',
+                                                            'name', wnEnergyConsumerUnified.name));
+
+    /!** neuen Namen einfügen
+     *  konsolidierte Leistungswerte einfügen *!/
+    wnEnergyConsumerUnified.name = unifiedName;
+    insertQueries.push(wnEnergyConsumerUnified.getPropertySparqlTriple(wnEnergyConsumerUnified.baseIRI, wnEnergyConsumerUnified.mrid, 'cim', 'IdentifiedObject', 'name', wnEnergyConsumerUnified.name));
+    insertQueries.push(wnEnergyConsumerUnified.getPropertySparqlTriple(wnEnergyConsumerUnified.baseIRI, wnEnergyConsumerUnified.mrid, 'westnetzneplan', 'WNEnergyConsumer', 'contractualP', wnEnergyConsumerUnified.contractualP +''));
+    insertQueries.push(wnEnergyConsumerUnified.getPropertySparqlTriple(wnEnergyConsumerUnified.baseIRI, wnEnergyConsumerUnified.mrid, 'westnetzneplan', 'WNEnergyConsumer', 'contractualQ', wnEnergyConsumerUnified.contractualQ +''));
+
+    insertQueries.push(wnEnergyConsumerUnified.getPropertySparqlTriple(wnEnergyConsumerUnified.baseIRI, wnEnergyConsumerUnified.mrid, 'westnetzneplan', 'WNEnergyConsumer', 'measuredP', wnEnergyConsumerUnified.measuredP +''));
+    insertQueries.push(wnEnergyConsumerUnified.getPropertySparqlTriple(wnEnergyConsumerUnified.baseIRI, wnEnergyConsumerUnified.mrid, 'westnetzneplan', 'WNEnergyConsumer', 'measuredQ', wnEnergyConsumerUnified.measuredQ +''));
+
+    insertQueries.push(wnEnergyConsumerUnified.getPropertySparqlTriple(wnEnergyConsumerUnified.baseIRI, wnEnergyConsumerUnified.mrid, 'westnetzneplan', 'WNEnergyConsumer', 'cosPhi', wnEnergyConsumerUnified.cosPhi +''));
+
+    /!** alle anderen Lastobjekte löschen *!/
+    const deleteLoadObjects = energyConsumer.filter(ec => ec.mrid !== wnEnergyConsumerUnified.mrid);
+    for (const delObject of deleteLoadObjects) {
+        deleteObjectsQueries.push(delObject.createDeleteStatementSPARQL(graphURI));
+        /!** die assoziierten Terminals löschen *!/
+        for (const terminal of delObject.terminals.values()) {
+            deleteObjectsQueries.push(terminal.createDeleteStatementSPARQL(graphURI));
+        }
+    }
+
+    let deleteQuery = '';
+    if(deleteQueries.length > 0) {
+        deleteQuery = deleteQueries.join(' ');
+    }
+
+    let insertQuery = '';
+    if(insertQueries.length > 0) {
+        insertQuery = insertQueries.join(' ');
+    }
+
+    const updateQuery = `
+                        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}{
+                                ${deleteQuery}
+                            }
+                        };
+                        INSERT DATA{
+                            GRAPH ${graphURI} {
+                                ${insertQuery}
+                            }
+                        }
+              `;
+
+    return updateQuery + ';' + deleteObjectsQueries.join(';')
+}*/
+
+
+export async function loadFusekiData(fusekiURI: string, graphURI: string,
+                                     loadConfig: string[],
+                                     neplanClassDefinitions: Map<string, any>): Promise<any[]> {
+    return await Promise.all(loadConfig.map(async (className) => {
+        const sparqlQuery = neplanClassDefinitions.get(className).getQuerySPARQL(graphURI);
+        const dataResponse = await fetch(`${fusekiURI}?query=${encodeURIComponent(sparqlQuery)}&format=json`);
+        return await dataResponse.json();
+    }));
+}
+
+export function parseFusekiData(cimModel: Model, cimFusekiDataRaw: any[], loadConfig: string[], neplanClassDefinitions: Map<string, any>) {
+    for (let i = 0; i < cimFusekiDataRaw.length; i++) {
+        const className = loadConfig[i];
+        const rawData = cimFusekiDataRaw[i];
+        neplanClassDefinitions.get(className).resolveClassFusekiJSON(rawData, cimModel);
+    }
+}
+
+