@enervance/insight-cim-model 1.0.2 → 1.0.4

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

@@ -0,0 +1,871 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EtlNeplanCSV = void 0;
+exports.processNetzknotenAgsData = processNetzknotenAgsData;
+exports.processNetzlastenData = processNetzlastenData;
+exports.neplanFindWireInfoByAttributes = neplanFindWireInfoByAttributes;
+exports.neplanFindStationInfoByAttributes = neplanFindStationInfoByAttributes;
+const cim_class_names_1 = require("../../constants/cim-class-names.js");
+const property_handler_westenergy_config_1 = require("../../config/westnetz-neplan/property-handler-westenergy.config.js");
+const utils_1 = require("../../util/utils.js");
+const util_search_1 = require("../../util/util-search.js");
+const sparql_utils_1 = require("../../util/sparql/sparql-utils.js");
+const WNSwitchTypeKind_1 = require("../../model/extensions/westnetz-neplan/core/WNSwitchTypeKind.js");
+const EVWireObject_1 = require("../../model/extensions/enervance/assets/EVWireObject.js");
+const etl_neplan_regex_1 = require("./etl-neplan-regex.js");
+const EnergyConnection_1 = require("../../model/wires/EnergyConnection.js");
+const AssetHealthEvent_1 = require("../../model/assets/AssetHealthEvent.js");
+const common_utils_1 = require("../../utils2/common.utils.js");
+const sparql_utils_2 = require("../../utils2/sparql.utils.js");
+const WNZUWOHealthScore_1 = require("../../model/extensions/westnetz-neplan/assets/WNZUWOHealthScore.js");
+const WNZUWOImportanceScore_1 = require("../../model/extensions/westnetz-neplan/assets/WNZUWOImportanceScore.js");
+const WNZUWOPriority_1 = require("../../model/extensions/westnetz-neplan/assets/WNZUWOPriority.js");
+const AggregateScore_1 = require("../../model/assets/AggregateScore.js");
+const parser_utils_1 = require("../../utils2/parser.utils.js");
+const cim_constants_1 = require("../../constants/cim-constants.js");
+const EconimicScoreKind_1 = require("../../model/extensions/westnetz-integral/assets/EconimicScoreKind.js");
+const WIEconomicScore_1 = require("../../model/extensions/westnetz-integral/assets/WIEconomicScore.js");
+const WNDigitalisationScore_1 = require("../../model/extensions/westnetz-neplan/assets/WNDigitalisationScore.js");
+const EVAssetOriginKind_1 = require("../../model/extensions/enervance/assets/EVAssetOriginKind.js");
+class EtlNeplanCSV {
+    static processNetzknotenData(modelContainer, netzknotenData, netzknotenAgsData, netzknotenIsoData) {
+        const graphURI = modelContainer.getGraphURI();
+        const limit = 0;
+        const insertDataSPARQL = [];
+        const deletePropertySPARQL = [];
+        const deleteAssociationSPARQL = [];
+        const processedCn = new Set;
+        /** Isolation */
+        for (const isoData of netzknotenIsoData) {
+            const cn = modelContainer.getObjectByName(isoData?.tp, cim_class_names_1.ClassNames.ConnectivityNode);
+            if (!cn)
+                continue;
+            if (isoData.insulation?.length && String(isoData.insulation).trim().length) {
+                if (!cn.insulation) {
+                    /** ist ein Array  */
+                    try {
+                        const isolierunArr = JSON.parse((0, utils_1.escapeSpecialChars)(isoData.insulation));
+                        /** wähle erstes Element aus dem Array */
+                        insertDataSPARQL.push(cn.setInsulation(isolierunArr.find(it => it)));
+                    }
+                    catch (err) {
+                        console.log("Err: JSON.parse insulation", err);
+                    }
+                }
+            }
+        }
+        for (const data of netzknotenData) {
+            const cn = modelContainer.getObjectByName(data?.tp, cim_class_names_1.ClassNames.ConnectivityNode);
+            /** CSV-Daten können multiple Einträge zu einem TP aufweisen.
+             * Mehrfache Verarbeitung wird dadurch verhindert*/
+            if (processedCn.has(cn.getUUID()))
+                continue;
+            processedCn.add(cn.getUUID());
+            const facility = cn.assets?.values().next()?.value;
+            if (!facility)
+                continue;
+            /** Schaltbarkeit */
+            if (cn.swtchable === undefined) {
+                switch (data.schaltbar) {
+                    case 'S': {
+                        /** schaltbar */
+                        const sparql = cn.setSwitchable(WNSwitchTypeKind_1.WNSwitchTypeKind.S);
+                        insertDataSPARQL.push(sparql);
+                        break;
+                    }
+                    case 'E': {
+                        /** eingeschränkt schaltbar */
+                        const sparql = cn.setSwitchable(WNSwitchTypeKind_1.WNSwitchTypeKind.E);
+                        insertDataSPARQL.push(sparql);
+                        break;
+                    }
+                    case 'N': {
+                        /** nicht schaltbar */
+                        const sparql = cn.setSwitchable(WNSwitchTypeKind_1.WNSwitchTypeKind.N);
+                        insertDataSPARQL.push(sparql);
+                        break;
+                    }
+                }
+            }
+            /** EIGENTUM */
+            const assetOwner = facility.getAssetOwner();
+            if (!assetOwner) {
+                const propHandlerOwner = property_handler_westenergy_config_1.PROPERTY_HANDLER_WESTNETZNEPLAN_CONFIG.wn_connectivity_node_assetowner;
+                switch (data.eigentum) {
+                    case 'ON': {
+                        /** Ortsnetzstation */
+                        const tripleData = propHandlerOwner.cb(modelContainer, cn, { propValue: 'Ortsnetzstation' });
+                        deleteAssociationSPARQL.push(tripleData.oldTriple);
+                        insertDataSPARQL.push(tripleData.newTriple);
+                        break;
+                    }
+                    case 'KD': {
+                        /** Kundenstation */
+                        const tripleData = propHandlerOwner.cb(modelContainer, cn, { propValue: 'Kundenstation' });
+                        deleteAssociationSPARQL.push(tripleData.oldTriple);
+                        insertDataSPARQL.push(tripleData.newTriple);
+                        break;
+                    }
+                    case 'GE': {
+                        /** Gemischte Station */
+                        const tripleData = propHandlerOwner.cb(modelContainer, cn, { propValue: 'Gemischte Station' });
+                        deleteAssociationSPARQL.push(tripleData.oldTriple);
+                        insertDataSPARQL.push(tripleData.newTriple);
+                        break;
+                    }
+                }
+            }
+            /** BAUTYP */
+            if (facility.type === undefined) {
+                const propHandlerTyp = property_handler_westenergy_config_1.PROPERTY_HANDLER_WESTNETZNEPLAN_CONFIG.wn_connectivity_node_type;
+                switch (data.bautyp) {
+                    case 'Kompakt': {
+                        /** C-Station */
+                        const tripleData = propHandlerTyp.cb(modelContainer, cn, { propValue: cim_constants_1.CimAssetAliasNames.ONS_C_Station });
+                        deletePropertySPARQL.push(tripleData.oldTriple);
+                        insertDataSPARQL.push(tripleData.newTriple);
+                        break;
+                    }
+                    case 'Mast': {
+                        /** Maststat */
+                        const tripleData = propHandlerTyp.cb(modelContainer, cn, { propValue: cim_constants_1.CimAssetAliasNames.Maststat });
+                        deletePropertySPARQL.push(tripleData.oldTriple);
+                        insertDataSPARQL.push(tripleData.newTriple);
+                        break;
+                    }
+                    case 'Muffe': {
+                        /** Muffe */
+                        const tripleData = propHandlerTyp.cb(modelContainer, cn, { propValue: cim_constants_1.CimAssetAliasNames.Muffe });
+                        deletePropertySPARQL.push(tripleData.oldTriple);
+                        insertDataSPARQL.push(tripleData.newTriple);
+                        break;
+                    }
+                    case 'Gebäude': {
+                        /** Gebäude */
+                        const tripleData = propHandlerTyp.cb(modelContainer, cn, { propValue: cim_constants_1.CimAssetAliasNames.Gebaeudestation });
+                        deletePropertySPARQL.push(tripleData.oldTriple);
+                        insertDataSPARQL.push(tripleData.newTriple);
+                        break;
+                    }
+                    case 'UA': {
+                        /** Umspannanlage */
+                        const tripleData = propHandlerTyp.cb(modelContainer, cn, { propValue: cim_constants_1.CimAssetAliasNames.Umspannanlage });
+                        deletePropertySPARQL.push(tripleData.oldTriple);
+                        insertDataSPARQL.push(tripleData.newTriple);
+                        break;
+                    }
+                    case 'Sonstige': {
+                        /** Sonstige */
+                        const tripleData = propHandlerTyp.cb(modelContainer, cn, { propValue: cim_constants_1.CimAssetAliasNames.Sonstiges });
+                        deletePropertySPARQL.push(tripleData.oldTriple);
+                        insertDataSPARQL.push(tripleData.newTriple);
+                        break;
+                    }
+                }
+            }
+            /** AssetInfo */
+            if (facility && !facility.getAssetInfo()) {
+                const stationInfo = neplanFindStationInfoByAttributes([...modelContainer.stationInfos.values()], facility.type, cn.insulation);
+                if (stationInfo)
+                    insertDataSPARQL.push(facility.setAssetInfo(stationInfo));
+            }
+            /** PROBLEMMELDUNG_S4 */
+            const s4Name = data.problemmeldung_s4;
+            const s4Description = data.s4;
+            if (s4Name) {
+                let healthEventAlreadyExits;
+                let healthEvent = (0, util_search_1.getObjectByProperties)(modelContainer.assetHealthEvents, ['name', 'description'], [s4Name, s4Description]);
+                if (!healthEvent) {
+                    healthEvent = new AssetHealthEvent_1.AssetHealthEvent(common_utils_1.CommonUtils.generateUUID(), s4Name, undefined, s4Description);
+                }
+                else {
+                    healthEventAlreadyExits = [...facility.getActivityRecords().values()].find(it => it.getUUID() === healthEvent.getUUID());
+                }
+                if (!healthEventAlreadyExits) {
+                    healthEvent.addAsset(facility);
+                    facility.addActivityRecord(healthEvent);
+                    modelContainer.addAssetHealthEvent(healthEvent);
+                    healthEvent.type = 'S4';
+                    switch (data.problemmeldung_s4) {
+                        case 'NV': {
+                            healthEvent.shortName = 'nicht vorhanden';
+                            healthEvent.severity = '0';
+                            break;
+                        }
+                        case 'P1': {
+                            /** Prio 1 */
+                            healthEvent.severity = '1';
+                            healthEvent.shortName = 'Prio 1';
+                            break;
+                        }
+                        case 'P2': {
+                            /** Prio 2 */
+                            healthEvent.severity = '2';
+                            healthEvent.shortName = 'Prio 2';
+                            break;
+                        }
+                        case 'P3': {
+                            /** Prio 3 */
+                            healthEvent.severity = '3';
+                            healthEvent.shortName = 'Prio 3';
+                            break;
+                        }
+                        case 'P4': {
+                            /** Prio 4 */
+                            healthEvent.severity = '4';
+                            healthEvent.shortName = 'Prio 4';
+                            break;
+                        }
+                    }
+                    insertDataSPARQL.push(...sparql_utils_2.SparqlUtils.getSparqlStatementFromCIM(sparql_utils_2.SparqlType.INSERT_DATA, modelContainer.modelsContainer.getRdfModel(), healthEvent, modelContainer.getBaseIRI()));
+                }
+            }
+            const newObjectsZuwo = EtlNeplanCSV.processZuwoData(facility, data, modelContainer);
+            newObjectsZuwo.forEach(it => insertDataSPARQL.push(...sparql_utils_2.SparqlUtils.getSparqlStatementFromCIM(sparql_utils_2.SparqlType.INSERT_DATA, modelContainer.modelsContainer.getRdfModel(), it, modelContainer.getBaseIRI())));
+            /** Unnötige description Felder entfernen */
+            /** Name */
+            if (data.name?.length > 0) {
+                if (facility && (facility.type === cim_constants_1.CimAssetAliasNames.Umspannanlage || facility.type === undefined)) {
+                    deletePropertySPARQL.push((0, sparql_utils_1.getDeleteWhereObjectSPARQL)(cn.baseIRI, cn.mrid, 'cim', 'IdentifiedObject', 'description'));
+                }
+                else {
+                    const tripleData = cn.setProperty('description', (0, utils_1.escapeSpecialChars)(data.name));
+                    deletePropertySPARQL.push(tripleData.oldTriple);
+                    insertDataSPARQL.push(tripleData.newTriple);
+                }
+            }
+            /** DigiONS */
+            if (data.digitalisierungsgrad) {
+                // digitalisierungsgrad
+                const propHandlerNodeKind = property_handler_westenergy_config_1.PROPERTY_HANDLER_WESTNETZNEPLAN_CONFIG.wn_connectivity_node_kind;
+                const tripleData = propHandlerNodeKind.cb(modelContainer, cn, { propValue: (0, utils_1.escapeSpecialChars)(String(data.digitalisierungsgrad)) });
+                deletePropertySPARQL.push(tripleData.oldTriple);
+                insertDataSPARQL.push(tripleData.newTriple);
+            }
+            // TODO eq_beschreibung
+        }
+        /**
+         * Zusatzprüfung: Sonstige ONS
+         * Wenn CSV-Informationen nicht vorhanden sind,
+         * finde 'Sonstige ONS' => mm Knoten ist ein Last- und oder Einspeiseobjekt vorhanden
+         * **/
+        for (const vl of modelContainer.voltageLevels.values()) {
+            // VLs nur mit einem CN!
+            if (vl.connectivityNodes.length === 1) {
+                const cn = vl.connectivityNodes[0];
+                if (!cn.getType() && cn.terminals.size) {
+                    const terminals = [...cn.terminals.values()];
+                    if (terminals.find(elem => elem.conductingEquipment instanceof EnergyConnection_1.EnergyConnection)) {
+                        /** Sonstige */
+                        const tripleData = property_handler_westenergy_config_1.PROPERTY_HANDLER_WESTNETZNEPLAN_CONFIG.wn_connectivity_node_type.cb(modelContainer, cn, { propValue: cim_constants_1.CimAssetAliasNames.Sonstiges });
+                        deletePropertySPARQL.push(tripleData.oldTriple);
+                        insertDataSPARQL.push(tripleData.newTriple);
+                    }
+                }
+            }
+        }
+        const insertAgsDataSPARQL = [];
+        for (const data of netzknotenAgsData) {
+            const cn = modelContainer.getObjectByName(data?.station_tp, cim_class_names_1.ClassNames.ConnectivityNode);
+            /** REGIONALZENTRUM */
+            if (cn) {
+                const propHandlerUser = property_handler_westenergy_config_1.PROPERTY_HANDLER_WESTNETZNEPLAN_CONFIG.wn_connectivity_node_assetuser;
+                if (data.rz_name?.length) {
+                    const tripleData = propHandlerUser.cb(modelContainer, cn, { propValue: data.rz_name });
+                    insertAgsDataSPARQL.push(tripleData.newTriple);
+                }
+            }
+        }
+        const length = insertDataSPARQL.length + deletePropertySPARQL.length + deleteAssociationSPARQL.length + insertAgsDataSPARQL.length;
+        const insertDataStatement = [];
+        if (limit && length) {
+            const intervaInsertData = (0, utils_1.splitArrayIntoChunks)(insertDataSPARQL, limit);
+            const intervalDelPropData = (0, utils_1.splitArrayIntoChunks)(deletePropertySPARQL, limit);
+            const intervalDelAssocData = (0, utils_1.splitArrayIntoChunks)(deleteAssociationSPARQL, limit);
+            const intervalAgsInsertData = (0, utils_1.splitArrayIntoChunks)(insertAgsDataSPARQL, limit);
+            insertDataStatement.push((0, sparql_utils_1.createSPARQLStatement)('DELETE_WHERE_VALUES', graphURI, intervalDelPropData), (0, sparql_utils_1.createSPARQLStatement)('DELETE_DATA', graphURI, intervalDelAssocData), (0, sparql_utils_1.createSPARQLStatement)('INSERT_DATA', graphURI, intervalAgsInsertData), (0, sparql_utils_1.createSPARQLStatement)('INSERT_DATA', graphURI, intervaInsertData));
+        }
+        else 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, deletePropertySPARQL)}
+                        ${(0, sparql_utils_1.getDeleteDataPartStatement)(graphURI, deleteAssociationSPARQL)}
+                        ${(0, sparql_utils_1.getInsertDataPartStatement)(graphURI, insertDataSPARQL)}
+                        ${(0, sparql_utils_1.getInsertDataPartStatement)(graphURI, insertAgsDataSPARQL)}
+    `);
+        }
+        return insertDataStatement;
+    }
+    static processStrangkonzeptData(modelContainer, data) {
+        const newObjects = [];
+        for (const date of data) {
+            const cn = modelContainer.getObjectByName(date.tp, cim_class_names_1.ClassNames.ConnectivityNode);
+            if (!cn)
+                continue;
+            const asset = cn.assets?.values().next()?.value;
+            if (!asset)
+                continue;
+            /** OPEX für Sanierung */
+            if ((0, parser_utils_1.isNumericI7)(date.refurbishment_opex)) {
+                const economicScore = new WIEconomicScore_1.WIEconomicScore(common_utils_1.CommonUtils.generateUUID());
+                economicScore.value = +date.refurbishment_opex;
+                economicScore.kind = EconimicScoreKind_1.EconimicScoreKind.refurbishmentOpex;
+                economicScore.setAsset(asset);
+                asset.addAnalyticScore(economicScore);
+                modelContainer.addAnalyticScore(economicScore);
+                newObjects.push(economicScore);
+            }
+            /** strangkonzept_digions */
+            if (date.strangkonzept_digions) {
+                const digitalisationScore = new WNDigitalisationScore_1.WNDigitalisationScore(common_utils_1.CommonUtils.generateUUID());
+                switch (date.strangkonzept_digions) {
+                    case 'nein': {
+                        digitalisationScore.value = 0;
+                        break;
+                    }
+                    case 'ja': {
+                        digitalisationScore.value = 1;
+                        break;
+                    }
+                }
+                newObjects.push(digitalisationScore);
+                digitalisationScore.setAsset(asset);
+                asset.addAnalyticScore(digitalisationScore);
+                modelContainer.addAnalyticScore(digitalisationScore);
+            }
+        }
+        return newObjects;
+    }
+    static processZuwoData(asset, data, modelContainer) {
+        const newObjects = [];
+        const analyticScore = [...asset.analyticScore.values()];
+        /** ZUWO_ZUSTAND */
+        let healthScore = asset.getHealthScore();
+        if (!healthScore && (0, parser_utils_1.isNumericI7)(data.zuwo_zustand)) {
+            healthScore = new WNZUWOHealthScore_1.WNZUWOHealthScore(common_utils_1.CommonUtils.generateUUID());
+            newObjects.push(healthScore);
+            healthScore.value = +data.zuwo_zustand;
+            healthScore.classifier = parser_utils_1.ParserUtils.CSVHealthScoreClassifierToCIM(data.zustand_bez);
+            // Asset
+            healthScore.setAsset(asset);
+            asset.addAnalyticScore(healthScore);
+            modelContainer.addAnalyticScore(healthScore);
+        }
+        /** ZUWO_WICHTIGKEIT */
+        let importanceScore = analyticScore.find(it => it instanceof WNZUWOImportanceScore_1.WNZUWOImportanceScore);
+        if (!importanceScore && (0, parser_utils_1.isNumericI7)(data.zuwo_wichtigkeit)) {
+            importanceScore = new WNZUWOImportanceScore_1.WNZUWOImportanceScore(common_utils_1.CommonUtils.generateUUID());
+            newObjects.push(importanceScore);
+            importanceScore.value = +data.zuwo_wichtigkeit;
+            importanceScore.classifier = parser_utils_1.ParserUtils.CSVImportanceClassifierToCIM(data.wichtigkeit_bez);
+            // Asset
+            importanceScore.setAsset(asset);
+            asset.addAnalyticScore(importanceScore);
+            modelContainer.addAnalyticScore(importanceScore);
+        }
+        /** ZUWO_PRIORITÄT */
+        let prioScore = analyticScore.find(it => it instanceof WNZUWOPriority_1.WNZUWOPriority);
+        if (!prioScore && (0, parser_utils_1.isNumericI7)(data.zuwo_prio)) {
+            prioScore = new WNZUWOPriority_1.WNZUWOPriority(common_utils_1.CommonUtils.generateUUID());
+            prioScore.value = +data.zuwo_prio;
+            newObjects.push(prioScore);
+            prioScore.classifier = parser_utils_1.ParserUtils.CSVPriorityClassifierToCIM(data.prioritaet_bez);
+            // Asset
+            prioScore.setAsset(asset);
+            asset.addAnalyticScore(prioScore);
+            modelContainer.addAnalyticScore(prioScore);
+        }
+        /** ZUWO_KATEGORIE AggregateScore */
+        const importanceScoreValue = importanceScore?.getValue();
+        const healthScoreValue = healthScore?.getValue();
+        if (importanceScoreValue && healthScoreValue) {
+            const aggScoreCategory = new AggregateScore_1.AggregateScore(common_utils_1.CommonUtils.generateUUID());
+            /** f(x) = -0.375x + 0.9375 */
+            const minImportanceScoreValue = -0.375 * importanceScoreValue + 0.9375;
+            aggScoreCategory.value = minImportanceScoreValue;
+            if (importanceScoreValue >= 0.9 && healthScoreValue <= 0.1 ||
+                importanceScoreValue >= 0.6 && healthScoreValue >= 0.9 ||
+                healthScoreValue >= minImportanceScoreValue) {
+                aggScoreCategory.name = cim_constants_1.ZuWoNames.CategoryII;
+            }
+            else {
+                aggScoreCategory.name = cim_constants_1.ZuWoNames.CategoryI;
+            }
+            newObjects.push(aggScoreCategory);
+            aggScoreCategory.setAsset(asset);
+            asset.addAnalyticScore(aggScoreCategory);
+            modelContainer.addAnalyticScore(aggScoreCategory);
+        }
+        /** ZUWO_KO AggregateScore */
+        if (data.k_o) {
+            const aggScoreKO = new AggregateScore_1.AggregateScore(common_utils_1.CommonUtils.generateUUID());
+            newObjects.push(aggScoreKO);
+            aggScoreKO.value = (0, parser_utils_1.isNumericI7)(+data.k_o) ? +data.k_o : 0;
+            aggScoreKO.name = cim_constants_1.ZuWoNames.KO;
+            aggScoreKO.description = data.k_o;
+            // Asset
+            aggScoreKO.setAsset(asset);
+            asset.addAnalyticScore(aggScoreKO);
+            modelContainer.addAnalyticScore(aggScoreKO);
+        }
+        return newObjects;
+    }
+    static processNetzstreckenData(modelContainer, netzstreckenData) {
+        try {
+            const netzstreckenMapData = new Map();
+            for (const data of netzstreckenData) {
+                if (!netzstreckenMapData.has(data.tp)) {
+                    netzstreckenMapData.set(data.tp, []);
+                }
+                netzstreckenMapData.get(data.tp).push(data);
+            }
+            const graphURI = modelContainer.getGraphURI();
+            const newObjects = [];
+            const insertSPARQL = [];
+            /** Assetmodell für Stromkreisabschnitte erstellen */
+            for (const entry of netzstreckenMapData.entries()) {
+                const key = entry[0];
+                const strecken = entry[1];
+                const lineSegment = modelContainer.getObjectByName(key, cim_class_names_1.ClassNames.ACLineSegment);
+                if (!lineSegment)
+                    continue;
+                let wireObjectSegment = [...lineSegment.assets.values()].find(elem => elem.type === cim_constants_1.CimAssetAliasNames.ACLineSegment);
+                /** Asset Instanz ACLineSegment */
+                if (!wireObjectSegment) {
+                    /** Erstelle Instanz, wenn keine vorhanden ist */
+                    wireObjectSegment = new EVWireObject_1.EVWireObject(common_utils_1.CommonUtils.generateUUID(), undefined, undefined, undefined);
+                    wireObjectSegment.setOrigin(EVAssetOriginKind_1.EVAssetOriginKind.stock);
+                    /** Stromkreisabschnitt Asset.type */
+                    wireObjectSegment.setType(cim_constants_1.CimAssetAliasNames.ACLineSegment);
+                    /** Stromkreisabschnitt PSR mit Asset verknüpfen */
+                    wireObjectSegment.addPowerSystemResource(lineSegment);
+                    newObjects.push(wireObjectSegment);
+                    modelContainer.addWireObject(wireObjectSegment);
+                }
+                /** Strecken: Assetmodell erstllen, befüllen und mit Stromkreisabschnitt assoziieren */
+                for (const strecke of strecken) {
+                    const number = (0, parser_utils_1.isNumericI7)(strecke.nummer) ? +strecke.nummer - 1 : 0;
+                    const length = (0, parser_utils_1.isNumericI7)(strecke.lange) ? strecke.lange : 0;
+                    const c1 = (0, parser_utils_1.isNumericI7)(strecke.c1) ? strecke.c1 : 0;
+                    const baujahr = (0, parser_utils_1.isNumericI7)(strecke.baujahr) ? strecke.baujahr : undefined;
+                    const assetTypeAsString = strecke.type ? strecke.type : '';
+                    const wireCount = assetTypeAsString?.match(etl_neplan_regex_1.REGEX_NEPLAN_WIRECOUNT)?.[0];
+                    const wireObjectSubsegment = new EVWireObject_1.EVWireObject(common_utils_1.CommonUtils.generateUUID(), `${lineSegment.name}_${number}`, undefined, undefined);
+                    /** Strecke Asset.type */
+                    wireObjectSubsegment.setType(cim_constants_1.CimAssetAliasNames.ACLineSubSegment);
+                    /** Strecke Number */
+                    wireObjectSubsegment.setNumber(String(number));
+                    /** Strecke Laenge */
+                    wireObjectSubsegment.setLength(length);
+                    wireObjectSubsegment.setC1(c1);
+                    /** Anzahl der Kabel-/Freileitung */
+                    wireObjectSubsegment.setWireCount((0, parser_utils_1.isNumericI7)(wireCount) ? +wireCount : 1);
+                    /** Strecke Beschreibung */
+                    wireObjectSubsegment.setDescription(assetTypeAsString);
+                    wireObjectSubsegment.setOrigin(EVAssetOriginKind_1.EVAssetOriginKind.stock);
+                    /** Strecke Baujahr */
+                    if (baujahr) {
+                        // insertSPARQL.push(wireObjectSubsegment.setLifecycleDate(String(baujahr), 'installationDate'));
+                        wireObjectSubsegment.setLifecycleDate(`${baujahr}-01-01`, 'installationDate');
+                    }
+                    /** Strecke AssetInfo Instanz */
+                    // ggfs. by Voltage, Name and Ir
+                    const wireAssetInfo = neplanFindWireInfoByAttributes([...modelContainer.evWireInfos.values()], assetTypeAsString, strecke.irmax);
+                    if (wireAssetInfo) {
+                        wireObjectSubsegment.setAssetInfo(wireAssetInfo);
+                    }
+                    /** Asset-Strecke mit Asset-Stromkreisabschnitt verknüpfen  */
+                    wireObjectSubsegment.setAssetContainer(wireObjectSegment);
+                    /** PSR Type */
+                    let psrType;
+                    switch (strecke.typ?.toLowerCase()) {
+                        case 'freileitung': {
+                            psrType = (0, util_search_1.getObjectByProperty)(modelContainer.psrTypes, 'name', cim_constants_1.CimAssetAliasNames.OverHeadLine);
+                            break;
+                        }
+                        case 'kabel': {
+                            psrType = (0, util_search_1.getObjectByProperty)(modelContainer.psrTypes, 'name', cim_constants_1.CimAssetAliasNames.Cable);
+                            break;
+                        }
+                    }
+                    if (psrType && !lineSegment.psrType) {
+                        insertSPARQL.push(lineSegment.setPsrType(psrType));
+                    }
+                    /** Owner */
+                    let owner;
+                    switch (strecke.eigentum?.toLowerCase()) {
+                        case 'eigen': {
+                            owner = modelContainer.getObjectByName(cim_constants_1.CimAssetAliasNames.AssetOwnerWestnetz, cim_class_names_1.ClassNames.AssetOwner);
+                            break;
+                        }
+                        case 'kunde': {
+                            owner = modelContainer.getObjectByName(cim_constants_1.CimAssetAliasNames.AssetOwnerFremd, cim_class_names_1.ClassNames.AssetOwner);
+                            break;
+                        }
+                    }
+                    if (owner && !wireObjectSegment.getAssetOwner()) {
+                        insertSPARQL.push(owner.addAsset(wireObjectSegment));
+                    }
+                    /** ZuWo Daten */
+                    const newZuwoObjects = EtlNeplanCSV.processZuwoData(wireObjectSubsegment, strecke, modelContainer);
+                    const test = [];
+                    newZuwoObjects.forEach(it => test.push(...sparql_utils_2.SparqlUtils.getSparqlStatementFromCIM(sparql_utils_2.SparqlType.INSERT_DATA, modelContainer.modelsContainer.getRdfModel(), it, modelContainer.getBaseIRI())));
+                    newObjects.push(...newZuwoObjects);
+                    newObjects.push(wireObjectSubsegment);
+                    modelContainer.addWireObject(wireObjectSubsegment);
+                }
+            }
+            newObjects.forEach(it => insertSPARQL.push(...sparql_utils_2.SparqlUtils.getSparqlStatementFromCIM(sparql_utils_2.SparqlType.INSERT_DATA, modelContainer.modelsContainer.getRdfModel(), it, modelContainer.getBaseIRI())));
+            if (insertSPARQL.length) {
+                return [
+                    `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.getInsertDataPartStatement)(graphURI, insertSPARQL)}
+            `
+                ];
+            }
+            else {
+                return [];
+            }
+        }
+        catch (err) {
+            console.log(err);
+        }
+    }
+    static processNetzeinspeiserData(modelContainer, netzeinspeiserData, overwritePowerData = false) {
+        const graphURI = modelContainer.getGraphURI();
+        const limit = 0;
+        /** Filter der mehrfachen Datensätze */
+        const processedTp = new Map();
+        const insertDataSPARQL = [];
+        const deletePropertySPARQL = [];
+        const deleteAssociationSPARQL = [];
+        const regExLv = new RegExp(/-NSE-/gm, 'i');
+        const regExMv = new RegExp(/[_]\d+/gm, 'i');
+        const regExMvPv = new RegExp(/-PV/gm, 'i');
+        const regExLvPv = new RegExp(/-NSE-PV/gm, 'i');
+        for (const data of netzeinspeiserData) {
+            if (processedTp.has(data.name))
+                continue;
+            processedTp.set(data.name, data);
+            const energySource = modelContainer.getObjectByName(common_utils_1.CommonUtils.shortenString(data.name, 10), cim_class_names_1.ClassNames.EnergySource);
+            if (!energySource)
+                continue;
+            /** Vorzeichen aus dem CGMES übernehmen */
+            const cosPhi = (0, parser_utils_1.isNumericI7)(data.cosr) ? data.cosr : 1;
+            const pSign = energySource.activePower < 0 ? -1 : 1;
+            const qSign = cosPhi < 0 ? -1 : (energySource.reactivePower < 0 ? -1 : 1);
+            const sr = (0, parser_utils_1.isNumericI7)(data.sr) ? data.sr : 0;
+            const p = sr * cosPhi * pSign;
+            const q = Math.sqrt(Math.pow(sr, 2) - Math.pow(p, 2)) * qSign;
+            const lvPsrPrefix = regExLv.test(data.name) ? ' NS' : '';
+            const hvPsrPrefix = regExMv.test(data.name) ? ' MS' : '';
+            /** Leistungsdaten */
+            if (overwritePowerData && (0, parser_utils_1.isNumericI7)(p)) {
+                // die initialen Angaben löschen
+                deletePropertySPARQL.push((0, sparql_utils_1.getDeleteWhereObjectSPARQL)(energySource.baseIRI, energySource.mrid, 'cim', 'EnergySource', 'activePower'));
+                deletePropertySPARQL.push((0, sparql_utils_1.getDeleteWhereObjectSPARQL)(energySource.baseIRI, energySource.mrid, 'cim', 'EnergySource', 'reactivePower'));
+                // neue Werte einfügen
+                insertDataSPARQL.push(energySource.setActivePower(p));
+                insertDataSPARQL.push(energySource.setReactivePower(q));
+            }
+            //
+            /** Typ */
+            /** Windenergie, Biomasse, Deponiegas, Grubengas, Klärgas, Solare Strahlungsenergie, Wasserkraft */
+            let psrType;
+            switch (data.energieart?.toLowerCase()) {
+                case 'windenergie': {
+                    psrType = (0, util_search_1.getObjectByProperty)(modelContainer.psrTypes, 'name', 'Windkraft');
+                    break;
+                }
+                case 'biomasse': {
+                    psrType = (0, util_search_1.getObjectByProperty)(modelContainer.psrTypes, 'name', 'Bio');
+                    break;
+                }
+                /*        case 'deponiegas': {
+                          psrType = getObjectByProperty(modelContainer.psrTypes, 'name', 'Deponiegas');
+                          break;
+                        }
+                        case 'grubengas': {
+                          psrType = getObjectByProperty(modelContainer.psrTypes, 'name', 'Grubengas');
+                          break;
+                        }
+                        case 'klärgas': {
+                          psrType = getObjectByProperty(modelContainer.psrTypes, 'name', 'Klärgas');
+                          break;
+                        }*/
+                case 'solare strahlungsenergie': {
+                    psrType = (0, util_search_1.getObjectByProperty)(modelContainer.psrTypes, 'name', 'Photovoltaik' + lvPsrPrefix + hvPsrPrefix);
+                    break;
+                }
+                /** Unterlagert */
+                case 'pv': {
+                    psrType = (0, util_search_1.getObjectByProperty)(modelContainer.psrTypes, 'name', 'Photovoltaik' + lvPsrPrefix + hvPsrPrefix);
+                    break;
+                }
+                /*        case 'bhkw': {
+                          psrType = getObjectByProperty(modelContainer.psrTypes, 'name', 'Blockheizkraftwerk' + lvPsrPrefix + hvPsrPrefix);
+                          break;
+                        }
+                        case 'eeu': {
+                          psrType = getObjectByProperty(modelContainer.psrTypes, 'name', 'Erneuerbare Energien' + lvPsrPrefix + hvPsrPrefix);
+                          break;
+                        }
+                        case 'wa': {
+                          psrType = getObjectByProperty(modelContainer.psrTypes, 'name', 'Wa' + lvPsrPrefix + hvPsrPrefix);
+                          break;
+                        }
+                        case 'wi': {
+                          psrType = getObjectByProperty(modelContainer.psrTypes, 'name', 'Wi' + lvPsrPrefix + hvPsrPrefix);
+                          break;
+                        }*/
+                default: {
+                    if (regExLvPv.test(data.name)) {
+                        psrType = (0, util_search_1.getObjectByProperty)(modelContainer.psrTypes, 'name', 'Photovoltaik NS');
+                    }
+                    else if (regExMvPv.test(data.name)) {
+                        psrType = (0, util_search_1.getObjectByProperty)(modelContainer.psrTypes, 'name', 'Photovoltaik');
+                    }
+                    else {
+                        psrType = (0, util_search_1.getObjectByProperty)(modelContainer.psrTypes, 'name', 'unbekannt');
+                    }
+                }
+            }
+            if (psrType) {
+                insertDataSPARQL.push(energySource.setPsrType(psrType));
+            }
+            /** Assetdaten */
+            const asset = energySource.getAsset();
+            if (!asset)
+                continue;
+            if (data.status)
+                insertDataSPARQL.push(asset.setStatus(data.status));
+            if (data.energieart)
+                insertDataSPARQL.push(asset.setType(data.energieart));
+        }
+        /** In dem .csv-Datensatz sind nicht alle EnergySource-Objekte enthalten.
+         *  Versuche die Typisierung anhand der Bezeichner durchzuführen */
+        for (const energySource of modelContainer.energySources.values()) {
+            // Suche nicht typisierte Einspeiser
+            if (energySource.psrType)
+                continue;
+            let psrType;
+            /** bezeichner auf prüfen */
+            if (regExLvPv.test(energySource.name)) {
+                psrType = (0, util_search_1.getObjectByProperty)(modelContainer.psrTypes, 'name', 'Photovoltaik NS');
+            }
+            else if (regExMvPv.test(energySource.name)) {
+                psrType = (0, util_search_1.getObjectByProperty)(modelContainer.psrTypes, 'name', 'Photovoltaik');
+            }
+            else {
+                psrType = (0, util_search_1.getObjectByProperty)(modelContainer.psrTypes, 'name', 'unbekannt');
+            }
+            if (psrType) {
+                insertDataSPARQL.push(energySource.setPsrType(psrType));
+            }
+        }
+        const length = insertDataSPARQL.length + deletePropertySPARQL.length + deleteAssociationSPARQL.length;
+        const insertDataStatement = [];
+        if (limit && length) {
+            const intervaInsertData = (0, utils_1.splitArrayIntoChunks)(insertDataSPARQL, limit);
+            const intervalDelPropData = (0, utils_1.splitArrayIntoChunks)(deletePropertySPARQL, limit);
+            const intervalDelAssocData = (0, utils_1.splitArrayIntoChunks)(deleteAssociationSPARQL, limit);
+            insertDataStatement.push((0, sparql_utils_1.createSPARQLStatement)('DELETE_WHERE_VALUES', graphURI, intervalDelPropData), (0, sparql_utils_1.createSPARQLStatement)('DELETE_DATA', graphURI, intervalDelAssocData));
+            (0, sparql_utils_1.createSPARQLStatement)('INSERT_DATA', graphURI, intervaInsertData);
+        }
+        else 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, deletePropertySPARQL)}
+                        ${(0, sparql_utils_1.getDeleteDataPartStatement)(graphURI, deleteAssociationSPARQL)}
+                        ${(0, sparql_utils_1.getInsertDataPartStatement)(graphURI, insertDataSPARQL)}
+                       
+                   
+    `);
+        }
+        return insertDataStatement;
+    }
+    static processNetzlastenData(modelContainer, lastData, overwritePowerData = false) {
+        const graphURI = modelContainer.getGraphURI();
+        const limit = 0;
+        const insertDataSPARQL = [];
+        const deletePropertySPARQL = [];
+        const deleteAssociationSPARQL = [];
+        for (const data of lastData) {
+            const energyConsumer = modelContainer.getObjectByName(data.name, cim_class_names_1.ClassNames.EnergyConsumer);
+            if (!energyConsumer)
+                continue;
+            const pSign = energyConsumer.p < 0 ? -1 : 1;
+            const qSign = energyConsumer.q < 0 ? -1 : 1;
+            const p = (0, parser_utils_1.isNumericI7)(data.p) ? (0, parser_utils_1.convertToNumberI7)(data.p) : 0;
+            const q = (0, parser_utils_1.isNumericI7)(data.q) ? (0, parser_utils_1.convertToNumberI7)(data.q) : 0;
+            const cosPhi = (0, parser_utils_1.isNumericI7)(data.cos) ? (0, parser_utils_1.convertToNumberI7)(data.cos) : 0;
+            // die initialen Angaben löschen
+            deletePropertySPARQL.push((0, sparql_utils_1.getDeleteWhereObjectSPARQL)(energyConsumer.baseIRI, energyConsumer.mrid, 'cim', 'EnergyConsumer', 'p'));
+            deletePropertySPARQL.push((0, sparql_utils_1.getDeleteWhereObjectSPARQL)(energyConsumer.baseIRI, energyConsumer.mrid, 'cim', 'EnergyConsumer', 'q'));
+            // neue Werte einfügen
+            insertDataSPARQL.push(energyConsumer.setP(p * pSign));
+            insertDataSPARQL.push(energyConsumer.setQ(q * qSign));
+            // insertDataSPARQL.push(energyConsumer.setCosPhi(cosPhi));
+        }
+        const length = insertDataSPARQL.length + deletePropertySPARQL.length + deleteAssociationSPARQL.length;
+        const insertDataStatement = [];
+        if (limit && length) {
+            const intervaInsertData = (0, utils_1.splitArrayIntoChunks)(insertDataSPARQL, limit);
+            const intervalDelPropData = (0, utils_1.splitArrayIntoChunks)(deletePropertySPARQL, limit);
+            const intervalDelAssocData = (0, utils_1.splitArrayIntoChunks)(deleteAssociationSPARQL, limit);
+            insertDataStatement.push(...(0, sparql_utils_1.createSPARQLStatement)('DELETE_WHERE_VALUES', graphURI, intervalDelPropData), ...(0, sparql_utils_1.createSPARQLStatement)('DELETE_DATA', graphURI, intervalDelAssocData), ...(0, sparql_utils_1.createSPARQLStatement)('INSERT_DATA', graphURI, intervaInsertData));
+        }
+        else 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, deletePropertySPARQL)}
+                        ${(0, sparql_utils_1.getDeleteDataPartStatement)(graphURI, deleteAssociationSPARQL)}
+                        ${(0, sparql_utils_1.getInsertDataPartStatement)(graphURI, insertDataSPARQL)}   
+    `);
+        }
+        return insertDataStatement;
+    }
+}
+exports.EtlNeplanCSV = EtlNeplanCSV;
+/**
+ * @deprecated
+ */
+function processNetzknotenAgsData(cimModel, netzknotenData, graphURI, limit) {
+    const insertAgsDataSPARQL = [];
+    for (const data of netzknotenData) {
+        const cn = cimModel.getObjectByName(data?.station_tp, cim_class_names_1.ClassNames.ConnectivityNode);
+        /** REGIONAL_ZENTRUM */
+        if (cn) {
+            const propHandlerUser = property_handler_westenergy_config_1.PROPERTY_HANDLER_WESTNETZNEPLAN_CONFIG.wn_connectivity_node_assetuser;
+            if (data.rz_name?.length) {
+                const tripleData = propHandlerUser.cb(cimModel, cn, { propValue: data.rz_name });
+                insertAgsDataSPARQL.push(tripleData.newTriple);
+            }
+        }
+    }
+    const intervaInsertData = (0, utils_1.splitArrayIntoChunks)(insertAgsDataSPARQL, limit);
+    return (0, sparql_utils_1.createSPARQLStatement)('INSERT_DATA', graphURI, intervaInsertData);
+}
+function processNetzlastenData(cimModel, lastData, graphURI, limit) {
+    const insertDataSPARQL = [];
+    const deletePropertySPARQL = [];
+    const deleteAssociationSPARQL = [];
+    for (const data of lastData) {
+        const energyConsumer = cimModel.getObjectByName(data.name, cim_class_names_1.ClassNames.EnergyConsumer);
+        if (!energyConsumer)
+            continue;
+        const pSign = energyConsumer.p < 0 ? -1 : 1;
+        const qSign = energyConsumer.q < 0 ? -1 : 1;
+        const p = (0, parser_utils_1.isNumericI7)(data.p) ? (0, parser_utils_1.convertToNumberI7)(data.p) : 0;
+        const q = (0, parser_utils_1.isNumericI7)(data.q) ? (0, parser_utils_1.convertToNumberI7)(data.q) : 0;
+        const cosPhi = (0, parser_utils_1.isNumericI7)(data.cos) ? (0, parser_utils_1.convertToNumberI7)(data.cos) : 0;
+        // die initialen Angaben löschen
+        deletePropertySPARQL.push((0, sparql_utils_1.getDeleteWhereObjectSPARQL)(energyConsumer.baseIRI, energyConsumer.mrid, 'cim', 'EnergyConsumer', 'p'));
+        deletePropertySPARQL.push((0, sparql_utils_1.getDeleteWhereObjectSPARQL)(energyConsumer.baseIRI, energyConsumer.mrid, 'cim', 'EnergyConsumer', 'q'));
+        // neue Werte einfügen
+        insertDataSPARQL.push(energyConsumer.setP(p * pSign));
+        insertDataSPARQL.push(energyConsumer.setQ(q * qSign));
+        insertDataSPARQL.push(energyConsumer.setCosPhi(cosPhi));
+    }
+    const length = insertDataSPARQL.length + deletePropertySPARQL.length + deleteAssociationSPARQL.length;
+    const insertDataStatement = [];
+    if (limit && length) {
+        const intervaInsertData = (0, utils_1.splitArrayIntoChunks)(insertDataSPARQL, limit);
+        const intervalDelPropData = (0, utils_1.splitArrayIntoChunks)(deletePropertySPARQL, limit);
+        const intervalDelAssocData = (0, utils_1.splitArrayIntoChunks)(deleteAssociationSPARQL, limit);
+        insertDataStatement.push(...(0, sparql_utils_1.createSPARQLStatement)('DELETE_WHERE_VALUES', graphURI, intervalDelPropData), ...(0, sparql_utils_1.createSPARQLStatement)('DELETE_DATA', graphURI, intervalDelAssocData), ...(0, sparql_utils_1.createSPARQLStatement)('INSERT_DATA', graphURI, intervaInsertData));
+    }
+    else 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, deletePropertySPARQL)}
+                        ${(0, sparql_utils_1.getDeleteDataPartStatement)(graphURI, deleteAssociationSPARQL)}
+                        ${(0, sparql_utils_1.getInsertDataPartStatement)(graphURI, insertDataSPARQL)}   
+    `);
+    }
+    return insertDataStatement;
+}
+function neplanFindWireInfoByAttributes(wireInfos, name, ir) {
+    // const voltage = name?.match(REGEX_NEPLAN_TYPE_VOLTAGE)?.[0];
+    const strandSize = name?.match(etl_neplan_regex_1.REGEX_NEPLAN_TYPE_SIZE_DECR)?.[0]?.split('x');
+    let sizeDescription = undefined;
+    let strandCount = undefined;
+    if (strandSize?.length === 2) {
+        sizeDescription = strandSize[1];
+        strandCount = +strandSize[0];
+    }
+    for (const wireInfo of wireInfos) {
+        /** Anhand des Typnames und ir suchen*/
+        if (name?.toLowerCase().includes(wireInfo.name?.toLowerCase()) && ir === wireInfo.ratedCurrent) {
+            /** Zusatzüberprüfung Querschnitt */
+            if (sizeDescription && wireInfo.sizeDescription === sizeDescription) {
+                return wireInfo;
+            }
+            /** Zusatzüberprüfung Anzahl der Leiter */
+            else if (strandCount && wireInfo.strandCount === strandCount) {
+                return wireInfo;
+            }
+            /** Wenn Querschnitt und Anzahl der Leiter nicht definiert sind */
+            else if (!strandCount && !sizeDescription) {
+                return wireInfo;
+            }
+        }
+    }
+}
+function neplanFindStationInfoByAttributes(stationInfos, type, insulation) {
+    switch (type) {
+        case (cim_constants_1.CimAssetAliasNames.Maststat):
+            return stationInfos.find(elem => elem.type === 'Maststation');
+        case (cim_constants_1.CimAssetAliasNames.ONS_C_Station):
+            let assetType;
+            if (insulation === 'LU') {
+                assetType = stationInfos.find(elem => elem.type === 'Kompaktstation' && elem.insulation === 'luft');
+            }
+            else if (insulation === 'FS') {
+                assetType = stationInfos.find(elem => elem.type === 'Kompaktstation' && elem.insulation === 'Feststoff');
+            }
+            else if (insulation === 'SF6') {
+                assetType = stationInfos.find(elem => elem.type === 'Kompaktstation' && elem.insulation === 'SF6');
+            }
+            return assetType;
+        case (cim_constants_1.CimAssetAliasNames.Gebaeudestation):
+            let assetTypeG;
+            if (insulation === 'LU') {
+                assetTypeG = stationInfos.find(elem => elem.type === cim_constants_1.CimAssetAliasNames.Gebaeudestation && elem.insulation === 'luft');
+            }
+            else if (insulation === 'FS') {
+                assetTypeG = stationInfos.find(elem => elem.type === cim_constants_1.CimAssetAliasNames.Gebaeudestation && elem.insulation === 'Feststoff');
+            }
+            else if (insulation === 'SF6') {
+                assetTypeG = stationInfos.find(elem => elem.type === cim_constants_1.CimAssetAliasNames.Gebaeudestation && elem.insulation === 'SF6');
+            }
+            return assetTypeG;
+        case (cim_constants_1.CimAssetAliasNames.Sonstiges):
+            return stationInfos.find(elem => elem.type === 'Sonstige');
+    }
+}
+//# sourceMappingURL=etl-neplan-csv.js.map