@enervance/insight-cim-model 0.0.25 → 0.0.27

package/dist/converter/integral7/converter-i7.js

@@ -0,0 +1,3175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConverterI7 = void 0;
+const tslib_1 = require("tslib");
+const Model_1 = require("../../model/model/Model");
+const export_frame_i7_1 = require("./interface-i7/export-frame-i7");
+const mysql_controller_1 = require("../../util/database/mysql-controller");
+const rdf_xml_1 = require("../../constants/rdf-xml");
+const utils_1 = require("../../util/utils");
+const LoadArea_1 = require("../../model/loadmodel/LoadArea");
+const SubLoadArea_1 = require("../../model/loadmodel/SubLoadArea");
+const ConformLoadGroup_1 = require("../../model/loadmodel/ConformLoadGroup");
+const CoordinateSystem_1 = require("../../model/common/CoordinateSystem");
+const integral_sql_1 = require("./sql/integral.sql");
+const GeographicalRegion_1 = require("../../model/core/GeographicalRegion");
+const SubGeographicalRegion_1 = require("../../model/core/SubGeographicalRegion");
+const integral_prefix_1 = require("./config/integral-prefix");
+const utils_2 = require("./utils");
+const AMPRIONSubstation_1 = require("../../model/extensions/amprion/core/AMPRIONSubstation");
+const Location_1 = require("../../model/common/Location");
+const PositionPoint_1 = require("../../model/common/PositionPoint");
+const Standort_1 = require("./model/integral/Standort");
+const ConverterIntegral7_1 = require("./ConverterIntegral7");
+const Line_1 = require("../../model/wires/Line");
+const Junction_1 = require("../../model/wires/Junction");
+const Schaltanlage_1 = require("./model/integral/Schaltanlage");
+const Schaltanlagenabschnitt_1 = require("./model/integral/Schaltanlagenabschnitt");
+const Schaltfeld_1 = require("./model/integral/Schaltfeld");
+const KnotenSo_1 = require("./model/integral/KnotenSo");
+const VoltageLevel_1 = require("../../model/core/VoltageLevel");
+const util_create_1 = require("../../util/util-create");
+const AMPRIONBay_1 = require("../../model/extensions/amprion/core/AMPRIONBay");
+const Substation_1 = require("../../model/core/Substation");
+const AMPRIONConnectivityNode_1 = require("../../model/extensions/amprion/core/AMPRIONConnectivityNode");
+const ConnectivityNode_1 = require("../../model/core/ConnectivityNode");
+const Bay_1 = require("../../model/core/Bay");
+const perf_hooks_1 = require("perf_hooks");
+const Terminal_1 = require("../../model/core/Terminal");
+const PhaseCode_1 = require("../../model/core/PhaseCode");
+const BusbarSection_1 = require("../../model/wires/BusbarSection");
+const cim_class_names_1 = require("../../constants/cim-class-names");
+const ConformLoad_1 = require("../../model/loadmodel/ConformLoad");
+const EnergyConsumer_1 = require("../../model/wires/EnergyConsumer");
+const EnergySource_1 = require("../../model/wires/EnergySource");
+const EquivalentInjection_1 = require("../../model/equivalents/EquivalentInjection");
+const ExternalNetworkInjection_1 = require("../../model/wires/ExternalNetworkInjection");
+const Disconnector_1 = require("../../model/wires/Disconnector");
+const Breaker_1 = require("../../model/wires/Breaker");
+const GroundingImpedance_1 = require("../../model/wires/GroundingImpedance");
+const PetersenCoil_1 = require("../../model/wires/PetersenCoil");
+const Leitung_1 = require("./model/integral/Leitung");
+const ACLineSegment_1 = require("../../model/wires/ACLineSegment");
+const CurrentLimit_1 = require("../../model/operationallimits/CurrentLimit");
+const CurrentFlow_1 = require("../../model/domain/CurrentFlow");
+const UnitMultiplier_1 = require("../../model/domain/UnitMultiplier");
+const UnitSymbol_1 = require("../../model/domain/UnitSymbol");
+const OperationalLimitSet_1 = require("../../model/operationallimits/OperationalLimitSet");
+const OperationalLimitType_1 = require("../../model/operationallimits/OperationalLimitType");
+const OperationalLimitDirectionKind_1 = require("../../model/operationallimits/OperationalLimitDirectionKind");
+const LimitTypeKind_1 = require("../../model/operationallimits/LimitTypeKind");
+const EVWireInfo_1 = require("../../model/extensions/enervance/assetinfo/EVWireInfo");
+const EVPowerTransformerInfo_1 = require("../../model/extensions/enervance/assetinfo/EVPowerTransformerInfo");
+const EVPowerTransformerEndInfo_1 = require("../../model/extensions/enervance/assetinfo/EVPowerTransformerEndInfo");
+const ApparentPower_1 = require("../../model/domain/ApparentPower");
+const Voltage_1 = require("../../model/domain/Voltage");
+const TapChangerInfo_1 = require("../../model/assetinfo/TapChangerInfo");
+const PowerTransformer_1 = require("../../model/wires/PowerTransformer");
+const PowerTransformerEnd_1 = require("../../model/wires/PowerTransformerEnd");
+const VoltageLimit_1 = require("../../model/operationallimits/VoltageLimit");
+const PhaseTapChangerAsymmetrical_1 = require("../../model/wires/PhaseTapChangerAsymmetrical");
+const PhaseTapChangerLinear_1 = require("../../model/wires/PhaseTapChangerLinear");
+const TapChangerControl_1 = require("../../model/wires/TapChangerControl");
+const RegulatingControlModeKind_1 = require("../../model/wires/RegulatingControlModeKind");
+const utils_trafo3w_1 = require("./utils-trafo3w");
+const SynchronousMachine_1 = require("../../model/wires/SynchronousMachine");
+const SynchronousMachineKind_1 = require("../../model/wires/SynchronousMachineKind");
+const SynchronousMachineOperatingMode_1 = require("../../model/wires/SynchronousMachineOperatingMode");
+const ReactiveCapabilityCurve_1 = require("../../model/wires/ReactiveCapabilityCurve");
+const CurveStyle_1 = require("../../model/core/CurveStyle");
+const CurveData_1 = require("../../model/core/CurveData");
+const RegulatingControl_1 = require("../../model/wires/RegulatingControl");
+const ThermalGeneratingUnit_1 = require("../../model/generation/ThermalGeneratingUnit");
+const SolarGeneratingUnit_1 = require("../../model/generation/SolarGeneratingUnit");
+const WindGeneratingUnit_1 = require("../../model/generation/WindGeneratingUnit");
+const WindGenUnitKind_1 = require("../../model/generation/WindGenUnitKind");
+const NuclearGeneratingUnit_1 = require("../../model/generation/NuclearGeneratingUnit");
+const HydroGeneratingUnit_1 = require("../../model/generation/HydroGeneratingUnit");
+const HydroEnergyConversionKind_1 = require("../../model/generation/HydroEnergyConversionKind");
+const GeneratingUnit_1 = require("../../model/generation/GeneratingUnit");
+const GeneratorControlSource_1 = require("../../model/generation/GeneratorControlSource");
+const SynchronousMachineTimeConstantReactance_1 = require("../../model/dynamics/standard-models/synchronous-machine-dynamics/SynchronousMachineTimeConstantReactance");
+const LinearShuntCompensator_1 = require("../../model/wires/LinearShuntCompensator");
+const StaticVarCompensator_1 = require("../../model/wires/StaticVarCompensator");
+const DCConverterUnit_1 = require("../../model/dc/DCConverterUnit");
+const CsConverter_1 = require("../../model/dc/CsConverter");
+const CsOperatingModeKind_1 = require("../../model/dc/CsOperatingModeKind");
+const DCNode_1 = require("../../model/dc/DCNode");
+const ACDCConverterDCTerminal_1 = require("../../model/dc/ACDCConverterDCTerminal");
+const VsConverter_1 = require("../../model/dc/VsConverter");
+const VsPpccControlKind_1 = require("../../model/dc/VsPpccControlKind");
+const VsQpccControlKind_1 = require("../../model/dc/VsQpccControlKind");
+const DCLine_1 = require("../../model/dc/DCLine");
+const DCLineSegment_1 = require("../../model/dc/DCLineSegment");
+const DCConverterOperatingModeKind_1 = require("../../model/dc/DCConverterOperatingModeKind");
+const DCTerminal_1 = require("../../model/dc/DCTerminal");
+const AMPRIONSeriesCompensator_1 = require("../../model/extensions/amprion/wires/AMPRIONSeriesCompensator");
+class ConverterI7 {
+    constructor() {
+        this.exportFrames = new Map();
+        this.cimModelDefault = new Model_1.Model();
+        this.availableTableNames = [];
+        this.integralID2Type = new Map();
+        this.coordinateSystem = 'EPSG:4326';
+        this.integralID2UUID = new Map();
+        this.UUID2Integral7ID = new Map();
+        this.integral7Modells = new Map();
+        this.kdrosseltypen = new Map();
+        this.leitungAnschlussKnotenIDs = new Set();
+        this.trafo2wAnschlussKnotenIDs = new Set();
+        this.trafo3wAnschlussKnotenIDs = new Set();
+        this.hgueAnschlussKnotenIDs = new Set();
+        this.lDrosselAnschlussKnotenIDs = new Set();
+        this.lKondensatorAnschlussKnotenIDs = new Set();
+        this.ersatzZweigAnschlussKnotenIDs = new Set();
+    }
+    convert(objectMappingConfig, defaultValuesConfig, energyTypesConfig, ukzExportConfig, tempDirPath) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                try {
+                    yield this.createColumnIndex();
+                    const ukz2GeoregionMapping = yield this.mysqlController.execQuery(`
+                                                                            SELECT gr.id AS georegion_id, sgr.id AS subgeoregion_id, group_concat(DISTINCT standort.ukz) AS ukzCSV
+                                                                            FROM netz_subgeoregion sgr
+                                                                            LEFT OUTER JOIN netz_georegion gr ON sgr.georegion = gr.id
+                                                                            LEFT OUTER JOIN netz_standort standort ON sgr.id = standort.subgeoregion
+                                                                            GROUP BY georegion_id;                                                               `);
+                    yield this.convertBetriebsmitteltypenKdrossel();
+                    yield this.convertBetriebsmitteltypenLeitung();
+                    yield this.convertBetriebsmitteltypenTrafo();
+                    yield this.queryLeitungsAnschlussIDs();
+                    yield this.queryTrafosAnschlussIDs();
+                    yield this.queryHgueAnschlussIDs();
+                    yield this.queryLDroselAnschlussIDs();
+                    yield this.queryErsatzLaengsAnschlussIDs();
+                    yield this.queryLkondensatorAnschlussIDs();
+                    ukz2GeoregionMapping.map(elem => elem.ukzArray = elem.ukzCSV.split(','));
+                    const allGeoRegions = yield this.convertGeoRegionen();
+                    const allSubGeoRegions = yield this.convertSubGeoRegionen(allGeoRegions, defaultValuesConfig);
+                    const boundaryGeoRegionSet = new Set();
+                    const internalGeoRegionSet = new Set();
+                    for (const ukzRegionMap of ukz2GeoregionMapping) {
+                        for (const bdUkz of ukzExportConfig.boundaryUkz) {
+                            const geoRegionUUID = this.integralID2UUID.get(ukzRegionMap.georegion_id);
+                            const geoRegion = allGeoRegions.find(elem => elem.mrid === geoRegionUUID);
+                            if (!geoRegion)
+                                continue;
+                            if (ukzRegionMap.ukzArray.indexOf(bdUkz.name) > -1) {
+                                if (!boundaryGeoRegionSet.has(geoRegion)) {
+                                    boundaryGeoRegionSet.add(geoRegion);
+                                }
+                            }
+                            else {
+                                internalGeoRegionSet.add(geoRegion);
+                            }
+                        }
+                    }
+                    const boundaryGeoRegions = Array.from(boundaryGeoRegionSet);
+                    const profileGeoRegions = Array.from(internalGeoRegionSet);
+                    this.logger.debug(`BoundaryGeoRegions ${boundaryGeoRegions.map(elem => elem.name).join()}`);
+                    this.logger.debug(`ProfileGeoRegions ${profileGeoRegions.map(elem => elem.name).join()}`);
+                    const bdExportFrame = new export_frame_i7_1.I7ExportFrame('Boundary', [rdf_xml_1.RDF_XML.PROFILE_EQ, rdf_xml_1.RDF_XML.PROFILE_SSH, rdf_xml_1.RDF_XML.PROFILE_GL, rdf_xml_1.RDF_XML.PROFILE_EQ_BD], tempDirPath, new Map());
+                    for (const bdRegion of boundaryGeoRegions) {
+                        bdExportFrame.cimModel.addGeographicalRegion(bdRegion);
+                        for (const subGeoRegion of bdRegion.regions) {
+                            bdExportFrame.cimModel.addSubGeographicalRegion(subGeoRegion);
+                        }
+                        this.addDefaultObjectsGeo(bdExportFrame.cimModel, defaultValuesConfig);
+                        this.exportFrames.set(bdRegion.mrid, bdExportFrame);
+                    }
+                    const cgmesExportProfiles = [rdf_xml_1.RDF_XML.PROFILE_EQ, rdf_xml_1.RDF_XML.PROFILE_SSH, rdf_xml_1.RDF_XML.PROFILE_SV, rdf_xml_1.RDF_XML.PROFILE_DL, rdf_xml_1.RDF_XML.PROFILE_GL, rdf_xml_1.RDF_XML.PROFILE_AMPI7];
+                    const dependentOnModels = new Map();
+                    dependentOnModels.set(rdf_xml_1.RDF_XML.PROFILE_EQ_BD, [bdExportFrame.getModelUUID(rdf_xml_1.RDF_XML.PROFILE_EQ_BD)]);
+                    for (const pRegion of profileGeoRegions) {
+                        if (!ukzExportConfig.exportGeoRegion.find(elem => elem.name === pRegion.name))
+                            continue;
+                        const exportFrame = new export_frame_i7_1.I7ExportFrame(pRegion.name, cgmesExportProfiles, tempDirPath, dependentOnModels);
+                        exportFrame.cimModel.addGeographicalRegion(pRegion);
+                        for (const subGeoRegion of pRegion.regions) {
+                            exportFrame.cimModel.addSubGeographicalRegion(subGeoRegion);
+                        }
+                        this.addDefaultObjectsLoadModel(exportFrame.cimModel, defaultValuesConfig);
+                        this.addDefaultObjectsGeo(exportFrame.cimModel, defaultValuesConfig);
+                        this.exportFrames.set(pRegion.mrid, exportFrame);
+                    }
+                    for (const entry of this.exportFrames.entries()) {
+                        const geoRegionUUID = entry[0];
+                        const frame = entry[1];
+                        const cimModel = frame.cimModel;
+                        const geoRegion = cimModel.getGeographicalRegion(geoRegionUUID);
+                        if (!geoRegion)
+                            continue;
+                        const integral7Modell = {
+                            integralStandorte: new Map(),
+                            integralSchaltanlagen: new Map(),
+                            integralSchaltanlagenAbschnitte: new Map(),
+                            integralSchaltfelder: new Map(),
+                            integralKnotenSo: new Map(),
+                            integralLeitungen: new Map(),
+                            knotenSfIDs: [],
+                            kontenZwIDs: [],
+                            querkupplungIDs: [],
+                            laengskupplungIDs: [],
+                            leitungsAnschlussIDs: [],
+                            trafo2wAnschlussKnotenIDs: [],
+                            trafo3wAnschlussKnotenIDs: [],
+                            hgueAnschlussKnotenIDs: [],
+                            lDrosselAnschlussKnotenIDs: [],
+                            lKondensatorAnschlussKnotenIDs: [],
+                            ersatzZweigAnschlussKnotenIDs: [],
+                            targetVoltages: new Map(),
+                            sternPunktImpModel: {
+                                stpSchieneJunctionUUIDs: new Map(),
+                                stpSchieneTerminal: new Map(),
+                                junctionUUIDstpImp: new Map(),
+                                petersenCoils: new Map(),
+                                junctions: new Map(),
+                                groundingImpedances: new Map(),
+                                connectivityNodes: new Map(),
+                            },
+                        };
+                        this.integral7Modells.set(geoRegionUUID, integral7Modell);
+                        const subGeoRegionsUUIDs = geoRegion.regions.map(elem => elem.mrid);
+                        const subGeoRegionsI7IDs = [];
+                        for (const uuid of subGeoRegionsUUIDs) {
+                            subGeoRegionsI7IDs.push(...this.UUID2Integral7ID.get(uuid));
+                        }
+                        let startTime = perf_hooks_1.performance.now();
+                        yield this.convertStandorte(cimModel, integral7Modell, subGeoRegionsI7IDs, defaultValuesConfig);
+                        logExecutionTime(this.logger, startTime, `convertStandorte(${cimModel.substations.size + cimModel.lines.size})`);
+                        startTime = perf_hooks_1.performance.now();
+                        const standortIDs = [...integral7Modell.integralStandorte.keys()];
+                        if (standortIDs.length)
+                            yield this.covertSchaltanlagen(cimModel, integral7Modell, standortIDs, defaultValuesConfig);
+                        logExecutionTime(this.logger, startTime, `covertSchaltanlagen(${standortIDs.length})`);
+                        startTime = perf_hooks_1.performance.now();
+                        const schaltanlagenIDs = [...integral7Modell.integralSchaltanlagen.keys()];
+                        if (schaltanlagenIDs.length)
+                            yield this.convertSchaltanlagenAbschnitte(cimModel, integral7Modell, schaltanlagenIDs);
+                        logExecutionTime(this.logger, startTime, `convertSchaltanlagenAbschnitte(${schaltanlagenIDs.length})`);
+                        startTime = perf_hooks_1.performance.now();
+                        const schaltanlagenAbschnittIDs = [...integral7Modell.integralSchaltanlagenAbschnitte.keys()];
+                        if (schaltanlagenAbschnittIDs.length > 0)
+                            yield this.convertSchaltfelder(cimModel, integral7Modell, schaltanlagenAbschnittIDs);
+                        logExecutionTime(this.logger, startTime, `convertSchaltfelder()`);
+                        startTime = perf_hooks_1.performance.now();
+                        if (schaltanlagenAbschnittIDs.length > 0) {
+                            yield this.convertQuerkupplungen(cimModel, integral7Modell, schaltanlagenAbschnittIDs);
+                            yield this.convertLaegskupplungen(cimModel, integral7Modell, schaltanlagenAbschnittIDs);
+                        }
+                        logExecutionTime(this.logger, startTime, `convertKupplungen()`);
+                        startTime = perf_hooks_1.performance.now();
+                        if (standortIDs.length)
+                            yield this.convertKnotenSo(cimModel, integral7Modell, standortIDs, defaultValuesConfig);
+                        logExecutionTime(this.logger, startTime, `convertKupplungen()`);
+                        const knotenSoIDs = [...integral7Modell.integralKnotenSo.keys()];
+                        startTime = perf_hooks_1.performance.now();
+                        const schaltfeldIDs = [...integral7Modell.integralSchaltfelder.keys()];
+                        if (knotenSoIDs.length)
+                            yield this.convertKnotenSf(cimModel, integral7Modell, schaltfeldIDs);
+                        logExecutionTime(this.logger, startTime, `convertKnotenSf()`);
+                        startTime = perf_hooks_1.performance.now();
+                        if (integral7Modell.querkupplungIDs.length > 0) {
+                            yield this.convertKnotenKf(cimModel, integral7Modell.querkupplungIDs);
+                        }
+                        logExecutionTime(this.logger, startTime, `convertKnotenKf()`);
+                        startTime = perf_hooks_1.performance.now();
+                        if (integral7Modell.laengskupplungIDs.length > 0) {
+                            yield this.convertKnotenLk(cimModel, integral7Modell.laengskupplungIDs);
+                        }
+                        logExecutionTime(this.logger, startTime, `convertKnotenLk()`);
+                        startTime = perf_hooks_1.performance.now();
+                        if (knotenSoIDs.length > 0)
+                            yield this.convertSchlaufen(cimModel, integral7Modell, knotenSoIDs);
+                        logExecutionTime(this.logger, startTime, `convertSchlaufen()`);
+                        startTime = perf_hooks_1.performance.now();
+                        if (schaltanlagenAbschnittIDs.length > 0)
+                            yield this.convertSammelschienenAbschnitte(cimModel, integral7Modell, schaltanlagenAbschnittIDs);
+                        logExecutionTime(this.logger, startTime, `convertSammelschienenAbschnitte(${cimModel.busbarSections.size})`);
+                        startTime = perf_hooks_1.performance.now();
+                        const eqiupmentContainerIDs = [...schaltfeldIDs, ...integral7Modell.querkupplungIDs, ...integral7Modell.laengskupplungIDs];
+                        if (eqiupmentContainerIDs.length > 0) {
+                            yield this.convertStarreVerbindungen(cimModel, eqiupmentContainerIDs);
+                        }
+                        logExecutionTime(this.logger, startTime, `convertStarreVerbindungen(${cimModel.junctions.size})`);
+                        const soSfKonoten = [...knotenSoIDs, ...integral7Modell.knotenSfIDs];
+                        startTime = perf_hooks_1.performance.now();
+                        if (knotenSoIDs.length > 0 || integral7Modell.knotenSfIDs.length > 0) {
+                            yield this.convertBelastungen(cimModel, soSfKonoten, defaultValuesConfig, objectMappingConfig.Belastung.class);
+                        }
+                        logExecutionTime(this.logger, startTime, `convertBelastungen()`);
+                        startTime = perf_hooks_1.performance.now();
+                        if (knotenSoIDs.length > 0 || integral7Modell.knotenSfIDs.length > 0) {
+                            yield this.convertEinspeisungen(cimModel, soSfKonoten, objectMappingConfig.Einspeisung.class);
+                        }
+                        logExecutionTime(this.logger, startTime, `convertEinspeisungen()`);
+                        if (knotenSoIDs.length > 0 || integral7Modell.knotenSfIDs.length > 0) {
+                            yield this.convertGeneratoren(cimModel, soSfKonoten, energyTypesConfig);
+                        }
+                        if (knotenSoIDs.length > 0 || integral7Modell.knotenSfIDs.length > 0) {
+                            yield this.convertKraftwerksbloecke(cimModel, soSfKonoten, energyTypesConfig);
+                        }
+                        if (knotenSoIDs.length > 0 || integral7Modell.knotenSfIDs.length > 0) {
+                            yield this.convertErsatzQuerZweige(cimModel, soSfKonoten);
+                        }
+                        if (knotenSoIDs.length > 0 || integral7Modell.knotenSfIDs.length > 0) {
+                            yield this.convertBoundaryInjections(cimModel, soSfKonoten);
+                        }
+                        if (knotenSoIDs.length > 0 || integral7Modell.knotenSfIDs.length > 0) {
+                            yield this.convertKompensationsdrossel(cimModel, soSfKonoten);
+                        }
+                        if (knotenSoIDs.length > 0 || integral7Modell.knotenSfIDs.length > 0) {
+                            yield this.convertKompensationskondensatoren(cimModel, soSfKonoten);
+                        }
+                        startTime = perf_hooks_1.performance.now();
+                        if (eqiupmentContainerIDs.length > 0) {
+                            yield this.convertTrenner3f(cimModel, eqiupmentContainerIDs);
+                        }
+                        logExecutionTime(this.logger, startTime, `convertTrenner3f()`);
+                        startTime = perf_hooks_1.performance.now();
+                        if (eqiupmentContainerIDs.length > 0) {
+                            yield this.convertTrennerFi3f(cimModel, eqiupmentContainerIDs);
+                        }
+                        logExecutionTime(this.logger, startTime, `convertTrennerFi3f(`);
+                        startTime = perf_hooks_1.performance.now();
+                        if (eqiupmentContainerIDs.length > 0) {
+                            yield this.convertLeistungsschalter(cimModel, eqiupmentContainerIDs);
+                        }
+                        logExecutionTime(this.logger, startTime, `convertLeistungsschalter(${cimModel.breakers.size})`);
+                        if (standortIDs.length > 0) {
+                            startTime = perf_hooks_1.performance.now();
+                            const stpSchieneID = yield this.convertSternpunktSchienen(cimModel, integral7Modell, standortIDs);
+                            yield this.convertKdrossel(cimModel, integral7Modell, stpSchieneID);
+                            yield this.convertStpSchaltelemente(integral7Modell, stpSchieneID);
+                            logExecutionTime(this.logger, startTime, `convertSternpunktImp-Modell()`);
+                        }
+                        if (standortIDs.length > 0) {
+                            startTime = perf_hooks_1.performance.now();
+                            yield this.convertTrafo2W(cimModel, integral7Modell, defaultValuesConfig, standortIDs);
+                            logExecutionTime(this.logger, startTime, `convertTrafo2W-Modell`);
+                        }
+                        if (standortIDs.length > 0) {
+                            startTime = perf_hooks_1.performance.now();
+                            yield this.convertTrafo3W(cimModel, integral7Modell, defaultValuesConfig, standortIDs);
+                            logExecutionTime(this.logger, startTime, `convertTrafo3W-Modell`);
+                        }
+                        if (knotenSoIDs.length > 0 || integral7Modell.knotenSfIDs.length > 0) {
+                            yield this.convertStatcom(cimModel, soSfKonoten);
+                        }
+                        if (knotenSoIDs.length > 0 || integral7Modell.knotenSfIDs.length > 0) {
+                            yield this.convertSVC(cimModel, soSfKonoten);
+                        }
+                        if (knotenSoIDs.length > 0 || integral7Modell.knotenSfIDs.length > 0) {
+                            yield this.convertCsConverterDC(cimModel, soSfKonoten);
+                        }
+                        if (knotenSoIDs.length > 0 || integral7Modell.knotenSfIDs.length > 0) {
+                            yield this.convertVsConverterDC(cimModel, soSfKonoten);
+                        }
+                        if (bdExportFrame !== frame) {
+                            startTime = perf_hooks_1.performance.now();
+                            yield this.convertLeitungen(cimModel, integral7Modell, defaultValuesConfig);
+                            logExecutionTime(this.logger, startTime, `convertLeitungen`);
+                        }
+                        yield this.convertDCLines(cimModel, integral7Modell, defaultValuesConfig);
+                        yield this.convertLaengskondensatoren(cimModel, integral7Modell, defaultValuesConfig);
+                        if (boundaryGeoRegions.indexOf(geoRegion) > -1) {
+                            yield this.transformBoundaryModel(frame.cimModel, defaultValuesConfig);
+                        }
+                        startTime = perf_hooks_1.performance.now();
+                        frame.openXMLModel();
+                        frame.serializeModel(defaultValuesConfig);
+                        yield frame.closeXMLModel();
+                        let endTime = perf_hooks_1.performance.now();
+                        console.log(`\tSerializeModel ${geoRegion.name} ${(endTime - startTime) / 1000} seconds`);
+                    }
+                }
+                catch (e) {
+                    this.logger.error(e);
+                    console.error("ERROR:" + e);
+                }
+                finally {
+                    yield this.dropColumnIndex();
+                    resolve();
+                }
+            }));
+        });
+    }
+    convertGeoRegionen() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                const regions = [];
+                if (this.isTableAvailable(integral_sql_1.Integral7TableNames.REGION)) {
+                    this.mysqlController.execQuery(integral_sql_1.getNetzQuery(integral_sql_1.I7Objects.REGION, 0, 0, []))
+                        .then((result) => {
+                        for (const i7Data of result) {
+                            const region = new GeographicalRegion_1.GeographicalRegion(utils_1.getUUID(i7Data.guid), i7Data.bezeichner, i7Data.kurzname);
+                            this.addIdMapping(i7Data.id, region.mrid, integral_sql_1.Integral7TableNames.REGION);
+                            regions.push(region);
+                        }
+                    })
+                        .catch(err => {
+                        this.logger.error(`convertGeoRegionen ${err.toString()}`);
+                    })
+                        .finally(() => {
+                        resolve(regions);
+                    });
+                }
+                else {
+                    this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.REGION} ist nicht vorhanden.`);
+                    resolve(regions);
+                }
+            }));
+        });
+    }
+    convertSubGeoRegionen(regions, defaultValuesConfig) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                const subRegions = [];
+                if (this.isTableAvailable(integral_sql_1.Integral7TableNames.SUBREGION)) {
+                    this.mysqlController.execQuery(integral_sql_1.getNetzQuery(integral_sql_1.I7Objects.SUBREGION, 0, 0, []))
+                        .then((result) => {
+                        for (const i7Data of result) {
+                            const subregion = new SubGeographicalRegion_1.SubGeographicalRegion(utils_1.getUUID(i7Data.guid), i7Data.bezeichner, i7Data.kurzname);
+                            const regionUUID = this.integralID2UUID.get(i7Data.georegion);
+                            let region = regions.find(elem => elem.mrid === regionUUID);
+                            if (!region) {
+                                region = utils_1.createIfNotExitsGeoregionByName(this.cimModelDefault, defaultValuesConfig.GeographicalRegion.name);
+                                this.logger.debug(`SubGeographicalRegion UUID ${subregion.mrid} I7-ID ${i7Data.id} Name ${i7Data.bezeichner} hat keine Region.`);
+                            }
+                            subregion.region = region;
+                            region.addSubGeographicalRegion(subregion);
+                            this.addIdMapping(i7Data.id, subregion.mrid, integral_sql_1.Integral7TableNames.SUBREGION);
+                            subRegions.push(subregion);
+                        }
+                    })
+                        .catch(err => {
+                        this.logger.error(`convertSubGeoRegionen ${err.toString()}`);
+                    })
+                        .finally(() => {
+                        resolve(subRegions);
+                    });
+                }
+                else {
+                    this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.SUBREGION} ist nicht vorhanden.`);
+                    resolve(subRegions);
+                }
+            }));
+        });
+    }
+    convertStandorte(cimModel, integral7, whereID, defaultValuesConfig) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.STANDORT)) {
+                const result = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.STANDORT, whereID));
+                for (const i7Data of result) {
+                    const i7Schluessel = integral_prefix_1.STANDORT_PRAEFIX +
+                        utils_2.ueberpruefeZeichenkette(i7Data.ukz) +
+                        integral_prefix_1.MITTIGER_PUNKT +
+                        utils_2.ueberpruefeZeichenkette(i7Data.bezeichner);
+                    const substation = new AMPRIONSubstation_1.AMPRIONSubstation(utils_1.getUUID(i7Data.guid), utils_2.getName(i7Data), i7Data.id + '', i7Schluessel, i7Data.stationsnummer);
+                    let subregion = cimModel.getSubGeographicalRegion(this.integralID2UUID.get(i7Data.subgeoregion));
+                    if (!subregion) {
+                        const region = utils_1.createIfNotExitsGeoregionByName(cimModel, defaultValuesConfig.GeographicalRegion.name);
+                        subregion = utils_1.createIfNotExitsSubGeoregionByName(cimModel, defaultValuesConfig.SubGeographicalRegion.name, region);
+                    }
+                    substation.subGeographicalRegion = subregion;
+                    subregion.addSubstation(substation);
+                    const coor = ConverterIntegral7_1.getGeoCoordinates(i7Data);
+                    if ((coor === null || coor === void 0 ? void 0 : coor.length) === 2) {
+                        const coordinateSystem = cimModel.getCoordinateSystemByName(this.coordinateSystem);
+                        const location = new Location_1.Location(utils_1.generateUUID(), `Location of ${substation.name}`);
+                        location.addPowerSystemResource(substation);
+                        substation.location = location;
+                        location.coordinateSystem = coordinateSystem;
+                        const positionPoint = new PositionPoint_1.PositionPoint(utils_1.generateUUID());
+                        positionPoint.xPosition = coor[0];
+                        positionPoint.yPosition = coor[1];
+                        positionPoint.location = location;
+                        location.addPositionPoint(positionPoint);
+                        cimModel.addLocation(location);
+                    }
+                    integral7.integralStandorte.set(i7Data.id, new Standort_1.StandortImpl(i7Data));
+                    this.addIdMapping(i7Data.id, substation.mrid, integral_sql_1.Integral7TableNames.STANDORT);
+                    cimModel.addSubstation(substation);
+                }
+            }
+            else {
+                this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.STANDORT} ist nicht vorhanden.`);
+            }
+        });
+    }
+    covertSchaltanlagen(cimModel, integral7, standortIDs, defaultValuesConfig) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.SCHALTANLAGE)) {
+                const result = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.SCHALTANLAGE, standortIDs));
+                for (const i7Data of result) {
+                    const substation = cimModel.getSubstation(this.integralID2UUID.get(i7Data.standort));
+                    const object = cimModel.getObject(this.integralID2UUID.get(i7Data.standort));
+                    if (!object) {
+                        this.logger.warn(`Schaltanlage ${i7Data.id}/${i7Data.guid} ist keinem Standort (${i7Data.standort}) zugeornet.`);
+                        continue;
+                    }
+                    else if (!(object instanceof Substation_1.Substation)) {
+                        continue;
+                    }
+                    const i7Schluessel = substation.description +
+                        integral_prefix_1.KNOTEN_STANDORT_PRAEFIX +
+                        i7Data.un +
+                        integral_prefix_1.MITTIGER_PUNKT +
+                        utils_2.ueberpruefeZeichenkette(i7Data.bezeichner);
+                    const vl = new VoltageLevel_1.VoltageLevel(utils_1.getUUID(i7Data.guid), utils_2.getName(i7Data), i7Data.kurzname, i7Schluessel);
+                    const un = utils_2.getU(i7Data.un, defaultValuesConfig.DefaultVoltage);
+                    const baseVoltage = util_create_1.createBaseVoltageIfNotExists(cimModel, un);
+                    vl.baseVoltage = baseVoltage;
+                    cimModel.addVoltageLevel(vl);
+                    this.addIdMapping(i7Data.id, vl.mrid, integral_sql_1.Integral7TableNames.SCHALTANLAGE);
+                    vl.substation = substation;
+                    substation.addVoltageLevel(vl);
+                    const schaltanlage = new Schaltanlage_1.SchaltanlageImpl(i7Data);
+                    schaltanlage.addStandort(integral7.integralStandorte.get(schaltanlage.standortid));
+                    integral7.integralSchaltanlagen.set(i7Data.id, schaltanlage);
+                }
+            }
+            else {
+                this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.SCHALTANLAGE} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertSchaltanlagenAbschnitte(cimModel, integral7, schaltanlagenIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.SCHALTANLAGENABSCHNITT)) {
+                const result = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.SCHALTANLAGENABSCHNITT, schaltanlagenIDs));
+                for (const i7Data of result) {
+                    const voltageLevel = cimModel.getVoltageLevel(this.integralID2UUID.get(i7Data.schaltanlage));
+                    if (!voltageLevel) {
+                        this.logger.warn(`Schaltanlagenabschnitt ${i7Data.id} ist keiner Schaltanlage zugeornet.`);
+                        continue;
+                    }
+                    const schaltanlagenabschnitt = new Schaltanlagenabschnitt_1.SchaltanlagenabschnittImpl(i7Data);
+                    schaltanlagenabschnitt.addSchaltanlage(integral7.integralSchaltanlagen.get(schaltanlagenabschnitt.schaltanlageid));
+                    integral7.integralSchaltanlagenAbschnitte.set(i7Data.id, schaltanlagenabschnitt);
+                    this.addIdMapping(i7Data.id, voltageLevel.mrid, integral_sql_1.Integral7TableNames.SCHALTANLAGENABSCHNITT);
+                }
+            }
+            else {
+                this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.SCHALTANLAGENABSCHNITT} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertSchaltfelder(cimModel, integral7, schaltanlagenAbschnittIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.SCHALTFELD)) {
+                const result = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.SCHALTFELD, schaltanlagenAbschnittIDs));
+                for (const i7Data of result) {
+                    const voltageLevel = cimModel.getVoltageLevel(this.integralID2UUID.get(i7Data.saabschnitt));
+                    if (!voltageLevel) {
+                        this.logger.warn(`Schaltfeld ${i7Data.id}/${i7Data.guid} ist keinem Schaltanlagenabschnitt zugeornet.`);
+                        continue;
+                    }
+                    const i7Schluessel = voltageLevel.description +
+                        integral_prefix_1.SCHALTFELD_PRAEFIX +
+                        utils_2.ueberpruefeZeichenkette(i7Data.bezeichner);
+                    const bay = new AMPRIONBay_1.AMPRIONBay(utils_1.getUUID(i7Data.guid), utils_2.getName(i7Data), i7Data.kurzname, i7Schluessel);
+                    bay.number = i7Data.feldnummer;
+                    bay.locationID = i7Data.ips_folder_id;
+                    bay.voltageLevel = voltageLevel;
+                    voltageLevel.addBay(bay);
+                    const sfImpl = new Schaltfeld_1.SchaltfeldImpl(i7Data);
+                    integral7.integralSchaltfelder.set(i7Data.id, sfImpl);
+                    if (integral7.integralSchaltanlagenAbschnitte.has(sfImpl.saabschnittid)) {
+                        sfImpl.saabschnitt = integral7.integralSchaltanlagenAbschnitte.get(sfImpl.saabschnittid);
+                        sfImpl.saabschnitt.schaltfelder.push(sfImpl);
+                    }
+                    cimModel.addBay(bay);
+                    this.addIdMapping(i7Data.id, bay.mrid, integral_sql_1.Integral7TableNames.SCHALTFELD);
+                }
+            }
+            else {
+                this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.SCHALTFELD} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertKnotenSo(cimModel, integral7, standortIDs, defaultValuesConfig) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.KNOTEN_SO)) {
+                const result = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.KNOTEN_SO, standortIDs));
+                for (const i7Data of result) {
+                    const substation = cimModel.getSubstation(this.integralID2UUID.get(i7Data.standort));
+                    const vl = new VoltageLevel_1.VoltageLevel(utils_1.getUUID(i7Data.guid), substation.name + "/" + utils_2.getName(i7Data), i7Data.kurzname);
+                    const connectivityNode = new AMPRIONConnectivityNode_1.AMPRIONConnectivityNode(utils_1.generateUUID(), 'Abzweig', String(i7Data.id));
+                    connectivityNode.connectivityNodeContainer = vl;
+                    connectivityNode.nodeNumber = i7Data.id_psse_cape;
+                    vl.addConnectivityNode(connectivityNode);
+                    const un = utils_2.getU(i7Data.un, defaultValuesConfig.DefaultVoltage);
+                    const baseVoltage = util_create_1.createBaseVoltageIfNotExists(cimModel, un);
+                    integral7.targetVoltages.set(i7Data.id, { usoll: i7Data.usoll, umin: i7Data.umin, umax: i7Data.umax });
+                    vl.baseVoltage = baseVoltage;
+                    if (substation) {
+                        vl.substation = substation;
+                        substation.addVoltageLevel(vl);
+                        const i7Schluessel = substation.description +
+                            integral_prefix_1.KNOTEN_STANDORT_PRAEFIX +
+                            i7Data.un +
+                            integral_prefix_1.MITTIGER_PUNKT +
+                            utils_2.ueberpruefeZeichenkette(i7Data.bezeichner);
+                        vl.description = i7Schluessel;
+                        connectivityNode.description = i7Schluessel;
+                    }
+                    else {
+                        this.logger.debug(`KnotenSo ${i7Data.id} ${vl.mrid} besitzt keine Substation.`);
+                    }
+                    const psrType = utils_2.getPSRType(cimModel, 'Abzweigmast');
+                    vl.psrTypeUUID = psrType === null || psrType === void 0 ? void 0 : psrType.mrid;
+                    const object = new KnotenSo_1.KnotenSoImpl(i7Data);
+                    integral7.integralKnotenSo.set(i7Data.id, object);
+                    object.standort = integral7.integralStandorte.get(object.standortid);
+                    cimModel.addVoltageLevel(vl);
+                    cimModel.addConnectivityNode(connectivityNode);
+                    this.addIdMapping(i7Data.id, connectivityNode.mrid, integral_sql_1.Integral7TableNames.KNOTEN_SO);
+                }
+            }
+            else {
+                this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.KNOTEN_SO} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertSammelschienenAbschnitte(cimModel, integral7, schaltanlagenAbschnittIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.SAMMELSCHIENE)) {
+                const result = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.SAMMELSCHIENE, schaltanlagenAbschnittIDs));
+                for (const i7Data of result) {
+                    const busbarSection = new BusbarSection_1.BusbarSection(utils_1.getUUID(i7Data.guid), utils_2.getName(i7Data), i7Data.kurzname);
+                    busbarSection.ipMax = i7Data.limit_ip;
+                    busbarSection.aggregate = false;
+                    const connectivityNode = new AMPRIONConnectivityNode_1.AMPRIONConnectivityNode(utils_1.generateUUID(), 'ssab cn');
+                    const terminal = this.createConnection(cimModel, busbarSection, connectivityNode, PhaseCode_1.PhaseCode.ABC, true, 1);
+                    const voltageLevel = cimModel.getVoltageLevel(this.integralID2UUID.get(i7Data.saabschnitt));
+                    connectivityNode.nodeNumber = i7Data.id_psse_cape;
+                    if (voltageLevel) {
+                        busbarSection.equipmentContainer = voltageLevel;
+                        voltageLevel.addEquipment(busbarSection);
+                        connectivityNode.connectivityNodeContainer = voltageLevel;
+                        voltageLevel.addConnectivityNode(connectivityNode);
+                        voltageLevel.highVoltageLimit = i7Data.umax;
+                        voltageLevel.lowVoltageLimit = i7Data.umin;
+                        const i7Schluessel = voltageLevel.description +
+                            integral_prefix_1.SAMMELSCHIENENABSCHNITT_PRAEFIX +
+                            utils_2.ueberpruefeZeichenkette(i7Data.bezeichner);
+                        busbarSection.description = i7Schluessel;
+                        connectivityNode.description = i7Schluessel;
+                        integral7.targetVoltages.set(i7Data.id, { usoll: i7Data.usoll, umin: i7Data.umin, umax: i7Data.umax });
+                    }
+                    else {
+                        this.logger.debug('Sammelschiene ' + i7Data.id + ' besitzt keine Schaltanlage.');
+                    }
+                    this.addIdMapping(i7Data.id, connectivityNode.mrid, integral_sql_1.Integral7TableNames.SAMMELSCHIENE);
+                    cimModel.addConnectivityNode(connectivityNode);
+                    cimModel.addBusbarSection(busbarSection);
+                    if (integral7.integralSchaltanlagenAbschnitte.has(i7Data.saabschnitt)) {
+                        integral7.integralSchaltanlagenAbschnitte.get(i7Data.saabschnitt).ssab.push(i7Data);
+                    }
+                }
+            }
+            else {
+                this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.SAMMELSCHIENE} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertKnotenSf(cimModel, integral7, schaltfeldIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.KNOTEN_SF)) {
+                const result = yield this.queryDataInChuncks(integral_sql_1.I7Objects.KNOTEN_SF, schaltfeldIDs);
+                for (const i7Data of result) {
+                    const bay = cimModel.getBay(this.integralID2UUID.get(i7Data.schaltfeld));
+                    const connectivityNode = new ConnectivityNode_1.ConnectivityNode(utils_1.getUUID(i7Data.guid), 'knotensf cn', 'knotensf', `${bay.description}/${i7Data.bezeichner}`);
+                    if (bay) {
+                        connectivityNode.connectivityNodeContainer = bay;
+                        bay.addConnectivityNode(connectivityNode);
+                    }
+                    else {
+                        this.logger.debug(`KnotenSf ${i7Data.id} besitzt kein Schaltfeld.`);
+                    }
+                    integral7.knotenSfIDs.push(i7Data.id);
+                    this.checkAnschlussIDs(i7Data.id, integral7);
+                    cimModel.addConnectivityNode(connectivityNode);
+                    this.addIdMapping(i7Data.id, connectivityNode.mrid, integral_sql_1.Integral7TableNames.KNOTEN_SF);
+                }
+            }
+            else {
+                this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.KNOTEN_SF} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertKnotenKf(cimModel, querkupplungIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.KNOTEN_KF)) {
+                const result = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.KNOTEN_KF, querkupplungIDs));
+                for (const i7Data of result) {
+                    const connectivityNode = new ConnectivityNode_1.ConnectivityNode(utils_1.getUUID(i7Data.guid), 'knotenkf cn', 'knotenkf');
+                    const bay = cimModel.getBay(this.integralID2UUID.get(i7Data.kpfeld));
+                    if (bay) {
+                        connectivityNode.connectivityNodeContainer = bay;
+                        bay.addConnectivityNode(connectivityNode);
+                    }
+                    else {
+                        this.logger.debug(`KnotenKf ${i7Data.id} besitzt kein Schaltfeld.`);
+                    }
+                    this.addIdMapping(i7Data.id, connectivityNode.mrid, integral_sql_1.Integral7TableNames.KNOTEN_KF);
+                    cimModel.addConnectivityNode(connectivityNode);
+                }
+            }
+            else {
+                this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.KNOTEN_KF} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertKnotenLk(cimModel, laengskupplungIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.KNOTEN_LK)) {
+                const result = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.KNOTEN_LK, laengskupplungIDs));
+                for (const i7Data of result) {
+                    const connectivityNode = new ConnectivityNode_1.ConnectivityNode(utils_1.generateUUID(), utils_2.getName(i7Data), 'KnotenLk');
+                    const bay = cimModel.getBay(this.integralID2UUID.get(i7Data.lkupplung));
+                    if (bay) {
+                        connectivityNode.connectivityNodeContainer = bay;
+                        bay.addConnectivityNode(connectivityNode);
+                    }
+                    else {
+                        this.logger.debug(`KnotenLk ${i7Data.id} besitzt kein Schaltfeld.`);
+                    }
+                    this.addIdMapping(i7Data.id, connectivityNode.mrid, integral_sql_1.Integral7TableNames.KNOTEN_LK);
+                    cimModel.addConnectivityNode(connectivityNode);
+                }
+            }
+            else {
+                this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.KNOTEN_LK} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertSchlaufen(cimModel, integral7, knotenSoIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.SCHLAUFE)) {
+                const result = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.SCHLAUFE, knotenSoIDs));
+                for (const i7Data of result) {
+                    const terminal = new Terminal_1.Terminal(utils_1.generateUUID(), 'T_Schlaufe', String(i7Data.id));
+                    terminal.connected = utils_2.convertToBooleanI7(i7Data.schaltzustand);
+                    terminal.phases = PhaseCode_1.PhaseCode.ABC;
+                    this.addIdMapping(i7Data.id, terminal.mrid, integral_sql_1.Integral7TableNames.SCHLAUFE);
+                    this.addIdMapping(i7Data.knotenzw, terminal.mrid, integral_sql_1.Integral7TableNames.SCHLAUFE);
+                    integral7.kontenZwIDs.push(i7Data.knotenzw);
+                    this.checkAnschlussIDs(i7Data.knotenzw, integral7);
+                    cimModel.addTerminal(terminal);
+                    const connectivityNode = cimModel.getConnectivityNode(this.integralID2UUID.get(i7Data.eknoten));
+                    if (connectivityNode) {
+                        connectivityNode.addTerminal(terminal);
+                        terminal.connectivityNode = connectivityNode;
+                    }
+                    else {
+                        this.logger.debug(`Schlaufe ${i7Data.id} besitzt keinen anschluss.`);
+                    }
+                }
+            }
+            else {
+                this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.SCHLAUFE} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertBelastungen(cimModel, knotenSfIDs, defaultValuesConfig, targetClass) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.BELASTUNG)) {
+                const result = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.BELASTUNG, knotenSfIDs));
+                for (const i7Data of result) {
+                    const load = targetClass === cim_class_names_1.CIM_CLASS_NAMES.ConformLoad ? new ConformLoad_1.ConformLoad(utils_1.getUUID(i7Data.guid), utils_2.getName(i7Data)) : new EnergyConsumer_1.EnergyConsumer(utils_1.getUUID(i7Data.guid), utils_2.getName(i7Data));
+                    this.setTopologyEnergySourceConsumerObject(cimModel, load, i7Data);
+                    const powerData = utils_2.getActiveReactivePower(i7Data);
+                    load.p = powerData[0];
+                    load.q = powerData[1];
+                    if (targetClass === cim_class_names_1.CIM_CLASS_NAMES.ConformLoad) {
+                        const conformLoadGroup = cimModel.getObjectByName(defaultValuesConfig.ConformLoadGroup.name, cim_class_names_1.CIM_CLASS_NAMES.ConformLoadGroup);
+                        load.loadGroup = conformLoadGroup;
+                        cimModel.addConformLoad(load);
+                    }
+                    else {
+                        cimModel.addEnergyConsumer(load);
+                    }
+                    this.addIdMapping(i7Data.id, load.mrid, integral_sql_1.Integral7TableNames.BELASTUNG);
+                }
+            }
+        });
+    }
+    convertEinspeisungen(cimModel, knotenSfIDs, targetClass) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.EINSPEISUNG)) {
+                const result = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.EINSPEISUNG, knotenSfIDs));
+                switch (targetClass) {
+                    case cim_class_names_1.CIM_CLASS_NAMES.EquivalentInjection: {
+                        yield this.convertEinspeisungen2EquivalentInjection(cimModel, result);
+                        break;
+                    }
+                    case cim_class_names_1.CIM_CLASS_NAMES.ExternalNetworkInjection: {
+                        yield this.convertEinspeisungen2ExternalNetworkInjection(cimModel, result);
+                        break;
+                    }
+                    default: {
+                        yield this.convertEinspeisungen2EnergySource(cimModel, result);
+                    }
+                }
+            }
+            else {
+                this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.EINSPEISUNG} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertGeneratoren(cimModel, knotenSfIDs, energyTypesConfig) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.GENERATOR)) {
+                const result = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.GENERATOR, knotenSfIDs));
+                for (const i7Data of result) {
+                    const synchronousMachine = new SynchronousMachine_1.SynchronousMachine(utils_1.getUUID(i7Data.guid), utils_2.getName(i7Data), i7Data.kurzname, i7Data.nameprimaertyp);
+                    synchronousMachine.type = SynchronousMachineKind_1.SynchronousMachineKind.generator;
+                    synchronousMachine.operatingMode = SynchronousMachineOperatingMode_1.SynchronousMachineOperatingMode.generator;
+                    synchronousMachine.referencePriority = utils_2.isNumericI7(i7Data.einspprio) ? utils_2.convertToNumberI7(i7Data.einspprio) : undefined;
+                    const maxP = utils_2.isNumericI7(i7Data.p_max) ? utils_2.convertToNumberI7(i7Data.p_max) : 0;
+                    const maxQ = utils_2.isNumericI7(i7Data.q_max) ? utils_2.convertToNumberI7(i7Data.q_max) : undefined;
+                    const minQ = utils_2.isNumericI7(i7Data.q_min) ? utils_2.convertToNumberI7(i7Data.q_min) : undefined;
+                    const maxQvonPmax = utils_2.isNumericI7(i7Data.qmax_von_pmax) ? utils_2.convertToNumberI7(i7Data.qmax_von_pmax) : undefined;
+                    const minQvonPmin = utils_2.isNumericI7(i7Data.qmin_von_pmin) ? utils_2.convertToNumberI7(i7Data.qmin_von_pmin) : undefined;
+                    synchronousMachine.maxQ = maxQ ? maxQ : maxQvonPmax;
+                    synchronousMachine.minQ = minQ ? minQ : minQvonPmin;
+                    const powerData = utils_2.getActiveReactivePower(i7Data);
+                    const p = powerData[0];
+                    const q = powerData[1];
+                    synchronousMachine.p = p;
+                    synchronousMachine.q = q;
+                    const sr = utils_2.isNumericI7(i7Data.sr) ? utils_2.convertToNumberI7(i7Data.sr) : undefined;
+                    if (sr && sr >= 0) {
+                        synchronousMachine.ratedS = sr;
+                    }
+                    else {
+                        synchronousMachine.ratedS = Math.sqrt(Math.pow(maxP, 2) + Math.pow(maxQvonPmax, 2));
+                    }
+                    if (!utils_2.isNumericI7(synchronousMachine.ratedS)) {
+                        console.log();
+                    }
+                    const ur = utils_2.isNumericI7(i7Data.ur) ? utils_2.convertToNumberI7(i7Data.ur) : undefined;
+                    const usoll = utils_2.isNumericI7(i7Data.usoll) ? utils_2.convertToNumberI7(i7Data.usoll) : undefined;
+                    synchronousMachine.ratedU = usoll ? usoll : ur;
+                    synchronousMachine.aggregate = true;
+                    synchronousMachine.ratedPowerFactor = utils_2.isNumericI7(i7Data.cosphir) ? utils_2.convertToNumberI7(i7Data.cosphir) : undefined;
+                    synchronousMachine.r = utils_2.isNumericI7(i7Data.rg) ? utils_2.convertToNumberI7(i7Data.rg) : undefined;
+                    const reactiveCapabilityCurve = new ReactiveCapabilityCurve_1.ReactiveCapabilityCurve(utils_1.generateUUID(), 'CurveData');
+                    reactiveCapabilityCurve.curveStyle = CurveStyle_1.CurveStyle.straightLineYValues;
+                    reactiveCapabilityCurve.xUnit = UnitSymbol_1.UnitSymbol.W;
+                    reactiveCapabilityCurve.y1Unit = UnitSymbol_1.UnitSymbol.VAr;
+                    reactiveCapabilityCurve.y2Unit = UnitSymbol_1.UnitSymbol.VAr;
+                    const curveData1 = new CurveData_1.CurveData(utils_1.generateUUID());
+                    curveData1.curve = reactiveCapabilityCurve;
+                    curveData1.xvalue = i7Data.p_min;
+                    curveData1.y1value = i7Data.qmin_von_pmin;
+                    curveData1.y2value = i7Data.qmax_von_pmin;
+                    cimModel.addCurveData(curveData1);
+                    const curveData2 = new CurveData_1.CurveData(utils_1.generateUUID());
+                    curveData2.curve = reactiveCapabilityCurve;
+                    curveData2.xvalue = i7Data.p_max;
+                    curveData2.y1value = i7Data.qmin_von_pmax;
+                    curveData2.y2value = i7Data.qmax_von_pmax;
+                    cimModel.addCurveData(curveData2);
+                    cimModel.addReactiveCapabilityCurve(reactiveCapabilityCurve);
+                    synchronousMachine.initialReactiveCapabilityCurveUUID = reactiveCapabilityCurve.mrid;
+                    const inBetrieb = utils_2.convertToBooleanI7(i7Data.betrieb);
+                    const regulatingControl = new RegulatingControl_1.RegulatingControl(utils_1.generateUUID(), `RG_Gen_${i7Data.id}`);
+                    regulatingControl.enabled = inBetrieb;
+                    regulatingControl.targetValue = usoll;
+                    switch (i7Data.spannungsgeregelt) {
+                        case 1: {
+                            regulatingControl.mode = RegulatingControlModeKind_1.RegulatingControlModeKind.voltage;
+                            break;
+                        }
+                        default: {
+                            regulatingControl.mode = RegulatingControlModeKind_1.RegulatingControlModeKind.voltage;
+                        }
+                    }
+                    synchronousMachine.regulatingControlUUID = regulatingControl.mrid;
+                    const generatingUnitConfig = energyTypesConfig[i7Data.nameprimaertyp];
+                    let generatingUnit;
+                    if (generatingUnitConfig) {
+                        switch (generatingUnitConfig.class) {
+                            case 'ThermalGeneratingUnit': {
+                                generatingUnit = new ThermalGeneratingUnit_1.ThermalGeneratingUnit(utils_1.getUUID(''), 'Generator_' + i7Data.bezeichner, i7Data.kurzname, i7Data.nameprimaertyp);
+                                if (generatingUnitConfig.fuelType) {
+                                    utils_2.generateFuelType(i7Data.nameprimaertyp, generatingUnitConfig.fuelType, generatingUnit, cimModel);
+                                }
+                                break;
+                            }
+                            case 'SolarGeneratingUnit': {
+                                generatingUnit = new SolarGeneratingUnit_1.SolarGeneratingUnit(utils_1.getUUID(''), 'Generator_' + i7Data.bezeichner, i7Data.kurzname, i7Data.nameprimaertyp);
+                                break;
+                            }
+                            case 'WindGeneratingUnit': {
+                                generatingUnit = new WindGeneratingUnit_1.WindGeneratingUnit(utils_1.getUUID(''), 'Generator_' + i7Data.bezeichner, i7Data.kurzname, i7Data.nameprimaertyp);
+                                switch (generatingUnitConfig.fuelType) {
+                                    case 'onshore': {
+                                        generatingUnit.windGenUnitType = WindGenUnitKind_1.WindGenUnitKind.onshore;
+                                        break;
+                                    }
+                                    case 'offshore': {
+                                        generatingUnit.windGenUnitType = WindGenUnitKind_1.WindGenUnitKind.offshore;
+                                        break;
+                                    }
+                                    default: {
+                                        generatingUnit.windGenUnitType = WindGenUnitKind_1.WindGenUnitKind.onshore;
+                                        break;
+                                    }
+                                }
+                                break;
+                            }
+                            case 'NuclearGeneratingUnit': {
+                                generatingUnit = new NuclearGeneratingUnit_1.NuclearGeneratingUnit(utils_1.getUUID(''), 'Generator_' + i7Data.bezeichner, i7Data.kurzname);
+                                break;
+                            }
+                            case 'HydroGeneratingUnit': {
+                                generatingUnit = new HydroGeneratingUnit_1.HydroGeneratingUnit(utils_1.getUUID(''), 'Generator_' + i7Data.bezeichner, i7Data.kurzname);
+                                generatingUnit.energyConversionCapability = HydroEnergyConversionKind_1.HydroEnergyConversionKind.pumpAndGenerator;
+                                break;
+                            }
+                        }
+                    }
+                    if (!generatingUnit) {
+                        generatingUnit = new GeneratingUnit_1.GeneratingUnit(utils_1.getUUID(''), 'Generator_' + i7Data.bezeichner, i7Data.kurzname);
+                    }
+                    generatingUnit.genControlSource = GeneratorControlSource_1.GeneratorControlSource.unavailable;
+                    generatingUnit.initialP = utils_2.isNumericI7(i7Data.p0) ? utils_2.convertToNumberI7(i7Data.p0) : undefined;
+                    generatingUnit.maxOperatingP = utils_2.isNumericI7(i7Data.p_max) ? utils_2.convertToNumberI7(i7Data.p_max) : undefined;
+                    generatingUnit.minOperatingP = utils_2.isNumericI7(i7Data.p_min) ? utils_2.convertToNumberI7(i7Data.p_min) : undefined;
+                    generatingUnit.nominalP = generatingUnit.maxOperatingP;
+                    const kr = utils_2.isNumericI7(i7Data.kr) ? utils_2.convertToNumberI7(i7Data.kr) : undefined;
+                    const fn = 50;
+                    const pn = generatingUnit.maxOperatingP;
+                    generatingUnit.governorSCD = (utils_2.isNumericI7(kr) && utils_2.isNumericI7(generatingUnit.nominalP)) ? utils_2.calculateSigma(fn, pn, kr) : undefined;
+                    generatingUnit.addRotatingMachine(synchronousMachine);
+                    synchronousMachine.generatingUnitUUID = generatingUnit.mrid;
+                    this.setTopologyEnergySourceConsumerObject(cimModel, synchronousMachine, i7Data, regulatingControl, generatingUnit);
+                    const smtcr = new SynchronousMachineTimeConstantReactance_1.SynchronousMachineTimeConstantReactance(utils_1.generateUUID(), `smtcr_${synchronousMachine.name}`);
+                    smtcr.enabled = utils_2.convertToBooleanI7(i7Data.betrieb);
+                    smtcr.tpdo = utils_2.isNumericI7(i7Data.td1s) ? utils_2.convertToNumberI7(i7Data.td1s) : undefined;
+                    smtcr.tppdo = utils_2.isNumericI7(i7Data.td2s) ? utils_2.convertToNumberI7(i7Data.td2s) : undefined;
+                    smtcr.tpqo = utils_2.isNumericI7(i7Data.tq1s) ? utils_2.convertToNumberI7(i7Data.tq1s) : undefined;
+                    smtcr.tppqo = utils_2.isNumericI7(i7Data.tq2s) ? utils_2.convertToNumberI7(i7Data.tq2s) : undefined;
+                    smtcr.xDirectSync = utils_2.isNumericI7(i7Data.xdu) ? utils_2.convertToNumberI7(i7Data.xdu) : undefined;
+                    smtcr.xDirectTrans = utils_2.isNumericI7(i7Data.xdu1s) ? utils_2.convertToNumberI7(i7Data.xdu1s) : undefined;
+                    smtcr.xDirectSubtrans = utils_2.isNumericI7(i7Data.xdu2s) ? utils_2.convertToNumberI7(i7Data.xdu2s) : undefined;
+                    smtcr.xQuadSync = utils_2.isNumericI7(i7Data.xqu) ? utils_2.convertToNumberI7(i7Data.xqu) : undefined;
+                    smtcr.xQuadTrans = utils_2.isNumericI7(i7Data.xqu1s) ? utils_2.convertToNumberI7(i7Data.xqu1s) : undefined;
+                    smtcr.xQuadSubtrans = utils_2.isNumericI7(i7Data.xqu2s) ? utils_2.convertToNumberI7(i7Data.xqu2s) : undefined;
+                    smtcr.synchronousMachine = synchronousMachine;
+                    synchronousMachine.synchronousMachineDynamics = smtcr;
+                    cimModel.addRegulatingControl(regulatingControl);
+                    cimModel.addGeneratingUnit(generatingUnit);
+                    cimModel.addSynchronousMachine(synchronousMachine);
+                    cimModel.addSynchronousMachineTimeConstantReactance(smtcr);
+                    this.addIdMapping(i7Data.id, synchronousMachine.mrid, integral_sql_1.Integral7TableNames.GENERATOR);
+                }
+            }
+        });
+    }
+    convertKraftwerksbloecke(cimModel, knotenSfIDs, energyTypesConfig) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.KWBLOCK)) {
+                const result = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.KWBLOCK, knotenSfIDs));
+                for (const i7Data of result) {
+                    const synchronousMachine = new SynchronousMachine_1.SynchronousMachine(utils_1.getUUID(i7Data.guid), utils_2.getName(i7Data), i7Data.kurzname);
+                    synchronousMachine.type = SynchronousMachineKind_1.SynchronousMachineKind.generator;
+                    synchronousMachine.operatingMode = SynchronousMachineOperatingMode_1.SynchronousMachineOperatingMode.generator;
+                    synchronousMachine.referencePriority = utils_2.isNumericI7(i7Data.einspprio) ? utils_2.convertToNumberI7(i7Data.einspprio) : undefined;
+                    const maxP = utils_2.isNumericI7(i7Data.p_max) ? utils_2.convertToNumberI7(i7Data.p_max) : 0;
+                    const maxQ = utils_2.isNumericI7(i7Data.q_max) ? utils_2.convertToNumberI7(i7Data.q_max) : undefined;
+                    const minQ = utils_2.isNumericI7(i7Data.q_min) ? utils_2.convertToNumberI7(i7Data.q_min) : undefined;
+                    synchronousMachine.maxQ = maxQ;
+                    synchronousMachine.minQ = minQ;
+                    const sr = utils_2.isNumericI7(i7Data.srg) ? utils_2.convertToNumberI7(i7Data.srg) : undefined;
+                    synchronousMachine.ratedS = sr;
+                    const ur = utils_2.isNumericI7(i7Data.urg) ? utils_2.convertToNumberI7(i7Data.urg) : undefined;
+                    synchronousMachine.ratedU = ur;
+                    synchronousMachine.aggregate = true;
+                    const regulatingControl = new RegulatingControl_1.RegulatingControl(utils_1.generateUUID(), `RG_KWBlock ${i7Data.id}`);
+                    switch (i7Data.spannungsgeregelt) {
+                        case 1: {
+                            regulatingControl.mode = RegulatingControlModeKind_1.RegulatingControlModeKind.voltage;
+                            break;
+                        }
+                        default: {
+                            regulatingControl.mode = RegulatingControlModeKind_1.RegulatingControlModeKind.timeScheduled;
+                        }
+                    }
+                    synchronousMachine.regulatingControlUUID = regulatingControl.mrid;
+                    const generatingUnitConfig = energyTypesConfig[i7Data.nameprimaertyp];
+                    let generatingUnit;
+                    if (generatingUnitConfig) {
+                        switch (generatingUnitConfig.class) {
+                            case 'ThermalGeneratingUnit': {
+                                generatingUnit = new ThermalGeneratingUnit_1.ThermalGeneratingUnit(utils_1.getUUID(''), 'Generator_' + i7Data.bezeichner, i7Data.kurzname, i7Data.nameprimaertyp);
+                                if (generatingUnitConfig.fuelType) {
+                                    utils_2.generateFuelType(i7Data.nameprimaertyp, generatingUnitConfig.fuelType, generatingUnit, cimModel);
+                                }
+                                break;
+                            }
+                            case 'SolarGeneratingUnit': {
+                                generatingUnit = new SolarGeneratingUnit_1.SolarGeneratingUnit(utils_1.getUUID(''), 'Generator_' + i7Data.bezeichner, i7Data.kurzname, i7Data.nameprimaertyp);
+                                break;
+                            }
+                            case 'WindGeneratingUnit': {
+                                generatingUnit = new WindGeneratingUnit_1.WindGeneratingUnit(utils_1.getUUID(''), 'Generator_' + i7Data.bezeichner, i7Data.kurzname, i7Data.nameprimaertyp);
+                                switch (generatingUnitConfig.fuelType) {
+                                    case 'onshore': {
+                                        generatingUnit.windGenUnitType = WindGenUnitKind_1.WindGenUnitKind.onshore;
+                                        break;
+                                    }
+                                    case 'offshore': {
+                                        generatingUnit.windGenUnitType = WindGenUnitKind_1.WindGenUnitKind.offshore;
+                                        break;
+                                    }
+                                    default: {
+                                        generatingUnit.windGenUnitType = WindGenUnitKind_1.WindGenUnitKind.onshore;
+                                        break;
+                                    }
+                                }
+                                break;
+                            }
+                            case 'NuclearGeneratingUnit': {
+                                generatingUnit = new NuclearGeneratingUnit_1.NuclearGeneratingUnit(utils_1.getUUID(''), 'Generator_' + i7Data.bezeichner, i7Data.kurzname);
+                                break;
+                            }
+                        }
+                    }
+                    if (!generatingUnit) {
+                        generatingUnit = new GeneratingUnit_1.GeneratingUnit(utils_1.getUUID(''), 'KWBlock' + i7Data.bezeichner, i7Data.kurzname);
+                    }
+                    generatingUnit.genControlSource = GeneratorControlSource_1.GeneratorControlSource.unavailable;
+                    generatingUnit.initialP = utils_2.isNumericI7(i7Data.p0) ? utils_2.convertToNumberI7(i7Data.p0) : undefined;
+                    generatingUnit.maxOperatingP = utils_2.isNumericI7(i7Data.p_max) ? utils_2.convertToNumberI7(i7Data.p_max) : undefined;
+                    generatingUnit.minOperatingP = utils_2.isNumericI7(i7Data.p_min) ? utils_2.convertToNumberI7(i7Data.p_min) : undefined;
+                    generatingUnit.nominalP = generatingUnit.maxOperatingP;
+                    const kr = utils_2.isNumericI7(i7Data.kr) ? utils_2.convertToNumberI7(i7Data.kr) : undefined;
+                    const fn = 50;
+                    const pn = generatingUnit.maxOperatingP;
+                    generatingUnit.governorSCD = (utils_2.isNumericI7(kr) && utils_2.isNumericI7(generatingUnit.nominalP)) ? utils_2.calculateSigma(fn, pn, kr) : undefined;
+                    generatingUnit.addRotatingMachine(synchronousMachine);
+                    synchronousMachine.generatingUnitUUID = generatingUnit.mrid;
+                    this.setTopologyEnergySourceConsumerObject(cimModel, synchronousMachine, i7Data, regulatingControl, generatingUnit);
+                    cimModel.addRegulatingControl(regulatingControl);
+                    cimModel.addGeneratingUnit(generatingUnit);
+                    cimModel.addSynchronousMachine(synchronousMachine);
+                    this.addIdMapping(i7Data.id, synchronousMachine.mrid, integral_sql_1.Integral7TableNames.KWBLOCK);
+                }
+            }
+        });
+    }
+    convertErsatzQuerZweige(cimModel, knotenSfIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.ERSATZQUERZWEIG)) {
+                const result = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.ERSATZQUERZWEIG, knotenSfIDs));
+                for (const i7Data of result) {
+                    const externalNetworkInjection = new ExternalNetworkInjection_1.ExternalNetworkInjection(utils_1.getUUID(i7Data.guid), utils_2.getName(i7Data), i7Data.kurzname);
+                    const usoll = utils_2.isNumericI7(i7Data.usoll) ? utils_2.convertToNumberI7(i7Data.usoll) : undefined;
+                    const kr = 0;
+                    externalNetworkInjection.governorSCD = kr;
+                    const prio = utils_2.isNumericI7(i7Data.einspprio) ? utils_2.convertToNumberI7(i7Data.einspprio) : undefined;
+                    externalNetworkInjection.referencePriority = prio;
+                    externalNetworkInjection.aggregate = true;
+                    externalNetworkInjection.ikSecond = true;
+                    this.setTopologyEnergySourceConsumerObject(cimModel, externalNetworkInjection, i7Data);
+                    cimModel.addExternalNetworkInjection(externalNetworkInjection);
+                    this.addIdMapping(i7Data.id, externalNetworkInjection.mrid, integral_sql_1.Integral7TableNames.ERSATZQUERZWEIG);
+                }
+            }
+            else {
+                this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.EINSPEISUNG} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertBoundaryInjections(cimModel, knotenSfIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.BOUNDARYINJECTION)) {
+                const result = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.BOUNDARYINJECTION, knotenSfIDs));
+                for (const i7Data of result) {
+                    const externalNetworkInjection = new ExternalNetworkInjection_1.ExternalNetworkInjection(utils_1.getUUID(i7Data.guid), utils_2.getName(i7Data), i7Data.kurzname);
+                    const inBetrieb = utils_2.convertToBooleanI7(i7Data.betrieb);
+                    const einspeisePrio = utils_2.convertToNumberI7(i7Data.einspprio);
+                    externalNetworkInjection.p = utils_2.convertToNumberI7(i7Data.p_ersatznetz) + utils_2.convertToNumberI7(i7Data.p_restnetz);
+                    externalNetworkInjection.q = utils_2.convertToNumberI7(i7Data.q_ersatznetz) + utils_2.convertToNumberI7(i7Data.q_restnetz);
+                    const kr = 0;
+                    externalNetworkInjection.governorSCD = kr;
+                    externalNetworkInjection.referencePriority = einspeisePrio;
+                    externalNetworkInjection.maxZ0ToZ1Ratio = utils_2.convertToNumberI7(i7Data.z0_z1);
+                    const regulatingControl = new RegulatingControl_1.RegulatingControl(utils_1.generateUUID(), `RG_BI_${i7Data.id}`);
+                    regulatingControl.mode = RegulatingControlModeKind_1.RegulatingControlModeKind.voltage;
+                    regulatingControl.discrete = true;
+                    regulatingControl.enabled = inBetrieb;
+                    regulatingControl.targetValueUnitMultiplier = UnitMultiplier_1.UnitMultiplier.k;
+                    externalNetworkInjection.regulatingControl = regulatingControl;
+                    this.setTopologyEnergySourceConsumerObject(cimModel, externalNetworkInjection, i7Data, regulatingControl);
+                    cimModel.addExternalNetworkInjection(externalNetworkInjection);
+                    cimModel.addRegulatingControl(regulatingControl);
+                    this.addIdMapping(i7Data.id, externalNetworkInjection.mrid, integral_sql_1.Integral7TableNames.BOUNDARYINJECTION);
+                }
+            }
+            else {
+                this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.EINSPEISUNG} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertKompensationsdrossel(cimModel, knotenSfIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.KOMPENSATIONSDROSSEL)) {
+                const result = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.KOMPENSATIONSDROSSEL, knotenSfIDs));
+                for (const i7Data of result) {
+                    const shunt = new LinearShuntCompensator_1.LinearShuntCompensator(utils_1.getUUID(i7Data.guid), utils_2.getName(i7Data), i7Data.kurzname, i7Data.kommentar);
+                    shunt.normalSections = i7Data.aktstufe;
+                    shunt.maximumSections = i7Data.maxstufe;
+                    shunt.nomU = i7Data.ur;
+                    shunt.gPerSection = i7Data.pr / Math.pow(i7Data.ur, 2);
+                    const inBetrieb = utils_2.convertToBooleanI7(i7Data.betrieb);
+                    const spannungsregelungLokal = utils_2.isBooleanI7(i7Data.flag_lf) ? utils_2.convertToBooleanI7(i7Data.flag_lf) : false;
+                    const spannungsregelungRemote = utils_2.isBooleanI7(i7Data.rpv_geregelt) ? utils_2.convertToBooleanI7(i7Data.rpv_geregelt) : false;
+                    let regulatingControl;
+                    if (spannungsregelungLokal || spannungsregelungRemote) {
+                        regulatingControl = new RegulatingControl_1.RegulatingControl(utils_1.generateUUID(), `RG_Kompdrossel ${i7Data.id}`);
+                        regulatingControl.mode = RegulatingControlModeKind_1.RegulatingControlModeKind.voltage;
+                        regulatingControl.discrete = true;
+                        regulatingControl.targetDeadband = i7Data.uband;
+                        regulatingControl.targetValueUnitMultiplier = UnitMultiplier_1.UnitMultiplier.k;
+                        regulatingControl.enabled = inBetrieb;
+                        shunt.regulatingControl = regulatingControl;
+                        cimModel.addRegulatingControl(regulatingControl);
+                    }
+                    this.setTopologyEnergySourceConsumerObject(cimModel, shunt, i7Data, regulatingControl);
+                    cimModel.addLinearShuntCompensator(shunt);
+                    this.addIdMapping(i7Data.id, shunt.mrid, integral_sql_1.Integral7TableNames.KOMPENSATIONSDROSSEL);
+                }
+            }
+            else {
+                this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.KOMPENSATIONSDROSSEL} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertKompensationskondensatoren(cimModel, knotenSfIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.KOMPENSATIONSKONDENSATOR)) {
+                const result = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.KOMPENSATIONSKONDENSATOR, knotenSfIDs));
+                for (const i7Data of result) {
+                    const shunt = new LinearShuntCompensator_1.LinearShuntCompensator(utils_1.getUUID(i7Data.guid), utils_2.getName(i7Data), i7Data.kurzname, i7Data.kommentar);
+                    shunt.normalSections = i7Data.aktstufe;
+                    shunt.maximumSections = i7Data.maxstufe;
+                    shunt.nomU = i7Data.ur;
+                    shunt.gPerSection = i7Data.pr / Math.pow(i7Data.ur, 2);
+                    const inBetrieb = utils_2.convertToBooleanI7(i7Data.betrieb);
+                    const spannungsregelungLokal = utils_2.isBooleanI7(i7Data.flag_lf) ? utils_2.convertToBooleanI7(i7Data.flag_lf) : false;
+                    const spannungsregelungRemote = utils_2.isBooleanI7(i7Data.rpv_geregelt) ? utils_2.convertToBooleanI7(i7Data.rpv_geregelt) : false;
+                    let regulatingControl;
+                    if (spannungsregelungLokal || spannungsregelungRemote) {
+                        regulatingControl = new RegulatingControl_1.RegulatingControl(utils_1.generateUUID(), `RG_Kompkond ${i7Data.id}`);
+                        regulatingControl.mode = RegulatingControlModeKind_1.RegulatingControlModeKind.voltage;
+                        regulatingControl.discrete = true;
+                        regulatingControl.enabled = inBetrieb;
+                        regulatingControl.targetDeadband = i7Data.uband;
+                        regulatingControl.targetValueUnitMultiplier = UnitMultiplier_1.UnitMultiplier.k;
+                        shunt.regulatingControl = regulatingControl;
+                        cimModel.addRegulatingControl(regulatingControl);
+                    }
+                    this.setTopologyEnergySourceConsumerObject(cimModel, shunt, i7Data);
+                    cimModel.addLinearShuntCompensator(shunt);
+                    this.addIdMapping(i7Data.id, shunt.mrid, integral_sql_1.Integral7TableNames.KOMPENSATIONSDROSSEL);
+                }
+            }
+            else {
+                this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.KOMPENSATIONSDROSSEL} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertStatcom(cimModel, knotenSfIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.STATCOM)) {
+                const result = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.STATCOM, knotenSfIDs));
+                for (const i7Data of result) {
+                    const statVarCom = new StaticVarCompensator_1.StaticVarCompensator(utils_1.getUUID(i7Data.guid), utils_2.getName(i7Data), i7Data.kurzname);
+                    const inBetrieb = utils_2.convertToBooleanI7(i7Data.betrieb);
+                    const regulatingControl = utils_2.createRegulatingControl(`RG_Statcom ${i7Data.id}`, inBetrieb, UnitMultiplier_1.UnitMultiplier.k, RegulatingControlModeKind_1.RegulatingControlModeKind.voltage, cimModel, statVarCom);
+                    this.setTopologyEnergySourceConsumerObject(cimModel, statVarCom, i7Data, regulatingControl);
+                    const uref = utils_2.isNumericI7(i7Data.uref) ? utils_2.convertToNumberI7(i7Data.uref) : undefined;
+                    regulatingControl.targetValue = uref;
+                    statVarCom.voltageSetPoint = uref;
+                    const flagOS = utils_2.convertToBooleanI7(i7Data.flag_os);
+                    if (flagOS && i7Data.trafo) {
+                        const trafoUUID = this.integralID2UUID.get(i7Data.trafo);
+                        const powerTransformer = cimModel.getObject(trafoUUID);
+                        if (powerTransformer) {
+                            try {
+                                const bvNumbers = powerTransformer.powerTransformerEnds.map(elem => { var _a, _b; return (_b = (_a = elem.baseVoltage) === null || _a === void 0 ? void 0 : _a.nominalVoltage) === null || _b === void 0 ? void 0 : _b.value; });
+                                const maxBv = Math.max(...bvNumbers);
+                                const powerTransformerEnd = powerTransformer.powerTransformerEnds[bvNumbers.indexOf(maxBv)];
+                                regulatingControl.terminal = powerTransformerEnd.terminal;
+                            }
+                            catch (e) {
+                                this.logger.debug(`Statcom Zuordnung zu Trafo fehlgeschlagen.`);
+                            }
+                        }
+                        else {
+                            this.logger.debug(`Statcom RegulatingControl ${i7Data.id} konnte dem Trafo ${i7Data.trafo} nicht zugeordnet werden.`);
+                        }
+                    }
+                    cimModel.addStaticVarCompensator(statVarCom);
+                    this.addIdMapping(i7Data.id, statVarCom.mrid, integral_sql_1.Integral7TableNames.STATCOM);
+                }
+            }
+            else {
+                this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.STATCOM} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertSVC(cimModel, knotenSfIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.SVC)) {
+                const result = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.SVC, knotenSfIDs));
+                for (const i7Data of result) {
+                    const statVarCom = new StaticVarCompensator_1.StaticVarCompensator(utils_1.getUUID(i7Data.guid), utils_2.getName(i7Data), i7Data.kurzname);
+                    const inBetrieb = utils_2.convertToBooleanI7(i7Data.betrieb);
+                    const regulatingControl = utils_2.createRegulatingControl(`RG_SVC ${i7Data.id}`, inBetrieb, UnitMultiplier_1.UnitMultiplier.k, RegulatingControlModeKind_1.RegulatingControlModeKind.voltage, cimModel, statVarCom);
+                    this.setTopologyEnergySourceConsumerObject(cimModel, statVarCom, i7Data, regulatingControl);
+                    const uref = utils_2.isNumericI7(i7Data.uref) ? utils_2.convertToNumberI7(i7Data.uref) : undefined;
+                    regulatingControl.targetValue = uref;
+                    statVarCom.voltageSetPoint = uref;
+                    const flagOS = utils_2.convertToBooleanI7(i7Data.flag_os);
+                    if (flagOS && i7Data.trafo) {
+                        const trafoUUID = this.integralID2UUID.get(i7Data.trafo);
+                        const powerTransformer = cimModel.getObject(trafoUUID);
+                        if (powerTransformer) {
+                            try {
+                                const bvNumbers = powerTransformer.powerTransformerEnds.map(elem => { var _a, _b; return (_b = (_a = elem.baseVoltage) === null || _a === void 0 ? void 0 : _a.nominalVoltage) === null || _b === void 0 ? void 0 : _b.value; });
+                                const maxBv = Math.max(...bvNumbers);
+                                const powerTransformerEnd = powerTransformer.powerTransformerEnds[bvNumbers.indexOf(maxBv)];
+                                regulatingControl.terminal = powerTransformerEnd.terminal;
+                            }
+                            catch (e) {
+                                this.logger.debug(`Statcom Zuordnung zu Trafo fehlgeschlagen.`);
+                            }
+                        }
+                        else {
+                            this.logger.debug(`Statcom RegulatingControl ${i7Data.id} konnte dem Trafo ${i7Data.trafo} nicht zugeordnet werden.`);
+                        }
+                    }
+                    cimModel.addStaticVarCompensator(statVarCom);
+                    this.addIdMapping(i7Data.id, statVarCom.mrid, integral_sql_1.Integral7TableNames.SVC);
+                }
+            }
+            else {
+                this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.STATCOM} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertCsConverterDC(cimModel, knotenSfIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.HGUE_KOPFSTATION_KLASSISCH)) {
+                const result = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.HGUE_KOPFSTATION_KLASSISCH, knotenSfIDs));
+                for (const i7Data of result) {
+                    const dcConverterUnit = new DCConverterUnit_1.DCConverterUnit(utils_1.generateUUID(), 'DCConverterUnit');
+                    const acConnectivityNode = cimModel.connectivityNodes.get(this.integralID2UUID.get(i7Data.anschluss));
+                    if (acConnectivityNode) {
+                        const equipmentContainer = this.determineEquipmentContainer('Substation', cimModel, acConnectivityNode.connectivityNodeContainer);
+                        if (equipmentContainer) {
+                            dcConverterUnit.name = `DCConverterUnit ${equipmentContainer.name}`;
+                            dcConverterUnit.setSubstation(equipmentContainer);
+                        }
+                        else {
+                            this.logger.debug(`DCConverterUnit ${i7Data.id} besitzt keinen EquipmentContainer.`);
+                        }
+                    }
+                    else {
+                        this.logger.debug(`DCConverterUnit ${i7Data.id} besitzt keinen ConnectivityNode.`);
+                    }
+                    const csConverter = new CsConverter_1.CsConverter(utils_1.getUUID(i7Data.guid), utils_2.getName(i7Data), i7Data.kurzname);
+                    csConverter.equipmentContainer = dcConverterUnit;
+                    csConverter.baseS = i7Data.pr;
+                    csConverter.ratedUdc = i7Data.ur;
+                    csConverter.idleLoss = i7Data.p_leer;
+                    csConverter.maxUdc = csConverter.ratedUdc * 1.05;
+                    csConverter.minUdc = csConverter.ratedUdc * 0.95;
+                    csConverter.resistiveLoss = 0;
+                    csConverter.switchingLoss = 0;
+                    const regelungU = utils_2.convertToBooleanI7(i7Data.u_geregelt);
+                    const regelungP = utils_2.convertToBooleanI7(i7Data.p_geregelt);
+                    const regelungW = utils_2.convertToBooleanI7(i7Data.grad_geregelt);
+                    if (regelungU) {
+                        csConverter.operatingMode = CsOperatingModeKind_1.CsOperatingModeKind.inverter;
+                    }
+                    else if (regelungP) {
+                        csConverter.operatingMode = CsOperatingModeKind_1.CsOperatingModeKind.rectifier;
+                    }
+                    else {
+                        csConverter.operatingMode = CsOperatingModeKind_1.CsOperatingModeKind.rectifier;
+                    }
+                    const inBetrieb = utils_2.convertToBooleanI7(i7Data.betrieb);
+                    util_create_1.createSvStatus(cimModel, inBetrieb, csConverter);
+                    if (acConnectivityNode) {
+                        this.createConnection(cimModel, csConverter, acConnectivityNode, PhaseCode_1.PhaseCode.ABC, true, 1);
+                    }
+                    else {
+                        this.logger.debug(`CsConverter ${i7Data.id} ${csConverter.mrid} besitzt keinen AC Anschluss.`);
+                    }
+                    const dcNode = new DCNode_1.DCNode(utils_1.generateUUID(), 'DCNode');
+                    dcNode.dcEquipmentContainer = dcConverterUnit;
+                    dcConverterUnit.dCNodes.set(dcNode.getUUID(), dcNode);
+                    const acDCConverterDCTerminal = new ACDCConverterDCTerminal_1.ACDCConverterDCTerminal(utils_1.generateUUID(), 'ACDCConvTerminal');
+                    acDCConverterDCTerminal.sequenceNumber = 1;
+                    acDCConverterDCTerminal.dCConductingEquipment = csConverter;
+                    csConverter.dCTerminals.set(acDCConverterDCTerminal.getUUID(), acDCConverterDCTerminal);
+                    acDCConverterDCTerminal.dcNode = dcNode;
+                    dcNode.dcTerminals.set(acDCConverterDCTerminal.getUUID(), acDCConverterDCTerminal);
+                    cimModel.addDCConverterUnit(dcConverterUnit);
+                    cimModel.addCSConverter(csConverter);
+                    cimModel.addDCNode(dcNode);
+                    cimModel.addACDCConverterDCTerminal(acDCConverterDCTerminal);
+                    this.addIdMapping(i7Data.id, csConverter.mrid, integral_sql_1.Integral7TableNames.HGUE_KOPFSTATION_KLASSISCH);
+                }
+            }
+        });
+    }
+    convertVsConverterDC(cimModel, knotenSfIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.HGUE_KOPFSTATION_VSC)) {
+                const result = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.HGUE_KOPFSTATION_VSC, knotenSfIDs));
+                for (const i7Data of result) {
+                    const dcConverterUnit = new DCConverterUnit_1.DCConverterUnit(utils_1.generateUUID(), 'DCConverterUnit');
+                    const acConnectivityNode = cimModel.connectivityNodes.get(this.integralID2UUID.get(i7Data.anschluss));
+                    if (acConnectivityNode) {
+                        const equipmentContainer = this.determineEquipmentContainer('Substation', cimModel, acConnectivityNode.connectivityNodeContainer);
+                        if (equipmentContainer) {
+                            dcConverterUnit.name = `DCConverterUnit ${equipmentContainer.name}`;
+                            dcConverterUnit.setSubstation(equipmentContainer);
+                        }
+                        else {
+                            this.logger.debug(`DCConverterUnit ${i7Data.id} besitzt keinen EquipmentContainer.`);
+                        }
+                    }
+                    else {
+                        this.logger.debug(`DCConverterUnit ${i7Data.id} besitzt keinen ConnectivityNode.`);
+                    }
+                    const vsConverter = new VsConverter_1.VsConverter(utils_1.getUUID(i7Data.guid), utils_2.getName(i7Data), i7Data.kurzname);
+                    vsConverter.equipmentContainer = dcConverterUnit;
+                    vsConverter.baseS = i7Data.pr;
+                    vsConverter.ratedUdc = i7Data.ur;
+                    vsConverter.idleLoss = i7Data.p_leer;
+                    vsConverter.maxUdc = vsConverter.ratedUdc * 1.05;
+                    vsConverter.minUdc = vsConverter.ratedUdc * 0.95;
+                    vsConverter.resistiveLoss = 0;
+                    vsConverter.switchingLoss = 0;
+                    const regelungU = utils_2.convertToBooleanI7(i7Data.u_geregelt);
+                    const regelungP = utils_2.convertToBooleanI7(i7Data.p_geregelt);
+                    const regelungW = utils_2.convertToBooleanI7(i7Data.grad_geregelt);
+                    if (regelungU) {
+                        vsConverter.pPccControl = VsPpccControlKind_1.VsPpccControlKind.pPcc;
+                        vsConverter.qPccControl = VsQpccControlKind_1.VsQpccControlKind.powerFactorPcc;
+                    }
+                    else if (regelungP) {
+                        vsConverter.pPccControl = VsPpccControlKind_1.VsPpccControlKind.pPcc;
+                        vsConverter.qPccControl = VsQpccControlKind_1.VsQpccControlKind.powerFactorPcc;
+                    }
+                    else {
+                        vsConverter.pPccControl = VsPpccControlKind_1.VsPpccControlKind.pPcc;
+                        vsConverter.qPccControl = VsQpccControlKind_1.VsQpccControlKind.powerFactorPcc;
+                    }
+                    const inBetrieb = utils_2.convertToBooleanI7(i7Data.betrieb);
+                    util_create_1.createSvStatus(cimModel, inBetrieb, vsConverter);
+                    if (acConnectivityNode) {
+                        util_create_1.createConnection(cimModel, vsConverter, acConnectivityNode, PhaseCode_1.PhaseCode.ABC, 1);
+                    }
+                    else {
+                        this.logger.debug(`VsConverter ${i7Data.id} ${vsConverter.mrid} besitzt keinen AC Anschluss.`);
+                    }
+                    const dcNode = new DCNode_1.DCNode(utils_1.generateUUID(), 'DCNode');
+                    dcNode.dcEquipmentContainer = dcConverterUnit;
+                    const acDCConverterDCTerminal = new ACDCConverterDCTerminal_1.ACDCConverterDCTerminal(utils_1.generateUUID(), 'ACDCConvTerminal');
+                    acDCConverterDCTerminal.sequenceNumber = 1;
+                    acDCConverterDCTerminal.dCConductingEquipmentUUID = vsConverter.mrid;
+                    acDCConverterDCTerminal.dcNodeUUID = dcNode.mrid;
+                    cimModel.addDCConverterUnit(dcConverterUnit);
+                    cimModel.addVSConverter(vsConverter);
+                    cimModel.addDCNode(dcNode);
+                    cimModel.addACDCConverterDCTerminal(acDCConverterDCTerminal);
+                    this.addIdMapping(i7Data.id, vsConverter.mrid, integral_sql_1.Integral7TableNames.HGUE_KOPFSTATION_VSC);
+                }
+            }
+        });
+    }
+    convertEinspeisungen2EnergySource(cimModel, result) {
+        var _a, _b, _c;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            for (const i7Data of result) {
+                try {
+                    const energySource = new EnergySource_1.EnergySource(utils_1.getUUID(i7Data.guid), utils_2.getName(i7Data), i7Data.kurzname);
+                    this.setTopologyEnergySourceConsumerObject(cimModel, energySource, i7Data);
+                    energySource.nominalVoltage = (_c = (_b = (_a = energySource.equipmentContainer) === null || _a === void 0 ? void 0 : _a.baseVoltage) === null || _b === void 0 ? void 0 : _b.nominalVoltage) === null || _c === void 0 ? void 0 : _c.value;
+                    const prio = i7Data.einspprio;
+                    const usoll = i7Data.usoll;
+                    const spannungsgeregelt = utils_2.convertToBooleanI7(i7Data.spannungsgeregelt);
+                    const powerData = utils_2.getActiveReactivePower(i7Data);
+                    energySource.activePower = powerData[0];
+                    energySource.reactivePower = powerData[1];
+                    cimModel.addEnergySource(energySource);
+                    this.addIdMapping(i7Data.id, energySource.mrid, integral_sql_1.Integral7TableNames.EINSPEISUNG);
+                }
+                catch (err) {
+                    this.logger.error(`Err convertEinspeisungen2EnergySource ${i7Data.id} ${err}`);
+                }
+            }
+        });
+    }
+    convertEinspeisungen2EquivalentInjection(cimModel, result) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            for (const i7Data of result) {
+                try {
+                    const equivalentInjection = new EquivalentInjection_1.EquivalentInjection(utils_1.getUUID(i7Data.guid), utils_2.getName(i7Data), i7Data.kurzname);
+                    const prio = i7Data.einspprio;
+                    const usoll = i7Data.usoll;
+                    const powerData = utils_2.getActiveReactivePower(i7Data);
+                    equivalentInjection.p = powerData[0];
+                    equivalentInjection.q = powerData[1];
+                    this.setTopologyEnergySourceConsumerObject(cimModel, equivalentInjection, i7Data);
+                    cimModel.addEquivalentInjection(equivalentInjection);
+                    this.addIdMapping(i7Data.id, equivalentInjection.mrid, integral_sql_1.Integral7TableNames.EINSPEISUNG);
+                }
+                catch (err) {
+                    this.logger.error(`Err convertEinspeisungen2EquivalentInjection ${i7Data.id} ${err}`);
+                }
+            }
+        });
+    }
+    convertEinspeisungen2ExternalNetworkInjection(cimModel, result) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            for (const i7Data of result) {
+                try {
+                    const externalNetworkInjection = new ExternalNetworkInjection_1.ExternalNetworkInjection(utils_1.getUUID(i7Data.guid), utils_2.getName(i7Data), i7Data.kurzname);
+                    const prio = i7Data.einspprio;
+                    externalNetworkInjection.referencePriority = prio;
+                    const usoll = i7Data.usoll;
+                    const powerData = utils_2.getActiveReactivePower(i7Data);
+                    externalNetworkInjection.p = powerData[0];
+                    externalNetworkInjection.q = powerData[1];
+                    this.setTopologyEnergySourceConsumerObject(cimModel, externalNetworkInjection, i7Data);
+                    cimModel.addExternalNetworkInjection(externalNetworkInjection);
+                    this.addIdMapping(i7Data.id, externalNetworkInjection.mrid, integral_sql_1.I7Objects.EINSPEISUNG);
+                }
+                catch (err) {
+                    this.logger.error(`Err convertEinspeisungen2EquivalentInjection ${i7Data.id} ${err}`);
+                }
+            }
+        });
+    }
+    setTopologyEnergySourceConsumerObject(cimModel, condEquip, i7Data, regulatingControl, generatingUnit) {
+        var _a, _b;
+        const inBetrieb = utils_2.convertToBooleanI7(i7Data.betrieb);
+        util_create_1.createSvStatus(cimModel, inBetrieb, condEquip);
+        const connectivityNode = cimModel.objects.get(this.integralID2UUID.get(i7Data.anschluss));
+        if (connectivityNode) {
+            const terminal = this.createConnection(cimModel, condEquip, connectivityNode, PhaseCode_1.PhaseCode.ABC, true);
+            if (regulatingControl)
+                regulatingControl.terminal = terminal;
+            const equipmentContainer = this.determineEquipmentContainer('VoltageLevel', cimModel, connectivityNode.connectivityNodeContainer);
+            if (equipmentContainer) {
+                condEquip.equipmentContainer = equipmentContainer;
+                equipmentContainer.addEquipment(condEquip);
+                const i7Schluesel = utils_2.getDescription(equipmentContainer === null || equipmentContainer === void 0 ? void 0 : equipmentContainer.getSubstation()) +
+                    integral_prefix_1.EINSPEISUNG_PRAEFIX + i7Data.bezeichner;
+                condEquip.description = i7Schluesel;
+                if (generatingUnit) {
+                    const substation = this.determineEquipmentContainer('Substation', cimModel, equipmentContainer);
+                    generatingUnit.equipmentContainer = substation;
+                }
+            }
+            else {
+                this.logger.error(`${(_a = condEquip === null || condEquip === void 0 ? void 0 : condEquip.constructor) === null || _a === void 0 ? void 0 : _a.name} ${i7Data.id} besitzt keinen EquipmentContainer.`);
+            }
+        }
+        else {
+            this.logger.error(`${(_b = condEquip === null || condEquip === void 0 ? void 0 : condEquip.constructor) === null || _b === void 0 ? void 0 : _b.name}  ${i7Data.id} besitzt keinen ConnectivityNode.`);
+        }
+    }
+    convertQuerkupplungen(cimModel, integral7, schaltanlagenAbschnittIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.QUERKUPPLUNG)) {
+                const result = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.QUERKUPPLUNG, schaltanlagenAbschnittIDs));
+                for (const i7Data of result) {
+                    const bay = new AMPRIONBay_1.AMPRIONBay(utils_1.getUUID(i7Data.guid), utils_2.getName(i7Data), 'Querkupplung');
+                    bay.number = i7Data.feldnummer;
+                    bay.locationID = i7Data.ips_folder_id;
+                    const voltageLevel = cimModel.getVoltageLevel(this.integralID2UUID.get(i7Data.saabschnitt));
+                    if (voltageLevel) {
+                        bay.voltageLevel = voltageLevel;
+                        voltageLevel.addBay(bay);
+                        const i7Schluessel = voltageLevel.description +
+                            '/QK-' +
+                            utils_2.ueberpruefeZeichenkette(i7Data.bezeichner);
+                        bay.description = i7Schluessel;
+                    }
+                    else {
+                        this.logger.debug(`Querkupplung ${i7Data.id} besitzt keine Anlage.`);
+                    }
+                    integral7.querkupplungIDs.push(i7Data.id);
+                    cimModel.addBay(bay);
+                    this.addIdMapping(i7Data.id, bay.mrid, integral_sql_1.Integral7TableNames.QUERKUPPLUNG);
+                }
+            }
+            else {
+                this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.QUERKUPPLUNG} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertLaegskupplungen(cimModel, integral7, schaltanlagenIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.LAENGSKUPPLUNG)) {
+                const result = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.LAENGSKUPPLUNG, schaltanlagenIDs));
+                for (const i7Data of result) {
+                    const bay = new AMPRIONBay_1.AMPRIONBay(utils_1.getUUID(i7Data.guid), utils_2.getName(i7Data), i7Data.kurzname, 'Laengskupplung');
+                    const voltageLevel = cimModel.getVoltageLevel(this.integralID2UUID.get(i7Data.schaltanlage));
+                    bay.number = i7Data.feldnummer;
+                    bay.locationID = i7Data.ips_folder_id;
+                    if (voltageLevel) {
+                        bay.voltageLevel = voltageLevel;
+                        voltageLevel.addBay(bay);
+                        const i7Schluessel = voltageLevel.description +
+                            '/LK-' +
+                            utils_2.ueberpruefeZeichenkette(i7Data.bezeichner);
+                        bay.description = i7Schluessel;
+                    }
+                    else {
+                        this.logger.debug(`Laengskupplung ${i7Data.id} besitzt keine Anlage.`);
+                    }
+                    integral7.laengskupplungIDs.push(i7Data.id);
+                    this.addIdMapping(i7Data.id, bay.mrid, integral_sql_1.Integral7TableNames.LAENGSKUPPLUNG);
+                    cimModel.addBay(bay);
+                }
+            }
+            else {
+                this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.LAENGSKUPPLUNG} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertStarreVerbindungen(cimModel, containerIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.KNOTEN_STARR)) {
+                const result = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.KNOTEN_STARR, containerIDs));
+                for (const i7Data of result) {
+                    const junction = new Junction_1.Junction(utils_1.getUUID(i7Data.guid), `${i7Data.bezeichner}`, 'JNCT', 'starre Verbindung');
+                    const schaltzustand = utils_2.convertToBooleanI7(i7Data.schaltzustand);
+                    const equipmentContainer = this.determineEquipmentContainer('VoltageLevel', cimModel, cimModel.getObject(this.integralID2UUID.get(i7Data.seliste)));
+                    if (equipmentContainer) {
+                        equipmentContainer.addEquipment(junction);
+                        junction.equipmentContainer = equipmentContainer;
+                    }
+                    else {
+                        this.logger.debug(`Starre verbindung ${i7Data.id} besitzt keinen EquipmentContainer.`);
+                    }
+                    const cnStart = cimModel.getConnectivityNode(this.integralID2UUID.get(i7Data.aknoten));
+                    const cnZiel = cimModel.getConnectivityNode(this.integralID2UUID.get(i7Data.eknoten));
+                    if (cnStart) {
+                        const terminal = this.createConnection(cimModel, junction, cnStart, PhaseCode_1.PhaseCode.ABC, true, 1);
+                        if (schaltzustand === false) {
+                            terminal.connected = schaltzustand;
+                        }
+                    }
+                    else {
+                        this.logger.debug(`Starre verbindung ${i7Data.id} besitzt keinen Anfangsknoten.`);
+                    }
+                    if (cnZiel) {
+                        const terminal = this.createConnection(cimModel, junction, cnZiel, PhaseCode_1.PhaseCode.ABC, true, 2);
+                        if (schaltzustand === false) {
+                            terminal.connected = schaltzustand;
+                        }
+                    }
+                    else {
+                        this.logger.debug(`Starre verbindung ${i7Data.id} besitzt keinen Zielknoten.`);
+                    }
+                    const baseVoltage = utils_2.getTerminalUn(cimModel, junction);
+                    if (baseVoltage) {
+                        junction.baseVoltage = baseVoltage;
+                    }
+                    this.addIdMapping(i7Data.id, junction.mrid, integral_sql_1.Integral7TableNames.KNOTEN_STARR);
+                    cimModel.addJunction(junction);
+                }
+            }
+            else {
+                this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.KNOTEN_STARR} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertTrennerFi3f(cimModel, containerIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.TRENNERFI_3P)) {
+                const result = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.TRENNERFI_3P, containerIDs));
+                for (const i7Data of result) {
+                    const disconnector = new Disconnector_1.Disconnector(utils_1.generateUUID(), i7Data.bezeichner);
+                    yield this.convertSwitch(disconnector, cimModel, i7Data);
+                    cimModel.addDisconnector(disconnector);
+                    this.addIdMapping(i7Data.id, disconnector.mrid, integral_sql_1.Integral7TableNames.TRENNERFI_3P);
+                }
+            }
+            else {
+                this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.TRENNERFI_3P} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertTrenner3f(cimModel, containerIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.TRENNER_3P)) {
+                const result = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.TRENNER_3P, containerIDs));
+                for (const i7Data of result) {
+                    const disconnector = new Disconnector_1.Disconnector(utils_1.getUUID(i7Data.guid), i7Data.bezeichner);
+                    yield this.convertSwitch(disconnector, cimModel, i7Data);
+                    cimModel.addDisconnector(disconnector);
+                    this.addIdMapping(i7Data.id, disconnector.mrid, integral_sql_1.Integral7TableNames.TRENNER_3P);
+                }
+            }
+            else {
+                this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.TRENNER_3P} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertLeistungsschalter(cimModel, containerIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.LEISTUNGSSCHALTER)) {
+                const result = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.LEISTUNGSSCHALTER, containerIDs));
+                for (const i7Data of result) {
+                    const breaker = new Breaker_1.Breaker(utils_1.generateUUID(), i7Data.bezeichner);
+                    yield this.convertSwitch(breaker, cimModel, i7Data);
+                    cimModel.addBreaker(breaker);
+                    this.addIdMapping(i7Data.id, breaker.mrid, integral_sql_1.Integral7TableNames.LEISTUNGSSCHALTER);
+                }
+            }
+            else {
+                this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.LEISTUNGSSCHALTER} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertSwitch(swtch, cimModel, i7Data) {
+        var _a;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            swtch.normalOpen = !utils_2.convertToBooleanI7(i7Data.schaltzustand);
+            swtch.open = !utils_2.convertToBooleanI7(i7Data.schaltzustand);
+            const equipmentContainer = cimModel.objects.get(this.integralID2UUID.get(i7Data.seliste));
+            const cnStart = cimModel.getConnectivityNode(this.integralID2UUID.get(i7Data.aknoten));
+            const cnZiel = cimModel.getConnectivityNode(this.integralID2UUID.get(i7Data.eknoten));
+            if (equipmentContainer) {
+                equipmentContainer.addEquipment(swtch);
+                swtch.equipmentContainer = equipmentContainer;
+            }
+            else {
+                this.logger.debug(`Schalter ${i7Data.id} besitzt keinen EquipmentContainer.`);
+            }
+            if (cnStart) {
+                this.createConnection(cimModel, swtch, cnStart, PhaseCode_1.PhaseCode.ABC, true, 1);
+            }
+            else {
+                this.logger.debug(`Schalter ${i7Data.id} besitzt keinen Anfangsknoten.`);
+            }
+            if (cnZiel) {
+                this.createConnection(cimModel, swtch, cnZiel, PhaseCode_1.PhaseCode.ABC, true, 2);
+            }
+            else {
+                this.logger.debug(`Schalter ${i7Data.id} besitzt keinen Zielknoten.`);
+            }
+            const voltageLevel = (_a = equipmentContainer) === null || _a === void 0 ? void 0 : _a.getVoltageLevel();
+            const baseVoltage = voltageLevel === null || voltageLevel === void 0 ? void 0 : voltageLevel.baseVoltage;
+            if (baseVoltage) {
+                swtch.baseVoltageUUID = baseVoltage.mrid;
+            }
+            else {
+                this.logger.debug(`Schalter ${i7Data.id} besitzt keine Anlage/BaseVoltage.`);
+            }
+        });
+    }
+    convertBetriebsmitteltypenKdrossel() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.TYP_KDROSSEL)) {
+                const result = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.TYP_KDROSSEL, []));
+                for (const i7Data of result) {
+                    this.kdrosseltypen.set(i7Data.name, i7Data);
+                }
+            }
+            else {
+                this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.TYP_KDROSSEL} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertSternpunktSchienen(cimModel, integral7, standortIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                const stpSchieneIDs = [];
+                if (this.isTableAvailable(integral_sql_1.Integral7TableNames.STERNPUNKT_SCHIENE)) {
+                    const stpSchiene = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.STERNPUNKT_SCHIENE, standortIDs));
+                    for (const i7DataSchiene of stpSchiene) {
+                        try {
+                            stpSchieneIDs.push(i7DataSchiene.id);
+                            const connectivityNode = new ConnectivityNode_1.ConnectivityNode(utils_1.generateUUID(), utils_2.getName(i7DataSchiene), `StpSchiene_${i7DataSchiene.id}`);
+                            const junction = new Junction_1.Junction(utils_1.generateUUID(), `StpSchiene/${i7DataSchiene.id}`, `${i7DataSchiene.bezeichner}`);
+                            const terminal = this.createConnection(cimModel, junction, connectivityNode, PhaseCode_1.PhaseCode.N, true);
+                            integral7.sternPunktImpModel.connectivityNodes.set(connectivityNode.mrid, connectivityNode);
+                            integral7.sternPunktImpModel.junctions.set(junction.mrid, junction);
+                            integral7.sternPunktImpModel.stpSchieneJunctionUUIDs.set(i7DataSchiene.id, junction.mrid);
+                            integral7.sternPunktImpModel.stpSchieneTerminal.set(i7DataSchiene.id, terminal);
+                            this.addIdMapping(i7DataSchiene.id, connectivityNode.mrid, integral_sql_1.Integral7TableNames.STERNPUNKT_SCHIENE);
+                        }
+                        catch (e) {
+                            this.logger.debug(e);
+                        }
+                    }
+                }
+                else {
+                    this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.STERNPUNKT_SCHIENE} ist nicht vorhanden.`);
+                }
+                resolve(stpSchieneIDs);
+            }));
+        });
+    }
+    convertKdrossel(cimModel, integral7, stpScheinenID) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                try {
+                    if (this.isTableAvailable(integral_sql_1.Integral7TableNames.STERNPUNKT_IMPEDANZ)) {
+                        if (stpScheinenID.length) {
+                            const result = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.STERNPUNKT_IMPEDANZ, stpScheinenID));
+                            for (const i7Data of result) {
+                                const kdType = this.kdrosseltypen.get(i7Data.nametyp);
+                                const imax = utils_2.isNumericI7(i7Data.imax) ? i7Data.imax : (utils_2.isNumericI7(kdType === null || kdType === void 0 ? void 0 : kdType.imax) ? kdType === null || kdType === void 0 ? void 0 : kdType.imax : undefined);
+                                const imin = utils_2.isNumericI7(i7Data.imin) ? i7Data.imin : (utils_2.isNumericI7(kdType === null || kdType === void 0 ? void 0 : kdType.imin) ? kdType === null || kdType === void 0 ? void 0 : kdType.imin : undefined);
+                                const connectivityNode = integral7.sternPunktImpModel.connectivityNodes.get(this.integralID2UUID.get(i7Data.anschluss));
+                                const junctionUUID = integral7.sternPunktImpModel.stpSchieneJunctionUUIDs.get((i7Data.anschluss));
+                                let conductingEquip;
+                                if (imax && imin) {
+                                    const petersenCoil = new PetersenCoil_1.PetersenCoil(utils_1.getUUID(i7Data.guid), utils_2.getName(i7Data), i7Data.id + '');
+                                    integral7.sternPunktImpModel.petersenCoils.set(petersenCoil.mrid, petersenCoil);
+                                    integral7.sternPunktImpModel.junctionUUIDstpImp.set(junctionUUID, petersenCoil);
+                                    this.addIdMapping(i7Data.id, petersenCoil.mrid, integral_sql_1.Integral7TableNames.STERNPUNKT_IMPEDANZ);
+                                    conductingEquip = petersenCoil;
+                                }
+                                else {
+                                    const groundingImpedance = new GroundingImpedance_1.GroundingImpedance(utils_1.getUUID(i7Data.guid), utils_2.getName(i7Data), i7Data.id + '');
+                                    groundingImpedance.r = utils_2.isNumericI7(i7Data.rne) ? i7Data.rne : (utils_2.isNumericI7(kdType === null || kdType === void 0 ? void 0 : kdType.rne) ? kdType === null || kdType === void 0 ? void 0 : kdType.rne : undefined);
+                                    groundingImpedance.x = utils_2.isNumericI7(i7Data.xne) ? i7Data.xne : (utils_2.isNumericI7(kdType === null || kdType === void 0 ? void 0 : kdType.xne) ? kdType === null || kdType === void 0 ? void 0 : kdType.xne : undefined);
+                                    integral7.sternPunktImpModel.groundingImpedances.set(groundingImpedance.mrid, groundingImpedance);
+                                    integral7.sternPunktImpModel.junctionUUIDstpImp.set(junctionUUID, groundingImpedance);
+                                    this.addIdMapping(i7Data.id, groundingImpedance.mrid, integral_sql_1.Integral7TableNames.STERNPUNKT_IMPEDANZ);
+                                    conductingEquip = groundingImpedance;
+                                }
+                                if (connectivityNode) {
+                                    const terminal = this.createConnection(cimModel, conductingEquip, connectivityNode, PhaseCode_1.PhaseCode.N, true);
+                                }
+                            }
+                        }
+                        else {
+                            this.logger.debug(`Kdrossel Keine Sternpunktschienen vorhanden.`);
+                        }
+                    }
+                    else {
+                        this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.STERNPUNKT_IMPEDANZ} ist nicht vorhanden.`);
+                    }
+                }
+                catch (e) {
+                    this.logger.debug(e);
+                }
+                finally {
+                    resolve('');
+                }
+            }));
+        });
+    }
+    convertStpSchaltelemente(integral7, stpScheinenID) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                try {
+                    if (this.isTableAvailable(integral_sql_1.Integral7TableNames.STERNPUNKT_SCHALTER)) {
+                        if (stpScheinenID.length) {
+                            const result = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.STERNPUNKT_SCHALTER, stpScheinenID));
+                            for (const i7Data of result) {
+                                const terminal = integral7.sternPunktImpModel.stpSchieneTerminal.get(i7Data.eknoten);
+                                if (terminal) {
+                                    terminal.connected = utils_2.isBooleanI7(i7Data.schaltzustand) ? utils_2.convertToBooleanI7(i7Data.schaltzustand) : true;
+                                }
+                                integral7.sternPunktImpModel.stpSchieneJunctionUUIDs.set(i7Data.id, integral7.sternPunktImpModel.stpSchieneJunctionUUIDs.get(i7Data.eknoten));
+                                integral7.sternPunktImpModel.stpSchieneJunctionUUIDs.set(i7Data.aknoten, integral7.sternPunktImpModel.stpSchieneJunctionUUIDs.get(i7Data.eknoten));
+                            }
+                        }
+                        else {
+                            this.logger.debug(`StpSchaltelemente Keine Sternpunktschienen vorhanden.`);
+                        }
+                    }
+                    else {
+                        this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.STERNPUNKT_SCHALTER} ist nicht vorhanden.`);
+                    }
+                }
+                catch (e) {
+                    this.logger.debug(e);
+                }
+                finally {
+                    resolve('');
+                }
+            }));
+        });
+    }
+    convertBetriebsmitteltypenLeitung() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.TYP_FREILEITUNG)) {
+                const result = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.TYP_FREILEITUNG, []));
+                for (const i7Data of result) {
+                    const typ = new EVWireInfo_1.EVWireInfo(utils_1.generateUUID(), i7Data.name);
+                    this.setWireInfoProperties(typ, i7Data, 'Freileitung');
+                    this.cimModelDefault.addEVWireInfo(typ);
+                }
+            }
+            else {
+                this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.TYP_FREILEITUNG} ist nicht vorhanden.`);
+            }
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.TYP_KABEL)) {
+                const result = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.TYP_KABEL, []));
+                for (const i7Data of result) {
+                    const typ = new EVWireInfo_1.EVWireInfo(utils_1.generateUUID(), i7Data.name);
+                    this.setWireInfoProperties(typ, i7Data, 'Kabel');
+                    this.cimModelDefault.addEVWireInfo(typ);
+                }
+            }
+            else {
+                this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.TYP_KABEL} ist nicht vorhanden.`);
+            }
+        });
+    }
+    setWireInfoProperties(object, data, type) {
+        object.name = data.name;
+        object.type = type;
+        object.voltage = data.un;
+        object.r1 = +data.r1;
+        object.x1 = +data.x1;
+        object.c1 = +data.c1;
+        object.r0 = +data.r0;
+        object.x0 = +data.x0;
+        object.c0 = +data.c0;
+        object.ratedCurrent = +data.ir;
+    }
+    convertLeitungen(cimModel, integral7, defaultValuesConfig) {
+        var _a, _b;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.LEITUNG) && integral7.leitungsAnschlussIDs.length) {
+                const limit = 3000;
+                const result = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.LEITUNG, integral7.leitungsAnschlussIDs));
+                const leitungIDs = result.map(elem => elem.id);
+                const leitungStromkreisabschnitt = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.STROMKREISABSCHNITT, leitungIDs));
+                for (const i7Data of result) {
+                    const stromkreisabschnitte = leitungStromkreisabschnitt.filter(elem => elem.leitung === i7Data.id);
+                    if (!(stromkreisabschnitte === null || stromkreisabschnitte === void 0 ? void 0 : stromkreisabschnitte.length))
+                        continue;
+                    const leitung = new Leitung_1.LeitungImpl(i7Data);
+                    integral7.integralLeitungen.set(i7Data.id, leitung);
+                    const i7Schluessel = integral_prefix_1.LEITUNG_PRAEFIX +
+                        utils_2.ueberpruefeZeichenkette(i7Data.ukz) +
+                        integral_prefix_1.MITTIGER_PUNKT +
+                        utils_2.ueberpruefeZeichenkette(i7Data.kurzname) +
+                        integral_prefix_1.MITTIGER_PUNKT +
+                        utils_2.ueberpruefeZeichenkette(i7Data.bezeichner) +
+                        integral_prefix_1.MITTIGER_PUNKT +
+                        utils_2.ueberpruefeZeichenkette(i7Data.stkabname);
+                    const name = integral_prefix_1.LEITUNG_PRAEFIX +
+                        utils_2.ueberpruefeZeichenkette(i7Data.ukz) +
+                        integral_prefix_1.MITTIGER_PUNKT +
+                        utils_2.ueberpruefeZeichenkette(i7Data.bezeichner) +
+                        integral_prefix_1.MITTIGER_PUNKT +
+                        utils_2.ueberpruefeZeichenkette(i7Data.stkabname);
+                    const line = new Line_1.Line(utils_1.getUUID(i7Data.guid), i7Data.name);
+                    const acLineSegments = [];
+                    for (const stk of stromkreisabschnitte) {
+                        const acLineSegment = new ACLineSegment_1.ACLineSegment(utils_1.generateUUID(), name, i7Data.stkabname, i7Schluessel);
+                        this.setACLineSegmentProperties(cimModel, acLineSegment, stk, defaultValuesConfig);
+                        acLineSegment.description = stk.nametyp;
+                        acLineSegment.equipmentContainer = line;
+                        line.addEquipment(acLineSegment);
+                        acLineSegments.push(acLineSegment);
+                        this.addIdMapping(stk.id, acLineSegment.mrid, integral_sql_1.Integral7TableNames.LEITUNG);
+                        cimModel.addACLineSegment(acLineSegment);
+                    }
+                    cimModel.addLine(line);
+                    const anzahl = acLineSegments.length;
+                    for (let i = 0; i < anzahl - 1; i++) {
+                        const cn = new ConnectivityNode_1.ConnectivityNode(utils_1.generateUUID(), 'CN_Lt');
+                        const acLineSegment1 = acLineSegments[i];
+                        const t1 = this.createConnection(cimModel, acLineSegment1, cn, PhaseCode_1.PhaseCode.ABC, true);
+                        this.setACLineSegmentCurrentLimt(cimModel, acLineSegment1, acLineSegment1.description, t1);
+                        const acLineSegment2 = acLineSegments[i + 1];
+                        const t2 = this.createConnection(cimModel, acLineSegment2, cn, PhaseCode_1.PhaseCode.ABC, true);
+                        this.setACLineSegmentCurrentLimt(cimModel, acLineSegment2, acLineSegment2.description, t2);
+                        cn.connectivityNodeContainer = acLineSegment1.equipmentContainer;
+                        cimModel.addConnectivityNode(cn);
+                    }
+                    const start = cimModel.getObject(this.integralID2UUID.get(i7Data.aknoten));
+                    const acLineSegmentStart = acLineSegments[0];
+                    if (start) {
+                        const terminal = this.createConnection(cimModel, acLineSegmentStart, start, PhaseCode_1.PhaseCode.ABC, acLineSegmentStart.terminalsUUIDs.length + 1);
+                        this.setACLineSegmentCurrentLimt(cimModel, acLineSegmentStart, acLineSegmentStart.description, terminal);
+                        if (!acLineSegmentStart.baseVoltage) {
+                            acLineSegmentStart.baseVoltage = (_a = terminal === null || terminal === void 0 ? void 0 : terminal.connectivityNode) === null || _a === void 0 ? void 0 : _a.getBaseVoltage();
+                            ;
+                        }
+                    }
+                    else {
+                        this.logger.debug(`Leitung ${i7Data.id} ${acLineSegmentStart.mrid} besitzt keinen Anfangsknoten. ${i7Data.aknoten} ${this.integralID2UUID.get(i7Data.aknoten)}`);
+                    }
+                    const target = cimModel.getObject(this.integralID2UUID.get(i7Data.eknoten));
+                    const acLineSegmentZiel = acLineSegments[anzahl - 1];
+                    if (target) {
+                        const terminal = this.createConnection(cimModel, acLineSegmentZiel, target, PhaseCode_1.PhaseCode.ABC, acLineSegmentStart.terminalsUUIDs.length + 2);
+                        this.setACLineSegmentCurrentLimt(cimModel, acLineSegmentZiel, acLineSegmentZiel.description, terminal);
+                        if (!acLineSegmentZiel.baseVoltage) {
+                            acLineSegmentZiel.baseVoltage = (_b = terminal === null || terminal === void 0 ? void 0 : terminal.connectivityNode) === null || _b === void 0 ? void 0 : _b.getBaseVoltage();
+                        }
+                    }
+                    else {
+                        this.logger.debug(`Leitung ${i7Data.id} ${acLineSegmentZiel.mrid} besitzt keinen Zielknoten.`);
+                    }
+                    const stkBaseVoltage = acLineSegments.find(elem => elem.baseVoltage !== undefined);
+                    if (!stkBaseVoltage) {
+                        this.logger.error(`Leitung ${i7Data.id}: Spannung konnte nicht bestimmt werden.`);
+                        continue;
+                    }
+                    for (const acLineSegment of acLineSegments) {
+                        acLineSegment.baseVoltage = stkBaseVoltage.baseVoltage;
+                        for (const terminal of acLineSegment.terminals.values()) {
+                        }
+                        const terminals = [...acLineSegment.terminals.values()];
+                        for (let i = 0; i < terminals.length; i++) {
+                            let terminal = terminals[i];
+                            if (terminal)
+                                terminal.sequenceNumber = i + 1;
+                        }
+                    }
+                    const region = utils_1.createIfNotExitsGeoregionByName(cimModel, defaultValuesConfig.GeographicalRegion.name);
+                    const subregion = utils_1.createIfNotExitsSubGeoregionByName(cimModel, defaultValuesConfig.SubGeographicalRegion.name, region);
+                    line.subGeographicalRegion = subregion;
+                }
+            }
+            else {
+                this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.LEITUNG} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertLaengskondensatoren(cimModel, integral7, defaultValuesConfig) {
+        var _a;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.LAENGSKONDENSATOR) && integral7.lKondensatorAnschlussKnotenIDs) {
+                const result = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.LAENGSKONDENSATOR, integral7.lKondensatorAnschlussKnotenIDs));
+                for (const i7Data of result) {
+                    const seriesCompensator = new AMPRIONSeriesCompensator_1.AMPRIONSeriesCompensator(utils_1.getUUID(i7Data.guid), utils_2.getName(i7Data), i7Data.id + '', i7Data.bezeichner);
+                    const start = cimModel.getObject(this.integralID2UUID.get(i7Data.aknoten));
+                    let startTerminal;
+                    if (start) {
+                        startTerminal = this.createConnection(cimModel, seriesCompensator, start, PhaseCode_1.PhaseCode.ABC, true, 1);
+                    }
+                    else {
+                        this.logger.debug(`Längskondensator ${i7Data.id} ${seriesCompensator.mrid} besitzt keinen Anfangsknoten.`);
+                    }
+                    const target = cimModel.getObject(this.integralID2UUID.get(i7Data.eknoten));
+                    let targetTerminal;
+                    if (target) {
+                        targetTerminal = this.createConnection(cimModel, seriesCompensator, target, PhaseCode_1.PhaseCode.ABC, true, 1);
+                    }
+                    else {
+                        this.logger.debug(`Längskondensator ${i7Data.id} ${seriesCompensator.mrid} besitzt keinen Zielknoten.`);
+                    }
+                    const ur = utils_2.getU(i7Data.ur, defaultValuesConfig.DefaultVoltage);
+                    const baseVoltage = util_create_1.createBaseVoltageIfNotExists(cimModel, ur);
+                    const i = utils_2.isNumericI7(i7Data.ir) ? utils_2.convertToNumberI7(i7Data.ir) : undefined;
+                    const ukr = utils_2.isNumericI7(i7Data.ukr) ? utils_2.convertToNumberI7(i7Data.ukr) : undefined;
+                    if (i > 0 && ukr > 0) {
+                        const voltage = baseVoltage.nominalVoltage.value * 1000;
+                        const z = (ukr / 100) * Math.pow(voltage, 2) / (voltage * i * Math.sqrt(3));
+                        seriesCompensator.x = z;
+                    }
+                    seriesCompensator.varistorRatedCurrent = i;
+                    const terminal = startTerminal;
+                    if (terminal) {
+                        this.setConductingEquipmentCurrentLimit(cimModel, 'Rating ' + seriesCompensator.name, terminal, i);
+                    }
+                    else {
+                        this.logger.debug(`Längsdrossel ${i7Data.id} ${seriesCompensator.mrid} besitzt keine Terminalinstanz.`);
+                    }
+                    const substationUUID = this.integralID2UUID.get(i7Data.standort);
+                    const voltageLevel = this.getVoltageLevelByVoltage((_a = (cimModel.getSubstation(substationUUID))) === null || _a === void 0 ? void 0 : _a.voltageLevels, ur);
+                    if (!voltageLevel) {
+                        this.logger.debug(`Längskondensator ${seriesCompensator === null || seriesCompensator === void 0 ? void 0 : seriesCompensator.mrid} hat kein EquipmentContainer`);
+                    }
+                    if (voltageLevel) {
+                        seriesCompensator.equipmentContainer = voltageLevel;
+                        seriesCompensator.baseVoltage = voltageLevel.baseVoltage;
+                    }
+                    else {
+                        this.logger.debug(`Längskondensator ${i7Data.id} besitzt kein VoltageLevel Ur ${i7Data.ur}.`);
+                    }
+                    const psrType = utils_1.createIfNotExitsPSRType(cimModel, 'Längskondensator');
+                    seriesCompensator.psrType = psrType;
+                    cimModel.addSeriesCompensator(seriesCompensator);
+                    this.addIdMapping(i7Data.id, seriesCompensator.mrid, integral_sql_1.Integral7TableNames.LAENGSKONDENSATOR);
+                }
+            }
+            else {
+                this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.LAENGSKONDENSATOR} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertDCLines(cimModel, integral7, defaultValuesConfig) {
+        var _a, _b;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.HGUE_LEITUNG) && integral7.hgueAnschlussKnotenIDs.length) {
+                const result = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.HGUE_LEITUNG, integral7.hgueAnschlussKnotenIDs));
+                for (const i7Data of result) {
+                    const dcLine = new DCLine_1.DCLine(utils_1.getUUID(i7Data['guid_dcline']), 'DCLine');
+                    const i7Schluessel = integral_prefix_1.LEITUNG_PRAEFIX +
+                        utils_2.ueberpruefeZeichenkette(i7Data.ukz) +
+                        integral_prefix_1.MITTIGER_PUNKT +
+                        utils_2.ueberpruefeZeichenkette(i7Data.kurzname) +
+                        integral_prefix_1.MITTIGER_PUNKT +
+                        utils_2.ueberpruefeZeichenkette(i7Data.bezeichner);
+                    const dcLineSegment = new DCLineSegment_1.DCLineSegment(utils_1.getUUID(i7Data.guid), i7Data.bezeichner, i7Data.kurzname, i7Schluessel);
+                    dcLineSegment.resistance = i7Data.rdc;
+                    dcLineSegment.equipmentContainer = dcLine;
+                    const bipol = utils_2.convertToBooleanI7(i7Data.bipol);
+                    const acDCConverterStart = cimModel.getObject(this.integralID2UUID.get(i7Data.anetzobjekt));
+                    const acDCConverterTarget = cimModel.getObject(this.integralID2UUID.get(i7Data.enetzobjekt));
+                    const converterUnitStart = (_a = acDCConverterStart) === null || _a === void 0 ? void 0 : _a.equipmentContainer;
+                    const converterUnitTarget = (_b = acDCConverterTarget) === null || _b === void 0 ? void 0 : _b.equipmentContainer;
+                    switch (bipol) {
+                        case (true): {
+                            converterUnitStart.operationMode = DCConverterOperatingModeKind_1.DCConverterOperatingModeKind.bipolar;
+                            converterUnitTarget.operationMode = DCConverterOperatingModeKind_1.DCConverterOperatingModeKind.bipolar;
+                        }
+                        default: {
+                            converterUnitStart.operationMode = DCConverterOperatingModeKind_1.DCConverterOperatingModeKind.monopolarGroundReturn;
+                            converterUnitTarget.operationMode = DCConverterOperatingModeKind_1.DCConverterOperatingModeKind.monopolarGroundReturn;
+                        }
+                    }
+                    const startDCNode = getDCNodeFromConverter(acDCConverterStart);
+                    if (startDCNode) {
+                        const dcTerminal = new DCTerminal_1.DCTerminal(utils_1.generateUUID(), 'DCTerminal_HGÜ_Leitung');
+                        dcTerminal.connected = true;
+                        dcTerminal.sequenceNumber = 1;
+                        dcTerminal.dCConductingEquipment = dcLineSegment;
+                        dcTerminal.dcNode = startDCNode;
+                        cimModel.addDCTerminal(dcTerminal);
+                    }
+                    else {
+                        this.logger.debug(`HGÜ-Leitung ${i7Data.id} ${dcLineSegment.mrid} besitzt keinen Anfangsknoten. ${i7Data.anetzobjekt} ${this.integralID2UUID.get(i7Data.anetzobjekt)}`);
+                    }
+                    const tartgetDCNode = getDCNodeFromConverter(acDCConverterTarget);
+                    if (tartgetDCNode) {
+                        const dcTerminal = new DCTerminal_1.DCTerminal(utils_1.generateUUID(), 'DCTerminal_HGÜ_Leitung');
+                        dcTerminal.connected = true;
+                        dcTerminal.sequenceNumber = 2;
+                        dcTerminal.dCConductingEquipment = dcLineSegment;
+                        dcTerminal.dcNode = tartgetDCNode;
+                        cimModel.addDCTerminal(dcTerminal);
+                    }
+                    else {
+                        this.logger.debug(`HGÜ-Leitung ${i7Data.id} ${dcLineSegment.mrid} besitzt keinen Zielknoten. ${i7Data.enetzobjekt} ${this.integralID2UUID.get(i7Data.enetzobjekt)}`);
+                    }
+                    cimModel.addDCLine(dcLine);
+                    cimModel.addDCLineSegment(dcLineSegment);
+                    this.addIdMapping(i7Data.id, dcLineSegment.mrid, integral_sql_1.Integral7TableNames.HGUE_LEITUNG);
+                }
+            }
+            else {
+                this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.HGUE_LEITUNG} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertBetriebsmitteltypenTrafo() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.TYP_TRAFO2W)) {
+                const result = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.TYP_TRAFO2W, []));
+                for (const i7Data of result) {
+                    const typTrafo = new EVPowerTransformerInfo_1.EVPowerTransformerInfo(utils_1.generateUUID(), i7Data.name);
+                    typTrafo.ukr12 = i7Data.ukr;
+                    typTrafo.pkr12 = i7Data.pkr;
+                    typTrafo.pLeer = i7Data.p_leer;
+                    typTrafo.iLeer = i7Data.i_leer;
+                    const typWicklung1 = new EVPowerTransformerEndInfo_1.EVPowerTransformerEndInfo(utils_1.generateUUID());
+                    typWicklung1.ratedS = new ApparentPower_1.ApparentPower(i7Data.sr, UnitMultiplier_1.UnitMultiplier.m, UnitSymbol_1.UnitSymbol.VA);
+                    this.setTransformerEndInfoProperties(typWicklung1, i7Data, 1);
+                    typWicklung1.powerTransformerInfo = typTrafo;
+                    typTrafo.addTransformerEndInfo(typWicklung1);
+                    const typWicklung2 = new EVPowerTransformerEndInfo_1.EVPowerTransformerEndInfo(utils_1.generateUUID());
+                    typWicklung2.ratedS = new ApparentPower_1.ApparentPower(i7Data.sr, UnitMultiplier_1.UnitMultiplier.m, UnitSymbol_1.UnitSymbol.VA);
+                    this.setTransformerEndInfoProperties(typWicklung2, i7Data, 2);
+                    typWicklung2.powerTransformerInfo = typTrafo;
+                    typTrafo.addTransformerEndInfo(typWicklung2);
+                    this.cimModelDefault.addEvPowerTransformerInfo(typTrafo);
+                    this.cimModelDefault.addEvPowerTransformerEndInfo(typWicklung1);
+                    this.cimModelDefault.addEvPowerTransformerEndInfo(typWicklung2);
+                }
+            }
+            else {
+                this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.TYP_TRAFO2W} ist nicht vorhanden.`);
+            }
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.TYP_TRAFO3W)) {
+                const result = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.TYP_TRAFO3W, []));
+                for (const i7Data of result) {
+                    const typTrafo = new EVPowerTransformerInfo_1.EVPowerTransformerInfo(utils_1.generateUUID(), i7Data.name);
+                    typTrafo.pLeer = i7Data.p_leer;
+                    typTrafo.iLeer = i7Data.i_leer;
+                    typTrafo.ukr12 = i7Data.ukr12;
+                    typTrafo.ukr13 = i7Data.ukr13;
+                    typTrafo.ukr23 = i7Data.ukr23;
+                    typTrafo.pkr12 = i7Data.pkr12;
+                    typTrafo.pkr13 = i7Data.pkr13;
+                    typTrafo.pkr23 = i7Data.pkr23;
+                    const typWicklung1 = new EVPowerTransformerEndInfo_1.EVPowerTransformerEndInfo(utils_1.generateUUID());
+                    typWicklung1.ratedS = new ApparentPower_1.ApparentPower(i7Data.sr1, UnitMultiplier_1.UnitMultiplier.m, UnitSymbol_1.UnitSymbol.VA);
+                    this.setTransformerEndInfoProperties(typWicklung1, i7Data, 1);
+                    typWicklung1.powerTransformerInfo = typTrafo;
+                    typTrafo.addTransformerEndInfo(typWicklung1);
+                    const typWicklung2 = new EVPowerTransformerEndInfo_1.EVPowerTransformerEndInfo(utils_1.generateUUID());
+                    typWicklung2.ratedS = new ApparentPower_1.ApparentPower(i7Data.sr2, UnitMultiplier_1.UnitMultiplier.m, UnitSymbol_1.UnitSymbol.VA);
+                    this.setTransformerEndInfoProperties(typWicklung2, i7Data, 2);
+                    typWicklung2.powerTransformerInfo = typTrafo;
+                    typTrafo.addTransformerEndInfo(typWicklung2);
+                    const typWicklung3 = new EVPowerTransformerEndInfo_1.EVPowerTransformerEndInfo(utils_1.generateUUID());
+                    typWicklung3.ratedS = new ApparentPower_1.ApparentPower(i7Data.sr3, UnitMultiplier_1.UnitMultiplier.m, UnitSymbol_1.UnitSymbol.VA);
+                    this.setTransformerEndInfoProperties(typWicklung3, i7Data, 3);
+                    typWicklung3.powerTransformerInfo = typTrafo;
+                    typTrafo.addTransformerEndInfo(typWicklung3);
+                    this.cimModelDefault.addEvPowerTransformerInfo(typTrafo);
+                    this.cimModelDefault.addEvPowerTransformerEndInfo(typWicklung1);
+                    this.cimModelDefault.addEvPowerTransformerEndInfo(typWicklung2);
+                    this.cimModelDefault.addEvPowerTransformerEndInfo(typWicklung3);
+                }
+            }
+            else {
+                this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.TYP_TRAFO3W} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertTrafo2W(cimModel, integral7, defaultValuesConfig, standortIDs) {
+        var _a;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.TRAFO2W)) {
+                const result = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.TRAFO2W, standortIDs));
+                const trafoIDs = result.map(obj => obj['id']);
+                const sternpunktKnotenMap = new Map();
+                for (const elem of trafoIDs) {
+                    sternpunktKnotenMap.set(elem, new Map());
+                }
+                if (this.isTableAvailable(integral_sql_1.Integral7TableNames.STERNPUNKT_KNOTEN) && trafoIDs.length) {
+                    const sternpunktKnotenResult = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.STERNPUNKT_KNOTEN, trafoIDs));
+                    for (const spKnoten of sternpunktKnotenResult) {
+                        (_a = sternpunktKnotenMap.get(spKnoten.netzobjekt)) === null || _a === void 0 ? void 0 : _a.set(spKnoten.id, spKnoten);
+                    }
+                }
+                for (const i7Data of result) {
+                    const powerTransformer = new PowerTransformer_1.PowerTransformer(utils_1.getUUID(i7Data.guid), utils_2.getName(i7Data), i7Data.id + '', i7Data.bezeichner);
+                    const substation = cimModel.getSubstation(this.integralID2UUID.get(i7Data.standort));
+                    if (substation) {
+                        powerTransformer.equipmentContainer = substation;
+                    }
+                    else {
+                        this.logger.debug(`Trafo2W ${i7Data.id} besitzt keine Umspannanlage.`);
+                    }
+                    const powerTransformerInfo = this.cimModelDefault.getPowerTransformerInfoByName(i7Data.nametyp);
+                    const powerTransformerEnd1 = new PowerTransformerEnd_1.PowerTransformerEnd(utils_1.getUUID(i7Data.guid_w1), `W1${powerTransformer.name}`);
+                    powerTransformerEnd1.endNumber = 1;
+                    const pkr = utils_2.getPkrTrafo(i7Data, powerTransformerInfo, '');
+                    const ukr = utils_2.getUkrTrafo(i7Data, powerTransformerInfo, '') / 100;
+                    const sr = utils_2.getSrTrafo(i7Data, powerTransformerInfo, powerTransformerEnd1.endNumber, false);
+                    const ur = utils_2.getUrTrafo(i7Data, powerTransformerInfo, powerTransformerEnd1.endNumber);
+                    const ir1 = sr * 1000000 / (ur * 1000 * Math.sqrt(3));
+                    const p0 = utils_2.isNumericI7(i7Data.p_leer) ? utils_2.convertToNumberI7(i7Data.p_leer) : 0;
+                    const iLeer = utils_2.isNumericI7(i7Data.i_leer) ? utils_2.convertToNumberI7(i7Data.i_leer) : 0;
+                    powerTransformerEnd1.r = utils_2.calculateR(ur, pkr, sr);
+                    powerTransformerEnd1.x = utils_2.calculateX(ur, ukr, sr, powerTransformerEnd1.r);
+                    powerTransformerEnd1.g = utils_2.calculateG(ur, p0) * 1000000;
+                    powerTransformerEnd1.b = utils_2.calculateB(ur, sr, iLeer, p0) * 1000000;
+                    powerTransformerEnd1.ratedU = ur;
+                    powerTransformerEnd1.ratedS = sr;
+                    const start = cimModel.getObject(this.integralID2UUID.get(i7Data.aknoten));
+                    const startTerminal = start ? this.createConnection(cimModel, powerTransformer, start, PhaseCode_1.PhaseCode.ABC, true, 1) : undefined;
+                    if (!startTerminal)
+                        this.logger.debug(`PowerTransformer2W ${i7Data.id} ${powerTransformer.mrid} besitzt keinen Anfangsknoten.`);
+                    this.setPowerTransformerEndProperties(cimModel, powerTransformerEnd1, powerTransformer, startTerminal, sternpunktKnotenMap, integral7, ir1, i7Data, defaultValuesConfig);
+                    const schaltgruppe = i7Data.schaltgr;
+                    const powerTransformerEnd2 = new PowerTransformerEnd_1.PowerTransformerEnd(utils_1.getUUID(i7Data.guid_w2), `W2${powerTransformer.name}`);
+                    powerTransformerEnd2.endNumber = 2;
+                    const sr2 = utils_2.getSrTrafo(i7Data, powerTransformerInfo, powerTransformerEnd2.endNumber, false);
+                    const ur2 = utils_2.getUrTrafo(i7Data, powerTransformerInfo, powerTransformerEnd2.endNumber);
+                    powerTransformerEnd2.r = 0;
+                    powerTransformerEnd2.x = 0;
+                    powerTransformerEnd2.ratedS = sr2;
+                    powerTransformerEnd2.ratedU = ur2;
+                    const ir2 = (sr * Math.pow(10, 6) / ur * 1000) / Math.sqrt(3);
+                    const ziel = cimModel.getObject(this.integralID2UUID.get(i7Data.eknoten));
+                    const zielTerminal = ziel ? this.createConnection(cimModel, powerTransformer, ziel, PhaseCode_1.PhaseCode.ABC, true, 2) : undefined;
+                    if (!zielTerminal)
+                        this.logger.debug(`PowerTransformer2W ${i7Data.id} ${powerTransformer.mrid} besitzt keinen Zielknoten.`);
+                    this.setPowerTransformerEndProperties(cimModel, powerTransformerEnd2, powerTransformer, zielTerminal, sternpunktKnotenMap, integral7, ir2, i7Data, defaultValuesConfig);
+                    powerTransformerEnd1.connectionKind = utils_2.getSchaltgruppe(schaltgruppe, powerTransformerEnd1.endNumber, [powerTransformerEnd1.ratedU, powerTransformerEnd2.ratedU]);
+                    powerTransformerEnd1.phaseAngleClock = utils_2.getSchaltgruppeAngleClock(schaltgruppe, powerTransformerEnd1.endNumber, [powerTransformerEnd1.ratedU, powerTransformerEnd2.ratedU]);
+                    powerTransformerEnd2.connectionKind = utils_2.getSchaltgruppe(schaltgruppe, powerTransformerEnd1.endNumber, [powerTransformerEnd1.ratedU, powerTransformerEnd2.ratedU]);
+                    powerTransformerEnd2.phaseAngleClock = utils_2.getSchaltgruppeAngleClock(schaltgruppe, powerTransformerEnd1.endNumber, [powerTransformerEnd1.ratedU, powerTransformerEnd2.ratedU]);
+                    powerTransformer.sortTransformerEnd('ratedU', 'desc');
+                    const powerTransformerEnds = [powerTransformerEnd1, powerTransformerEnd2];
+                    const terminals = [startTerminal, zielTerminal];
+                    const spRegKnoten = yield this.getSpannungsbandTrafo2W(i7Data);
+                    const spannungsband = integral7.targetVoltages.get(spRegKnoten.id);
+                    const cnUUID = this.integralID2UUID.get(spRegKnoten.id);
+                    const connectivityNode = cimModel.getObject(cnUUID);
+                    for (const powerTransformerEnd of powerTransformerEnds) {
+                        const winkel = utils_2.convertToNumberI7(i7Data[`uzus_winkel_s${powerTransformerEnd.endNumber}`]);
+                        switch (i7Data.trafo_spezial) {
+                            case (1): {
+                                this.createPhaseTapChanger(i7Data, powerTransformerEnd, cimModel, powerTransformerEnd.ratedU, connectivityNode, spannungsband);
+                                break;
+                            }
+                            case (2): {
+                                this.createPhaseTapChanger(i7Data, powerTransformerEnd, cimModel, powerTransformerEnd.ratedU, connectivityNode, spannungsband);
+                                break;
+                            }
+                            default: {
+                                if (winkel !== 0) {
+                                    this.createPhaseTapChanger(i7Data, powerTransformerEnd, cimModel, powerTransformerEnd.ratedU, connectivityNode, spannungsband);
+                                }
+                                else {
+                                    this.createPhaseTapChanger(i7Data, powerTransformerEnd, cimModel, powerTransformerEnd.ratedU, connectivityNode, spannungsband);
+                                }
+                                break;
+                            }
+                        }
+                    }
+                    for (let i = 0; i < powerTransformer.powerTransformerEnds.length; i++) {
+                        const powerTransformerEnd = powerTransformer.powerTransformerEnds[i];
+                        powerTransformerEnd.endNumber = i + 1;
+                    }
+                    cimModel.addPowerTransformerEnd(powerTransformerEnd1);
+                    cimModel.addPowerTransformerEnd(powerTransformerEnd2);
+                    cimModel.addPowerTransformer(powerTransformer);
+                    this.addIdMapping(i7Data.id, powerTransformer.mrid, integral_sql_1.Integral7TableNames.TRAFO2W);
+                }
+            }
+            else {
+                this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.TRAFO2W} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertTrafo3W(cimModel, integral7, defaultValuesConfig, standortIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.TRAFO3W)) {
+                const result = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.TRAFO3W, standortIDs));
+                const trafoIDs = result.map(obj => obj['id']);
+                const trafoWicklungen = new Map();
+                const trafoWicklungIDs = [];
+                if (this.isTableAvailable(integral_sql_1.Integral7TableNames.TRAFO3_WICKLUNG) && trafoIDs.length) {
+                    const wicklungenResult = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.TRAFO3_WICKLUNG, trafoIDs));
+                    for (const wicklung of wicklungenResult) {
+                        trafoWicklungen.set(wicklung.id, wicklung);
+                        trafoWicklungIDs.push(wicklung.id);
+                    }
+                }
+                else {
+                    this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.TRAFO3_WICKLUNG} ist nicht vorhanden.`);
+                }
+                const sternpunktKnotenMap = new Map();
+                if (this.isTableAvailable(integral_sql_1.Integral7TableNames.STERNPUNKT_KNOTEN) && trafoWicklungIDs.length) {
+                    const sternpunktKnotenResult = yield this.mysqlController.execQuery(integral_sql_1.getI7Query(integral_sql_1.I7Objects.STERNPUNKT_KNOTEN, trafoWicklungIDs));
+                    for (const spKnoten of sternpunktKnotenResult) {
+                        sternpunktKnotenMap.set(spKnoten.netzobjekt, spKnoten);
+                    }
+                }
+                for (const i7Data of result) {
+                    const powerTransformer = new PowerTransformer_1.PowerTransformer(utils_1.getUUID(i7Data.guid), utils_2.getName(i7Data), i7Data.id + '', i7Data.bezeichner);
+                    const substation = cimModel.getSubstation(this.integralID2UUID.get(i7Data.standort));
+                    if (substation) {
+                        powerTransformer.equipmentContainer = substation;
+                    }
+                    else {
+                        this.logger.debug(`Trafo3W ${i7Data.id} besitzt keine Umspannanlage.`);
+                    }
+                    const powerTransformerInfo = this.cimModelDefault.getPowerTransformerInfoByName(i7Data.nametyp);
+                    const pkr12 = utils_2.getPkrTrafo(i7Data, powerTransformerInfo, '12');
+                    const pkr13 = utils_2.getPkrTrafo(i7Data, powerTransformerInfo, '13');
+                    const pkr23 = utils_2.getPkrTrafo(i7Data, powerTransformerInfo, '23');
+                    const ukr12 = utils_2.getUkrTrafo(i7Data, powerTransformerInfo, '12');
+                    const ukr13 = utils_2.getUkrTrafo(i7Data, powerTransformerInfo, '13');
+                    const ukr23 = utils_2.getUkrTrafo(i7Data, powerTransformerInfo, '23');
+                    const sr1 = utils_2.getSrTrafo(i7Data, powerTransformerInfo, 1, true);
+                    const sr2 = utils_2.getSrTrafo(i7Data, powerTransformerInfo, 2, true);
+                    const sr3 = utils_2.getSrTrafo(i7Data, powerTransformerInfo, 3, true);
+                    const ur1 = utils_2.getUrTrafo(i7Data, powerTransformerInfo, 1);
+                    const ur2 = utils_2.getUrTrafo(i7Data, powerTransformerInfo, 2);
+                    const ur3 = utils_2.getUrTrafo(i7Data, powerTransformerInfo, 3);
+                    const ir1 = sr1 * 1000000 / ((ur1 * 1000) * Math.sqrt(3));
+                    const ir2 = sr2 * 1000000 / ((ur2 * 1000) * Math.sqrt(3));
+                    const ir3 = sr3 * 1000000 / ((ur3 * 1000) * Math.sqrt(3));
+                    const pLeer = utils_2.getTrafoPleer(i7Data, powerTransformerInfo);
+                    const iLeer = utils_2.getTrafoIleer(i7Data, powerTransformerInfo);
+                    const impedanzW1 = utils_trafo3w_1.calculateImpedanzenTrafo3W(1, ur1, ur2, ur3, sr1, sr2, sr3, pkr12, pkr13, pkr23, ukr12, ukr13, ukr23, pLeer, iLeer);
+                    const impedanzW2 = utils_trafo3w_1.calculateImpedanzenTrafo3W(2, ur1, ur2, ur3, sr1, sr2, sr3, pkr12, pkr13, pkr23, ukr12, ukr13, ukr23, pLeer, iLeer);
+                    const impedanzW3 = utils_trafo3w_1.calculateImpedanzenTrafo3W(3, ur1, ur2, ur3, sr1, sr2, sr3, pkr12, pkr13, pkr23, ukr12, ukr13, ukr23, pLeer, iLeer);
+                    const schaltgruppe = i7Data.schaltgr;
+                    const powerTransformerEnd1 = new PowerTransformerEnd_1.PowerTransformerEnd(utils_1.getUUID(i7Data.guid_w1), `W1 ${powerTransformer.name}`);
+                    powerTransformerEnd1.endNumber = 1;
+                    const wicklung1 = trafoWicklungen.get(i7Data.trafowicklung3w1);
+                    const knotenUUID = this.integralID2UUID.get(wicklung1.aknoten);
+                    const start = cimModel.getObject(knotenUUID);
+                    const terminal1 = start ? this.createConnection(cimModel, powerTransformer, start, PhaseCode_1.PhaseCode.ABC, true, 1) : undefined;
+                    if (!terminal1)
+                        this.logger.debug(`PowerTransformer3W ${i7Data.id} ${powerTransformer.mrid} besitzt keinen Anfangsknoten.`);
+                    powerTransformerEnd1.r = impedanzW1.r;
+                    powerTransformerEnd1.x = impedanzW1.x;
+                    powerTransformerEnd1.g = impedanzW1.g * 1000000;
+                    powerTransformerEnd1.b = impedanzW1.b * 1000000;
+                    powerTransformerEnd1.ratedU = ur1;
+                    powerTransformerEnd1.ratedS = sr1;
+                    this.setBaseVoltagePowerTransformerEnd(cimModel, powerTransformerEnd1);
+                    powerTransformerEnd1.powerTransformer = powerTransformer;
+                    powerTransformer.addPowerTransformerEnd(powerTransformerEnd1);
+                    if (terminal1) {
+                        powerTransformerEnd1.terminal = terminal1;
+                        this.setConductingEquipmentCurrentLimit(cimModel, 'W1 ' + powerTransformer.name, terminal1, ir1);
+                        if (sternpunktKnotenMap.has(wicklung1.id)) {
+                            this.convertTrafoGrounding(cimModel, powerTransformer, powerTransformerEnd1, integral7, sternpunktKnotenMap.get(wicklung1.id), defaultValuesConfig);
+                        }
+                    }
+                    else {
+                        this.logger.debug(`Wicklung3W ${i7Data.id} ${powerTransformerEnd1.endNumber} ${powerTransformerEnd1.mrid} besitzt keine Terminalinstanz.`);
+                    }
+                    const wicklung2 = trafoWicklungen.get(i7Data.trafowicklung3w2);
+                    const start2 = cimModel.getObject(this.integralID2UUID.get(wicklung2.aknoten));
+                    const terminal2 = start ? this.createConnection(cimModel, powerTransformer, start2, PhaseCode_1.PhaseCode.ABC, true, 2) : undefined;
+                    if (!terminal2)
+                        this.logger.debug(`PowerTransformer3W ${i7Data.id} ${powerTransformer.mrid} besitzt keinen Anfangsknoten.`);
+                    const powerTransformerEnd2 = new PowerTransformerEnd_1.PowerTransformerEnd(utils_1.getUUID(i7Data.guid_w2), `W2 ${powerTransformer.name}`);
+                    powerTransformerEnd2.endNumber = 2;
+                    powerTransformerEnd2.r = impedanzW2.r;
+                    powerTransformerEnd2.x = impedanzW2.x;
+                    powerTransformerEnd2.g = impedanzW2.g * 1000000;
+                    powerTransformerEnd2.b = impedanzW2.b * 1000000;
+                    powerTransformerEnd2.ratedS = sr2;
+                    powerTransformerEnd2.ratedU = ur2;
+                    this.setBaseVoltagePowerTransformerEnd(cimModel, powerTransformerEnd2);
+                    powerTransformerEnd2.powerTransformer = powerTransformer;
+                    powerTransformer.addPowerTransformerEnd(powerTransformerEnd2);
+                    if (terminal2) {
+                        powerTransformerEnd2.terminal = terminal2;
+                        this.setConductingEquipmentCurrentLimit(cimModel, 'W1 ' + powerTransformer.name, terminal2, ir2);
+                        if (sternpunktKnotenMap.has(wicklung2.id)) {
+                            this.convertTrafoGrounding(cimModel, powerTransformer, powerTransformerEnd2, integral7, sternpunktKnotenMap.get(wicklung2.id), defaultValuesConfig);
+                        }
+                    }
+                    else {
+                        this.logger.debug(`Wicklung3W ${i7Data.id} ${powerTransformerEnd2.endNumber} ${powerTransformerEnd2.mrid} besitzt keine Terminalinstanz.`);
+                    }
+                    const wicklung3 = trafoWicklungen.get(i7Data.trafowicklung3w3);
+                    const start3 = cimModel.getObject(this.integralID2UUID.get(wicklung2.aknoten));
+                    const terminal3 = start ? this.createConnection(cimModel, powerTransformer, start3, PhaseCode_1.PhaseCode.ABC, true, 3) : undefined;
+                    if (!terminal3)
+                        this.logger.debug(`PowerTransformer3W ${i7Data.id} ${powerTransformer.mrid} besitzt keinen Anfangsknoten.`);
+                    const powerTransformerEnd3 = new PowerTransformerEnd_1.PowerTransformerEnd(utils_1.getUUID(i7Data.guid_w3), `Wicklung 3 ${powerTransformer.name}`);
+                    powerTransformerEnd3.endNumber = 3;
+                    powerTransformerEnd3.r = impedanzW3.r;
+                    powerTransformerEnd3.x = impedanzW3.x;
+                    powerTransformerEnd3.g = impedanzW3.g * 1000000;
+                    powerTransformerEnd3.b = impedanzW3.b * 1000000;
+                    powerTransformerEnd3.ratedS = sr3;
+                    powerTransformerEnd3.ratedU = ur3;
+                    this.setBaseVoltagePowerTransformerEnd(cimModel, powerTransformerEnd3);
+                    powerTransformerEnd3.powerTransformer = powerTransformer;
+                    powerTransformer.addPowerTransformerEnd(powerTransformerEnd3);
+                    if (terminal3) {
+                        powerTransformerEnd3.terminal = terminal3;
+                        this.setConductingEquipmentCurrentLimit(cimModel, 'W1 ' + powerTransformer.name, terminal3, ir3);
+                        if (sternpunktKnotenMap.has(wicklung3.id)) {
+                            this.convertTrafoGrounding(cimModel, powerTransformer, powerTransformerEnd3, integral7, sternpunktKnotenMap.get(wicklung3.id), defaultValuesConfig);
+                        }
+                    }
+                    else {
+                        this.logger.debug(`Wicklung3W ${i7Data.id} ${powerTransformerEnd3.endNumber} ${powerTransformerEnd3.mrid} besitzt keine Terminalinstanz.`);
+                    }
+                    powerTransformerEnd1.connectionKind = utils_2.getSchaltgruppe(schaltgruppe, powerTransformerEnd1.endNumber, [powerTransformerEnd1.ratedU, powerTransformerEnd2.ratedU, powerTransformerEnd3.ratedU]);
+                    powerTransformerEnd1.phaseAngleClock = utils_2.getSchaltgruppeAngleClock(schaltgruppe, powerTransformerEnd1.endNumber, [powerTransformerEnd1.ratedU, powerTransformerEnd2.ratedU, powerTransformerEnd3.ratedU]);
+                    powerTransformerEnd2.connectionKind = utils_2.getSchaltgruppe(schaltgruppe, powerTransformerEnd1.endNumber, [powerTransformerEnd1.ratedU, powerTransformerEnd2.ratedU, powerTransformerEnd3.ratedU]);
+                    powerTransformerEnd2.phaseAngleClock = utils_2.getSchaltgruppeAngleClock(schaltgruppe, powerTransformerEnd1.endNumber, [powerTransformerEnd1.ratedU, powerTransformerEnd2.ratedU, powerTransformerEnd3.ratedU]);
+                    powerTransformerEnd3.connectionKind = utils_2.getSchaltgruppe(schaltgruppe, powerTransformerEnd1.endNumber, [powerTransformerEnd1.ratedU, powerTransformerEnd2.ratedU, powerTransformerEnd3.ratedU]);
+                    powerTransformerEnd3.phaseAngleClock = utils_2.getSchaltgruppeAngleClock(schaltgruppe, powerTransformerEnd1.endNumber, [powerTransformerEnd1.ratedU, powerTransformerEnd2.ratedU, powerTransformerEnd3.ratedU]);
+                    powerTransformer.sortTransformerEnd('ratedU', 'desc');
+                    const terminals = [terminal1, terminal2, terminal3];
+                    const powerTransformerEnds = [powerTransformerEnd1, powerTransformerEnd2, powerTransformerEnd3];
+                    const spRegKnoten = yield this.getSpannungsbandTrafo2W(i7Data);
+                    const spannungsband = integral7.targetVoltages.get(spRegKnoten.id);
+                    const cnUUID = this.integralID2UUID.get(spRegKnoten.id);
+                    const connectivityNode = cimModel.getObject(cnUUID);
+                    for (const powerTransformerEnd of powerTransformerEnds) {
+                        const winkel = utils_2.convertToNumberI7(i7Data[`uzus_winkel_s${powerTransformerEnd.endNumber}`]);
+                        switch (i7Data.trafo_spezial) {
+                            case (1): {
+                                this.createPhaseTapChanger(i7Data, powerTransformerEnd, cimModel, powerTransformerEnd.ratedU, connectivityNode, spannungsband);
+                                break;
+                            }
+                            case (2): {
+                                this.createPhaseTapChanger(i7Data, powerTransformerEnd, cimModel, powerTransformerEnd.ratedU, connectivityNode, spannungsband);
+                                break;
+                            }
+                            default: {
+                                if (winkel !== 0) {
+                                    this.createPhaseTapChanger(i7Data, powerTransformerEnd, cimModel, powerTransformerEnd.ratedU, connectivityNode, spannungsband);
+                                }
+                                else {
+                                    this.createPhaseTapChanger(i7Data, powerTransformerEnd, cimModel, powerTransformerEnd.ratedU, connectivityNode, spannungsband);
+                                }
+                                break;
+                            }
+                        }
+                    }
+                    for (let i = 0; i < powerTransformer.powerTransformerEnds.length; i++) {
+                        powerTransformer.powerTransformerEnds[i].endNumber = i + 1;
+                    }
+                    cimModel.addPowerTransformer(powerTransformer);
+                    cimModel.addPowerTransformerEnd(powerTransformerEnd1);
+                    cimModel.addPowerTransformerEnd(powerTransformerEnd2);
+                    cimModel.addPowerTransformerEnd(powerTransformerEnd3);
+                    this.addIdMapping(i7Data.id, powerTransformer.mrid, integral_sql_1.Integral7TableNames.TRAFO3W);
+                }
+            }
+            else {
+                this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.TRAFO3W} ist nicht vorhanden.`);
+            }
+        });
+    }
+    setTransformerEndInfoProperties(wicklung, data, endNumber) {
+        const minstufe = `minstufe_s${endNumber}`;
+        const mittelstufe = `mittelstufe_s${endNumber}`;
+        const maxstufe = `maxstufe_s${endNumber}`;
+        const umax = `umax_s${endNumber}`;
+        const umin = `umin_s${endNumber}`;
+        const gestufte_seite = `gestufte_seite_s${endNumber}`;
+        const ur = `ur${endNumber}`;
+        wicklung.endNumber = endNumber;
+        wicklung.ratedU = new Voltage_1.Voltage(data[ur], UnitMultiplier_1.UnitMultiplier.k, UnitSymbol_1.UnitSymbol.V);
+        wicklung.tapActive = utils_2.convertToBooleanI7(data[gestufte_seite]);
+        const tapChangerInfo = new TapChangerInfo_1.TapChangerInfo(utils_1.generateUUID(), `TapChangerInfo_${data['id']}`);
+        tapChangerInfo.highStep = data[maxstufe];
+        tapChangerInfo.lowStep = data[minstufe];
+        tapChangerInfo.neutralStep = data[mittelstufe];
+        wicklung.uMax = data[umax];
+        wicklung.uMin = data[umin];
+    }
+    transformBoundaryModel(cimModel, defaultValuesConfig) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const substations = Array.from(cimModel.substations.values());
+            for (const substation of substations) {
+                const line = new Line_1.Line(substation.mrid, substation.name, substation.shortName, substation.description);
+                const subregion = substation.subGeographicalRegion;
+                line.subGeographicalRegion = subregion;
+                subregion.addLine(line);
+                const connectivityNodes = [];
+                const equipments = [];
+                const index = subregion.substations.indexOf(substation);
+                if (index > -1)
+                    subregion.substations.splice(index, 1);
+                substation.subGeographicalRegion = undefined;
+                connectivityNodes.push(...substation.connectivityNodes);
+                substation.connectivityNodes.length = 0;
+                equipments.push(...substation.equipments);
+                substation.equipments.length = 0;
+                for (const voltageLevel of substation.voltageLevels) {
+                    connectivityNodes.push(...voltageLevel.connectivityNodes);
+                    equipments.push(...voltageLevel.equipments);
+                    for (const bay of voltageLevel.bays) {
+                        connectivityNodes.push(...bay.connectivityNodes);
+                        equipments.push(...bay.equipments);
+                        bay.connectivityNodes.length = 0;
+                        bay.equipments.length = 0;
+                        bay.voltageLevel = undefined;
+                        cimModel.bays.delete(bay.mrid);
+                        cimModel.removeObject(bay);
+                    }
+                    voltageLevel.bays.length = 0;
+                    voltageLevel.connectivityNodes.length = 0;
+                    voltageLevel.equipments.length = 0;
+                    voltageLevel.substation = undefined;
+                    cimModel.voltageLevels.delete(voltageLevel.mrid);
+                    cimModel.removeObject(voltageLevel);
+                }
+                substation.voltageLevels.length = 0;
+                for (const equipment of equipments) {
+                    this.logger.debug(`Grenz-Standort ${substation.name} I7-ID ${this.UUID2Integral7ID.get(substation.mrid)} UUID ${substation.mrid} hat Equipment ${equipment.constructor.name} I7-ID ${this.UUID2Integral7ID.get(equipment.mrid)} UUID ${equipment.mrid}`);
+                    equipment.equipmentContainer = undefined;
+                    cimModel.removeObject(equipment);
+                }
+                for (const connectivityNode of connectivityNodes) {
+                    connectivityNode.connectivityNodeContainer = line;
+                    line.addConnectivityNode(connectivityNode);
+                }
+                cimModel.substations.delete(substation.mrid);
+                cimModel.removeObject(substation);
+                const junction = new Junction_1.Junction(utils_1.generateUUID(), `BD_Junc/`, `Junction`, 'Junction for Geo');
+                junction.equipmentContainer = line;
+                line.addEquipment(junction);
+                const location = substation.location;
+                if (!location)
+                    continue;
+                location.powerSystemResources.delete(substation.mrid);
+                location.addPowerSystemResource(junction);
+                junction.location = location;
+                cimModel.addJunction(junction);
+                cimModel.addLine(line);
+            }
+        });
+    }
+    setACLineSegmentProperties(cimModel, acLineSegment, data, defaultValuesConfig) {
+        const assetType = this.cimModelDefault.getWireInfoByName(data.nametyp);
+        let voltage = defaultValuesConfig.DefaultVoltage;
+        if (!acLineSegment.baseVoltage) {
+            if (data.un && data.un > 0) {
+                voltage = data.un;
+            }
+            else if (assetType === null || assetType === void 0 ? void 0 : assetType.voltage) {
+                voltage = assetType.voltage;
+            }
+            const baseVoltage = util_create_1.createBaseVoltageIfNotExists(cimModel, voltage);
+            acLineSegment.baseVoltage = baseVoltage;
+        }
+        if (data.laenge) {
+            acLineSegment.length = data.laenge;
+        }
+        if (data.r0 && data.r0 !== 0) {
+            acLineSegment.r0 = data.laenge <= 0 ? data.r0 : data.r0;
+        }
+        else {
+            if (assetType) {
+                acLineSegment.r0 = assetType.r0 * acLineSegment.length;
+            }
+        }
+        if (data.x0 && data.x0 !== 0) {
+            acLineSegment.x0 = data.laenge <= 0 ? data.x0 : data.x0;
+        }
+        else {
+            if (assetType) {
+                acLineSegment.x0 = assetType.x0 * acLineSegment.length;
+            }
+        }
+        if (data.r1 && data.r1 !== 0) {
+            acLineSegment.r = data.laenge <= 0 ? data.r1 : data.r1;
+        }
+        else {
+            if (assetType) {
+                acLineSegment.r = assetType.r1 * data.laenge;
+            }
+        }
+        if (data.x1 && data.x1 !== 0) {
+            acLineSegment.x = data.laenge <= 0 ? data.x1 : data.x1;
+        }
+        else {
+            if (assetType) {
+                acLineSegment.x = assetType.x1 * data.laenge;
+            }
+        }
+        for (const terminal of acLineSegment.terminals.values()) {
+            if (data.ir && data.ir !== 0) {
+                this.setConductingEquipmentCurrentLimit(cimModel, acLineSegment.name, terminal, data.ir);
+            }
+            else if (assetType && assetType.ratedCurrent && assetType.ratedCurrent !== 0) {
+                this.setConductingEquipmentCurrentLimit(cimModel, acLineSegment.name, terminal, assetType.ratedCurrent);
+            }
+        }
+        const psrType = utils_1.createIfNotExitsPSRType(cimModel, data.typ);
+        acLineSegment.psrTypeUUID = psrType.mrid;
+    }
+    setConductingEquipmentCurrentLimit(cimModel, name, terminal, ir) {
+        const currentLimit = new CurrentLimit_1.CurrentLimit(utils_1.generateUUID(), `${name}`);
+        cimModel.addCurrentLimit(currentLimit);
+        currentLimit.value = new CurrentFlow_1.CurrentFlow(ir, UnitMultiplier_1.UnitMultiplier.none, UnitSymbol_1.UnitSymbol.A);
+        const operationalLimitSet = new OperationalLimitSet_1.OperationalLimitSet(utils_1.generateUUID(), `${name}`);
+        cimModel.addOperationalLimitSet(operationalLimitSet);
+        operationalLimitSet.addOperationalLimit(currentLimit);
+        currentLimit.operationalLimitSet = operationalLimitSet;
+        const operationalLimitType = this.createIfNotExistOperationalLimitType(cimModel, 'patl', LimitTypeKind_1.LimitTypeKind.patl, OperationalLimitDirectionKind_1.OperationalLimitDirectionKind.absoluteValue);
+        operationalLimitType.addOperationalLimit(currentLimit);
+        currentLimit.operationalLimitType = operationalLimitType;
+        operationalLimitSet.terminal = terminal;
+    }
+    setVoltageLimit(cimModel, name, terminal, voltage, type, direction) {
+        const voltageLimit = new VoltageLimit_1.VoltageLimit(utils_1.generateUUID(), `${name}`);
+        cimModel.addVoltageLimit(voltageLimit);
+        voltageLimit.value = voltage;
+        const operationalLimitSet = new OperationalLimitSet_1.OperationalLimitSet(utils_1.generateUUID(), `${name}`);
+        cimModel.addOperationalLimitSet(operationalLimitSet);
+        operationalLimitSet.addOperationalLimit(voltageLimit);
+        voltageLimit.operationalLimitSet = operationalLimitSet;
+        const operationalLimitType = this.createIfNotExistOperationalLimitType(cimModel, name, type, direction);
+        operationalLimitType.addOperationalLimit(voltageLimit);
+        voltageLimit.operationalLimitType = operationalLimitType;
+        operationalLimitSet.terminal = terminal;
+    }
+    setACLineSegmentCurrentLimt(cimModel, acLineSegment, nametyp, terminal) {
+        const assetType = this.cimModelDefault.getWireInfoByName(nametyp);
+        if (assetType && assetType.ratedCurrent && assetType.ratedCurrent !== 0) {
+            this.setConductingEquipmentCurrentLimit(cimModel, acLineSegment.name, terminal, assetType.ratedCurrent);
+        }
+    }
+    createIfNotExistOperationalLimitType(cimModel, name, type, direction) {
+        let operationalLimitType = cimModel.getOperationalLimitTypeByName(name);
+        if (!operationalLimitType) {
+            operationalLimitType = new OperationalLimitType_1.OperationalLimitType(utils_1.generateUUID(), name);
+            operationalLimitType.direction = direction;
+            operationalLimitType.limitType = type;
+            cimModel.addOperationalLimitType(operationalLimitType);
+        }
+        return operationalLimitType;
+    }
+    createConnection(cimModel, conductingEquipment, object, phase, connected, sequenceNumber) {
+        let terminal;
+        if (object instanceof ConnectivityNode_1.ConnectivityNode) {
+            const cn = object;
+            terminal = new Terminal_1.Terminal(utils_1.generateUUID(), 'T');
+            terminal.connectivityNode = cn;
+            cn.addTerminal(terminal);
+            cimModel.addTerminal(terminal);
+        }
+        else if (object instanceof Terminal_1.Terminal) {
+            terminal = object;
+        }
+        if (terminal) {
+            terminal.phases = phase;
+            terminal.conductingEquipment = conductingEquipment;
+            terminal.sequenceNumber = sequenceNumber ? sequenceNumber : 1;
+            conductingEquipment.addTerminal(terminal);
+            terminal.connected = connected;
+        }
+        return terminal;
+    }
+    determineEquipmentContainer(equipmentContainerType, cimModel, equipmentContainer) {
+        switch (equipmentContainerType) {
+            case ('Bay'): {
+                return equipmentContainer;
+            }
+            case ('VoltageLevel'): {
+                if (equipmentContainer instanceof Bay_1.Bay) {
+                    return equipmentContainer.getVoltageLevel();
+                }
+                return equipmentContainer;
+            }
+            case ('Substation'): {
+                if (equipmentContainer instanceof Bay_1.Bay) {
+                    const voltageLevel = equipmentContainer.getVoltageLevel();
+                    return voltageLevel === null || voltageLevel === void 0 ? void 0 : voltageLevel.substation;
+                }
+                else if (equipmentContainer instanceof VoltageLevel_1.VoltageLevel) {
+                    return equipmentContainer.getSubstation();
+                }
+                else {
+                    return equipmentContainer;
+                }
+            }
+            default: {
+                return equipmentContainer;
+            }
+        }
+        if (equipmentContainer instanceof Bay_1.Bay) {
+            return cimModel.getObject(equipmentContainer.voltageLevelUUID);
+        }
+        return equipmentContainer;
+    }
+    getSpannungsbandTrafo2W(i7Data) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                let minMaxSollResult;
+                const spgKnotenId = i7Data.spgreg_knoten;
+                let tempKnotenId = i7Data.spgreg_anschluss === 0 ? i7Data.aknoten :
+                    (i7Data.spgreg_anschluss === 1 ? i7Data.eknoten : undefined);
+                if (tempKnotenId !== undefined) {
+                    let queryResult = yield this.mysqlController.execQuery(`SELECT id FROM ${integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.KNOTEN_SF]} WHERE id = ${tempKnotenId};`);
+                    if (queryResult.length === 1) {
+                        const tabName_NetzSSAB = integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.SAMMELSCHIENE];
+                        const tabName_NetzSchaltfeld = integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.SCHALTFELD];
+                        const tabName_NetzKnotenSf = integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.KNOTEN_SF];
+                        const sqlStatement = `SELECT ${tabName_NetzSSAB}.id, ${tabName_NetzSSAB}.umin, ${tabName_NetzSSAB}.umax, ${tabName_NetzSSAB}.usoll
+                                          FROM  ${tabName_NetzSSAB}
+                                          LEFT JOIN ${tabName_NetzSchaltfeld} ON ${tabName_NetzSSAB}.saabschnitt = ${tabName_NetzSchaltfeld}.saabschnitt
+                                          LEFT JOIN ${tabName_NetzKnotenSf} ON  ${tabName_NetzKnotenSf}.schaltfeld = ${tabName_NetzSchaltfeld}.id
+                                          WHERE ${tabName_NetzKnotenSf}.id = ${tempKnotenId}`;
+                        minMaxSollResult = yield this.mysqlController.execQuery(sqlStatement);
+                    }
+                    else {
+                        queryResult = yield this.mysqlController.execQuery(`SELECT id FROM ${integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.KNOTEN_ZW]} WHERE id = ${tempKnotenId};`);
+                        if (queryResult.length === 1) {
+                            const tabName_NetzSo = integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.KNOTEN_SO];
+                            const tabName_NetzSchlaufe = integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.SCHLAUFE];
+                            const tabName_NetzKnotenZw = integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.KNOTEN_ZW];
+                            minMaxSollResult = yield this.mysqlController.execQuery(`SELECT ${tabName_NetzSo}.id, ${tabName_NetzSo}.umin, ${tabName_NetzSo}.umax, ${tabName_NetzSo}.usoll 
+                                       FROM ${tabName_NetzKnotenZw} 
+                                       LEFT JOIN ${tabName_NetzSchlaufe} ON 
+                                             ${tabName_NetzSchlaufe}.id = ${tabName_NetzKnotenZw}.schlaufe
+                                       LEFT JOIN ${tabName_NetzSo} ON 
+                                             ${tabName_NetzSchlaufe}.eknoten = ${tabName_NetzSo}.id 
+                                       WHERE ${tabName_NetzKnotenZw}.id = ${tempKnotenId};`);
+                        }
+                        else {
+                            minMaxSollResult = yield this.mysqlController.execQuery(`SELECT id, umin, umax, usoll FROM ${integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.KNOTEN_SO]} where id = ${tempKnotenId};`);
+                        }
+                    }
+                }
+                else if (spgKnotenId !== undefined) {
+                    const tabName_NetzSo = integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.KNOTEN_SO];
+                    const tabName_NetzSSAB = integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.SAMMELSCHIENE];
+                    const query = ` SELECT Voltage.id, Voltage.umin,  Voltage.umax,  Voltage.usoll
+                                FROM (
+                                SELECT id, umin, umax, usoll FROM ${tabName_NetzSo} WHERE ${tabName_NetzSo}.id = ${spgKnotenId}
+                                UNION
+                                SELECT id, umin, umax, usoll FROM ${tabName_NetzSSAB} WHERE ${tabName_NetzSSAB}.id = ${spgKnotenId}) as Voltage`;
+                    minMaxSollResult = yield this.mysqlController.execQuery(query);
+                }
+                if (minMaxSollResult && minMaxSollResult.length) {
+                    resolve(minMaxSollResult[0]);
+                }
+                else {
+                    resolve({ id: 0, usoll: 0, umin: 0, umax: 0 });
+                }
+            }));
+        });
+    }
+    getAvailableTableNames(database) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const results = yield this.mysqlController.execQuery(`SHOW TABLES FROM  ${database}`);
+                for (const table of results) {
+                    this.availableTableNames.push(table[`Tables_in_${database}`]);
+                }
+            }
+            catch (e) {
+                this.logger.error(e);
+                console.error("ERROR:" + e);
+            }
+        });
+    }
+    init(mySqlConfig, logger) {
+        return new Promise((resolve) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const status = { status: 'successful', message: 'Konverter I7 initialisiert' };
+            try {
+                this.logger = logger;
+                this.initMySQLConnection(mySqlConfig);
+                yield this.getAvailableTableNames(mySqlConfig.database);
+            }
+            catch (e) {
+                status.status = 'error';
+                status.message = e.toString();
+                this.logger.error(e);
+                console.error("ERROR:" + e);
+            }
+            resolve(status);
+        }));
+    }
+    queryDataInChuncks(objectName, ids) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const limit = 500;
+            const anzahl = ids.length;
+            const restCount = anzahl < limit ? anzahl : (anzahl % limit);
+            const intervalCount = (anzahl - restCount) / limit;
+            const numberOfIntervals = restCount > 0 ? intervalCount + 1 : intervalCount;
+            const result = [];
+            for (let i = 0; i < numberOfIntervals; i++) {
+                const offset = i * limit;
+                const currentLimit = (i + 1 === numberOfIntervals && restCount > 0) ? restCount : limit;
+                const partSchaltfeldIDs = ids.slice(offset, offset + currentLimit);
+                result.push(...yield this.mysqlController.execQuery(integral_sql_1.getI7Query(objectName, partSchaltfeldIDs)));
+            }
+            return result;
+        });
+    }
+    createColumnIndex() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            yield Promise.all([
+                this.createDropIndex('create index netz_standort_subgeoregion_index on netz_standort (subgeoregion);'),
+                this.createDropIndex('create index netz_schaltanlage_standort_index on netz_schaltanlage (standort);'),
+                this.createDropIndex('create index netz_saabschnitt_schaltanlage_index on netz_saabschnitt (schaltanlage);'),
+                this.createDropIndex('create index netz_schaltfeld_saabschnitt_index on netz_schaltfeld (saabschnitt);'),
+                this.createDropIndex('create index netz_knotenso_standort_index on netz_knotenso (standort);'),
+                this.createDropIndex('create index netz_knotensf_schaltfeld_index on netz_knotensf (schaltfeld);'),
+                this.createDropIndex('create index netz_ssab_saabschnitt_index on netz_ssab (saabschnitt);'),
+                this.createDropIndex('create index netz_belastung_anschluss_index on netz_belastung (anschluss);'),
+                this.createDropIndex('create index netz_netzeinspeisung_anschluss_index on netz_netzeinspeisung (anschluss);'),
+                this.createDropIndex('create index netz_trenner3p_seliste_index on netz_trenner3p (seliste);'),
+                this.createDropIndex('create index netz_leitung_aknoten_index on netz_leitung (aknoten);'),
+                this.createDropIndex('create index netz_leitung_eknoten_index on netz_leitung (eknoten);'),
+                this.createDropIndex('create index netz_freileitungabschnitt_leitung_index on netz_freileitungabschnitt (leitung);'),
+                this.createDropIndex('create index netz_kabelabschnitt_leitung_index on netz_kabelabschnitt (leitung);'),
+            ]);
+        });
+    }
+    dropColumnIndex() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            yield Promise.all([
+                this.createDropIndex('drop index netz_standort_subgeoregion_index on netz_standort;'),
+                this.createDropIndex('drop index netz_schaltanlage_standort_index on netz_schaltanlage;'),
+                this.createDropIndex('drop index netz_saabschnitt_schaltanlage_index on netz_saabschnitt;'),
+                this.createDropIndex('drop index netz_schaltfeld_saabschnitt_index on netz_schaltfeld;'),
+                this.createDropIndex('drop index netz_knotenso_standort_index on netz_knotenso;'),
+                this.createDropIndex('drop index netz_knotensf_schaltfeld_index on netz_knotensf;'),
+                this.createDropIndex('drop index netz_ssab_saabschnitt_index on netz_ssab;'),
+                this.createDropIndex('drop index netz_belastung_anschluss_index on netz_belastung;'),
+                this.createDropIndex('drop index netz_netzeinspeisung_anschluss_index on netz_netzeinspeisung;'),
+                this.createDropIndex('drop index netz_trenner3p_seliste_index on netz_trenner3p;'),
+                this.createDropIndex('drop index netz_leitung_aknoten_index on netz_leitung;'),
+                this.createDropIndex('drop index netz_leitung_eknoten_index on netz_leitung;'),
+                this.createDropIndex('drop index netz_freileitungabschnitt_leitung_index on netz_freileitungabschnitt;'),
+                this.createDropIndex('drop index netz_kabelabschnitt_leitung_index on netz_kabelabschnitt;'),
+            ]);
+        });
+    }
+    initMySQLConnection(mySqlConfig) {
+        this.mysqlController = new mysql_controller_1.MysqlController(mySqlConfig);
+        this.mysqlController.openConnection();
+    }
+    createDropIndex(sql) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.mysqlController.execQuery(sql);
+            }
+            catch (e) {
+                this.logger.error(e.toString());
+            }
+        });
+    }
+    addDefaultObjects(cimModel, defaultValuesConfig) {
+        this.addDefaultObjectsRegion(cimModel, defaultValuesConfig);
+        this.addDefaultObjectsLoadModel(cimModel, defaultValuesConfig);
+        this.addDefaultObjectsGeo(cimModel, defaultValuesConfig);
+    }
+    addDefaultObjectsRegion(cimModel, defaultValuesConfig) {
+        const region = utils_1.createIfNotExitsGeoregionByName(cimModel, defaultValuesConfig.GeographicalRegion.name);
+        region.description = defaultValuesConfig.GeographicalRegion.description;
+        const subregion = utils_1.createIfNotExitsSubGeoregionByName(cimModel, defaultValuesConfig.SubGeographicalRegion.name, region);
+        subregion.shortName = defaultValuesConfig.SubGeographicalRegion.shortName;
+        subregion.description = defaultValuesConfig.SubGeographicalRegion.description;
+    }
+    addDefaultObjectsLoadModel(cimModel, defaultValuesConfig) {
+        const loadArea = new LoadArea_1.LoadArea(utils_1.generateUUID(), defaultValuesConfig.LoadArea.name);
+        cimModel.addLoadArea(loadArea);
+        const subLoadArea = new SubLoadArea_1.SubLoadArea(utils_1.generateUUID(), defaultValuesConfig.SubLoadArea.name);
+        subLoadArea.loadArea = loadArea;
+        cimModel.addSubLoadArea(subLoadArea);
+        const conformLoadGroup = new ConformLoadGroup_1.ConformLoadGroup(utils_1.generateUUID(), defaultValuesConfig.ConformLoadGroup.name);
+        conformLoadGroup.subLoadArea = subLoadArea;
+        cimModel.addConformLoadGroup(conformLoadGroup);
+    }
+    addDefaultObjectsGeo(cimModel, defaultValuesConfig) {
+        const crsUrn = 'urn:ogc:def:crs:EPSG::4326';
+        const coordinateSystem = new CoordinateSystem_1.CoordinateSystem(utils_1.generateUUID(), this.coordinateSystem);
+        coordinateSystem.crsUrn = crsUrn;
+        cimModel.addCoordinateSystem(coordinateSystem);
+    }
+    setPowerTransformerEndProperties(cimModel, powerTransformerEnd, powerTransformer, terminal, sternpunktKnotenMap, integral7, ir, i7Data, defaultValuesConfig) {
+        if (terminal) {
+            powerTransformerEnd.terminal = terminal;
+            this.setConductingEquipmentCurrentLimit(cimModel, 'W1 ' + powerTransformer.name, terminal, ir);
+            if (sternpunktKnotenMap.has(i7Data.id)) {
+                if (sternpunktKnotenMap.get(i7Data.id).has(i7Data.aknknoten1p)) {
+                    this.convertTrafoGrounding(cimModel, powerTransformer, powerTransformerEnd, integral7, sternpunktKnotenMap.get(i7Data.id).get(i7Data.aknknoten1p), defaultValuesConfig);
+                }
+            }
+        }
+        else {
+            this.logger.debug(`Wicklung2W ${i7Data.id} ${powerTransformerEnd.endNumber} ${powerTransformerEnd.mrid} keine Terminalinstanz.`);
+        }
+        this.setBaseVoltagePowerTransformerEnd(cimModel, powerTransformerEnd);
+        powerTransformerEnd.powerTransformer = powerTransformer;
+        powerTransformer.addPowerTransformerEnd(powerTransformerEnd);
+    }
+    setBaseVoltagePowerTransformerEnd(cimModel, powerTransformerEnd) {
+        if (powerTransformerEnd.ratedU) {
+            const baseVoltage = util_create_1.createBaseVoltageIfNotExists(cimModel, powerTransformerEnd.ratedU);
+            powerTransformerEnd.baseVoltage = baseVoltage;
+        }
+        else {
+            this.logger.debug(`Wicklung ${powerTransformerEnd.mrid} Nr. ${powerTransformerEnd.endNumber} keine Spannungsangabe.`);
+        }
+    }
+    createPhaseTapChanger(i7Data, transformerEnd, cimModel, neutralU, connectivityNode, spannungsband) {
+        var _a, _b;
+        const wicklungsnummer = transformerEnd.endNumber;
+        const gestufteSeite = i7Data[`gestufte_seite_s${wicklungsnummer}`] === 0 ? 1 : i7Data[`gestufte_seite_s${wicklungsnummer}`];
+        if (gestufteSeite === wicklungsnummer) {
+            const spezialregelung = i7Data.trafo_spezial;
+            let phaseTapChanger;
+            switch (spezialregelung) {
+                case (2): {
+                    const phaseTapChangerAsync = new PhaseTapChangerAsymmetrical_1.PhaseTapChangerAsymmetrical(utils_1.generateUUID(), `${transformerEnd.name} W_${transformerEnd.endNumber}`);
+                    phaseTapChangerAsync.windingConnectionAngle = utils_2.convertToNumberI7(i7Data[`uzus_winkel_s${transformerEnd.endNumber}`]);
+                    phaseTapChanger = phaseTapChangerAsync;
+                    cimModel.addPhaseTapChangerAsymmetrical(phaseTapChangerAsync);
+                    break;
+                }
+                default: {
+                    const phaseTapChangerLinear = new PhaseTapChangerLinear_1.PhaseTapChangerLinear(utils_1.generateUUID(), `${transformerEnd.name} W_${transformerEnd.endNumber}`);
+                    phaseTapChangerLinear.stepPhaseShiftIncrement = utils_2.convertToNumberI7(i7Data[`uzus_winkel_s${transformerEnd.endNumber}`]);
+                    cimModel.addPhaseTapChangerLinear(phaseTapChangerLinear);
+                    phaseTapChanger = phaseTapChangerLinear;
+                }
+            }
+            phaseTapChanger.ltcFlag = false;
+            phaseTapChanger.lowStep = i7Data[`minstufe_s${transformerEnd.endNumber}`];
+            phaseTapChanger.highStep = i7Data[`maxstufe_s${transformerEnd.endNumber}`];
+            phaseTapChanger.neutralStep = i7Data[`mittelstufe_s${transformerEnd.endNumber}`];
+            phaseTapChanger.normalStep = phaseTapChanger.neutralStep;
+            phaseTapChanger.step = i7Data[`aktstufe_s${transformerEnd.endNumber}`];
+            phaseTapChanger.neutralU = neutralU;
+            transformerEnd.phaseTapChanger = phaseTapChanger;
+            phaseTapChanger.transformerEndUUID = transformerEnd.mrid;
+            const regelung = +i7Data[`regelung_s${transformerEnd.endNumber}`];
+            if (regelung > 0) {
+                const tapChangerControl = new TapChangerControl_1.TapChangerControl(utils_1.generateUUID(), `${transformerEnd.name} W_${transformerEnd.endNumber}`);
+                tapChangerControl.discrete = true;
+                const umax = utils_2.getSpannungsband('umax', spannungsband, neutralU);
+                const umin = utils_2.getSpannungsband('umin', spannungsband, neutralU);
+                const usoll = utils_2.getSpannungsband('usoll', spannungsband, (umax + umin) / 2);
+                const pVorgabe = utils_2.isNumericI7(i7Data[`p_vorgabe`]) ? +i7Data[`p_vorgabe`] : undefined;
+                switch (regelung) {
+                    case 1: {
+                        phaseTapChanger.controlEnabled = true;
+                        tapChangerControl.enabled = true;
+                        tapChangerControl.mode = RegulatingControlModeKind_1.RegulatingControlModeKind.voltage;
+                        tapChangerControl.targetValue = usoll;
+                        tapChangerControl.targetDeadband = umax - usoll;
+                        tapChangerControl.targetValueUnitMultiplier = UnitMultiplier_1.UnitMultiplier.k;
+                        break;
+                    }
+                    case 2: {
+                        phaseTapChanger.controlEnabled = true;
+                        tapChangerControl.enabled = true;
+                        tapChangerControl.mode = RegulatingControlModeKind_1.RegulatingControlModeKind.activePower;
+                        tapChangerControl.targetValue = pVorgabe;
+                        tapChangerControl.targetValueUnitMultiplier = UnitMultiplier_1.UnitMultiplier.M;
+                        break;
+                    }
+                    case 3: {
+                        phaseTapChanger.controlEnabled = true;
+                        tapChangerControl.enabled = true;
+                        tapChangerControl.mode = RegulatingControlModeKind_1.RegulatingControlModeKind.currentFlow;
+                        break;
+                    }
+                    case 4: {
+                        phaseTapChanger.controlEnabled = true;
+                        tapChangerControl.enabled = true;
+                        tapChangerControl.mode = RegulatingControlModeKind_1.RegulatingControlModeKind.reactivePower;
+                        tapChangerControl.targetValueUnitMultiplier = UnitMultiplier_1.UnitMultiplier.M;
+                        break;
+                    }
+                }
+                phaseTapChanger.tapChangerControl = tapChangerControl;
+                tapChangerControl.addTapChanger(phaseTapChanger);
+                cimModel.addTapChangerControl(tapChangerControl);
+            }
+            else {
+                phaseTapChanger.controlEnabled = false;
+            }
+            if ((_a = connectivityNode === null || connectivityNode === void 0 ? void 0 : connectivityNode.terminals) === null || _a === void 0 ? void 0 : _a.size) {
+                const terminal = [...connectivityNode.terminals.values()].find(elem => elem.connected);
+                if (terminal)
+                    this.setTapChangerControl(phaseTapChanger, terminal);
+            }
+            if (!((_b = phaseTapChanger.tapChangerControl) === null || _b === void 0 ? void 0 : _b.terminal)) {
+                this.logger.error(`Trafo ${i7Data.id}: Kein Terminal für TapChangerControl`);
+                if (transformerEnd.phaseTapChanger) {
+                    transformerEnd.phaseTapChanger.tapChangerControl = undefined;
+                    transformerEnd.phaseTapChanger.tapChangerControlUUID = undefined;
+                }
+            }
+        }
+    }
+    setTapChangerControl(tapChanger, terminal) {
+        if ((tapChanger === null || tapChanger === void 0 ? void 0 : tapChanger.tapChangerControl) && terminal) {
+            tapChanger.tapChangerControl.terminal = terminal;
+        }
+    }
+    convertTrafoGrounding(cimModel, powerTransformer, powerTransformerEnd, i7Modell, stpKnoten, defaultValuesConfig) {
+        var _a, _b;
+        if (stpKnoten) {
+            const junctionUUID = i7Modell.sternPunktImpModel.stpSchieneJunctionUUIDs.get(stpKnoten.schaltelement1pelem);
+            const junction = i7Modell.sternPunktImpModel.junctions.get(junctionUUID);
+            powerTransformerEnd.grounded = true;
+            powerTransformerEnd.rground = defaultValuesConfig.TransformerEnd.rground;
+            if (!junctionUUID) {
+            }
+            else {
+                const terminal = this.createConnection(cimModel, junction, (_a = powerTransformerEnd.terminal) === null || _a === void 0 ? void 0 : _a.connectivityNode, PhaseCode_1.PhaseCode.ABC, true, 1);
+                terminal.name = 't_stp_trafo';
+                if (junction)
+                    junction.name = (junction === null || junction === void 0 ? void 0 : junction.name) + '/Trafo';
+                const pSpuleGroundImpedance = i7Modell.sternPunktImpModel.junctionUUIDstpImp.get(junctionUUID);
+                const voltageLevel = this.getVoltageLevelByVoltage((_b = powerTransformer.equipmentContainer) === null || _b === void 0 ? void 0 : _b.voltageLevels, powerTransformerEnd.ratedU);
+                if (!voltageLevel) {
+                    this.logger.debug(`Trafo ${powerTransformer === null || powerTransformer === void 0 ? void 0 : powerTransformer.mrid} hat kein EquipmentContainer`);
+                }
+                if (junction && voltageLevel) {
+                    junction.baseVoltage = (voltageLevel === null || voltageLevel === void 0 ? void 0 : voltageLevel.baseVoltage) ? voltageLevel === null || voltageLevel === void 0 ? void 0 : voltageLevel.baseVoltage : powerTransformerEnd.baseVoltage;
+                    junction.equipmentContainer = voltageLevel;
+                }
+                else {
+                    this.logger.debug(`TrafoObjektID ${powerTransformer === null || powerTransformer === void 0 ? void 0 : powerTransformer.mrid} hat keine Junction ${junctionUUID} oder VoltageLevel`);
+                }
+                if (pSpuleGroundImpedance) {
+                    pSpuleGroundImpedance.baseVoltage = (voltageLevel === null || voltageLevel === void 0 ? void 0 : voltageLevel.baseVoltage) ? voltageLevel === null || voltageLevel === void 0 ? void 0 : voltageLevel.baseVoltage : powerTransformerEnd.baseVoltage;
+                    pSpuleGroundImpedance.equipmentContainer = voltageLevel;
+                }
+                else {
+                    this.logger.debug(`TrafoObjektID ${powerTransformer === null || powerTransformer === void 0 ? void 0 : powerTransformer.mrid} hat keine pSpuleGroundImpedance`);
+                }
+            }
+        }
+    }
+    queryLeitungsAnschlussIDs() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let results = this.isTableAvailable(integral_sql_1.Integral7TableNames.LEITUNG) ? yield this.mysqlController.execQuery(`SELECT DISTINCT aknoten, eknoten FROM ${integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.LEITUNG]}`) : [];
+            for (const result of results) {
+                this.leitungAnschlussKnotenIDs.add(result[`aknoten`]);
+                this.leitungAnschlussKnotenIDs.add(result[`eknoten`]);
+            }
+        });
+    }
+    queryTrafosAnschlussIDs() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let results = this.isTableAvailable(integral_sql_1.Integral7TableNames.TRAFO2W) ? yield this.mysqlController.execQuery(`SELECT DISTINCT aknoten, eknoten
+                                                                                                            FROM ${integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.TRAFO2W]}`) : [];
+            for (const result of results) {
+                this.trafo2wAnschlussKnotenIDs.add(result[`aknoten`]);
+                this.trafo2wAnschlussKnotenIDs.add(result[`eknoten`]);
+            }
+            results = this.isTableAvailable(integral_sql_1.Integral7TableNames.TRAFO3_WICKLUNG) ? yield this.mysqlController.execQuery(`SELECT DISTINCT aknoten, eknoten
+                                                                                                                    FROM ${integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.TRAFO3_WICKLUNG]}`) : [];
+            for (const result of results) {
+                this.trafo3wAnschlussKnotenIDs.add(result[`aknoten`]);
+                this.trafo3wAnschlussKnotenIDs.add(result[`eknoten`]);
+            }
+        });
+    }
+    queryHgueAnschlussIDs() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let results = this.isTableAvailable(integral_sql_1.Integral7TableNames.HGUE_LEITUNG) ? yield this.mysqlController.execQuery(`SELECT DISTINCT anetzobjekt, enetzobjekt FROM ${integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.HGUE_LEITUNG]}`) : [];
+            for (const result of results) {
+                this.hgueAnschlussKnotenIDs.add(result[`anetzobjekt`]);
+                this.hgueAnschlussKnotenIDs.add(result[`enetzobjekt`]);
+            }
+        });
+    }
+    queryLDroselAnschlussIDs() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let results = this.isTableAvailable(integral_sql_1.Integral7TableNames.LAENGSDROSSEL) ? yield this.mysqlController.execQuery(`SELECT DISTINCT aknoten, eknoten FROM ${integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.LAENGSDROSSEL]}`) : [];
+            for (const result of results) {
+                this.lDrosselAnschlussKnotenIDs.add(result[`aknoten`]);
+                this.lDrosselAnschlussKnotenIDs.add(result[`eknoten`]);
+            }
+        });
+    }
+    queryErsatzLaengsAnschlussIDs() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let results = this.isTableAvailable(integral_sql_1.Integral7TableNames.ERSATZLAENGSZWEIG) ? yield this.mysqlController.execQuery(`SELECT DISTINCT aknoten, eknoten FROM ${integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.ERSATZLAENGSZWEIG]}`) : [];
+            for (const result of results) {
+                this.ersatzZweigAnschlussKnotenIDs.add(result[`aknoten`]);
+                this.ersatzZweigAnschlussKnotenIDs.add(result[`eknoten`]);
+            }
+        });
+    }
+    queryLkondensatorAnschlussIDs() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let results = this.isTableAvailable(integral_sql_1.Integral7TableNames.LAENGSKONDENSATOR) ? yield this.mysqlController.execQuery(`SELECT DISTINCT aknoten, eknoten FROM ${integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.LAENGSKONDENSATOR]}`) : [];
+            for (const result of results) {
+                this.lKondensatorAnschlussKnotenIDs.add(result[`aknoten`]);
+                this.lKondensatorAnschlussKnotenIDs.add(result[`eknoten`]);
+            }
+        });
+    }
+    getVoltageLevelByVoltage(voltageLevels, ur) {
+        if (voltageLevels === null || voltageLevels === void 0 ? void 0 : voltageLevels.length) {
+            const vlNumbers = voltageLevels.map(elem => elem.getBaseVoltageAsNumber());
+            const vlDiff = vlNumbers.map(elem => Math.abs(elem - ur));
+            const vlIndex = vlDiff.indexOf(Math.min(...vlDiff));
+            return voltageLevels[vlIndex];
+        }
+        else {
+            return;
+        }
+    }
+    checkAnschlussIDs(i7ID, integral7) {
+        this.checkLeitungsID(i7ID, integral7);
+        this.checkTrafo2WID(i7ID, integral7);
+        this.checkTrafo3WID(i7ID, integral7);
+        this.checkHgueID(i7ID, integral7);
+        this.checkLDrosselID(i7ID, integral7);
+        this.checkErsatzZweigID(i7ID, integral7);
+        this.checkLKondensatorID(i7ID, integral7);
+    }
+    checkLeitungsID(i7ID, integral7) {
+        if (this.leitungAnschlussKnotenIDs.has(i7ID)) {
+            integral7.leitungsAnschlussIDs.push(i7ID);
+        }
+    }
+    checkTrafo2WID(i7ID, integral7) {
+        if (this.trafo2wAnschlussKnotenIDs.has(i7ID)) {
+            integral7.trafo2wAnschlussKnotenIDs.push(i7ID);
+        }
+    }
+    checkTrafo3WID(i7ID, integral7) {
+        if (this.trafo3wAnschlussKnotenIDs.has(i7ID)) {
+            integral7.trafo3wAnschlussKnotenIDs.push(i7ID);
+        }
+    }
+    checkHgueID(i7ID, integral7) {
+        if (this.hgueAnschlussKnotenIDs.has(i7ID)) {
+            integral7.hgueAnschlussKnotenIDs.push(i7ID);
+        }
+    }
+    checkLDrosselID(i7ID, integral7) {
+        if (this.lDrosselAnschlussKnotenIDs.has(i7ID)) {
+            integral7.lDrosselAnschlussKnotenIDs.push(i7ID);
+        }
+    }
+    checkErsatzZweigID(i7ID, integral7) {
+        if (this.ersatzZweigAnschlussKnotenIDs.has(i7ID)) {
+            integral7.ersatzZweigAnschlussKnotenIDs.push(i7ID);
+        }
+    }
+    checkLKondensatorID(i7ID, integral7) {
+        if (this.lKondensatorAnschlussKnotenIDs.has(i7ID)) {
+            integral7.lKondensatorAnschlussKnotenIDs.push(i7ID);
+        }
+    }
+    isTableAvailable(tableName) {
+        return this.availableTableNames.indexOf(tableName) > -1 ? true : false;
+    }
+    addIdMapping(i7ID, uuid, type) {
+        if (this.integralID2UUID.has(i7ID)) {
+            console.log(`ID ${i7ID} existiert bereits. Typ ${this.integralID2Type.get(i7ID)} neuer Typ ${type}`);
+        }
+        else {
+            this.integralID2UUID.set(i7ID, uuid);
+            this.integralID2Type.set(i7ID, type);
+        }
+        if (this.UUID2Integral7ID.has(uuid)) {
+            this.UUID2Integral7ID.get(uuid).push(i7ID);
+        }
+        else {
+            this.UUID2Integral7ID.set(uuid, [i7ID]);
+        }
+    }
+}
+exports.ConverterI7 = ConverterI7;
+function getDCNodeFromConverter(acDcConverter) {
+    var _a;
+    for (const terminal of (_a = acDcConverter === null || acDcConverter === void 0 ? void 0 : acDcConverter.dCTerminals) === null || _a === void 0 ? void 0 : _a.values()) {
+        if (terminal.dcNode)
+            return terminal.dcNode;
+    }
+    return;
+}
+function logExecutionTime(logger, startTime, text) {
+    logger.debug(`${text} ${(perf_hooks_1.performance.now() - startTime) / 1000} seconds`);
+    console.log(`${text} ${(perf_hooks_1.performance.now() - startTime) / 1000} seconds`);
+}
+//# sourceMappingURL=converter-i7.js.map