@enervance/insight-cim-model 0.0.486 → 1.0.0-dev

package/dist/etl/etl-neplan/etl-neplan.js

@@ -1,16 +1,669 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.NeplanModelEnrichment = void 0;
 exports.getUnifiedEnergyConsumersNames = getUnifiedEnergyConsumersNames;
 exports.determineMeasuredContractualPower = determineMeasuredContractualPower;
 exports.getEnergyConsumerSPARQL = getEnergyConsumerSPARQL;
 exports.getDeleteDiagramSPARQLFromObject = getDeleteDiagramSPARQLFromObject;
 exports.getTrafoApprentPower = getTrafoApprentPower;
-const sparql_utils_1 = require("../../util/sparql/sparql-utils.js");
+const sparql_utils_1 = require("../../util/sparql/sparql-utils");
+const AssetDeployment_1 = require("../../model/assets/AssetDeployment");
+const ConnectivityNode_1 = require("../../model/core/ConnectivityNode");
+const VoltageLevel_1 = require("../../model/core/VoltageLevel");
+const ExternalNetworkInjection_1 = require("../../model/wires/ExternalNetworkInjection");
+const common_utils_1 = require("../../utils2/common.utils");
+const ACLineSegment_1 = require("../../model/wires/ACLineSegment");
+const WNFacility_1 = require("../../model/extensions/westnetz-neplan/assets/WNFacility");
+const Equipment_1 = require("../../model/core/Equipment");
+const Switch_1 = require("../../model/wires/Switch");
+const Terminal_1 = require("../../model/core/Terminal");
+const Bay_1 = require("../../model/core/Bay");
+const BusbarSection_1 = require("../../model/wires/BusbarSection");
+const utils_1 = require("../../util/utils");
+class NeplanModelEnrichment {
+    /**
+     * Ändert (Bestands-)Terminalinstanzen in EVTerminals um
+     * @param modelContainer Netzmodel
+     * */
+    static typeTerminals(modelContainer) {
+        const graphURI = modelContainer.getGraphURI();
+        const deleteRdfTypes = new Array();
+        const insertRdfType = new Array();
+        for (const terminal of modelContainer.terminals.values()) {
+            /**
+             * Aufgrund der Erweiterung rdf:type von cim:ConnectivityNode zu westnetzneplan:WNConnectivityNode wechseln. */
+            deleteRdfTypes.push(`<${terminal.baseIRI}${terminal.mrid}> rdf:type cim:Terminal .`);
+            insertRdfType.push(`<${terminal.baseIRI}${terminal.mrid}> rdf:type enervance:EVTerminal .`);
+        }
+        const length = insertRdfType.length + deleteRdfTypes.length;
+        const insertDataStatement = [];
+        if (length) {
+            insertDataStatement.push(`
+            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#>
+            
+            ${(0, sparql_utils_1.getInsertDataPartStatement)(graphURI, insertRdfType)}
+            ${(0, sparql_utils_1.getDeleteDataPartStatement)(graphURI, deleteRdfTypes)}
+        `);
+        }
+        return insertDataStatement;
+    }
+    static typeACLineSegments(modelContainer) {
+        const graphURI = modelContainer.getGraphURI();
+        const deleteRdfTypes = new Array();
+        const insertRdfType = new Array();
+        for (const acLineSegment of modelContainer.acLineSegments.values()) {
+            /**
+             * Aufgrund der Erweiterung rdf:type von cim:ConnectivityNode zu westnetzneplan:WNConnectivityNode wechseln. */
+            deleteRdfTypes.push(`<${acLineSegment.baseIRI}${acLineSegment.mrid}> rdf:type cim:ACLineSegment .`);
+            insertRdfType.push(`<${acLineSegment.baseIRI}${acLineSegment.mrid}> rdf:type enervance:EVACLineSegment .`);
+        }
+        const length = insertRdfType.length + deleteRdfTypes.length;
+        const insertDataStatement = [];
+        if (length) {
+            insertDataStatement.push(`
+            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#>
+            
+            ${(0, sparql_utils_1.getInsertDataPartStatement)(graphURI, insertRdfType)}
+            ${(0, sparql_utils_1.getDeleteDataPartStatement)(graphURI, deleteRdfTypes)}
+        `);
+        }
+        return insertDataStatement;
+    }
+    static rearrangeVoltageLevels(modelContainer, csvData) {
+        const graphURI = modelContainer.getGraphURI();
+        const deleteSparql = new Array();
+        const insertSparql = new Array();
+        const processedNodes = new Set();
+        const nodesToCombine = new Array();
+        /** 1) Alle zusammengehörige CNs und CunductingEquipments bestimmen */
+        for (const connectivityNode of modelContainer.connectivityNodes.values()) {
+            if (!processedNodes.has(connectivityNode?.getUUID())) {
+                const objectsFound = NeplanModelEnrichment.getVoltageLevelObjects(connectivityNode);
+                nodesToCombine.push(objectsFound);
+                objectsFound.forEach(it => {
+                    processedNodes.add(it?.getUUID());
+                });
+            }
+        }
+        /** 2) Zussamengehördende VoltageLevels bestimmen */
+        const voltageLevelToCombine = new Map();
+        const psrTypeUA = modelContainer.getPsrTypeByName('Umspannanlage');
+        if (psrTypeUA === undefined || psrTypeUA === null)
+            return [];
+        voltageLevelToCombine.set(psrTypeUA.getUUID(), new Array());
+        const psrTypeONS = modelContainer.getPsrTypeByName('Ortsnetzstation');
+        if (psrTypeONS === undefined || psrTypeONS === null)
+            return [];
+        voltageLevelToCombine.set(psrTypeONS.getUUID(), new Array());
+        for (const nodes of nodesToCombine) {
+            const vlSet = new Set();
+            const connectivityNodes = new Set();
+            const equipments = new Set();
+            const substationType = nodes.some(it => it instanceof ExternalNetworkInjection_1.ExternalNetworkInjection) ? psrTypeUA : psrTypeONS;
+            for (const node of nodes) {
+                if (node instanceof Equipment_1.Equipment) {
+                    if (!node.equipmentContainer) {
+                        console.log(`node ${node.mrid} ohne equipmentContainer`);
+                        continue;
+                    }
+                    const equipmentContainer = node.equipmentContainer;
+                    vlSet.add(equipmentContainer);
+                    equipments.add(node);
+                }
+                else if (node instanceof ConnectivityNode_1.ConnectivityNode) {
+                    if (!node.connectivityNodeContainer) {
+                        console.log(`node ${node.mrid} ohne equipmentContainer`);
+                        continue;
+                    }
+                    const connectivityNodeContainer = node.connectivityNodeContainer;
+                    vlSet.add(connectivityNodeContainer);
+                    connectivityNodes.add(node);
+                }
+                else {
+                    console.log(`rearrangeVoltageLevels: unbekannter Node -> Class ${node?.constructor?.name} | UUID ${node?.getUUID()}`);
+                }
+            }
+            voltageLevelToCombine.get(substationType.getUUID()).push({
+                voltageLevels: Array.from(vlSet),
+                connectivityNodes: Array.from(connectivityNodes),
+                equipments: Array.from(equipments)
+            });
+        }
+        const baseURL = modelContainer.getBaseURL();
+        /** VoltageLevels (ONS) ohne Spannungsquelle (Slack) zu einem Substation-Objekt zuordnen */
+        const onsNodes = voltageLevelToCombine.get(psrTypeONS.getUUID());
+        const removedVls = new Set();
+        for (const onsValue of onsNodes) {
+            const voltageLevels = onsValue.voltageLevels;
+            const connectivityNodes = onsValue.connectivityNodes;
+            const equipments = onsValue.equipments;
+            if (!connectivityNodes.length) {
+                console.log('keine VoltageLevels zur Zusammenfassung gefunden');
+                continue;
+            }
+            const tp = connectivityNodes?.find(it => it.name?.length === 21)?.name;
+            const substationName = (0, utils_1.escapeSpecialChars)(tp ? tp : connectivityNodes?.find(it => it?.name)?.name);
+            const substationDescription = (0, utils_1.escapeSpecialChars)(connectivityNodes?.find(it => it.description)?.description);
+            const newVoltageLevelUUID = common_utils_1.CommonUtils.generateUUID();
+            const newSubstationUUID = common_utils_1.CommonUtils.generateUUID();
+            const baseVoltage = connectivityNodes?.find(it => it.getBaseVoltage())?.getBaseVoltage();
+            const baseURL = modelContainer.getBaseURL();
+            /** neue Substation */
+            insertSparql.push(`<${baseURL}${newSubstationUUID}> rdf:type cim:Substation .`);
+            insertSparql.push(`<${baseURL}${newSubstationUUID}> cim:IdentifiedObject.name '${substationName}' .`);
+            insertSparql.push(`<${baseURL}${newSubstationUUID}> cim:IdentifiedObject.description '${substationDescription}' .`);
+            insertSparql.push(`<${baseURL}${newSubstationUUID}> cim:PowerSystemResource.PSRType <${psrTypeONS.baseIRI}${psrTypeONS.getUUID()}> .`);
+            /** neues VoltageLevel */
+            insertSparql.push(`<${baseURL}${newVoltageLevelUUID}> rdf:type cim:VoltageLevel .`);
+            insertSparql.push(`<${baseURL}${newVoltageLevelUUID}> cim:IdentifiedObject.name '${baseVoltage?.name ? baseVoltage.name : 'unbekannt'}' .`);
+            insertSparql.push(`<${baseURL}${newVoltageLevelUUID}> cim:VoltageLevel.Substation <${baseURL}${newSubstationUUID}> .`);
+            insertSparql.push(`<${baseURL}${newVoltageLevelUUID}> cim:VoltageLevel.BaseVoltage <${baseVoltage.baseIRI}${baseVoltage?.getUUID()}> .`);
+            connectivityNodes.forEach(it => {
+                const voltageLevel = it.connectivityNodeContainer;
+                if (!removedVls.has(voltageLevel?.getUUID())) {
+                    deleteSparql.push(`<${voltageLevel.baseIRI}${voltageLevel.getUUID()}> rdf:type cim:VoltageLevel .`);
+                    removedVls.add(voltageLevel.getUUID());
+                }
+                deleteSparql.push(`<${it.baseIRI}${it.getUUID()}> cim:ConnectivityNode.ConnectivityNodeContainer <${voltageLevel?.baseIRI}${voltageLevel.getUUID()}> .`);
+                insertSparql.push(`<${it.baseIRI}${it.getUUID()}> cim:ConnectivityNode.ConnectivityNodeContainer <${baseURL}${newVoltageLevelUUID}> .`);
+            });
+            equipments.forEach(it => {
+                const voltageLevel = it.equipmentContainer;
+                if (it.equipmentContainer) {
+                    // Lösche Vl, wenn kein SlackVL
+                    if (!removedVls.has(voltageLevel?.getUUID())) {
+                        deleteSparql.push(`<${voltageLevel.baseIRI}${voltageLevel.getUUID()}> rdf:type cim:VoltageLevel .`);
+                        removedVls.add(voltageLevel.getUUID());
+                    }
+                    deleteSparql.push(`<${it.baseIRI}${it.getUUID()}> cim:Equipment.EquipmentContainer <${it.baseIRI}${voltageLevel.getUUID()}> .`);
+                    insertSparql.push(`<${it.baseIRI}${it.getUUID()}> cim:Equipment.EquipmentContainer <${baseURL}${newVoltageLevelUUID}> .`);
+                }
+            });
+            for (const voltageLevel of voltageLevels) {
+                const oldSubstation = voltageLevel.getSubstation();
+                /** alte Substation aus VoltageLevel löschen */
+                deleteSparql.push(`<${voltageLevel.baseIRI}${voltageLevel.getUUID()}> cim:VoltageLevel.Substation <${oldSubstation?.baseIRI}${oldSubstation?.getUUID()}> .`);
+                deleteSparql.push(`<${voltageLevel.baseIRI}${voltageLevel.getUUID()}> cim:IdentifiedObject.name '${voltageLevel.name}' .`);
+            }
+        }
+        /** VoltageLevels (Umspannanlage) mit Spannungsquelle (Slack) zu einem Substation-Objekt zuordnen */
+        const uaNodes = voltageLevelToCombine.get(psrTypeUA.getUUID());
+        for (const uaValue of uaNodes) {
+            const equipmentContainers = uaValue.voltageLevels;
+            const voltageLevels = equipmentContainers.filter(it => it instanceof VoltageLevel_1.VoltageLevel);
+            const connectivityNodes = uaValue.connectivityNodes;
+            const connectivityNodeNames = connectivityNodes.map(it => it.name);
+            const equipments = uaValue.equipments;
+            /** Name der Umspannanlage bestimmen */
+            const nameData = csvData.find(it => connectivityNodeNames.includes(it.tp))?.name;
+            const substationName = nameData ? nameData : connectivityNodes?.find(it => it.name)?.description;
+            const substationTP = connectivityNodes?.find(it => it.name.length)?.name.substr(0, 21);
+            const substationDescription = substationTP ? substationTP : connectivityNodes?.find(it => it.name.length)?.name;
+            const baseVoltage = connectivityNodes?.find(it => it.getBaseVoltage() !== undefined)?.getBaseVoltage();
+            const newVoltageLevelUUID = common_utils_1.CommonUtils.generateUUID();
+            const newSubstationUUID = common_utils_1.CommonUtils.generateUUID();
+            /** neue Substation */
+            insertSparql.push(`<${baseURL}${newSubstationUUID}> rdf:type cim:Substation .`);
+            insertSparql.push(`<${baseURL}${newSubstationUUID}> cim:IdentifiedObject.name 'UA ${substationName ? substationName : 'unbekannt'}' .`);
+            insertSparql.push(`<${baseURL}${newSubstationUUID}> cim:IdentifiedObject.description '${substationDescription}' .`);
+            insertSparql.push(`<${baseURL}${newSubstationUUID}> cim:PowerSystemResource.PSRType <${psrTypeUA.baseIRI}${psrTypeUA.getUUID()}> .`);
+            /** neues VoltageLevel */
+            insertSparql.push(`<${baseURL}${newVoltageLevelUUID}> rdf:type cim:VoltageLevel .`);
+            insertSparql.push(`<${baseURL}${newVoltageLevelUUID}> cim:IdentifiedObject.name '${baseVoltage?.name ? baseVoltage.name : 'unbekannt'}' .`);
+            insertSparql.push(`<${baseURL}${newVoltageLevelUUID}> cim:VoltageLevel.Substation <${baseURL}${newSubstationUUID}> .`);
+            insertSparql.push(`<${baseURL}${newVoltageLevelUUID}> cim:VoltageLevel.BaseVoltage <${baseVoltage.baseIRI}${baseVoltage?.getUUID()}> .`);
+            connectivityNodes.forEach(it => {
+                const voltageLevel = it.connectivityNodeContainer;
+                if (!removedVls.has(voltageLevel?.getUUID())) {
+                    deleteSparql.push(`<${voltageLevel.baseIRI}${voltageLevel.getUUID()}> rdf:type cim:VoltageLevel .`);
+                    removedVls.add(voltageLevel.getUUID());
+                }
+                deleteSparql.push(`<${it.baseIRI}${it.getUUID()}> cim:ConnectivityNode.ConnectivityNodeContainer <${voltageLevel?.baseIRI}${voltageLevel.getUUID()}> .`);
+                insertSparql.push(`<${it.baseIRI}${it.getUUID()}> cim:ConnectivityNode.ConnectivityNodeContainer <${baseURL}${newVoltageLevelUUID}> .`);
+            });
+            equipments.forEach(it => {
+                const voltageLevel = it.equipmentContainer;
+                if (it.equipmentContainer) {
+                    // Lösche Vl, wenn kein SlackVL
+                    if (!removedVls.has(voltageLevel?.getUUID())) {
+                        deleteSparql.push(`<${voltageLevel.baseIRI}${voltageLevel.getUUID()}> rdf:type cim:VoltageLevel .`);
+                        removedVls.add(voltageLevel.getUUID());
+                    }
+                    deleteSparql.push(`<${it.baseIRI}${it.getUUID()}> cim:Equipment.EquipmentContainer <${it.baseIRI}${voltageLevel.getUUID()}> .`);
+                    insertSparql.push(`<${it.baseIRI}${it.getUUID()}> cim:Equipment.EquipmentContainer <${baseURL}${newVoltageLevelUUID}> .`);
+                }
+            });
+            for (const voltageLevel of voltageLevels) {
+                const oldSubstation = voltageLevel.getSubstation();
+                /** alte Substation aus VoltageLevel löschen */
+                deleteSparql.push(`<${oldSubstation.baseIRI}${oldSubstation.getUUID()}> rdf:type cim:Substation .`);
+                deleteSparql.push(`<${voltageLevel.baseIRI}${voltageLevel.getUUID()}> cim:VoltageLevel.Substation <${oldSubstation.baseIRI}${oldSubstation.getUUID()}> .`);
+            }
+        }
+        const length = insertSparql.length + deleteSparql.length;
+        const insertDataStatement = [];
+        if (length) {
+            insertDataStatement.push(`
+            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#>
+            
+            ${(0, sparql_utils_1.getInsertDataPartStatement)(graphURI, insertSparql)}
+            ${(0, sparql_utils_1.getDeleteDataPartStatement)(graphURI, deleteSparql)}
+        `);
+        }
+        return insertDataStatement;
+    }
+    /**
+     * Bestimmt alle zu einem VoltageLevel gehörigen Objekte.
+     * @param startCN Startknoten
+     * @return Ein Array mit zu einem VoltageLevel gehörigen Objekte
+     * */
+    static getVoltageLevelObjects(startCN) {
+        const objectsFound = new Array();
+        let nodesOnCurrentLevel = new Array();
+        let nodesOnNextLevel = new Array(startCN);
+        let nodesVisited = [];
+        while (nodesOnNextLevel.length) {
+            nodesOnCurrentLevel.length = 0;
+            nodesOnCurrentLevel = [...nodesOnNextLevel];
+            /** next level nodes leeren */
+            nodesOnNextLevel.length = 0;
+            for (const currentNode of nodesOnCurrentLevel) {
+                objectsFound.push(currentNode);
+                nodesVisited.push(currentNode.getUUID());
+                for (const terminal of currentNode.terminals.values()) {
+                    if (!terminal)
+                        continue;
+                    /** Terminal traversierbar und nicht besucht */
+                    if (nodesVisited.indexOf(terminal.getUUID()) > -1)
+                        continue;
+                    const terminalConductingEquipment = terminal.conductingEquipment;
+                    if (!terminalConductingEquipment)
+                        continue;
+                    if (nodesVisited.indexOf(terminalConductingEquipment?.getUUID()) === -1) {
+                        let toAdd = true;
+                        /** Stromkreisabschnitte mit einer Länge von 0.001 oder 0 werden häufig als Hilfselemente verwendet innerhalb von Stationen verwendet.
+                         * Daher werden derartige Stromkreisabschnitte als Bestandteil von Station berücksichtigt.
+                         * Es gibt Stromkreisabschnitte mit einer kürzeren Länge. Die Letzteren sind 'korrekte' Abschnitte.
+                         * */
+                        if (terminalConductingEquipment instanceof ACLineSegment_1.ACLineSegment) {
+                            const acLineSegment = terminalConductingEquipment;
+                            const length = acLineSegment.length;
+                            if (length !== 0.001) {
+                                toAdd = false;
+                            }
+                            else if (!acLineSegment?.isConnected()) {
+                                /** 1 Meter Leitung Sonderfall.
+                                 *  Wenn die Leitung nicht angeschlossen ist,
+                                 *  dann werden diese Knoten nicht zu einer ONS-Substation zusammengefasst. */
+                                toAdd = false;
+                            }
+                        }
+                        if (toAdd) {
+                            nodesOnNextLevel.push(terminalConductingEquipment);
+                        }
+                    }
+                    const terminalConnectivityNode = terminal.connectivityNode;
+                    if (!terminalConnectivityNode)
+                        continue;
+                    if (nodesVisited.indexOf(terminalConnectivityNode.getUUID()) === -1) {
+                        nodesOnNextLevel.push(terminalConnectivityNode);
+                    }
+                }
+            }
+        }
+        return objectsFound;
+    }
+    /**
+     *  Erstellt für ConnectivityNodes das Assetmodell.
+     * @param modelContainer Netzmodel
+     * */
+    static createAssetModelConnectivityNode(modelContainer) {
+        const graphURI = modelContainer.getGraphURI();
+        const createObjectsSPARQL = [];
+        const setValueSPARQL = [];
+        const addReleationsSPARQL = [];
+        const deleteRdfTypes = new Array();
+        const insertRdfType = new Array();
+        for (const cn of modelContainer.connectivityNodes.values()) {
+            const facility = new WNFacility_1.WNFacility(common_utils_1.CommonUtils.generateUUID(), cn.mrid, '', '', cn.baseIRI);
+            /** CN <-> Facility */
+            createObjectsSPARQL.push(facility.createNewStatementSPARQL());
+            addReleationsSPARQL.push(facility.addConnectivityNode(cn));
+            /**
+             * Aufgrund der Erweiterung rdf:type von cim:ConnectivityNode zu westnetzneplan:WNConnectivityNode wechseln.
+             * */
+            deleteRdfTypes.push(`<${cn.baseIRI}${cn.mrid}> rdf:type cim:ConnectivityNode .\n`);
+            insertRdfType.push(`<${cn.baseIRI}${cn.mrid}> rdf:type westnetzneplan:WNConnectivityNode .\n`);
+        }
+        const length = createObjectsSPARQL.length + setValueSPARQL.length + addReleationsSPARQL.length;
+        const insertDataStatement = [];
+        if (length) {
+            insertDataStatement.push(`
+            PREFIX rdf:             <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+            PREFIX enervance:       <http://enervance.com/CIM/Extensions#> 
+            PREFIX entsoe:	 	          <http://entsoe.eu/CIM/SchemaExtension/3/1#> 
+            PREFIX cim:             <http://iec.ch/TC57/2013/CIM-schema-cim16#>
+            PREFIX westnetzneplan:  <http://westnetzneplan.de/CIM/Extensions#>
+            
+            ${(0, sparql_utils_1.getInsertDataPartStatement)(graphURI, [...createObjectsSPARQL, ...addReleationsSPARQL, ...setValueSPARQL, ...insertRdfType])}
+            ${(0, sparql_utils_1.getDeleteDataPartStatement)(graphURI, deleteRdfTypes)}
+        `);
+        }
+        return insertDataStatement;
+    }
+    /**
+     *  Erstellt für EnergySources das Assetmodell.
+     * @param modelContainer Netzmodel
+     * */
+    static createAssetModelEnergySources(modelContainer) {
+        const graphURI = modelContainer.getGraphURI();
+        const createObjectsSPARQL = [];
+        const setValueSPARQL = [];
+        const addReleationsSPARQL = [];
+        const energyConnections = [...modelContainer.energySources.values()];
+        for (const ec of energyConnections) {
+            const facility = new WNFacility_1.WNFacility(common_utils_1.CommonUtils.generateUUID(), ec.name, '', '', ec.baseIRI);
+            const assetDeployment = new AssetDeployment_1.AssetDeployment(common_utils_1.CommonUtils.generateUUID(), ec.name, '', '', ec.baseIRI);
+            /** CN <-> Facility */
+            createObjectsSPARQL.push(facility.createNewStatementSPARQL());
+            addReleationsSPARQL.push(facility.addPowerSystemResource(ec));
+            /** AssetDeployment <-> Facility */
+            createObjectsSPARQL.push(assetDeployment.createNewStatementSPARQL());
+            addReleationsSPARQL.push(assetDeployment.setAsset(facility));
+        }
+        const length = createObjectsSPARQL.length + setValueSPARQL.length + addReleationsSPARQL.length;
+        const insertDataStatement = [];
+        if (length) {
+            insertDataStatement.push(`
+            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#>
+            
+            ${(0, sparql_utils_1.getInsertDataPartStatement)(graphURI, [...createObjectsSPARQL, ...addReleationsSPARQL, ...setValueSPARQL])}
+        `);
+        }
+        return insertDataStatement;
+    }
+    /**
+     * Aufgrund der Erweiterung rdf:type von cim:EnergyConsumer
+     * zu westnetzneplan:WNEnergyConsumer wechseln. */
+    static transformEnergyConsumers(modelContainer) {
+        const graphURI = modelContainer.getGraphURI();
+        const deleteRdfTypes = new Array();
+        const insertRdfType = new Array();
+        for (const ec of modelContainer.energyConsumers.values()) {
+            deleteRdfTypes.push(`<${ec.baseIRI}${ec.mrid}> rdf:type cim:EnergyConsumer .`);
+            insertRdfType.push(`<${ec.baseIRI}${ec.mrid}> rdf:type westnetzneplan:WNEnergyConsumer .`);
+        }
+        const length = deleteRdfTypes.length + insertRdfType.length;
+        const insertDataStatement = [];
+        if (length) {
+            insertDataStatement.push(`
+            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#>
+            
+            ${(0, sparql_utils_1.getInsertDataPartStatement)(graphURI, insertRdfType)}
+            ${(0, sparql_utils_1.getDeleteDataPartStatement)(graphURI, deleteRdfTypes)}
+        `);
+        }
+        return insertDataStatement;
+    }
+    static unifyEnergyConsumers(modelContainer) {
+        const graphURI = modelContainer.getGraphURI();
+        const sparqlUpdates = [];
+        /** key unifiedName, Value -> EnergySourceArray*/
+        const tpEnergyConsumerMap = getUnifiedEnergyConsumersNames(modelContainer);
+        if (tpEnergyConsumerMap.size > 0) {
+            for (const entry of tpEnergyConsumerMap.entries()) {
+                const unifiedName = entry[0];
+                const energyConsumers = entry[1];
+                const energyConsumerUnified = determineMeasuredContractualPower(unifiedName, energyConsumers);
+                if (energyConsumerUnified.size > 0) {
+                    const sparqlUpdate = getEnergyConsumerSPARQL(energyConsumerUnified, unifiedName, graphURI, 0);
+                    sparqlUpdates.push(sparqlUpdate);
+                }
+            }
+        }
+        else {
+            console.log(`tpEnergyConsumerMap.size ${tpEnergyConsumerMap.size}`);
+        }
+        const insertQueries = [];
+        for (const row of sparqlUpdates) {
+            insertQueries.push(...row.insert);
+        }
+        const deleteWhereQueries = [];
+        for (const row of sparqlUpdates) {
+            deleteWhereQueries.push(...row.deleteWhere);
+        }
+        const deleteWhereValuesQueries = [];
+        for (const row of sparqlUpdates) {
+            deleteWhereValuesQueries.push(...row.deleteWhereValues);
+        }
+        const length = insertQueries.length + deleteWhereQueries.length + deleteWhereValuesQueries.length;
+        const insertDataStatement = [];
+        if (length) {
+            insertDataStatement.push(`
+                        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 enervance: <http://enervance.com/CIM/Extensions#>
+                        PREFIX westnetzneplan:  <http://westnetzneplan.de/CIM/Extensions#>
+
+                        ${(0, sparql_utils_1.getDeleteWhereValuesPartStatement)(graphURI, deleteWhereValuesQueries)}
+                        ${(0, sparql_utils_1.getDeleteWherePartStatement)(graphURI, deleteWhereQueries)}
+                        ${(0, sparql_utils_1.getInsertDataPartStatement)(graphURI, insertQueries)}
+        `);
+        }
+        return insertDataStatement;
+    }
+    /**
+     * Anreicherungen der Mittelspannungsumspannanlagen um Schaltfeld-Objekte
+     * */
+    static createBays(modelContainer) {
+        const substations = [...modelContainer.substations.values()].filter(it => it.getPsrType()?.getName() === 'Umspannanlage');
+        const baseURL = modelContainer.getBaseURL();
+        const deleteSparql = new Array();
+        const insertSparql = new Array();
+        const report = new Array();
+        report.push(`CreateBays: Netz ${modelContainer.graphUri}`);
+        for (const substation of substations) {
+            for (const feeder of substation.normalEnergizingFeeder.values()) {
+                report.push(`\tAbgang ${feeder.name}`);
+                /** Anfangsknoten */
+                const headConnectivityNodes = Array.from(new Set([...feeder.normalHeadTerminal.values()].map(it => it.getConnectivityNode())));
+                for (const headConnectivityNode of headConnectivityNodes) {
+                    const bayEquipments = NeplanModelEnrichment.getBusbarSectionConnectivityNode(headConnectivityNode);
+                    const bayVoltageLevel = headConnectivityNode.connectivityNodeContainer;
+                    const distinctConnectivityNode = Array.from(new Set([...bayEquipments.filter(it => it instanceof ConnectivityNode_1.ConnectivityNode)]));
+                    const distinctSwitches = Array.from(new Set([...bayEquipments.filter(it => it instanceof Switch_1.Switch)]));
+                    const distinctAcLines = Array.from(new Set([...bayEquipments.filter(it => it instanceof ACLineSegment_1.ACLineSegment)]));
+                    report.push(`\t\tConnectivityNode Anzahl ${distinctConnectivityNode?.length} | Switch Anzahl  ${distinctSwitches?.length} | ACLineSegment Anzahl  ${distinctAcLines?.length}`);
+                    if (!distinctSwitches.length) {
+                        console.log(`\t\tEs wird kein Schaltfeld angelegt`);
+                        continue;
+                    }
+                    const bayUuid = common_utils_1.CommonUtils.generateUUID();
+                    const bay = new Bay_1.Bay(bayUuid, feeder.name, feeder.number);
+                    bay.voltageLevel = bayVoltageLevel;
+                    insertSparql.push(`<${baseURL}${bayUuid}> rdf:type cim:Bay .`);
+                    insertSparql.push(`<${baseURL}${bayUuid}> cim:IdentifiedObject.name '${bay.name}' .`);
+                    insertSparql.push(`<${baseURL}${bayUuid}> entsoe:IdentifiedObject.shortName '${bay.shortName}' .`);
+                    insertSparql.push(`<${baseURL}${bayUuid}> cim:Bay.VoltageLevel <${bayVoltageLevel.baseIRI}${bayVoltageLevel.getUUID()}> .`);
+                    /** Switches vom VoltageLevel zu Schaltfeld umhängen */
+                    for (const swtch of distinctSwitches) {
+                        const equipmentContainer = swtch.equipmentContainer;
+                        insertSparql.push(`<${swtch.baseIRI}${swtch.getUUID()}> cim:Equipment.EquipmentContainer <${baseURL}${bayUuid}> .`);
+                        deleteSparql.push(`<${swtch.baseIRI}${swtch.getUUID()}> cim:Equipment.EquipmentContainer <${equipmentContainer.baseIRI}${equipmentContainer.getUUID()}> .`);
+                    }
+                    /** Connectivity vom VoltageLevel zu Schaltfeld umhängen */
+                    for (const cn of distinctConnectivityNode) {
+                        const connectivityNodeContainer = cn.connectivityNodeContainer;
+                        insertSparql.push(`<${cn.baseIRI}${cn.getUUID()}> cim:ConnectivityNode.ConnectivityNodeContainer <${baseURL}${bayUuid}> .`);
+                        deleteSparql.push(`<${cn.baseIRI}${cn.getUUID()}> cim:ConnectivityNode.ConnectivityNodeContainer <${connectivityNodeContainer.baseIRI}${connectivityNodeContainer.getUUID()}> .`);
+                    }
+                    report.push(`\t\tBay für Feeder ${feeder.name} hinzugefügt`);
+                }
+            }
+        }
+        const graphURI = modelContainer.getGraphURI();
+        const length = insertSparql.length + deleteSparql.length;
+        const insertDataStatement = [];
+        if (length) {
+            insertDataStatement.push(`
+            PREFIX rdf:             <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+            PREFIX entsoe:             <http://entsoe.eu/CIM/SchemaExtension/3/1#>
+            PREFIX enervance:       <http://enervance.com/CIM/Extensions#> 
+            PREFIX cim:             <http://iec.ch/TC57/2013/CIM-schema-cim16#>
+            PREFIX westnetzneplan:  <http://westnetzneplan.de/CIM/Extensions#>
+            
+            ${(0, sparql_utils_1.getInsertDataPartStatement)(graphURI, insertSparql)}
+            ${(0, sparql_utils_1.getDeleteDataPartStatement)(graphURI, deleteSparql)}
+        `);
+        }
+        return { sparql: insertDataStatement, report: report };
+    }
+    /**
+     * Sucht vom Anfang des Abgangs aus das ConnectivityNode mit assozierten Sammelschiene.
+     * @param startCN Startknoten
+     * @return Ein Array mit zu einem Bay gehörigen Objekte
+     * */
+    static getBusbarSectionConnectivityNode(startCN) {
+        const objectsFound = new Array();
+        let nodesOnCurrentLevel = new Array();
+        let nodesOnNextLevel = new Array(startCN);
+        let nodesVisited = [];
+        while (nodesOnNextLevel.length) {
+            nodesOnCurrentLevel.length = 0;
+            nodesOnCurrentLevel = [...nodesOnNextLevel];
+            /** next level nodes leeren */
+            nodesOnNextLevel.length = 0;
+            for (const currentNode of nodesOnCurrentLevel) {
+                if (currentNode.getUUID() !== startCN.getUUID()) {
+                    objectsFound.push(currentNode);
+                }
+                nodesVisited.push(currentNode.getUUID());
+                for (const terminal of currentNode.terminals.values()) {
+                    /** Terminal traversierbar und nicht besucht */
+                    if (nodesVisited.indexOf(terminal.getUUID()) > -1)
+                        continue;
+                    const terminalConductingEquipment = terminal.conductingEquipment;
+                    if (nodesVisited.indexOf(terminalConductingEquipment?.getUUID()) === -1) {
+                        let toAdd = true;
+                        /** Stromkreisabschnitte mit einer Länge von 0.001 oder 0 werden häufig als Hilfselemente verwendet innerhalb von Stationen verwendet.
+                         * Daher werden derartige Stromkreisabschnitte als Bestandteil von Station berücksichtigt.
+                         * Es gibt Stromkreisabschnitte mit einer kürzeren Länge. Die Letzteren sind 'korrekte' Abschnitte.
+                         * */
+                        if (terminalConductingEquipment instanceof ACLineSegment_1.ACLineSegment) {
+                            if (terminalConductingEquipment.length !== 0.001) {
+                                toAdd = false;
+                            }
+                        }
+                        else if (terminalConductingEquipment instanceof BusbarSection_1.BusbarSection) {
+                            toAdd = false;
+                        }
+                        if (toAdd) {
+                            nodesOnNextLevel.push(terminalConductingEquipment);
+                        }
+                    }
+                    const terminalConnectivityNode = terminal.connectivityNode;
+                    if (nodesVisited.indexOf(terminalConnectivityNode?.getUUID()) === -1) {
+                        const busbarSection = [...terminalConnectivityNode.terminals.values()].find(it => it.conductingEquipment instanceof BusbarSection_1.BusbarSection);
+                        if (!busbarSection)
+                            nodesOnNextLevel.push(terminalConnectivityNode);
+                    }
+                }
+            }
+        }
+        return objectsFound;
+    }
+    static getConnectedSwitches(terminals) {
+        return [...terminals.values()].map(it => it.conductingEquipment).filter(it => it instanceof Switch_1.Switch);
+    }
+    static getConnectedProvisionalLineSegments(terminals) {
+        return [...terminals.values()].map(it => {
+            if (it.conductingEquipment instanceof ACLineSegment_1.ACLineSegment) {
+                if (it.conductingEquipment.length === 0.001) {
+                    return it.conductingEquipment;
+                }
+            }
+        }).filter(it => it instanceof ACLineSegment_1.ACLineSegment);
+    }
+    /**
+     * Anreicherung der Mittelspannungsumspannanlagen um Sammelschienen-Objekte, wenn keine vorhanden sind.
+     * */
+    static createBusbarSections(modelContainer) {
+        const substations = [...modelContainer.substations.values()].filter(it => it.getPsrType()?.getName() === 'Umspannanlage');
+        const insertSparql = new Array();
+        const report = new Array();
+        report.push(`Create createBusbarSections: Netz ${modelContainer.modelsContainer.graphUri}`);
+        const baseURL = modelContainer.getBaseURL();
+        for (const substation of substations) {
+            for (const voltageLevel of substation.getVoltageLevels()) {
+                /** Fahre fort, wenn keine Spannungsquelle vorhanden ist */
+                // if (!slacks.length) continue;
+                /** bestimme Anzahl der angeschlossenen Schaltelemente je Konten*/
+                for (const cn of voltageLevel.connectivityNodes) {
+                    const busbarSectionCount = [...cn.terminals.values()].filter(it => it.conductingEquipment instanceof BusbarSection_1.BusbarSection).length;
+                    /** Wenn eine Sammelschiene bereits vorhanden ist, dann überspringe */
+                    if (busbarSectionCount > 0)
+                        continue;
+                    const switchCount = [...cn.terminals.values()].filter(it => it.conductingEquipment instanceof Switch_1.Switch).length;
+                    /** Für Knoten mit mehr als drei Switches wird eine Sammelschiene angelegt
+                     * 4-Fach kommen in MS-Netzen nicht vor */
+                    if (switchCount < 4)
+                        continue;
+                    const busbarSecUuid = common_utils_1.CommonUtils.generateUUID();
+                    const busbarSection = new BusbarSection_1.BusbarSection(busbarSecUuid, cn.name, 'SS', 'Eine automatisch generierte Sammelschiene');
+                    busbarSection.equipmentContainer = cn.connectivityNodeContainer;
+                    insertSparql.push(`<${baseURL}${busbarSecUuid}> rdf:type cim:BusbarSection .`);
+                    insertSparql.push(`<${baseURL}${busbarSecUuid}> cim:IdentifiedObject.name '${busbarSection.name}' .`);
+                    insertSparql.push(`<${baseURL}${busbarSecUuid}> entsoe:IdentifiedObject.shortName '${busbarSection.shortName}' .`);
+                    insertSparql.push(`<${baseURL}${busbarSecUuid}> cim:IdentifiedObject.description '${busbarSection.description}' .`);
+                    insertSparql.push(`<${baseURL}${busbarSecUuid}> cim:Equipment.EquipmentContainer <${cn.connectivityNodeContainer.baseIRI}${cn.connectivityNodeContainer?.getUUID()}> .`);
+                    const terminalUuid = common_utils_1.CommonUtils.generateUUID();
+                    const terminal = new Terminal_1.Terminal(terminalUuid, 'SS Terminal');
+                    insertSparql.push(`<${baseURL}${terminalUuid}> rdf:type cim:Terminal .`);
+                    insertSparql.push(`<${baseURL}${terminalUuid}> cim:IdentifiedObject.name '${terminal.name}' .`);
+                    insertSparql.push(`<${baseURL}${terminalUuid}> cim:Terminal.ConductingEquipment <${baseURL}${busbarSecUuid}> .`);
+                    insertSparql.push(`<${baseURL}${terminalUuid}> cim:Terminal.ConnectivityNode <${cn.baseIRI}${cn.getUUID()}> .`);
+                    report.push(`\tSammelschiene für Knoten ${cn.name} hinzugefügt`);
+                }
+            }
+        }
+        const graphURI = modelContainer.getGraphURI();
+        const length = insertSparql.length;
+        const insertDataStatement = [];
+        if (length) {
+            insertDataStatement.push(`
+            PREFIX rdf:             <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+            PREFIX entsoe:          <http://entsoe.eu/CIM/SchemaExtension/3/1#>
+            PREFIX enervance:       <http://enervance.com/CIM/Extensions#> 
+            PREFIX cim:             <http://iec.ch/TC57/2013/CIM-schema-cim16#>
+            PREFIX westnetzneplan:  <http://westnetzneplan.de/CIM/Extensions#>
+            
+            ${(0, sparql_utils_1.getInsertDataPartStatement)(graphURI, insertSparql)}
+        `);
+        }
+        return { sparql: insertDataStatement, report: report };
+    }
+}
+exports.NeplanModelEnrichment = NeplanModelEnrichment;
 function getUnifiedEnergyConsumersNames(cimModelXML) {
     const tpEnergyConsumerMap = new Map();
     for (const ec of cimModelXML.energyConsumers.values()) {
-        if (ec.name && ec.name.length >= 10) {
-            const unifiedName = ec.name.substr(0, 10);
+        if (ec.name && ec.name.length >= 21) {
+            const unifiedName = ec.name.substr(0, 21);
             let unifiedNameArray = tpEnergyConsumerMap.get(unifiedName);
             if (!unifiedNameArray) {
                 unifiedNameArray = [];
@@ -48,7 +701,7 @@ function determineMeasuredContractualPower(unifiedName, energyConsumer) {
         result.set('consolidated', energyConsumerMain);
         result.set('remove', ecToRemove);
         for (const ec of energyConsumer) {
-            const type = ec.name.substring(10, ec.name.length);
+            const type = ec.name.substring(ec.name.length - 2, ec.name.length);
             switch (type) {
                 case '-M': {
                     energyConsumerMain.measuredP = ec.p;
@@ -60,17 +713,22 @@ function determineMeasuredContractualPower(unifiedName, energyConsumer) {
                     energyConsumerMain.contractualQ = ec.q;
                     break;
                 }
-                case '-MB': {
+                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': {
+                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 '-BA00-SP01': {
+                case '-T': {
+                    energyConsumerMain.powerTransfomer1P = ec.p;
+                    energyConsumerMain.powerTransfomer1Q = ec.q;
+                    break;
+                }
+                case 'T1': {
                     energyConsumerMain.powerTransfomer1P = ec.p;
                     energyConsumerMain.powerTransfomer1Q = ec.q;
                     break;
@@ -98,6 +756,7 @@ function determineMeasuredContractualPower(unifiedName, energyConsumer) {
         }
     }
     return result;
+    // const regexTrafo = /-T\d*/;
 }
 function getEnergyConsumerSPARQL(result, unifiedName, graphURI, limit) {
     const wnEnergyConsumerUnified = result.get('consolidated');