@enervance/insight-cim-model 0.0.1

package/dist/converter/integral7/ConverterIntegral7.js

@@ -0,0 +1,2275 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConverterIntegral7 = void 0;
+const tslib_1 = require("tslib");
+const __1 = require("../..");
+const mysql = tslib_1.__importStar(require("mysql"));
+const utils_1 = require("../../util/utils");
+const integral_prefix_1 = require("./config/integral-prefix");
+const utils_2 = require("./utils");
+const utils_trafo3w_1 = require("./utils-trafo3w");
+const generation_unit_fuel_types_1 = require("./config/generation-unit-fuel-types");
+const integral_sql_1 = require("./sql/integral.sql");
+const path_1 = tslib_1.__importDefault(require("path"));
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const xml_writer_1 = tslib_1.__importDefault(require("xml-writer"));
+const jszip_1 = tslib_1.__importDefault(require("jszip"));
+const Standort_1 = require("./model/integral/Standort");
+const Schaltanlage_1 = require("./model/integral/Schaltanlage");
+const Schaltanlagenabschnitt_1 = require("./model/integral/Schaltanlagenabschnitt");
+const StandortNsg_1 = require("./model/integral/StandortNsg");
+const SchaltanlageNSG_1 = require("./model/integral/SchaltanlageNSG");
+const SchaltanlagenabschnittNsg_1 = require("./model/integral/SchaltanlagenabschnittNsg");
+const Point_1 = require("./model/integral/Point");
+const utils_schema_1 = require("./utils-schema");
+const Schaltfeld_1 = require("./model/integral/Schaltfeld");
+const SchaltfeldNsg_1 = require("./model/integral/SchaltfeldNsg");
+const KnotenSo_1 = require("./model/integral/KnotenSo");
+const KnotenSoNsg_1 = require("./model/integral/KnotenSoNsg");
+const Leitung_1 = require("./model/integral/Leitung");
+const TapChangerInfo_1 = require("../../model/assetinfo/TapChangerInfo");
+const AMPRIONBay_1 = require("../../model/extensions/amprion/core/AMPRIONBay");
+const AMPRIONConnectivityNode_1 = require("../../model/extensions/amprion/core/AMPRIONConnectivityNode");
+class ConverterIntegral7 {
+    constructor() {
+        this.integralID2UUID = new Map();
+        this.UUID2IntegralID = new Map();
+        this.limit = 100;
+        this.integralStandorte = new Map();
+        this.integralSchaltanlagen = new Map();
+        this.integralSchaltanlagenAbschnitte = new Map();
+        this.integralSchaltfelder = new Map();
+        this.integralKnotenSo = new Map();
+        this.integralNsgStandort = new Map();
+        this.integralNsgSchaltanlage = new Map();
+        this.integralNsgSchaltanlagenabschnitt = new Map();
+        this.integralNsgSchaltfelder = new Map();
+        this.integralNsgKnotenSo = new Map();
+        this.integralLeitungen = new Map();
+        this.schaltfeldIDs = [];
+        this.querkupplungIDs = [];
+        this.laengskupplungIDs = [];
+        this.knotenSoIDs = [];
+        this.knotenSfIDs = [];
+        this.leitungsIDs = [];
+        this.trafo2WIDs = [];
+        this.memoryObjects = new Map();
+        this.leitungAnschlussKnotenIDs = new Set();
+        this.knotenSpannung = new Map();
+        this.cimModel = new __1.Model();
+        this.availableTableNames = [];
+    }
+    init(mySqlConfig) {
+        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 {
+                    this.initDbConnection(mySqlConfig);
+                    this.openConnection();
+                    yield this.getAvailableTableNames(mySqlConfig.database);
+                    this.standortAnzahl = yield this.queryObjectCount(integral_sql_1.Integral7TableNames.STANDORT);
+                    this.leitungsAnzahl = yield this.queryObjectCount(integral_sql_1.Integral7TableNames.LEITUNG);
+                    this.trafo2WAnzahl = yield this.queryObjectCount(integral_sql_1.Integral7TableNames.TRAFO2W);
+                    this.trafo3WAnzahl = yield this.queryObjectCount(integral_sql_1.Integral7TableNames.TRAFO3W);
+                    yield this.queryAnschlussIDs();
+                    resolve({ status: 'successful', message: 'ok' });
+                }
+                catch (e) {
+                    reject({ status: 'error', message: e.toString() });
+                }
+            }));
+        });
+    }
+    start() {
+        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 {
+                    const tempDirPath = yield utils_2.createTempDirPath();
+                    const filePathEQ = path_1.default.join(tempDirPath, 'eq.xml');
+                    const writeStreamEQ = fs_1.default.createWriteStream(filePathEQ);
+                    const xmlWriterEQ = new xml_writer_1.default(true, (string, encoding) => {
+                        writeStreamEQ.write(string, encoding);
+                    });
+                    this.writeHeaderStart(xmlWriterEQ);
+                    const modelEQUUID = __1.generateUUID();
+                    const profiles = [__1.RDF_XML.EQ_CORE_PROFILE_URI, __1.RDF_XML.EQ_SC_PROFILE_URI, __1.RDF_XML.EQ_OPER_PROFILE_URI];
+                    this.cimModel.toCIMXML(xmlWriterEQ, modelEQUUID, profiles, undefined, __1.RDF_XML.AMP_MAS);
+                    const filePathDL = path_1.default.join(tempDirPath, 'dl.xml');
+                    const writeStreamDL = fs_1.default.createWriteStream(filePathDL);
+                    const xmlWriterDL = new xml_writer_1.default(true, (string, encoding) => {
+                        writeStreamDL.write(string, encoding);
+                    });
+                    this.writeHeaderStart(xmlWriterDL);
+                    const modelDLUUID = __1.generateUUID();
+                    const profilesDl = [__1.RDF_XML.DL_OPER_PROFILE_URI];
+                    this.cimModel.toCIMXML(xmlWriterDL, modelDLUUID, profilesDl, [modelEQUUID], __1.RDF_XML.AMP_MAS);
+                    const filePathSSH = path_1.default.join(tempDirPath, 'ssh.xml');
+                    const writeStreamSSH = fs_1.default.createWriteStream(filePathSSH);
+                    const xmlWriterSSH = new xml_writer_1.default(true, (string, encoding) => {
+                        writeStreamSSH.write(string, encoding);
+                    });
+                    this.writeHeaderStart(xmlWriterSSH);
+                    const modelSSHUUID = __1.generateUUID();
+                    const profilesSSH = [__1.RDF_XML.SSH_OPER_PROFILE_URI];
+                    this.cimModel.toCIMXML(xmlWriterSSH, modelSSHUUID, profilesSSH, [modelEQUUID], __1.RDF_XML.AMP_MAS);
+                    const filePathSV = path_1.default.join(tempDirPath, 'sv.xml');
+                    const writeStreamSV = fs_1.default.createWriteStream(filePathSV);
+                    const xmlWriterSV = new xml_writer_1.default(true, (string, encoding) => {
+                        writeStreamSV.write(string, encoding);
+                    });
+                    this.writeHeaderStart(xmlWriterSV);
+                    const modelSVUUID = __1.generateUUID();
+                    const profilesSV = [__1.RDF_XML.SV_OPER_PROFILE_URI];
+                    this.cimModel.toCIMXML(xmlWriterSV, modelSVUUID, profilesSV, [modelEQUUID, modelSSHUUID], __1.RDF_XML.AMP_MAS);
+                    const filePathAmpI7 = path_1.default.join(tempDirPath, 'AMP_I7.xml');
+                    const writeStreamAmpI7 = fs_1.default.createWriteStream(filePathAmpI7);
+                    const xmlWriterAmpI7 = new xml_writer_1.default(true, (string, encoding) => {
+                        writeStreamAmpI7.write(string, encoding);
+                    });
+                    this.writeHeaderStart(xmlWriterAmpI7, __1.RDF_XML.AMP_I7_PROFILE_URI);
+                    const modelAmpI7UUID = __1.generateUUID();
+                    const profilesAmpI7UUID = [__1.RDF_XML.AMP_I7_PROFILE_URI];
+                    this.cimModel.toCIMXML(xmlWriterAmpI7, modelAmpI7UUID, profilesAmpI7UUID, [modelEQUUID], __1.RDF_XML.AMP_MAS);
+                    const restCount = this.standortAnzahl < this.limit ? this.standortAnzahl : (this.standortAnzahl % this.limit);
+                    const intervalCount = (this.standortAnzahl - restCount) / this.limit;
+                    const numberOfIntervals = restCount > 0 ? intervalCount + 1 : intervalCount;
+                    yield this.convertGeoRegionen();
+                    yield this.convertSubGeoRegionen();
+                    yield this.convertStromkreise();
+                    yield this.convertBetriebsmitteltypenLeitung();
+                    yield this.convertBetriebsmitteltypenTrafo();
+                    yield this.convertNetzvarianten();
+                    this.objectToCIMXML(xmlWriterEQ, this.cimModel.geographicalRegions, __1.RDF_XML.PROFILE_EQ);
+                    this.objectToCIMXML(xmlWriterEQ, this.cimModel.subgeographicalRegions, __1.RDF_XML.PROFILE_EQ);
+                    this.objectToCIMXML(xmlWriterEQ, this.cimModel.lines, __1.RDF_XML.PROFILE_EQ);
+                    this.objectToCIMXML(xmlWriterDL, this.cimModel.diagrams, __1.RDF_XML.PROFILE_DL);
+                    this.objectArrayToCIMXML(xmlWriterDL, this.cimModel.diagramStyles, __1.RDF_XML.PROFILE_DL);
+                    for (let i = 0; i < numberOfIntervals; i++) {
+                        const offset = i * this.limit;
+                        const currentLimit = (i + 1 === numberOfIntervals && restCount > 0) ? restCount : this.limit;
+                        yield this.convertStandorte(currentLimit, offset);
+                        const standortIDs = [...this.integralStandorte.keys()];
+                        yield this.covertSchaltanlagen(standortIDs);
+                        const schaltanlagenIDs = [...this.integralSchaltanlagen.keys()];
+                        if (schaltanlagenIDs.length > 0) {
+                            yield this.convertSchaltanlagenAbschnitte(schaltanlagenIDs);
+                        }
+                        const schaltanlagenAbschnittIDs = [...this.integralSchaltanlagenAbschnitte.keys()];
+                        if (schaltanlagenAbschnittIDs.length > 0) {
+                            yield this.convertSchaltfelder(schaltanlagenAbschnittIDs);
+                        }
+                        this.schaltfeldIDs = [...this.integralSchaltfelder.keys()];
+                        if (schaltanlagenAbschnittIDs.length > 0) {
+                            yield this.convertQuerkupplungen(schaltanlagenAbschnittIDs);
+                        }
+                        if (schaltanlagenIDs.length > 0) {
+                            yield this.convertLaegskupplungen(schaltanlagenIDs);
+                        }
+                        yield this.convertKnotenSo(standortIDs);
+                        const knotenSoIDs = [...this.integralKnotenSo.keys()];
+                        if (this.schaltfeldIDs.length > 0) {
+                            yield this.convertKnotenSf(this.schaltfeldIDs);
+                        }
+                        if (this.querkupplungIDs.length > 0) {
+                            yield this.convertKnotenKf(this.querkupplungIDs);
+                        }
+                        if (this.laengskupplungIDs.length > 0) {
+                            yield this.convertKnotenLk(this.laengskupplungIDs);
+                        }
+                        if (knotenSoIDs.length > 0) {
+                            yield this.convertSchlaufen(knotenSoIDs);
+                        }
+                        if (schaltanlagenAbschnittIDs.length > 0) {
+                            yield this.convertSammelschienenAbschnitte(schaltanlagenAbschnittIDs);
+                        }
+                        if (knotenSoIDs.length > 0 || this.knotenSfIDs.length > 0) {
+                            yield this.convertBelastungen([...knotenSoIDs, ...this.knotenSfIDs]);
+                        }
+                        if (knotenSoIDs.length > 0 || this.knotenSfIDs.length > 0) {
+                            yield this.convertEinspeisungen([...knotenSoIDs, ...this.knotenSfIDs]);
+                        }
+                        if (knotenSoIDs.length > 0 || this.knotenSfIDs.length > 0) {
+                            yield this.convertGeneratoren([...knotenSoIDs, ...this.knotenSfIDs]);
+                        }
+                        const containerStarreVerbindungen = [...this.schaltfeldIDs, ...this.querkupplungIDs, ...this.laengskupplungIDs];
+                        if (containerStarreVerbindungen.length > 0) {
+                            yield this.convertStarreVerbindungen(containerStarreVerbindungen);
+                        }
+                        if (containerStarreVerbindungen.length > 0) {
+                            yield this.convertTrenner3f(containerStarreVerbindungen);
+                        }
+                        if (containerStarreVerbindungen.length > 0) {
+                            yield this.convertTrennerFi3f(containerStarreVerbindungen);
+                        }
+                        if (containerStarreVerbindungen.length > 0) {
+                            yield this.convertLeistungsschalter(containerStarreVerbindungen);
+                        }
+                        yield this.convertSchemaStandorte(standortIDs);
+                        if (knotenSoIDs.length > 0) {
+                            yield this.convertSchemaKnotenSo(knotenSoIDs);
+                        }
+                        if (schaltanlagenIDs.length > 0) {
+                            yield this.convertSchemaSchaltanlage(schaltanlagenIDs);
+                        }
+                        if (schaltanlagenAbschnittIDs.length > 0) {
+                            yield this.convertSchemaSchaltanlagenAbschnitte(schaltanlagenAbschnittIDs);
+                        }
+                        yield this.convertSchemaSammelschienenAbschnitte();
+                        if (this.schaltfeldIDs.length > 0) {
+                            yield this.convertSchemaSchaltfelder(this.schaltfeldIDs);
+                        }
+                        this.objectToCIMXML(xmlWriterEQ, this.cimModel.substations, __1.RDF_XML.PROFILE_EQ);
+                        this.objectToCIMXML(xmlWriterEQ, this.cimModel.voltageLevels, __1.RDF_XML.PROFILE_EQ);
+                        this.objectToCIMXML(xmlWriterEQ, this.cimModel.bays, __1.RDF_XML.PROFILE_EQ);
+                        this.objectToCIMXML(xmlWriterEQ, this.cimModel.busbarSections, __1.RDF_XML.PROFILE_EQ);
+                        this.objectToCIMXML(xmlWriterEQ, this.cimModel.powerTransformer, __1.RDF_XML.PROFILE_EQ);
+                        this.objectToCIMXML(xmlWriterEQ, this.cimModel.junctions, __1.RDF_XML.PROFILE_EQ);
+                        this.objectToCIMXML(xmlWriterEQ, this.cimModel.energyConsumers, __1.RDF_XML.PROFILE_EQ);
+                        this.objectToCIMXML(xmlWriterEQ, this.cimModel.energySources, __1.RDF_XML.PROFILE_EQ);
+                        this.objectToCIMXML(xmlWriterEQ, this.cimModel.disconnectors, __1.RDF_XML.PROFILE_EQ);
+                        this.objectToCIMXML(xmlWriterEQ, this.cimModel.breakers, __1.RDF_XML.PROFILE_EQ);
+                        this.objectToCIMXML(xmlWriterEQ, this.cimModel.synchronousMachine, __1.RDF_XML.PROFILE_EQ);
+                        this.objectToCIMXML(xmlWriterEQ, this.cimModel.generatingUnit, __1.RDF_XML.PROFILE_EQ);
+                        this.objectToCIMXML(xmlWriterEQ, this.cimModel.thermalGeneratingUnit, __1.RDF_XML.PROFILE_EQ);
+                        this.objectToCIMXML(xmlWriterEQ, this.cimModel.nuclearGeneratingUnit, __1.RDF_XML.PROFILE_EQ);
+                        this.objectToCIMXML(xmlWriterEQ, this.cimModel.hydroGeneratingUnit, __1.RDF_XML.PROFILE_EQ);
+                        this.objectToCIMXML(xmlWriterEQ, this.cimModel.windGeneratingUnit, __1.RDF_XML.PROFILE_EQ);
+                        this.objectToCIMXML(xmlWriterEQ, this.cimModel.solarGeneratingUnit, __1.RDF_XML.PROFILE_EQ);
+                        this.objectToCIMXML(xmlWriterEQ, this.cimModel.regulatingControl, __1.RDF_XML.PROFILE_EQ);
+                        this.objectArrayToCIMXML(xmlWriterEQ, this.cimModel.fossilFuel, __1.RDF_XML.PROFILE_EQ);
+                        this.objectToCIMXML(xmlWriterEQ, this.cimModel.reactiveCapabilityCurve, __1.RDF_XML.PROFILE_EQ);
+                        this.objectArrayToCIMXML(xmlWriterEQ, this.cimModel.curveData, __1.RDF_XML.PROFILE_EQ);
+                        this.objectToCIMXML(xmlWriterEQ, this.cimModel.operationalLimitSets, __1.RDF_XML.PROFILE_EQ);
+                        this.objectToCIMXML(xmlWriterEQ, this.cimModel.currentLimits, __1.RDF_XML.PROFILE_EQ);
+                        this.objectToCIMXML(xmlWriterEQ, this.cimModel.connectivityNodes, __1.RDF_XML.PROFILE_EQ);
+                        this.objectToCIMXML(xmlWriterEQ, this.cimModel.terminals, __1.RDF_XML.PROFILE_EQ);
+                        this.objectToCIMXML(xmlWriterDL, this.cimModel.diagramObjects, __1.RDF_XML.PROFILE_DL);
+                        this.objectToCIMXML(xmlWriterSSH, this.cimModel.energyConsumers, __1.RDF_XML.PROFILE_SSH);
+                        this.objectToCIMXML(xmlWriterSSH, this.cimModel.energySources, __1.RDF_XML.PROFILE_SSH);
+                        this.objectToCIMXML(xmlWriterSSH, this.cimModel.terminals, __1.RDF_XML.PROFILE_SSH);
+                        this.objectToCIMXML(xmlWriterSSH, this.cimModel.disconnectors, __1.RDF_XML.PROFILE_SSH);
+                        this.objectToCIMXML(xmlWriterSSH, this.cimModel.breakers, __1.RDF_XML.PROFILE_SSH);
+                        this.objectArrayToCIMXML(xmlWriterSV, this.cimModel.svStatus, __1.RDF_XML.PROFILE_SV);
+                        this.objectArrayToCIMXML(xmlWriterSV, this.cimModel.svTapSteps, __1.RDF_XML.PROFILE_SV);
+                        this.objectToCIMXML(xmlWriterAmpI7, this.cimModel.bays, __1.RDF_XML.PROFILE_AMPI7);
+                        this.objectToCIMXML(xmlWriterAmpI7, this.cimModel.connectivityNodes, __1.RDF_XML.PROFILE_AMPI7);
+                        this.cimModel.substations.clear();
+                        this.cimModel.voltageLevels.clear();
+                        this.cimModel.bays.clear();
+                        this.cimModel.busbarSections.clear();
+                        this.cimModel.disconnectors.clear();
+                        this.cimModel.breakers.clear();
+                        this.cimModel.energyConsumers.clear();
+                        this.cimModel.energySources.clear();
+                        this.cimModel.synchronousMachine.clear();
+                        this.cimModel.generatingUnit.clear();
+                        this.cimModel.thermalGeneratingUnit.clear();
+                        this.cimModel.nuclearGeneratingUnit.clear();
+                        this.cimModel.hydroGeneratingUnit.clear();
+                        this.cimModel.windGeneratingUnit.clear();
+                        this.cimModel.solarGeneratingUnit.clear();
+                        this.cimModel.regulatingControl.clear();
+                        this.cimModel.reactiveCapabilityCurve.clear();
+                        this.cimModel.junctions.clear();
+                        this.cimModel.curveData.length = 0;
+                        this.cimModel.fossilFuel.length = 0;
+                        this.cimModel.connectivityNodes.clear();
+                        this.cimModel.terminals.clear();
+                        this.cimModel.diagramObjects.clear();
+                        this.cimModel.objects.clear();
+                        this.cimModel.svStatus.length = 0;
+                        this.cimModel.svTapSteps.length = 0;
+                        this.querkupplungIDs.length = 0;
+                        this.laengskupplungIDs.length = 0;
+                        this.knotenSoIDs.length = 0;
+                        this.knotenSfIDs.length = 0;
+                        this.knotenSfIDs.length = 0;
+                        this.integralStandorte.clear();
+                        this.integralSchaltanlagen.clear();
+                        this.integralSchaltanlagenAbschnitte.clear();
+                        this.integralSchaltfelder.clear();
+                        this.integralKnotenSo.clear();
+                        this.integralNsgStandort.clear();
+                        this.integralNsgSchaltanlage.clear();
+                        this.integralNsgSchaltanlagenabschnitt.clear();
+                        this.integralNsgSchaltfelder.clear();
+                        this.integralNsgKnotenSo.clear();
+                        console.log(`Offset ${offset} done`);
+                    }
+                    const restCountLeitung = this.leitungsAnzahl < this.limit ? this.leitungsAnzahl : (this.leitungsAnzahl % this.limit);
+                    const intervalCountLeitung = (this.leitungsAnzahl - restCountLeitung) / this.limit;
+                    const numberOfIntervalsLeitung = restCountLeitung > 0 ? intervalCountLeitung + 1 : intervalCountLeitung;
+                    console.log('Convert ACLineSegments ' + this.leitungsAnzahl + ' restCountLeitung ' + restCountLeitung);
+                    for (let i = 0; i < numberOfIntervalsLeitung; i++) {
+                        const offset = i * this.limit;
+                        const currentLimit = (i + 1 === numberOfIntervalsLeitung && restCountLeitung > 0) ? restCountLeitung : this.limit;
+                        yield this.convertLeitungen(currentLimit, offset);
+                        this.leitungsIDs = [...this.integralLeitungen.keys()];
+                        if (this.leitungsIDs.length > 0)
+                            yield this.determineLeitungsTypen(this.leitungsIDs);
+                        this.objectToCIMXML(xmlWriterEQ, this.cimModel.acLineSegments, __1.RDF_XML.PROFILE_EQ);
+                        this.objectToCIMXML(xmlWriterEQ, this.cimModel.terminals, __1.RDF_XML.PROFILE_EQ);
+                        this.objectToCIMXML(xmlWriterSV, this.cimModel.terminals, __1.RDF_XML.PROFILE_SSH);
+                        this.cimModel.acLineSegments.clear();
+                        this.cimModel.connectivityNodes.clear();
+                        this.cimModel.terminals.clear();
+                        this.cimModel.diagramObjects.clear();
+                        this.cimModel.objects.clear();
+                        this.integralLeitungen.clear();
+                        this.leitungsIDs.length = 0;
+                    }
+                    const restCountTrafo2W = this.trafo2WAnzahl < this.limit ? this.trafo2WAnzahl : (this.trafo2WAnzahl % this.limit);
+                    const intervalCountTrafo2W = (this.trafo2WAnzahl - restCountTrafo2W) / this.limit;
+                    const numberOfIntervalsTrafo2W = restCountTrafo2W > 0 ? intervalCountTrafo2W + 1 : intervalCountTrafo2W;
+                    console.log('Convert Transformers');
+                    for (let i = 0; i < numberOfIntervalsTrafo2W; i++) {
+                        const offset = i * this.limit;
+                        const currentLimit = (i + 1 === numberOfIntervalsTrafo2W && restCountTrafo2W > 0) ? restCountTrafo2W : this.limit;
+                        yield this.convertTrafo2W(currentLimit, offset);
+                        this.objectToCIMXML(xmlWriterEQ, this.cimModel.powerTransformer, __1.RDF_XML.PROFILE_EQ);
+                        this.objectToCIMXML(xmlWriterEQ, this.cimModel.terminals, __1.RDF_XML.PROFILE_EQ);
+                        this.objectToCIMXML(xmlWriterEQ, this.cimModel.tapChangerControls, __1.RDF_XML.PROFILE_EQ);
+                        this.objectToCIMXML(xmlWriterEQ, this.cimModel.ratioTapChangers, __1.RDF_XML.PROFILE_EQ);
+                        this.objectToCIMXML(xmlWriterEQ, this.cimModel.ratioTapChangerTables, __1.RDF_XML.PROFILE_EQ);
+                        this.objectToCIMXML(xmlWriterEQ, this.cimModel.operationalLimitSets, __1.RDF_XML.PROFILE_EQ);
+                        this.objectToCIMXML(xmlWriterEQ, this.cimModel.currentLimits, __1.RDF_XML.PROFILE_EQ);
+                        this.objectToCIMXML(xmlWriterSV, this.cimModel.terminals, __1.RDF_XML.PROFILE_SSH);
+                        this.cimModel.powerTransformer.clear();
+                        this.cimModel.currentLimits.clear();
+                        this.cimModel.operationalLimitSets.clear();
+                        this.cimModel.tapChangerControls.clear();
+                        this.cimModel.ratioTapChangers.clear();
+                        for (const table of this.cimModel.ratioTapChangerTables.values()) {
+                            table.ratioTapChangerTablePoints = [];
+                        }
+                        this.cimModel.ratioTapChangerTables.clear();
+                        this.cimModel.svTapSteps.length = 0;
+                        this.cimModel.terminals.clear();
+                        this.cimModel.objects.clear();
+                    }
+                    const restCountTrafo3W = this.trafo2WAnzahl < this.limit ? this.trafo3WAnzahl : (this.trafo3WAnzahl % this.limit);
+                    const intervalCountTrafo3W = (this.trafo3WAnzahl - restCountTrafo3W) / this.limit;
+                    const numberOfIntervalsTrafo3W = restCountTrafo3W > 0 ? intervalCountTrafo3W + 1 : intervalCountTrafo3W;
+                    console.log('Convert Transformers3W');
+                    for (let i = 0; i < numberOfIntervalsTrafo3W; i++) {
+                        const offset = i * this.limit;
+                        const currentLimit = (i + 1 === numberOfIntervalsTrafo3W && restCountTrafo3W > 0) ? restCountTrafo3W : this.limit;
+                        yield this.convertTrafo3W(currentLimit, offset);
+                        this.objectToCIMXML(xmlWriterEQ, this.cimModel.powerTransformer, __1.RDF_XML.PROFILE_EQ);
+                        this.cimModel.powerTransformer.clear();
+                        this.objectToCIMXML(xmlWriterEQ, this.cimModel.currentLimits, __1.RDF_XML.PROFILE_EQ);
+                        this.cimModel.currentLimits.clear();
+                        this.objectToCIMXML(xmlWriterEQ, this.cimModel.terminals, __1.RDF_XML.PROFILE_EQ);
+                        this.cimModel.terminals.clear();
+                        this.objectToCIMXML(xmlWriterEQ, this.cimModel.tapChangerControls, __1.RDF_XML.PROFILE_EQ);
+                        this.cimModel.tapChangerControls.clear();
+                        this.objectToCIMXML(xmlWriterEQ, this.cimModel.ratioTapChangers, __1.RDF_XML.PROFILE_EQ);
+                        this.cimModel.ratioTapChangers.clear();
+                        this.objectToCIMXML(xmlWriterEQ, this.cimModel.ratioTapChangerTables, __1.RDF_XML.PROFILE_EQ);
+                        this.objectToCIMXML(xmlWriterEQ, this.cimModel.operationalLimitSets, __1.RDF_XML.PROFILE_EQ);
+                        this.objectToCIMXML(xmlWriterSV, this.cimModel.terminals, __1.RDF_XML.PROFILE_SSH);
+                        this.cimModel.operationalLimitSets.clear();
+                        for (const table of this.cimModel.ratioTapChangerTables.values()) {
+                            table.ratioTapChangerTablePoints = [];
+                        }
+                        this.cimModel.ratioTapChangerTables.clear();
+                        this.cimModel.svTapSteps.length = 0;
+                        this.cimModel.objects.clear();
+                    }
+                    const memoryTerminals = new Map();
+                    for (const value of this.memoryObjects.values()) {
+                        if (value instanceof __1.Terminal) {
+                            const terminal = value;
+                            if (terminal.conductingEquipment || terminal.conductingEquipmentUUID) {
+                                memoryTerminals.set(value.mrid, value);
+                            }
+                        }
+                    }
+                    this.objectToCIMXML(xmlWriterEQ, this.cimModel.operationalLimitTypes, __1.RDF_XML.PROFILE_EQ);
+                    this.objectToCIMXML(xmlWriterEQ, this.cimModel.baseVoltages, __1.RDF_XML.PROFILE_EQ);
+                    this.objectToCIMXML(xmlWriterEQ, memoryTerminals, __1.RDF_XML.PROFILE_EQ);
+                    this.objectToCIMXML(xmlWriterSSH, memoryTerminals, __1.RDF_XML.PROFILE_SSH);
+                    this.objectToCIMXML(xmlWriterAmpI7, this.cimModel.psrTypes, __1.RDF_XML.PROFILE_AMPI7);
+                    this.cimModel.operationalLimitTypes.clear();
+                    this.cimModel.baseVoltages.clear();
+                    memoryTerminals.clear();
+                    this.writeHeaderEnd(xmlWriterEQ);
+                    writeStreamEQ.end();
+                    writeStreamEQ.close();
+                    this.writeHeaderEnd(xmlWriterDL);
+                    writeStreamDL.end();
+                    writeStreamDL.close();
+                    this.writeHeaderEnd(xmlWriterSSH);
+                    writeStreamSSH.end();
+                    writeStreamSSH.close();
+                    this.writeHeaderEnd(xmlWriterSV);
+                    writeStreamSV.end();
+                    writeStreamSV.close();
+                    this.writeHeaderEnd(xmlWriterAmpI7);
+                    writeStreamAmpI7.end();
+                    writeStreamAmpI7.close();
+                    yield Promise.all([
+                        utils_2.createWriteStreamPromise(writeStreamEQ),
+                        utils_2.createWriteStreamPromise(writeStreamDL),
+                        utils_2.createWriteStreamPromise(writeStreamSSH),
+                        utils_2.createWriteStreamPromise(writeStreamSV),
+                        utils_2.createWriteStreamPromise(writeStreamAmpI7),
+                    ]);
+                    const zip = new jszip_1.default();
+                    const filePathZip = path_1.default.join(tempDirPath, 'cgmes.zip');
+                    const readStreamEq = fs_1.default.createReadStream(filePathEQ);
+                    zip.file('EQ.xml', readStreamEq);
+                    const readStreamDl = fs_1.default.createReadStream(filePathDL);
+                    zip.file('DL.xml', readStreamDl);
+                    const readStreamSSH = fs_1.default.createReadStream(filePathSSH);
+                    zip.file('SSH.xml', readStreamSSH);
+                    const readStreamSV = fs_1.default.createReadStream(filePathSV);
+                    zip.file('SV.xml', readStreamSV);
+                    const readStreamAmpI7 = fs_1.default.createReadStream(filePathAmpI7);
+                    zip.file('AMP_I7.xml', readStreamAmpI7);
+                    yield utils_2.writeZipFile(zip, filePathZip);
+                    resolve({ status: 'successful', message: 'ok' });
+                    console.log('path ' + tempDirPath);
+                }
+                catch (e) {
+                    console.log(e);
+                    reject({ status: 'error', message: e.toString() });
+                }
+            }));
+        });
+    }
+    end() {
+        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 {
+                    this.closeConnection();
+                    this.cimModel.purgeData();
+                    resolve({ status: 'successful', message: 'ok' });
+                }
+                catch (e) {
+                    reject({ status: 'error', message: e.toString() });
+                }
+            }));
+        });
+    }
+    getAvailableTableNames(database) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const results = yield this.queryFunctionWrapper(`SHOW TABLES FROM  ${database}`);
+                for (const table of results) {
+                    this.availableTableNames.push(table[`Tables_in_${database}`]);
+                }
+            }
+            catch (e) {
+                console.error("ERROR:" + e);
+            }
+        });
+    }
+    queryObjectCount(tableName) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                this.queryFunctionWrapper(`SELECT COUNT(id) FROM ${tableName}`).then(results => {
+                    try {
+                        for (const result of results) {
+                            return resolve(Number(result[`COUNT(id)`]));
+                        }
+                    }
+                    catch (e) {
+                        return reject(0);
+                    }
+                });
+            });
+        });
+    }
+    queryAnschlussIDs() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                let results = yield this.queryFunctionWrapper(`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`]);
+                }
+                results = yield this.queryFunctionWrapper(`SELECT DISTINCT aknoten, eknoten FROM ${integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.TRAFO2W]}`);
+                for (const result of results) {
+                    this.leitungAnschlussKnotenIDs.add(result[`aknoten`]);
+                    this.leitungAnschlussKnotenIDs.add(result[`eknoten`]);
+                }
+                results = yield this.queryFunctionWrapper(`SELECT DISTINCT aknoten, eknoten FROM ${integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.TRAFO3_WICKLUNG]}`);
+                for (const result of results) {
+                    this.leitungAnschlussKnotenIDs.add(result[`aknoten`]);
+                    this.leitungAnschlussKnotenIDs.add(result[`eknoten`]);
+                }
+            }
+            catch (e) {
+                console.error("ERROR:" + e);
+            }
+        });
+    }
+    convertGeoRegionen() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.REGION)) {
+                const result = yield this.queryFunctionWrapper(integral_sql_1.getNetzQuery(integral_sql_1.I7Objects.REGION, 0, 0, []));
+                for (const i7Data of result) {
+                    const region = new __1.GeographicalRegion(__1.getUUID(i7Data.guid), i7Data.bezeichner, i7Data.kurzname);
+                    this.cimModel.addGeographicalRegion(region);
+                    this.integralID2UUID.set(i7Data.id, region.mrid);
+                }
+            }
+            else {
+                console.log(`Tabelle ${integral_sql_1.Integral7TableNames.REGION} ist nicht vorhanden.`);
+                console.log(`Erstelle Standard Region ENTSO-E.`);
+                __1.createGeoregion(__1.generateUUID(), 'ENTSO-E', 'default', 'Default GeographicalRegion', this.cimModel);
+            }
+        });
+    }
+    convertSubGeoRegionen() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.SUBREGION)) {
+                const result = yield this.queryFunctionWrapper(integral_sql_1.getNetzQuery(integral_sql_1.I7Objects.SUBREGION, 0, 0, []));
+                for (const i7Data of result) {
+                    const subregion = new __1.SubGeographicalRegion(__1.getUUID(i7Data.guid), i7Data.bezeichner, i7Data.kurzname);
+                    let region = this.cimModel.getGeographicalRegion(this.integralID2UUID.get(i7Data.georegion));
+                    if (!region) {
+                        region = utils_1.createIfNotExitsGeoregionByName(this.cimModel, 'ENTSO-E');
+                    }
+                    subregion.region = region;
+                    region.addSubGeographicalRegion(subregion);
+                    this.cimModel.addSubGeographicalRegion(subregion);
+                    this.integralID2UUID.set(i7Data.id, subregion.mrid);
+                }
+            }
+            else {
+                console.log(`Tabelle ${integral_sql_1.Integral7TableNames.SUBREGION} ist nicht vorhanden.`);
+                console.log(`Erstelle Standard Subregion Deutschland.`);
+                const region = utils_1.createIfNotExitsGeoregionByName(this.cimModel, 'ENTSO-E');
+                utils_1.createIfNotExitsSubGeoregionByName(this.cimModel, 'Detschland', region);
+            }
+        });
+    }
+    convertStandorte(limit, offset) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.STANDORT)) {
+                const result = yield this.queryFunctionWrapper(integral_sql_1.getNetzQuery(integral_sql_1.I7Objects.STANDORT, limit, offset, []));
+                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 __1.Substation(__1.getUUID(i7Data.guid), utils_2.getName(i7Data), i7Data.id + '', i7Schluessel);
+                    let subregion = this.cimModel.getSubGeographicalRegion(this.integralID2UUID.get(i7Data.subgeoregion));
+                    if (!subregion) {
+                        const region = utils_1.createIfNotExitsGeoregionByName(this.cimModel, 'ENTSO-E');
+                        subregion = utils_1.createIfNotExitsSubGeoregionByName(this.cimModel, 'Deutschland', region);
+                    }
+                    substation.subGeographicalRegion = subregion;
+                    this.cimModel.addSubstation(substation);
+                    this.integralID2UUID.set(i7Data.id, substation.mrid);
+                    utils_2.putUUIDtoI7Ids(substation.mrid, i7Data.id, this.UUID2IntegralID);
+                    const standort = new Standort_1.StandortImpl(i7Data);
+                    this.integralStandorte.set(i7Data.id, standort);
+                }
+            }
+            else {
+                console.log(`Tabelle ${integral_sql_1.Integral7TableNames.STANDORT} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertKnotenSo(standortIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.KNOTEN_SO)) {
+                const result = yield this.queryFunctionWrapper(integral_sql_1.getNetzQuery(integral_sql_1.I7Objects.KNOTEN_SO, 0, 0, standortIDs));
+                for (const i7Data of result) {
+                    const object = new KnotenSo_1.KnotenSoImpl(i7Data);
+                    this.integralKnotenSo.set(i7Data.id, object);
+                    object.standort = this.integralStandorte.get(object.standortid);
+                    const vl = new __1.VoltageLevel(__1.getUUID(i7Data.guid), utils_2.getName(i7Data), i7Data.kurzname);
+                    const connectivityNode = new AMPRIONConnectivityNode_1.AMPRIONConnectivityNode(__1.generateUUID(), 'Abzweig', 'knotenso');
+                    connectivityNode.connectivityNodeContainer = vl;
+                    connectivityNode.nodeNumber = i7Data.id_psse_cape;
+                    vl.addConnectivityNode(connectivityNode);
+                    const baseVoltage = __1.createBaseVoltageIfNotExists(this.cimModel, i7Data.un);
+                    vl.baseVoltage = baseVoltage;
+                    const substation = this.cimModel.getSubstation(this.integralID2UUID.get(i7Data.standort));
+                    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 {
+                        console.log(`KnotenSo ${i7Data.id} ${vl.mrid} besitzt keine Substation.`);
+                    }
+                    const psrType = utils_2.getPSRType(this.cimModel, 'Abzweigmast');
+                    vl.psrTypeUUID = psrType === null || psrType === void 0 ? void 0 : psrType.mrid;
+                    this.integralID2UUID.set(i7Data.id, connectivityNode.mrid);
+                    this.knotenSoIDs.push(i7Data.id);
+                    this.cimModel.addVoltageLevel(vl);
+                    this.cimModel.addConnectivityNode(connectivityNode);
+                    this.knotenSpannung.set(connectivityNode.mrid, baseVoltage);
+                    this.checkMemoryObject(i7Data.id, connectivityNode);
+                }
+            }
+            else {
+                console.log(`Tabelle ${integral_sql_1.Integral7TableNames.KNOTEN_SO} ist nicht vorhanden.`);
+            }
+        });
+    }
+    covertSchaltanlagen(standortIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.SCHALTANLAGE)) {
+                const result = yield this.queryFunctionWrapper(integral_sql_1.getNetzQuery(integral_sql_1.I7Objects.SCHALTANLAGE, 0, 0, standortIDs));
+                for (const i7Data of result) {
+                    const vl = new __1.VoltageLevel(__1.getUUID(i7Data.guid), utils_2.getName(i7Data), i7Data.kurzname);
+                    const baseVoltage = __1.createBaseVoltageIfNotExists(this.cimModel, i7Data.un);
+                    vl.baseVoltageUUID = baseVoltage.mrid;
+                    this.cimModel.addVoltageLevel(vl);
+                    this.integralID2UUID.set(i7Data.id, vl.mrid);
+                    utils_2.putUUIDtoI7Ids(vl.mrid, i7Data.id, this.UUID2IntegralID);
+                    const substation = this.cimModel.getSubstation(this.integralID2UUID.get(i7Data.standort));
+                    if (substation) {
+                        vl.substationUUID = substation.mrid;
+                        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;
+                        const schaltanlage = new Schaltanlage_1.SchaltanlageImpl(i7Data);
+                        schaltanlage.addStandort(this.integralStandorte.get(schaltanlage.standortid));
+                        this.integralSchaltanlagen.set(i7Data.id, schaltanlage);
+                    }
+                    else {
+                        console.log(`VoltageLevel ${i7Data.id} ${vl.mrid} besitzt keine Umspannanlage.`);
+                    }
+                }
+            }
+            else {
+                console.log(`Tabelle ${integral_sql_1.Integral7TableNames.SCHALTANLAGE} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertSchaltanlagenAbschnitte(schaltanlagenIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.SCHALTANLAGENABSCHNITT)) {
+                const result = yield this.queryFunctionWrapper(integral_sql_1.getNetzQuery(integral_sql_1.I7Objects.SCHALTANLAGENABSCHNITT, 0, 0, schaltanlagenIDs));
+                for (const i7Data of result) {
+                    const voltageLevel = this.cimModel.getVoltageLevel(this.integralID2UUID.get(i7Data.schaltanlage));
+                    this.integralID2UUID.set(i7Data.id, voltageLevel.mrid);
+                    utils_2.putUUIDtoI7Ids(voltageLevel.mrid, i7Data.id, this.UUID2IntegralID);
+                    const schaltanlagenabschnitt = new Schaltanlagenabschnitt_1.SchaltanlagenabschnittImpl(i7Data);
+                    schaltanlagenabschnitt.addSchaltanlage(this.integralSchaltanlagen.get(schaltanlagenabschnitt.schaltanlageid));
+                    this.integralSchaltanlagenAbschnitte.set(i7Data.id, schaltanlagenabschnitt);
+                }
+            }
+            else {
+                console.log(`Tabelle ${integral_sql_1.Integral7TableNames.SCHALTANLAGENABSCHNITT} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertSammelschienenAbschnitte(schaltanlagenAbschnittIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.SAMMELSCHIENE)) {
+                const result = yield this.queryFunctionWrapper(integral_sql_1.getNetzQuery(integral_sql_1.I7Objects.SAMMELSCHIENE, 0, 0, schaltanlagenAbschnittIDs));
+                for (const i7Data of result) {
+                    const busbarSection = new __1.BusbarSection(__1.getUUID(i7Data.guid), utils_2.getName(i7Data), i7Data.kurzname);
+                    const connectivityNode = new AMPRIONConnectivityNode_1.AMPRIONConnectivityNode(__1.generateUUID(), 'ssab cn');
+                    __1.createConnection(this.cimModel, busbarSection, connectivityNode, __1.PhaseCode.ABC, 1);
+                    const voltageLevel = this.cimModel.getVoltageLevel(this.integralID2UUID.get(i7Data.saabschnitt));
+                    connectivityNode.nodeNumber = i7Data.id_psse_cape;
+                    if (voltageLevel) {
+                        busbarSection.equipmentContainerUUID = voltageLevel.mrid;
+                        connectivityNode.connectivityNodeContainerUUID = voltageLevel.mrid;
+                        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;
+                    }
+                    else {
+                        console.log('Sammelschiene ' + i7Data.id + ' besitzt keine Schaltanlage.');
+                    }
+                    this.integralID2UUID.set(i7Data.id, connectivityNode.mrid);
+                    utils_2.putUUIDtoI7Ids(busbarSection.mrid, i7Data.id, this.UUID2IntegralID);
+                    this.cimModel.addConnectivityNode(connectivityNode);
+                    this.cimModel.addBusbarSection(busbarSection);
+                    if (this.integralSchaltanlagenAbschnitte.has(i7Data.saabschnitt)) {
+                        this.integralSchaltanlagenAbschnitte.get(i7Data.saabschnitt).ssab.push(i7Data);
+                    }
+                }
+            }
+            else {
+                console.log(`Tabelle ${integral_sql_1.Integral7TableNames.SAMMELSCHIENE} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertSchaltfelder(schaltanlagenAbschnittIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.SCHALTFELD)) {
+                const result = yield this.queryFunctionWrapper(integral_sql_1.getNetzQuery(integral_sql_1.I7Objects.SCHALTFELD, 0, 0, schaltanlagenAbschnittIDs));
+                for (const i7Data of result) {
+                    const bay = new AMPRIONBay_1.AMPRIONBay(__1.getUUID(i7Data.guid), utils_2.getName(i7Data));
+                    bay.number = i7Data.feldnummer;
+                    bay.locationID = i7Data.ips_folder_id;
+                    const sfImpl = new Schaltfeld_1.SchaltfeldImpl(i7Data);
+                    this.integralSchaltfelder.set(i7Data.id, sfImpl);
+                    if (this.integralSchaltanlagenAbschnitte.has(sfImpl.saabschnittid)) {
+                        sfImpl.saabschnitt = this.integralSchaltanlagenAbschnitte.get(sfImpl.saabschnittid);
+                        sfImpl.saabschnitt.schaltfelder.push(sfImpl);
+                    }
+                    else {
+                        console.log(`Schaltfeld ${i7Data.id} besitzt keine Anlage.`);
+                    }
+                    const voltageLevel = this.cimModel.getVoltageLevel(this.integralID2UUID.get(i7Data.saabschnitt));
+                    if (voltageLevel) {
+                        bay.voltageLevelUUID = voltageLevel.mrid;
+                        const i7Schluessel = voltageLevel.description +
+                            integral_prefix_1.SCHALTFELD_PRAEFIX +
+                            utils_2.ueberpruefeZeichenkette(i7Data.bezeichner);
+                        bay.description = i7Schluessel;
+                    }
+                    else {
+                        console.log(`Schaltfeld ${i7Data.id} besitzt keine Anlage.`);
+                    }
+                    this.cimModel.addBay(bay);
+                    this.integralID2UUID.set(i7Data.id, bay.mrid);
+                }
+            }
+            else {
+                console.log(`Tabelle ${integral_sql_1.Integral7TableNames.SCHALTFELD} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertQuerkupplungen(schaltanlagenAbschnittIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.QUERKUPPLUNG)) {
+                const result = yield this.queryFunctionWrapper(integral_sql_1.getNetzQuery(integral_sql_1.I7Objects.QUERKUPPLUNG, 0, 0, schaltanlagenAbschnittIDs));
+                for (const i7Data of result) {
+                    const bay = new AMPRIONBay_1.AMPRIONBay(__1.getUUID(i7Data.guid), utils_2.getName(i7Data), 'Querkupplung');
+                    bay.number = i7Data.feldnummer;
+                    bay.locationID = i7Data.ips_folder_id;
+                    const voltageLevel = this.cimModel.getVoltageLevel(this.integralID2UUID.get(i7Data.saabschnitt));
+                    if (voltageLevel) {
+                        bay.voltageLevelUUID = voltageLevel.mrid;
+                        const i7Schluessel = voltageLevel.description +
+                            '/QK-' +
+                            utils_2.ueberpruefeZeichenkette(i7Data.bezeichner);
+                        bay.description = i7Schluessel;
+                    }
+                    else {
+                        console.log(`Querkupplung ${i7Data.id} besitzt keine Anlage.`);
+                    }
+                    this.querkupplungIDs.push(i7Data.id);
+                    this.cimModel.addBay(bay);
+                    this.integralID2UUID.set(i7Data.id, bay.mrid);
+                }
+            }
+            else {
+                console.log(`Tabelle ${integral_sql_1.Integral7TableNames.QUERKUPPLUNG} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertLaegskupplungen(schaltanlagenIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.LAENGSKUPPLUNG)) {
+                const result = yield this.queryFunctionWrapper(integral_sql_1.getNetzQuery(integral_sql_1.I7Objects.LAENGSKUPPLUNG, 0, 0, schaltanlagenIDs));
+                for (const i7Data of result) {
+                    const bay = new AMPRIONBay_1.AMPRIONBay(__1.getUUID(i7Data.guid), utils_2.getName(i7Data), i7Data.kurzname, 'Laengskupplung');
+                    const voltageLevel = this.cimModel.getVoltageLevel(this.integralID2UUID.get(i7Data.schaltanlage));
+                    bay.number = i7Data.feldnummer;
+                    bay.locationID = i7Data.ips_folder_id;
+                    if (voltageLevel) {
+                        bay.voltageLevelUUID = voltageLevel.mrid;
+                        const i7Schluessel = voltageLevel.description +
+                            '/LK-' +
+                            utils_2.ueberpruefeZeichenkette(i7Data.bezeichner);
+                        bay.description = i7Schluessel;
+                    }
+                    else {
+                        console.log(`Laengskupplung ${i7Data.id} besitzt keine Anlage.`);
+                    }
+                    this.laengskupplungIDs.push(i7Data.id);
+                    this.integralID2UUID.set(i7Data.id, bay.mrid);
+                    this.cimModel.addBay(bay);
+                }
+            }
+            else {
+                console.log(`Tabelle ${integral_sql_1.Integral7TableNames.LAENGSKUPPLUNG} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertBelastungen(knotenSfIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.BELASTUNG)) {
+                const result = yield this.queryFunctionWrapper(integral_sql_1.getNetzQuery(integral_sql_1.I7Objects.BELASTUNG, 0, 0, knotenSfIDs));
+                for (const i7Data of result) {
+                    const energyConsumer = new __1.EnergyConsumer(__1.getUUID(i7Data.guid), utils_2.getName(i7Data));
+                    const inBetrieb = utils_2.convertToBooleanI7(i7Data.betrieb);
+                    const powerData = utils_2.getActiveReactivePower(i7Data);
+                    __1.createSvStatus(this.cimModel, inBetrieb, energyConsumer);
+                    energyConsumer.p = powerData[0] ? powerData[0] : 0;
+                    energyConsumer.q = powerData[1] ? powerData[1] : 0;
+                    energyConsumer.pFixed = energyConsumer.p;
+                    energyConsumer.qFixed = energyConsumer.q;
+                    const connectivityNode = this.cimModel.objects.get(this.integralID2UUID.get(i7Data.anschluss));
+                    if (connectivityNode) {
+                        __1.createConnection(this.cimModel, energyConsumer, connectivityNode, __1.PhaseCode.ABC);
+                        const equipmentContainer = utils_2.determineEquipmentContainer('VoltageLevel', this.cimModel, this.cimModel.getObject(connectivityNode.getConnectivityNodeContainerUUID()));
+                        if (equipmentContainer) {
+                            energyConsumer.equipmentContainerUUID = equipmentContainer.mrid;
+                            const i7Schluesel = utils_2.getDescription(equipmentContainer.getSubstation()) +
+                                integral_prefix_1.BELASTUNG_PRAEFIX + i7Data.bezeichner;
+                            energyConsumer.description = i7Schluesel;
+                        }
+                        else {
+                            console.log(`EnergyConsumer ${i7Data.id} besitzt keinen EquipmentContainer.`);
+                        }
+                    }
+                    else {
+                        console.log(`EnergyConsumer ${i7Data.id} besitzt keinen ConnectivityNode.`);
+                    }
+                    this.cimModel.addEnergyConsumer(energyConsumer);
+                    this.integralID2UUID.set(i7Data.id, energyConsumer.mrid);
+                }
+            }
+            else {
+                console.log(`Tabelle ${integral_sql_1.Integral7TableNames.BELASTUNG} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertEinspeisungen(knotenSfIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.EINSPEISUNG)) {
+                const result = yield this.queryFunctionWrapper(integral_sql_1.getNetzQuery(integral_sql_1.I7Objects.EINSPEISUNG, 0, 0, knotenSfIDs));
+                for (const i7Data of result) {
+                    const energySource = new __1.EnergySource(__1.getUUID(i7Data.guid), utils_2.getName(i7Data), i7Data.kurzname);
+                    const inBetrieb = utils_2.convertToBooleanI7(i7Data.betrieb);
+                    const prio = i7Data.einspprio;
+                    const usoll = i7Data.usoll;
+                    __1.createSvStatus(this.cimModel, inBetrieb, energySource);
+                    const spannungsgeregelt = utils_2.convertToBooleanI7(i7Data.spannungsgeregelt);
+                    const powerData = utils_2.getActiveReactivePower(i7Data);
+                    energySource.activePower = powerData[0];
+                    energySource.reactivePower = powerData[1];
+                    const connectivityNode = this.cimModel.objects.get(this.integralID2UUID.get(i7Data.anschluss));
+                    if (connectivityNode) {
+                        __1.createConnection(this.cimModel, energySource, connectivityNode, __1.PhaseCode.ABC);
+                        const equipmentContainer = utils_2.determineEquipmentContainer('VoltageLevel', this.cimModel, this.cimModel.getObject(connectivityNode.getConnectivityNodeContainerUUID()));
+                        if (equipmentContainer) {
+                            energySource.equipmentContainerUUID = equipmentContainer.mrid;
+                            const i7Schluesel = integral_prefix_1.EINSPEISUNG_PRAEFIX + i7Data.bezeichner;
+                            energySource.description = i7Schluesel;
+                        }
+                        else {
+                            console.log(`EnergySource ${i7Data.id} besitzt keinen EquipmentContainer.`);
+                        }
+                    }
+                    else {
+                        console.log(`EnergySource ${i7Data.id} besitzt keinen ConnectivityNode.`);
+                    }
+                    this.cimModel.addEnergySource(energySource);
+                    this.integralID2UUID.set(i7Data.id, energySource.mrid);
+                }
+            }
+            else {
+                console.log(`Tabelle ${integral_sql_1.Integral7TableNames.EINSPEISUNG} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertGeneratoren(knotenSfIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.GENERATOR)) {
+                const result = yield this.queryFunctionWrapper(integral_sql_1.getNetzQuery(integral_sql_1.I7Objects.GENERATOR, 0, 0, knotenSfIDs));
+                for (const i7Data of result) {
+                    const synchronousMachine = new __1.SynchronousMachine(__1.getUUID(i7Data.guid), i7Data.bezeichner, i7Data.kurzname);
+                    const s = utils_2.getActiveReactivePower(i7Data);
+                    const s0 = utils_2.getNumber(i7Data.sr);
+                    synchronousMachine.ratedS = s0 === 0 ? s[0] : s0;
+                    synchronousMachine.ratedU = i7Data.ur;
+                    synchronousMachine.type = __1.SynchronousMachineKind.generator;
+                    synchronousMachine.referencePriority = i7Data.einspprio;
+                    const maxQ = utils_2.getNumber(i7Data.q_max);
+                    synchronousMachine.maxQ = maxQ !== 0 ? maxQ : utils_2.getNumber(i7Data.qmax_von_pmax);
+                    const minQ = utils_2.getNumber(i7Data.q_min);
+                    synchronousMachine.minQ = minQ !== 0 ? minQ : utils_2.getNumber(i7Data.qmin_von_pmin);
+                    const reactiveCapabilityCurve = new __1.ReactiveCapabilityCurve(__1.generateUUID(), 'CurveData');
+                    reactiveCapabilityCurve.curveStyle = __1.CurveStyle.straightLineYValues;
+                    reactiveCapabilityCurve.xUnit = __1.UnitSymbol.W;
+                    reactiveCapabilityCurve.y1Unit = __1.UnitSymbol.VAr;
+                    reactiveCapabilityCurve.y2Unit = __1.UnitSymbol.VAr;
+                    const curveData1 = new __1.CurveData(__1.generateUUID());
+                    curveData1.curve = reactiveCapabilityCurve;
+                    curveData1.xvalue = i7Data.p_min;
+                    curveData1.y1value = i7Data.qmin_von_pmin;
+                    curveData1.y2value = i7Data.qmax_von_pmin;
+                    this.cimModel.addCurveData(curveData1);
+                    const curveData2 = new __1.CurveData(__1.generateUUID());
+                    curveData2.curve = reactiveCapabilityCurve;
+                    curveData2.xvalue = i7Data.p_max;
+                    curveData2.y1value = i7Data.qmin_von_pmax;
+                    curveData2.y2value = i7Data.qmax_von_pmax;
+                    this.cimModel.addCurveData(curveData2);
+                    this.cimModel.addReactiveCapabilityCurve(reactiveCapabilityCurve);
+                    synchronousMachine.initialReactiveCapabilityCurveUUID = reactiveCapabilityCurve.mrid;
+                    const inBetrieb = utils_2.convertToBooleanI7(i7Data.betrieb);
+                    __1.createSvStatus(this.cimModel, inBetrieb, synchronousMachine);
+                    synchronousMachine.ratedPowerFactor = i7Data.cosphir ? i7Data.cosphir : 0;
+                    synchronousMachine.qPercent = i7Data.cos_phi ? (1 - i7Data.cosphir) : 0;
+                    synchronousMachine.earthing = false;
+                    synchronousMachine.r = 0;
+                    synchronousMachine.r0 = 0;
+                    synchronousMachine.r2 = 0;
+                    synchronousMachine.x0 = 0;
+                    synchronousMachine.x2 = 0;
+                    synchronousMachine.satDirectSubtransX = i7Data.xd2s ? i7Data.xd2s : 0;
+                    const regulatingControl = new __1.RegulatingControl(__1.generateUUID(), `RegulatingControl_${synchronousMachine.name}`);
+                    switch (i7Data.spannungsgeregelt) {
+                        case 1: {
+                            regulatingControl.mode = __1.RegulatingControlModeKind.voltage;
+                        }
+                        default: {
+                            regulatingControl.mode = __1.RegulatingControlModeKind.voltage;
+                        }
+                    }
+                    synchronousMachine.regulatingControlUUID = regulatingControl.mrid;
+                    const generatingUnitConfig = generation_unit_fuel_types_1.FUEL_TYPE_CONFIG[i7Data.nameprimaertyp];
+                    let generatingUnit;
+                    if (generatingUnitConfig) {
+                        switch (generatingUnitConfig.class) {
+                            case 'ThermalGeneratingUnit': {
+                                generatingUnit = new __1.ThermalGeneratingUnit(__1.getUUID(''), 'Generator_' + i7Data.bezeichner, i7Data.kurzname, i7Data.nameprimaertyp);
+                                if (generatingUnitConfig.fuelType) {
+                                    utils_2.generateFuelType(i7Data.nameprimaertyp, generatingUnitConfig.fuelType, generatingUnit, this.cimModel);
+                                }
+                                break;
+                            }
+                            case 'SolarGeneratingUnit': {
+                                generatingUnit = new __1.SolarGeneratingUnit(__1.getUUID(''), 'Generator_' + i7Data.bezeichner, i7Data.kurzname, i7Data.nameprimaertyp);
+                                break;
+                            }
+                            case 'WindGeneratingUnit': {
+                                generatingUnit = new __1.WindGeneratingUnit(__1.getUUID(''), 'Generator_' + i7Data.bezeichner, i7Data.kurzname, i7Data.nameprimaertyp);
+                                switch (generatingUnitConfig.fuelType) {
+                                    case 'onshore':
+                                        generatingUnit.windGenUnitType = __1.WindGenUnitKind.onshore;
+                                        break;
+                                    case 'offshore':
+                                        generatingUnit.windGenUnitType = __1.WindGenUnitKind.offshore;
+                                        break;
+                                }
+                                break;
+                            }
+                            case 'NuclearGeneratingUnit': {
+                                generatingUnit = new __1.NuclearGeneratingUnit(__1.getUUID(''), 'Generator_' + i7Data.bezeichner, i7Data.kurzname);
+                                break;
+                            }
+                        }
+                    }
+                    if (!generatingUnit) {
+                        generatingUnit = new __1.GeneratingUnit(__1.getUUID(''), 'Generator_' + i7Data.bezeichner, i7Data.kurzname);
+                    }
+                    generatingUnit.maxOperatingP = utils_2.getNumber(i7Data.p_max);
+                    generatingUnit.minOperatingP = utils_2.getNumber(i7Data.p_min);
+                    generatingUnit.maxOperatingQ = utils_2.getNumber(i7Data.q_max);
+                    generatingUnit.minOperatingQ = utils_2.getNumber(i7Data.q_min);
+                    generatingUnit.initialP = utils_2.getNumber(i7Data.p0);
+                    generatingUnit.nominalP = utils_2.getNumber(generatingUnit.maxOperatingP);
+                    generatingUnit.genControlSource = __1.GeneratorControlSource.unavailable;
+                    generatingUnit.addRotatingMachine(synchronousMachine);
+                    synchronousMachine.generatingUnitUUID = generatingUnit.mrid;
+                    const connectivityNode = this.cimModel.objects.get(this.integralID2UUID.get(i7Data.anschluss));
+                    if (connectivityNode) {
+                        const terminal = __1.createConnection(this.cimModel, synchronousMachine, connectivityNode, __1.PhaseCode.ABC);
+                        regulatingControl.terminalUUID = terminal.mrid;
+                        const equipmentContainerEquip = utils_2.determineEquipmentContainer('VoltageLevel', this.cimModel, this.cimModel.getObject(connectivityNode.getConnectivityNodeContainerUUID()));
+                        if (equipmentContainerEquip) {
+                            synchronousMachine.equipmentContainerUUID = equipmentContainerEquip.mrid;
+                            const i7Schluesel = integral_prefix_1.GENERATOR_PRAEFIX + i7Data.bezeichner;
+                            synchronousMachine.description = i7Schluesel;
+                            const vlEqipContainer = equipmentContainerEquip;
+                            const equipmentContainergenUnitUUID = vlEqipContainer === null || vlEqipContainer === void 0 ? void 0 : vlEqipContainer.getSubstationUUID();
+                            if (equipmentContainergenUnitUUID) {
+                                generatingUnit.equipmentContainerUUID = equipmentContainergenUnitUUID;
+                            }
+                            else {
+                                console.log(`GeneratingUnit ${i7Data.id} besitzt keinen EquipmentContainer/Substation.`);
+                            }
+                        }
+                        else {
+                            console.log(`SynchronousMachine ${i7Data.id} besitzt keinen EquipmentContainer.`);
+                            console.log(`SynchronousMachine ${i7Data.id} besitzt keinen EquipmentContainer.`);
+                        }
+                    }
+                    else {
+                        console.log(`SynchronousMachine ${i7Data.id} besitzt keinen ConnectivityNode.`);
+                    }
+                    this.cimModel.addRegulatingControl(regulatingControl);
+                    this.cimModel.addGeneratingUnit(generatingUnit);
+                    this.cimModel.addSynchronousMachine(synchronousMachine);
+                    this.integralID2UUID.set(i7Data.id, synchronousMachine.mrid);
+                }
+            }
+        });
+    }
+    convertKnotenSf(schaltfeldIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.KNOTEN_SF)) {
+                const result = yield this.queryFunctionWrapper(integral_sql_1.getNetzQuery(integral_sql_1.I7Objects.KNOTEN_SF, 0, 0, schaltfeldIDs));
+                for (const i7Data of result) {
+                    const connectivityNode = new __1.ConnectivityNode(__1.getUUID(i7Data.guid), 'knotensf cn', 'knotensf');
+                    const bay = this.cimModel.getBay(this.integralID2UUID.get(i7Data.schaltfeld));
+                    if (bay) {
+                        connectivityNode.connectivityNodeContainerUUID = bay.mrid;
+                    }
+                    else {
+                        console.log(`KnotenSf ${i7Data.id} besitzt kein Schaltfeld.`);
+                    }
+                    this.knotenSfIDs.push(i7Data.id);
+                    this.cimModel.addConnectivityNode(connectivityNode);
+                    this.integralID2UUID.set(i7Data.id, connectivityNode.mrid);
+                    this.knotenSpannung.set(connectivityNode.mrid, connectivityNode.getBaseVoltage());
+                    this.checkMemoryObject(i7Data.id, connectivityNode);
+                }
+            }
+            else {
+                console.log(`Tabelle ${integral_sql_1.Integral7TableNames.KNOTEN_SF} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertKnotenKf(querkupplungIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.KNOTEN_KF)) {
+                const result = yield this.queryFunctionWrapper(integral_sql_1.getNetzQuery(integral_sql_1.I7Objects.KNOTEN_KF, 0, 0, querkupplungIDs));
+                for (const i7Data of result) {
+                    const connectivityNode = new __1.ConnectivityNode(__1.getUUID(i7Data.guid), 'knotenkf cn', 'knotenkf');
+                    const bay = this.cimModel.getBay(this.integralID2UUID.get(i7Data.kpfeld));
+                    if (bay) {
+                        connectivityNode.connectivityNodeContainerUUID = bay.mrid;
+                    }
+                    else {
+                        console.log(`KnotenKf ${i7Data.id} besitzt kein Schaltfeld.`);
+                    }
+                    this.integralID2UUID.set(i7Data.id, connectivityNode.mrid);
+                    this.cimModel.addConnectivityNode(connectivityNode);
+                }
+            }
+            else {
+                console.log(`Tabelle ${integral_sql_1.Integral7TableNames.KNOTEN_KF} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertKnotenLk(laengskupplungIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.KNOTEN_LK)) {
+                const result = yield this.queryFunctionWrapper(integral_sql_1.getNetzQuery(integral_sql_1.I7Objects.KNOTEN_LK, 0, 0, laengskupplungIDs));
+                for (const i7Data of result) {
+                    const connectivityNode = new __1.ConnectivityNode(__1.generateUUID(), utils_2.getName(i7Data), 'KnotenLk');
+                    const bay = this.cimModel.getBay(this.integralID2UUID.get(i7Data.lkupplung));
+                    if (bay) {
+                        connectivityNode.connectivityNodeContainerUUID = bay.mrid;
+                    }
+                    else {
+                        console.log(`KnotenLk ${i7Data.id} besitzt kein Schaltfeld.`);
+                    }
+                    this.integralID2UUID.set(i7Data.id, connectivityNode.mrid);
+                    this.cimModel.addConnectivityNode(connectivityNode);
+                }
+            }
+            else {
+                console.log(`Tabelle ${integral_sql_1.Integral7TableNames.KNOTEN_LK} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertSchlaufen(knotenSoIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.SCHLAUFE)) {
+                const result = yield this.queryFunctionWrapper(integral_sql_1.getNetzQuery(integral_sql_1.I7Objects.SCHLAUFE, 0, 0, knotenSoIDs));
+                for (const i7Data of result) {
+                    const terminal = new __1.Terminal(__1.generateUUID(), 'T_Schlaufe', String(i7Data.id));
+                    terminal.connected = utils_2.convertToBooleanI7(i7Data.schaltzustand);
+                    terminal.phases = __1.PhaseCode.ABC;
+                    this.integralID2UUID.set(i7Data.id, terminal.mrid);
+                    this.integralID2UUID.set(i7Data.knotenzw, terminal.mrid);
+                    this.memoryObjects.set(i7Data.id, terminal);
+                    this.memoryObjects.set(i7Data.knotenzw, terminal);
+                    const eknotenUUID = this.integralID2UUID.get(i7Data.eknoten);
+                    if (eknotenUUID) {
+                        terminal.connectivityNodeUUID = eknotenUUID;
+                        const connectivityNode = this.cimModel.getConnectivityNode(eknotenUUID);
+                        this.knotenSpannung.set(connectivityNode === null || connectivityNode === void 0 ? void 0 : connectivityNode.mrid, connectivityNode === null || connectivityNode === void 0 ? void 0 : connectivityNode.getBaseVoltage());
+                    }
+                    else {
+                        console.log(`Schlaufe ${i7Data.id} besitzt kein KnotenSO).`);
+                    }
+                }
+            }
+            else {
+                console.log(`Tabelle ${integral_sql_1.Integral7TableNames.SCHLAUFE} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertSchemaStandorte(standortIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.NSG_STANDORT)) {
+                const result = yield this.queryFunctionWrapper(integral_sql_1.getNetzQuery(integral_sql_1.I7Objects.NSG_STANDORT, 0, 0, standortIDs));
+                for (const i7Data of result) {
+                    const standortNsgImpl = new StandortNsg_1.StandortNsgImpl(i7Data);
+                    this.integralNsgStandort.set(i7Data.id, standortNsgImpl);
+                    if (this.integralStandorte.has(standortNsgImpl.standortid)) {
+                        standortNsgImpl.standort = this.integralStandorte.get(standortNsgImpl.standortid);
+                        standortNsgImpl.standort.standortNsg = standortNsgImpl;
+                    }
+                    else {
+                        console.log(`standortNsg/DiagramObject ${standortNsgImpl.id} hat keine Standort-Instanz.`);
+                    }
+                }
+            }
+            else {
+                console.log(`Tabelle ${integral_sql_1.Integral7TableNames.NSG_STANDORT} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertSchemaKnotenSo(knotenSoIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.NSG_KNOTEN_SO)) {
+                const result = yield this.queryFunctionWrapper(integral_sql_1.getNetzQuery(integral_sql_1.I7Objects.NSG_KNOTEN_SO, 0, 0, knotenSoIDs));
+                for (const i7Data of result) {
+                    const knotenSoNsgImpl = new KnotenSoNsg_1.KnotenSoNsg(i7Data);
+                    this.integralNsgKnotenSo.set(i7Data.id, knotenSoNsgImpl);
+                    if (this.integralKnotenSo.has(knotenSoNsgImpl.knotensoid)) {
+                        knotenSoNsgImpl.knotenso = this.integralKnotenSo.get(knotenSoNsgImpl.knotensoid);
+                        knotenSoNsgImpl.knotenso.knotenSoNsg = knotenSoNsgImpl;
+                    }
+                    const diagramObject = new __1.DiagramObject(__1.getUUID(i7Data.guid), 'Abzweig', String(i7Data.variantennr));
+                    this.cimModel.addDiagramObject(diagramObject);
+                    const nsgStandortData = this.integralNsgStandort.get(i7Data.nsgso);
+                    if (nsgStandortData) {
+                        const diagramObjectPoint = new __1.DiagramObjectPoint(nsgStandortData.xrel + i7Data.xrel, nsgStandortData.yrel + i7Data.yrel);
+                        diagramObjectPoint.mrid = __1.generateUUID();
+                        diagramObjectPoint.diagramObject = diagramObject;
+                        diagramObject.addDiagramObjectPoint(diagramObjectPoint);
+                        const cnUUID = this.integralID2UUID.get(i7Data.knotenso);
+                        const cn = this.cimModel.getObject(cnUUID);
+                        if (cn) {
+                            diagramObject.identifiedObjectUUID = cn.mrid;
+                        }
+                        else {
+                            console.log(`KnotenSo/DiagramObject ${diagramObject.mrid} hat kein PSR-Objekt.`);
+                        }
+                        const diagramUUID = this.integralID2UUID.get(i7Data.variantennr);
+                        const diagram = this.cimModel.getDiagram(diagramUUID);
+                        if (diagram) {
+                            diagramObject.diagramUUID = diagram.mrid;
+                        }
+                        else {
+                        }
+                    }
+                    else {
+                    }
+                }
+            }
+            else {
+                console.log(`Tabelle ${integral_sql_1.Integral7TableNames.NSG_KNOTEN_SO} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertSchemaSchaltanlage(saIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.NSG_SCHALTANLAGE)) {
+                const result = yield this.queryFunctionWrapper(integral_sql_1.getNetzQuery(integral_sql_1.I7Objects.NSG_SCHALTANLAGE, 0, 0, saIDs));
+                for (const i7Data of result) {
+                    const saNsgImpl = new SchaltanlageNSG_1.SchaltanlageNsgImpl(i7Data);
+                    this.integralNsgSchaltanlage.set(i7Data.id, saNsgImpl);
+                    if (this.integralSchaltanlagen.has(saNsgImpl.schaltanlageid)) {
+                        saNsgImpl.schaltanlage = this.integralSchaltanlagen.get(saNsgImpl.schaltanlageid);
+                        saNsgImpl.schaltanlage.schaltanlageNsg = saNsgImpl;
+                    }
+                    else {
+                        console.log(`SchaltanlageNSG  ${i7Data.id} hat keine PSR Instanz.`);
+                    }
+                    if (this.integralNsgStandort.has(saNsgImpl.nsgsoid)) {
+                        saNsgImpl.nsgso = this.integralNsgStandort.get(saNsgImpl.nsgsoid);
+                        saNsgImpl.nsgso.schaltanlagenNsg.push(saNsgImpl);
+                    }
+                    else {
+                        console.log(`SchaltanlageNSG  ${i7Data.id} hat keine standortNsg Instanz.`);
+                    }
+                }
+            }
+            else {
+                console.log(`Tabelle ${integral_sql_1.Integral7TableNames.NSG_KNOTEN_SO} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertSchemaSchaltanlagenAbschnitte(schaltanlagenabschnittIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.NSG_SCHALTANLAGENABSCHNITT)) {
+                const result = yield this.queryFunctionWrapper(integral_sql_1.getNetzQuery(integral_sql_1.I7Objects.NSG_SCHALTANLAGENABSCHNITT, 0, 0, schaltanlagenabschnittIDs));
+                for (const i7Data of result) {
+                    const saabNsgImpl = new SchaltanlagenabschnittNsg_1.SchaltanlagenabschnittNsg(i7Data);
+                    this.integralNsgSchaltanlagenabschnitt.set(i7Data.id, saabNsgImpl);
+                    if (this.integralSchaltanlagenAbschnitte.has(saabNsgImpl.saabschnittid)) {
+                        saabNsgImpl.saabschnitt = this.integralSchaltanlagenAbschnitte.get(saabNsgImpl.saabschnittid);
+                        saabNsgImpl.saabschnitt.schaltanlagenabschnittNsg = saabNsgImpl;
+                    }
+                    else {
+                        console.log(`NSG Schaltanlagenabschnitt hat keinen PSR-Abschnitt`);
+                    }
+                    if (saabNsgImpl.saabschnitt && saabNsgImpl.saabschnitt.schaltanlage) {
+                        if (saabNsgImpl.saabschnitt.schaltanlage.schaltanlageNsg) {
+                            saabNsgImpl.saabschnitt.schaltanlage.schaltanlageNsg.saabNsg.push(saabNsgImpl);
+                            saabNsgImpl.nsgsa = saabNsgImpl.saabschnitt.schaltanlage.schaltanlageNsg;
+                        }
+                    }
+                }
+            }
+            else {
+                console.log(`Tabelle ${integral_sql_1.Integral7TableNames.NSG_KNOTEN_SO} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertSchemaSammelschienenAbschnitte() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            for (const sa of this.integralSchaltanlagen.values()) {
+                const totalSlots = sa.getTotalSlots();
+                if (sa.schaltanlageNsg) {
+                    const saAusrichtung = sa.schaltanlageNsg.ausrichtung;
+                    for (const saab of sa.saab) {
+                        for (const ssab of saab.ssab) {
+                            const cnUUID = this.integralID2UUID.get(ssab.id);
+                            const connectivityNode = this.cimModel.getConnectivityNode(cnUUID);
+                            const standortPoint = sa.standort.getPoint();
+                            const saPoint = sa.getPoint();
+                            const ssabPoint = standortPoint.translate(saPoint.x, saPoint.y);
+                            const offset = saab.schaltanlagenabschnittNsg.nslots;
+                            const laenge = saab.schaltanlagenabschnittNsg.laenge;
+                            const delta = sa.getDelta(saab);
+                            const hoehe = saab.ssab.length * 8;
+                            const diagramObject = new __1.DiagramObject(__1.getUUID(''), 'SSAB Diagram', String(sa.schaltanlageNsg.variantennr));
+                            const points = [];
+                            if (saAusrichtung === 0) {
+                                points.push(new Point_1.Point(ssabPoint.x - 8 + (offset * 16), ssabPoint.y + 4 - hoehe + ssab.pos * 8 + delta));
+                                points.push(new Point_1.Point(ssabPoint.x - 8 + (offset * 16) + (laenge * 16), ssabPoint.y + 4 - hoehe + ssab.pos * 8 + delta));
+                            }
+                            else if (saAusrichtung === 1) {
+                                points.push(new Point_1.Point(ssabPoint.x + 4 - hoehe + ssab.pos * 8 + delta, ssabPoint.y - 8 + (offset * 16)));
+                                points.push(new Point_1.Point(ssabPoint.x + 4 - hoehe + ssab.pos * 8 + delta, ssabPoint.y - 8 + (offset * 16) + (laenge * 16)));
+                            }
+                            else if (saAusrichtung === 2) {
+                                points.push(new Point_1.Point(ssabPoint.x - 8 + (offset * 16), ssabPoint.y + 4 - hoehe + ssab.pos * 8 + delta));
+                                points.push(new Point_1.Point(ssabPoint.x - 8 + (offset * 16) + (laenge * 16), ssabPoint.y + 4 - hoehe + ssab.pos * 8 + delta));
+                            }
+                            else if (saAusrichtung === 3) {
+                                points.push(new Point_1.Point(ssabPoint.x + 4 - hoehe + ssab.pos * 8 + delta, ssabPoint.y - 8 + (totalSlots * 16) - (offset * 16)));
+                                points.push(new Point_1.Point(ssabPoint.x + 4 - hoehe + ssab.pos * 8 + delta, ssabPoint.y - 8 + (totalSlots * 16) - (offset * 16 + laenge * 16)));
+                            }
+                            utils_schema_1.createDiagramObjectPoints(diagramObject, points);
+                            diagramObject.identifiedObjectUUID = connectivityNode.mrid;
+                            this.cimModel.addDiagramObject(diagramObject);
+                            const diagramUUID = this.integralID2UUID.get(sa.schaltanlageNsg.variantennr);
+                            const diagram = this.cimModel.getDiagram(diagramUUID);
+                            if (diagram) {
+                                diagramObject.diagramUUID = diagram.mrid;
+                            }
+                            else {
+                            }
+                        }
+                    }
+                }
+            }
+        });
+    }
+    convertSchemaSchaltfelder(schaltfeldIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.NSG_SCHALTFELD)) {
+                const result = yield this.queryFunctionWrapper(integral_sql_1.getNetzQuery(integral_sql_1.I7Objects.NSG_SCHALTFELD, 0, 0, schaltfeldIDs));
+                for (const i7Data of result) {
+                    const sfNSG = new SchaltfeldNsg_1.SchaltfeldNsgImpl(i7Data);
+                    sfNSG.schaltfeld = this.integralSchaltfelder.get(sfNSG.schaltfeldid);
+                    if (sfNSG.schaltfeld) {
+                        sfNSG.schaltfeld.schaltfeldNsg = sfNSG;
+                    }
+                    sfNSG.nsgsaa = this.integralNsgSchaltanlagenabschnitt.get(sfNSG.nsgsaaid);
+                    this.integralNsgSchaltfelder.set(i7Data.id, sfNSG);
+                    const sf = sfNSG.schaltfeld;
+                    if (sf) {
+                        const standort = sf.getStandort();
+                        const sa = sf.getSA();
+                        const saab = sf.getSAAB();
+                        if (standort && sa && saab) {
+                            const pointSt = standort.getPoint();
+                            const pointSaRel = sa.getPoint();
+                            const pointSa = pointSt.translate(pointSaRel.x, pointSaRel.y);
+                            const slotOffset = saab.getSlotOffset();
+                            const saAusrichtung = sa.schaltanlageNsg.ausrichtung;
+                            const deltaAusrichtung = sfNSG.deltaausrichtung;
+                            const slotnummer = sfNSG.slotnummer;
+                            const d = 4;
+                            const deltaSSAB = sa.getDelta(saab);
+                            const posSSAB = sfNSG.schaltfeld.getPosSSAB(saAusrichtung, deltaAusrichtung);
+                            let pointLinksOben, pointRechtsUnten;
+                            if (saAusrichtung === 0) {
+                                const pointSf = pointSa.translate(16 * (slotnummer + slotOffset) - 16, 0);
+                                if (deltaAusrichtung === 1) {
+                                    pointSf.y = pointSf.y + 65 + deltaSSAB;
+                                    pointRechtsUnten = pointSf.translate(32, 0);
+                                    pointLinksOben = pointSf.translate(0, -sfNSG.hoehe);
+                                }
+                                else {
+                                    pointSf.y = pointSf.y - sfNSG.hoehe + deltaSSAB;
+                                    pointLinksOben = pointSf.translate(0, 0);
+                                    pointRechtsUnten = pointSf.translate(32, sfNSG.hoehe);
+                                }
+                            }
+                            else if (saAusrichtung === 1) {
+                            }
+                            else if (saAusrichtung === 2) {
+                            }
+                            else if (saAusrichtung === 3) {
+                            }
+                            if (pointLinksOben && pointRechtsUnten) {
+                                const points = [];
+                                points.push(new Point_1.Point(pointLinksOben.x, pointLinksOben.y));
+                                points.push(new Point_1.Point(pointRechtsUnten.x, pointLinksOben.y));
+                                points.push(new Point_1.Point(pointRechtsUnten.x, pointRechtsUnten.y));
+                                points.push(new Point_1.Point(pointLinksOben.x, pointRechtsUnten.y));
+                                points.push(new Point_1.Point(pointLinksOben.x, pointLinksOben.y));
+                                points.push(new Point_1.Point(pointLinksOben.x + 16, pointLinksOben.y));
+                                points.push(new Point_1.Point(pointLinksOben.x + 16, pointRechtsUnten.y));
+                                const diagramObject = new __1.DiagramObject(__1.getUUID(''), 'Schaltfeld', String(sa.schaltanlageNsg.variantennr));
+                                const bayUUID = this.integralID2UUID.get(sf.id);
+                                const bay = this.cimModel.getBay(bayUUID);
+                                if (bay) {
+                                    utils_schema_1.createDiagramObjectPoints(diagramObject, points);
+                                    diagramObject.identifiedObjectUUID = bay.mrid;
+                                    const diagramUUID = this.integralID2UUID.get(sa.schaltanlageNsg.variantennr);
+                                    const diagram = this.cimModel.getDiagram(diagramUUID);
+                                    if (diagram) {
+                                        diagramObject.diagramUUID = diagram.mrid;
+                                    }
+                                    else {
+                                    }
+                                }
+                                else {
+                                    console.log(`DiagramObject Schaltfeld ${diagramObject.mrid} mit der VariantenNr ${sa.schaltanlageNsg.variantennr} hat kein CIM Schaltfeld ${sf.id} ${bayUUID}.`);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            else {
+                console.log(`Tabelle ${integral_sql_1.Integral7TableNames.NSG_KNOTEN_SO} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertStarreVerbindungen(containerIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.KNOTEN_STARR)) {
+                const result = yield this.queryFunctionWrapper(integral_sql_1.getNetzQuery(integral_sql_1.I7Objects.KNOTEN_STARR, 0, 0, containerIDs));
+                for (const i7Data of result) {
+                    const junction = new __1.Junction(__1.getUUID(i7Data.guid), i7Data.bezeichner, 'JNCT', 'starre Verbindung');
+                    const schaltzustand = utils_2.convertToBooleanI7(i7Data.schaltzustand);
+                    const equipmentContainer = utils_2.determineEquipmentContainer('VoltageLevel', this.cimModel, this.cimModel.getObject(this.integralID2UUID.get(i7Data.seliste)));
+                    const cnStart = this.cimModel.getConnectivityNode(this.integralID2UUID.get(i7Data.aknoten));
+                    const cnZiel = this.cimModel.getConnectivityNode(this.integralID2UUID.get(i7Data.eknoten));
+                    if (equipmentContainer) {
+                        junction.equipmentContainerUUID = equipmentContainer.mrid;
+                    }
+                    else {
+                        console.log(`Starre verbindung ${i7Data.id} besitzt keinen EquipmentContainer.`);
+                    }
+                    if (cnStart) {
+                        const terminal = __1.createConnection(this.cimModel, junction, cnStart, __1.PhaseCode.ABC, 1);
+                        if (schaltzustand === false) {
+                            terminal.connected = schaltzustand;
+                        }
+                    }
+                    else {
+                        console.log(`Starre verbindung ${i7Data.id} besitzt keinen Anfangsknoten.`);
+                    }
+                    if (cnZiel) {
+                        const terminal = __1.createConnection(this.cimModel, junction, cnZiel, __1.PhaseCode.ABC, 2);
+                        if (schaltzustand === false) {
+                            terminal.connected = schaltzustand;
+                        }
+                    }
+                    else {
+                        console.log(`Starre verbindung ${i7Data.id} besitzt keinen Zielknoten.`);
+                    }
+                    const baseVoltage = utils_2.getTerminalUn(this.cimModel, junction);
+                    if (baseVoltage) {
+                        junction.baseVoltageUUID = baseVoltage.mrid;
+                    }
+                    this.integralID2UUID.set(i7Data.id, junction.mrid);
+                    this.cimModel.addJunction(junction);
+                }
+            }
+            else {
+                console.log(`Tabelle ${integral_sql_1.Integral7TableNames.KNOTEN_STARR} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertStromkreise() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.LEITUNG)) {
+                const result = yield this.queryFunctionWrapper(`SELECT DISTINCT kurzname, bezeichner FROM ${integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.LEITUNG]}`);
+                for (const i7Data of result) {
+                    let line = utils_2.getLineByAttribute(this.cimModel, 'name', i7Data.bezeichner);
+                    if (!line) {
+                        line = new __1.Line(__1.generateUUID());
+                        line.name = i7Data.bezeichner ? i7Data.bezeichner : 'Stromkreis_' + i7Data.kurzname;
+                        line.shortName = i7Data.kurzname;
+                        const region = utils_1.createIfNotExitsGeoregionByName(this.cimModel, 'ENTSO-E');
+                        const subregion = utils_1.createIfNotExitsSubGeoregionByName(this.cimModel, 'Deutschland', region);
+                        line.regionUUID = subregion.mrid;
+                        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);
+                        line.description = i7Schluessel;
+                        this.cimModel.addLine(line);
+                    }
+                }
+            }
+            else {
+                console.log(`Tabelle ${integral_sql_1.Integral7TableNames.LEITUNG} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertBetriebsmitteltypenLeitung() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.TYP_FREILEITUNG)) {
+                const result = yield this.queryFunctionWrapper(integral_sql_1.getNetzQuery(integral_sql_1.I7Objects.TYP_FREILEITUNG, 0, 0, []));
+                for (const i7Data of result) {
+                    const typ = new __1.OverheadWireInfo(__1.generateUUID(), i7Data.name);
+                    this.setWireInfoProperties(typ, i7Data);
+                    this.cimModel.addOverheadWireInfo(typ);
+                }
+            }
+            else {
+                console.log(`Tabelle ${integral_sql_1.Integral7TableNames.TYP_FREILEITUNG} ist nicht vorhanden.`);
+            }
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.TYP_KABEL)) {
+                const result = yield this.queryFunctionWrapper(integral_sql_1.getNetzQuery(integral_sql_1.I7Objects.TYP_KABEL, 0, 0, []));
+                for (const i7Data of result) {
+                    const typ = new __1.CableInfo(__1.generateUUID(), i7Data.name);
+                    this.setWireInfoProperties(typ, i7Data);
+                    this.cimModel.addCableInfo(typ);
+                }
+            }
+            else {
+                console.log(`Tabelle ${integral_sql_1.Integral7TableNames.TYP_KABEL} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertLeitungen(limit, offset) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.LEITUNG)) {
+                const result = yield this.queryFunctionWrapper(integral_sql_1.getNetzQuery(integral_sql_1.I7Objects.LEITUNG, limit, offset, []));
+                for (const i7Data of result) {
+                    const leitung = new Leitung_1.LeitungImpl(i7Data);
+                    this.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 acLineSegment = new __1.ACLineSegment(__1.getUUID(i7Data.guid), i7Data.bezeichner, i7Data.stkabname, i7Schluessel);
+                    this.cimModel.addACLineSegment(acLineSegment);
+                    this.integralID2UUID.set(i7Data.id, acLineSegment.mrid);
+                    const line = utils_2.getLine(this.cimModel, i7Data.bezeichner, i7Data.kurzname);
+                    if (line) {
+                        acLineSegment.equipmentContainerUUID = line.mrid;
+                    }
+                    else {
+                        console.log(`Leitung  ${i7Data.id} besitzt keinen Stromkreis.`);
+                    }
+                    const start = this.memoryObjects.get(i7Data.aknoten);
+                    if (start) {
+                        const terminal = __1.createConnection(this.cimModel, acLineSegment, start, __1.PhaseCode.ABC, 1);
+                        const baseVoltage = this.knotenSpannung.get(terminal.connectivityNodeUUID);
+                        acLineSegment.baseVoltage = baseVoltage;
+                    }
+                    else {
+                        console.log(`Leitung ${i7Data.id} ${acLineSegment.mrid} besitzt keinen Anfangsknoten. ${i7Data.aknoten} ${this.integralID2UUID.get(i7Data.aknoten)}`);
+                    }
+                    const target = this.memoryObjects.get(i7Data.eknoten);
+                    if (target) {
+                        const terminal = __1.createConnection(this.cimModel, acLineSegment, target, __1.PhaseCode.ABC, 2);
+                        const baseVoltage = this.knotenSpannung.get(terminal.connectivityNodeUUID);
+                        acLineSegment.baseVoltage = baseVoltage;
+                    }
+                    else {
+                        console.log(`Leitung ${i7Data.id} ${acLineSegment.mrid} besitzt keinen Zielknoten.`);
+                    }
+                }
+            }
+            else {
+                console.log(`Tabelle ${integral_sql_1.Integral7TableNames.LEITUNG} ist nicht vorhanden.`);
+            }
+        });
+    }
+    determineLeitungsTypen(leitungsIDs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.FREILEITUNG)) {
+                const result = yield this.queryFunctionWrapper(integral_sql_1.getNetzQuery(integral_sql_1.I7Objects.FREILEITUNG, 0, 0, leitungsIDs));
+                for (const i7Data of result) {
+                    const acLineSegment = this.cimModel.getACLineSegment(this.integralID2UUID.get(i7Data.leitung));
+                    if (acLineSegment) {
+                        this.setACLineSegmentProperties(acLineSegment, i7Data, 'OverheadLine');
+                    }
+                    else {
+                        console.log(`Freileitung ${i7Data.id} besitzt kein Leitungsobjekt.`);
+                    }
+                }
+            }
+            else {
+                console.log(`Tabelle ${integral_sql_1.Integral7TableNames.TYP_FREILEITUNG} ist nicht vorhanden.`);
+            }
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.KABEL)) {
+                const result = yield this.queryFunctionWrapper(integral_sql_1.getNetzQuery(integral_sql_1.I7Objects.KABEL, 0, 0, leitungsIDs));
+                for (const i7Data of result) {
+                    const acLineSegment = this.cimModel.getACLineSegment(this.integralID2UUID.get(i7Data.leitung));
+                    if (acLineSegment) {
+                        this.setACLineSegmentProperties(acLineSegment, i7Data, 'Cable');
+                    }
+                    else {
+                        console.log(`Kabel ${i7Data.id} besitzt kein Leitungsobjekt.`);
+                    }
+                }
+            }
+            else {
+                console.log(`Tabelle ${integral_sql_1.Integral7TableNames.TYP_FREILEITUNG} 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.queryFunctionWrapper(integral_sql_1.getNetzQuery(integral_sql_1.I7Objects.TYP_TRAFO2W, 0, 0, []));
+                for (const i7Data of result) {
+                    const typTrafo = new __1.PowerTransformer2WInfo(__1.generateUUID(), i7Data.name);
+                    typTrafo.ukr = i7Data.ukr;
+                    typTrafo.pkr = i7Data.pkr;
+                    typTrafo.pLeer = i7Data.p_leer;
+                    typTrafo.iLeer = i7Data.i_leer;
+                    const typWicklung1 = new __1.TransformerEndInfo(__1.generateUUID());
+                    typWicklung1.ratedS = new __1.ApparentPower(i7Data.sr, __1.UnitMultiplier.m, __1.UnitSymbol.VA);
+                    this.setTransformerEndInfoProperties(typWicklung1, i7Data, 1);
+                    typWicklung1.powerTransformerInfo = typTrafo;
+                    typTrafo.transformerEndInfo.push(typWicklung1);
+                    const typWicklung2 = new __1.TransformerEndInfo(__1.generateUUID());
+                    typWicklung2.ratedS = new __1.ApparentPower(i7Data.sr, __1.UnitMultiplier.m, __1.UnitSymbol.VA);
+                    this.setTransformerEndInfoProperties(typWicklung2, i7Data, 2);
+                    typWicklung2.powerTransformerInfo = typTrafo;
+                    typTrafo.transformerEndInfo.push(typWicklung2);
+                    this.cimModel.addPowerTransformer2WInfo(typTrafo);
+                }
+            }
+            else {
+                console.log(`Tabelle ${integral_sql_1.Integral7TableNames.TYP_TRAFO2W} ist nicht vorhanden.`);
+            }
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.TYP_TRAFO3W)) {
+                const result = yield this.queryFunctionWrapper(integral_sql_1.getNetzQuery(integral_sql_1.I7Objects.TYP_TRAFO3W, 0, 0, []));
+                for (const i7Data of result) {
+                    const typTrafo = new __1.PowerTransformer3WInfo(__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 __1.TransformerEndInfo(__1.generateUUID());
+                    typWicklung1.ratedS = new __1.ApparentPower(i7Data.sr1, __1.UnitMultiplier.m, __1.UnitSymbol.VA);
+                    this.setTransformerEndInfoProperties(typWicklung1, i7Data, 1);
+                    typWicklung1.powerTransformerInfo = typTrafo;
+                    typTrafo.transformerEndInfo.push(typWicklung1);
+                    const typWicklung2 = new __1.TransformerEndInfo(__1.generateUUID());
+                    typWicklung2.ratedS = new __1.ApparentPower(i7Data.sr2, __1.UnitMultiplier.m, __1.UnitSymbol.VA);
+                    this.setTransformerEndInfoProperties(typWicklung2, i7Data, 2);
+                    typWicklung2.powerTransformerInfo = typTrafo;
+                    typTrafo.transformerEndInfo.push(typWicklung2);
+                    const typWicklung3 = new __1.TransformerEndInfo(__1.generateUUID());
+                    typWicklung3.ratedS = new __1.ApparentPower(i7Data.sr3, __1.UnitMultiplier.m, __1.UnitSymbol.VA);
+                    this.setTransformerEndInfoProperties(typWicklung3, i7Data, 3);
+                    typWicklung3.powerTransformerInfo = typTrafo;
+                    typTrafo.transformerEndInfo.push(typWicklung3);
+                    this.cimModel.addPowerTransformer3WInfo(typTrafo);
+                }
+            }
+            else {
+                console.log(`Tabelle ${integral_sql_1.Integral7TableNames.TYP_TRAFO3W} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertTrafo2W(limit, offset) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.TRAFO2W)) {
+                const result = yield this.queryFunctionWrapper(integral_sql_1.getNetzQuery(integral_sql_1.I7Objects.TRAFO2W, limit, offset, []));
+                for (const i7Data of result) {
+                    const powerTransformer = new __1.PowerTransformer(__1.getUUID(i7Data.guid), utils_2.getName(i7Data), i7Data.id + '', i7Data.bezeichner);
+                    const powerTransformerInfo = this.cimModel.getPowerTransformer2WInfoByName(i7Data.nametyp);
+                    const start = this.memoryObjects.get(i7Data.aknoten);
+                    let startTerminal;
+                    if (start) {
+                        startTerminal = __1.createConnection(this.cimModel, powerTransformer, start, __1.PhaseCode.ABC, 1);
+                    }
+                    else {
+                        console.log(`PowerTransformer2W ${i7Data.id} ${powerTransformer.mrid} besitzt keinen Anfangsknoten.`);
+                    }
+                    const target = this.memoryObjects.get(i7Data.eknoten);
+                    let targetTerminal;
+                    if (target) {
+                        targetTerminal = __1.createConnection(this.cimModel, powerTransformer, target, __1.PhaseCode.ABC, 2);
+                    }
+                    else {
+                        console.log(`PowerTransformer2W ${i7Data.id} ${powerTransformer.mrid} besitzt keinen Zielknoten.`);
+                    }
+                    const schaltgruppe = i7Data.schaltgr;
+                    const powerTransformerEnd1 = new __1.PowerTransformerEnd(__1.getUUID(i7Data.guid_w1), `W1_${powerTransformer.name}`);
+                    powerTransformerEnd1.endNumber = 1;
+                    powerTransformerEnd1.connectionKind = utils_2.getSchaltgruppe(schaltgruppe, powerTransformerEnd1.endNumber);
+                    powerTransformerEnd1.phaseAngleClock = utils_2.getSchaltgruppeAngleClock(schaltgruppe, powerTransformerEnd1.endNumber);
+                    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 * Math.pow(10, 6) / ur * 1000) / Math.sqrt(3);
+                    powerTransformerEnd1.r = utils_2.calculateR(ur, pkr, sr);
+                    powerTransformerEnd1.x = utils_2.calculateX(ur, ukr, sr, powerTransformerEnd1.r);
+                    powerTransformerEnd1.g = utils_2.calculateG(ur, 0);
+                    powerTransformerEnd1.b = utils_2.calculateB(ur, sr, 0, 0);
+                    powerTransformerEnd1.ratedU = ur;
+                    powerTransformerEnd1.ratedS = sr;
+                    if (powerTransformerEnd1.ratedU) {
+                        let baseVoltage = this.cimModel.getBaseVoltage(powerTransformerEnd1.ratedU);
+                        if (!baseVoltage) {
+                            baseVoltage = __1.createBaseVoltageIfNotExists(this.cimModel, powerTransformerEnd1.ratedU);
+                        }
+                        powerTransformerEnd1.baseVoltageUUID = baseVoltage.mrid;
+                    }
+                    else {
+                        console.log(`Wicklung2W ${i7Data.id} ${powerTransformerEnd1.endNumber} ${powerTransformerEnd1.mrid} besitzt keine Spannungsangabe.`);
+                    }
+                    const terminal = startTerminal;
+                    if (terminal) {
+                        powerTransformerEnd1.terminalUUID = terminal.mrid;
+                        this.setConductingEquipmentCurrentLimit('W1 ' + powerTransformer.name, terminal.mrid, ir1);
+                    }
+                    else {
+                        console.log(`Wicklung2W ${i7Data.id} ${powerTransformerEnd1.endNumber} ${powerTransformerEnd1.mrid} besitzt keine Terminalinstanz.`);
+                    }
+                    powerTransformerEnd1.powerTransformerUUID = powerTransformer.mrid;
+                    powerTransformer.addPowerTransformerEnd(powerTransformerEnd1);
+                    utils_2.createTapChanger(i7Data, powerTransformerEnd1, this.cimModel, powerTransformerEnd1.ratedU);
+                    const powerTransformerEnd2 = new __1.PowerTransformerEnd(__1.getUUID(i7Data.guid_w2), `W2_${powerTransformer.name}`);
+                    powerTransformerEnd2.endNumber = 2;
+                    powerTransformerEnd2.connectionKind = utils_2.getSchaltgruppe(schaltgruppe, powerTransformerEnd2.endNumber);
+                    powerTransformerEnd2.phaseAngleClock = utils_2.getSchaltgruppeAngleClock(schaltgruppe, powerTransformerEnd2.endNumber);
+                    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);
+                    if (powerTransformerEnd2.ratedU) {
+                        let baseVoltage = this.cimModel.getBaseVoltage(powerTransformerEnd2.ratedU);
+                        if (!baseVoltage) {
+                            baseVoltage = __1.createBaseVoltageIfNotExists(this.cimModel, powerTransformerEnd2.ratedU);
+                        }
+                        powerTransformerEnd2.baseVoltageUUID = baseVoltage.mrid;
+                    }
+                    else {
+                        console.log(`Wicklung ${i7Data.id} ${powerTransformerEnd2.endNumber} ${powerTransformerEnd2.mrid} besitzt keine Spannungsangabe.`);
+                    }
+                    const terminal2 = targetTerminal;
+                    if (terminal2) {
+                        powerTransformerEnd2.terminalUUID = terminal2.mrid;
+                        this.setConductingEquipmentCurrentLimit('W2 ' + powerTransformer.name, terminal.mrid, ir2);
+                    }
+                    else {
+                        console.log(`Wicklung2W ${i7Data.id} ${powerTransformerEnd2.endNumber} ${powerTransformerEnd2.mrid} besitzt keine Terminalinstanz.`);
+                        console.log(`TargetTerminal created ` + (targetTerminal === undefined));
+                    }
+                    powerTransformerEnd2.powerTransformerUUID = powerTransformer.mrid;
+                    powerTransformer.addPowerTransformerEnd(powerTransformerEnd2);
+                    utils_2.createTapChanger(i7Data, powerTransformerEnd2, this.cimModel, powerTransformerEnd2.ratedU);
+                    const substationUUID = this.integralID2UUID.get(i7Data.standort);
+                    if (substationUUID) {
+                        powerTransformer.equipmentContainerUUID = substationUUID;
+                        const i7Schluessel = +integral_prefix_1.TRAFO2WPRAEFIX_PRAEFIX +
+                            i7Data.bezeichner;
+                        powerTransformer.description = i7Schluessel;
+                    }
+                    else {
+                        console.log(`Trafo2W ${i7Data.id} besitzt keine Umspannanlage.`);
+                    }
+                    this.cimModel.addPowerTransformer(powerTransformer);
+                    this.integralID2UUID.set(i7Data.id, powerTransformer.mrid);
+                }
+            }
+            else {
+                console.log(`Tabelle ${integral_sql_1.Integral7TableNames.TRAFO2W} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertTrafo3W(limit, offset) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.TRAFO3W)) {
+                const result = yield this.queryFunctionWrapper(integral_sql_1.getNetzQuery(integral_sql_1.I7Objects.TRAFO3W, limit, offset, []));
+                const trafoIDs = result.map(obj => obj['id']);
+                const trafoWicklungen = new Map();
+                if (this.isTableAvailable(integral_sql_1.Integral7TableNames.TRAFO3_WICKLUNG) && trafoIDs.length) {
+                    const wicklungenResult = yield this.queryFunctionWrapper(integral_sql_1.getNetzQuery(integral_sql_1.I7Objects.TRAFO3_WICKLUNG, 0, 0, trafoIDs));
+                    for (const wicklung of wicklungenResult) {
+                        trafoWicklungen.set(wicklung.id, wicklung);
+                    }
+                }
+                else {
+                    console.log(`Tabelle ${integral_sql_1.Integral7TableNames.TRAFO3_WICKLUNG} ist nicht vorhanden.`);
+                }
+                for (const i7Data of result) {
+                    const powerTransformer = new __1.PowerTransformer(__1.getUUID(i7Data.guid), utils_2.getName(i7Data), i7Data.id + '', i7Data.bezeichner);
+                    const powerTransformerInfo = this.cimModel.getPowerTransformer3WInfoByName(i7Data.nametyp);
+                    const schaltgruppe = i7Data.schaltgr;
+                    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 * Math.pow(10, 6) / ur1 * 1000) / Math.sqrt(3);
+                    const ir2 = (sr2 * Math.pow(10, 6) / ur2 * 1000) / Math.sqrt(3);
+                    const ir3 = (sr3 * Math.pow(10, 6) / 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 wicklung1 = trafoWicklungen.get(i7Data.trafowicklung3w1);
+                    let terminal1, terminal2, terminal3;
+                    if (wicklung1) {
+                        const start = this.memoryObjects.get(wicklung1.aknoten);
+                        if (start) {
+                            terminal1 = __1.createConnection(this.cimModel, powerTransformer, start, __1.PhaseCode.ABC, 1);
+                        }
+                        else {
+                            console.log(`PowerTransformer ${i7Data.id} ${powerTransformer.mrid} besitzt keinen Anfangsknoten.`);
+                        }
+                    }
+                    else {
+                        console.log(`Trafo ${i7Data.id} Wicklung 1 ${i7Data.trafowicklung3w1} ist nicht vorhanden.`);
+                    }
+                    const powerTransformerEnd1 = new __1.PowerTransformerEnd(__1.getUUID(i7Data.guid_w1), `W1 ${powerTransformer.name}`);
+                    powerTransformerEnd1.endNumber = 1;
+                    powerTransformerEnd1.connectionKind = utils_2.getSchaltgruppe(schaltgruppe, powerTransformerEnd1.endNumber);
+                    powerTransformerEnd1.phaseAngleClock = utils_2.getSchaltgruppeAngleClock(schaltgruppe, powerTransformerEnd1.endNumber);
+                    powerTransformerEnd1.r = impedanzW1.r;
+                    powerTransformerEnd1.x = impedanzW1.x;
+                    powerTransformerEnd1.g = impedanzW1.g;
+                    powerTransformerEnd1.b = impedanzW1.b;
+                    powerTransformerEnd1.ratedU = ur1;
+                    powerTransformerEnd1.ratedS = sr1;
+                    if (powerTransformerEnd1.ratedU) {
+                        let baseVoltage = this.cimModel.getBaseVoltage(powerTransformerEnd1.ratedU);
+                        if (!baseVoltage) {
+                            baseVoltage = __1.createBaseVoltageIfNotExists(this.cimModel, powerTransformerEnd1.ratedU);
+                        }
+                        powerTransformerEnd1.baseVoltageUUID = baseVoltage.mrid;
+                    }
+                    else {
+                        console.log(`Wicklung ${i7Data.id} ${powerTransformerEnd1.endNumber} ${powerTransformerEnd1.mrid} besitzt keine Spannungsangabe.`);
+                    }
+                    powerTransformerEnd1.powerTransformerUUID = powerTransformer.mrid;
+                    powerTransformer.addPowerTransformerEnd(powerTransformerEnd1);
+                    if (terminal1) {
+                        powerTransformerEnd1.terminalUUID = terminal1.mrid;
+                        this.setConductingEquipmentCurrentLimit('W1 ' + powerTransformer.name, terminal1.mrid, ir1);
+                    }
+                    else {
+                        console.log(`Wicklung3W ${i7Data.id} ${powerTransformerEnd1.endNumber} ${powerTransformerEnd1.mrid} besitzt keine Terminalinstanz.`);
+                    }
+                    const wicklung2 = trafoWicklungen.get(i7Data.trafowicklung3w2);
+                    if (wicklung2) {
+                        const start = this.memoryObjects.get(wicklung2.aknoten);
+                        if (start) {
+                            terminal2 = __1.createConnection(this.cimModel, powerTransformer, start, __1.PhaseCode.ABC, 2);
+                        }
+                        else {
+                            console.log(`PowerTransformer ${i7Data.id} ${powerTransformer.mrid} besitzt keinen Anfangsknoten.`);
+                        }
+                    }
+                    else {
+                        console.log(`Trafo ${i7Data.id} Wicklung 2 ${i7Data.trafowicklung3w2} ist nicht vorhanden.`);
+                    }
+                    const powerTransformerEnd2 = new __1.PowerTransformerEnd(__1.getUUID(i7Data.guid_w2), `Wicklung 2 ${powerTransformer.name}`);
+                    powerTransformerEnd2.endNumber = 2;
+                    powerTransformerEnd2.connectionKind = utils_2.getSchaltgruppe(schaltgruppe, powerTransformerEnd2.endNumber);
+                    powerTransformerEnd2.phaseAngleClock = utils_2.getSchaltgruppeAngleClock(schaltgruppe, powerTransformerEnd2.endNumber);
+                    powerTransformerEnd2.r = impedanzW2.r;
+                    powerTransformerEnd2.x = impedanzW2.x;
+                    powerTransformerEnd2.g = impedanzW2.g;
+                    powerTransformerEnd2.b = impedanzW2.b;
+                    powerTransformerEnd2.ratedS = sr2;
+                    powerTransformerEnd2.ratedU = ur2;
+                    if (powerTransformerEnd2.ratedU) {
+                        let baseVoltage = this.cimModel.getBaseVoltage(powerTransformerEnd2.ratedU);
+                        if (!baseVoltage) {
+                            baseVoltage = __1.createBaseVoltageIfNotExists(this.cimModel, powerTransformerEnd2.ratedU);
+                        }
+                        powerTransformerEnd2.baseVoltageUUID = baseVoltage.mrid;
+                    }
+                    else {
+                        console.log(`Wicklung ${i7Data.id} ${powerTransformerEnd2.endNumber} ${powerTransformerEnd2.mrid} besitzt keine Spannungsangabe.`);
+                    }
+                    powerTransformerEnd2.powerTransformerUUID = powerTransformer.mrid;
+                    powerTransformer.addPowerTransformerEnd(powerTransformerEnd2);
+                    if (terminal2) {
+                        powerTransformerEnd2.terminalUUID = terminal2.mrid;
+                        this.setConductingEquipmentCurrentLimit('W2 ' + powerTransformer.name, terminal2.mrid, ir2);
+                    }
+                    else {
+                        console.log(`Wicklung3W ${i7Data.id} ${powerTransformerEnd2.endNumber} ${powerTransformerEnd2.mrid} besitzt keine Terminalinstanz.`);
+                    }
+                    const wicklung3 = trafoWicklungen.get(i7Data.trafowicklung3w3);
+                    if (wicklung3) {
+                        const start = this.memoryObjects.get(wicklung3.aknoten);
+                        if (start) {
+                            terminal3 = __1.createConnection(this.cimModel, powerTransformer, start, __1.PhaseCode.ABC, 3);
+                        }
+                        else {
+                            console.log(`PowerTransformer ${i7Data.id} ${powerTransformer.mrid} besitzt keinen Anfangsknoten.`);
+                        }
+                    }
+                    else {
+                        console.log(`Trafo ${i7Data.id} Wicklung 3 ${i7Data.trafowicklung3w2} ist nicht vorhanden.`);
+                    }
+                    const powerTransformerEnd3 = new __1.PowerTransformerEnd(__1.getUUID(i7Data.guid_w3), `Wicklung 3 ${powerTransformer.name}`);
+                    powerTransformerEnd3.endNumber = 3;
+                    powerTransformerEnd3.connectionKind = utils_2.getSchaltgruppe(schaltgruppe, powerTransformerEnd3.endNumber);
+                    powerTransformerEnd3.phaseAngleClock = utils_2.getSchaltgruppeAngleClock(schaltgruppe, powerTransformerEnd3.endNumber);
+                    powerTransformerEnd3.r = impedanzW3.r;
+                    powerTransformerEnd3.x = impedanzW3.x;
+                    powerTransformerEnd2.g = impedanzW3.g;
+                    powerTransformerEnd2.b = impedanzW3.b;
+                    powerTransformerEnd3.ratedS = sr3;
+                    powerTransformerEnd3.ratedU = ur3;
+                    if (powerTransformerEnd3.ratedU) {
+                        let baseVoltage = this.cimModel.getBaseVoltage(powerTransformerEnd3.ratedU);
+                        if (!baseVoltage) {
+                            baseVoltage = __1.createBaseVoltageIfNotExists(this.cimModel, powerTransformerEnd3.ratedU);
+                        }
+                        powerTransformerEnd3.baseVoltageUUID = baseVoltage.mrid;
+                    }
+                    else {
+                        console.log(`Wicklung3W ${i7Data.id} ${powerTransformerEnd3.endNumber} ${powerTransformerEnd3.mrid} besitzt keine Spannungsangabe.`);
+                    }
+                    powerTransformerEnd3.powerTransformerUUID = powerTransformer.mrid;
+                    powerTransformer.addPowerTransformerEnd(powerTransformerEnd3);
+                    if (terminal3) {
+                        powerTransformerEnd3.terminalUUID = terminal3.mrid;
+                        this.setConductingEquipmentCurrentLimit('W3 ' + powerTransformer.name, terminal3.mrid, ir3);
+                    }
+                    else {
+                        console.log(`Wicklung ${i7Data.id} ${powerTransformerEnd3.endNumber} ${powerTransformerEnd3.mrid} besitzt keine Terminalinstanz.`);
+                    }
+                    const substationUUID = this.integralID2UUID.get(i7Data.standort);
+                    if (substationUUID) {
+                        powerTransformer.equipmentContainerUUID = substationUUID;
+                        const i7Schluessel = integral_prefix_1.TRAFO3WPRAEFIX_PRAEFIX +
+                            i7Data.bezeichner;
+                        powerTransformer.description = i7Schluessel;
+                    }
+                    else {
+                        console.log(`Trafo2W ${i7Data.id} besitzt keine Umspannanlage.`);
+                    }
+                    this.cimModel.addPowerTransformer(powerTransformer);
+                    this.integralID2UUID.set(i7Data.id, powerTransformer.mrid);
+                }
+            }
+            else {
+                console.log(`Tabelle ${integral_sql_1.Integral7TableNames.TRAFO3W} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertTrenner3f(containerIDs) {
+        var _a;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.TRENNER_3P)) {
+                const result = yield this.queryFunctionWrapper(integral_sql_1.getNetzQuery(integral_sql_1.I7Objects.TRENNER_3P, 0, 0, containerIDs));
+                for (const i7Data of result) {
+                    const disconnector = new __1.Disconnector(__1.getUUID(i7Data.guid), i7Data.bezeichner);
+                    disconnector.normalOpen = utils_2.convertToBooleanI7(!i7Data.schaltzustand);
+                    disconnector.open = utils_2.convertToBooleanI7(!i7Data.schaltzustand);
+                    const equipmentContainer = this.cimModel.objects.get(this.integralID2UUID.get(i7Data.seliste));
+                    const cnStart = this.cimModel.getConnectivityNode(this.integralID2UUID.get(i7Data.aknoten));
+                    const cnZiel = this.cimModel.getConnectivityNode(this.integralID2UUID.get(i7Data.eknoten));
+                    if (equipmentContainer) {
+                        disconnector.equipmentContainerUUID = equipmentContainer.mrid;
+                    }
+                    else {
+                        console.log(`Disconnector ${i7Data.id} besitzt keinen EquipmentContainer.`);
+                    }
+                    if (cnStart) {
+                        __1.createConnection(this.cimModel, disconnector, cnStart, __1.PhaseCode.ABC, 1);
+                    }
+                    else {
+                        console.log(`Disconnector ${i7Data.id} besitzt keinen Anfangsknoten.`);
+                    }
+                    if (cnZiel) {
+                        __1.createConnection(this.cimModel, disconnector, cnZiel, __1.PhaseCode.ABC, 2);
+                    }
+                    else {
+                        console.log(`Disconnector ${i7Data.id} besitzt keinen Zielknoten.`);
+                    }
+                    const vl = this.cimModel.objects.get((_a = equipmentContainer) === null || _a === void 0 ? void 0 : _a.voltageLevelUUID);
+                    const baseVoltage = this.cimModel.getBaseVoltageByUUID(vl === null || vl === void 0 ? void 0 : vl.baseVoltageUUID);
+                    if (baseVoltage) {
+                        disconnector.baseVoltageUUID = baseVoltage.mrid;
+                    }
+                    this.cimModel.addDisconnector(disconnector);
+                    this.integralID2UUID.set(i7Data.id, disconnector.mrid);
+                }
+            }
+            else {
+                console.log(`Tabelle ${integral_sql_1.Integral7TableNames.TRENNER_3P} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertTrennerFi3f(containerIDs) {
+        var _a;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.TRENNERFI_3P)) {
+                const result = yield this.queryFunctionWrapper(integral_sql_1.getNetzQuery(integral_sql_1.I7Objects.TRENNERFI_3P, 0, 0, containerIDs));
+                for (const i7Data of result) {
+                    const disconnector = new __1.Disconnector(__1.generateUUID(), i7Data.bezeichner);
+                    disconnector.normalOpen = utils_2.convertToBooleanI7(i7Data.schaltzustand);
+                    disconnector.open = utils_2.convertToBooleanI7(i7Data.schaltzustand);
+                    const equipmentContainer = this.cimModel.objects.get(this.integralID2UUID.get(i7Data.seliste));
+                    const cnStart = this.cimModel.getConnectivityNode(this.integralID2UUID.get(i7Data.aknoten));
+                    const cnZiel = this.cimModel.getConnectivityNode(this.integralID2UUID.get(i7Data.eknoten));
+                    if (equipmentContainer) {
+                        disconnector.equipmentContainerUUID = equipmentContainer.mrid;
+                    }
+                    else {
+                        console.log(`Disconnector Fi3 ${i7Data.id} besitzt keinen EquipmentContainer.`);
+                    }
+                    if (cnStart) {
+                        __1.createConnection(this.cimModel, disconnector, cnStart, __1.PhaseCode.ABC, 1);
+                    }
+                    else {
+                        console.log(`Disconnector Fi3 ${i7Data.id} besitzt keinen Anfangsknoten.`);
+                    }
+                    if (cnZiel) {
+                        __1.createConnection(this.cimModel, disconnector, cnZiel, __1.PhaseCode.ABC, 2);
+                    }
+                    else {
+                        console.log(`Disconnector Fi3 ${i7Data.id} besitzt keinen Zielknoten.`);
+                    }
+                    const vl = this.cimModel.objects.get((_a = equipmentContainer) === null || _a === void 0 ? void 0 : _a.voltageLevelUUID);
+                    const baseVoltage = this.cimModel.getBaseVoltageByUUID(vl === null || vl === void 0 ? void 0 : vl.baseVoltageUUID);
+                    if (baseVoltage) {
+                        disconnector.baseVoltageUUID = baseVoltage.mrid;
+                    }
+                    this.cimModel.addDisconnector(disconnector);
+                    this.integralID2UUID.set(i7Data.id, disconnector.mrid);
+                }
+            }
+            else {
+                console.log(`Tabelle ${integral_sql_1.Integral7TableNames.TRENNERFI_3P} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertLeistungsschalter(containerIDs) {
+        var _a;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.LEISTUNGSSCHALTER)) {
+                const result = yield this.queryFunctionWrapper(integral_sql_1.getNetzQuery(integral_sql_1.I7Objects.LEISTUNGSSCHALTER, 0, 0, containerIDs));
+                for (const i7Data of result) {
+                    const breaker = new __1.Breaker(__1.generateUUID(), i7Data.bezeichner);
+                    breaker.normalOpen = utils_2.convertToBooleanI7(i7Data.schaltzustand);
+                    breaker.open = utils_2.convertToBooleanI7(i7Data.schaltzustand);
+                    const equipmentContainer = this.cimModel.objects.get(this.integralID2UUID.get(i7Data.seliste));
+                    const cnStart = this.cimModel.getConnectivityNode(this.integralID2UUID.get(i7Data.aknoten));
+                    const cnZiel = this.cimModel.getConnectivityNode(this.integralID2UUID.get(i7Data.eknoten));
+                    if (equipmentContainer) {
+                        breaker.equipmentContainerUUID = equipmentContainer.mrid;
+                    }
+                    else {
+                        console.log(`LS ${i7Data.id} besitzt keinen EquipmentContainer.`);
+                    }
+                    if (cnStart) {
+                        __1.createConnection(this.cimModel, breaker, cnStart, __1.PhaseCode.ABC, 1);
+                    }
+                    else {
+                        console.log(`LS ${i7Data.id} besitzt keinen Anfangsknoten.`);
+                    }
+                    if (cnZiel) {
+                        __1.createConnection(this.cimModel, breaker, cnZiel, __1.PhaseCode.ABC, 2);
+                    }
+                    else {
+                        console.log(`LS ${i7Data.id} besitzt keinen Zielknoten.`);
+                    }
+                    const vl = this.cimModel.objects.get((_a = equipmentContainer) === null || _a === void 0 ? void 0 : _a.voltageLevelUUID);
+                    const baseVoltage = this.cimModel.getBaseVoltageByUUID(vl === null || vl === void 0 ? void 0 : vl.baseVoltageUUID);
+                    if (baseVoltage) {
+                        breaker.baseVoltageUUID = baseVoltage.mrid;
+                    }
+                    this.cimModel.addBreaker(breaker);
+                    this.integralID2UUID.set(i7Data.id, breaker.mrid);
+                }
+            }
+            else {
+                console.log(`Tabelle ${integral_sql_1.Integral7TableNames.LEISTUNGSSCHALTER} ist nicht vorhanden.`);
+            }
+        });
+    }
+    convertNetzvarianten() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.isTableAvailable(integral_sql_1.Integral7TableNames.NETZVARIANTEN)) {
+                const result = yield this.queryFunctionWrapper(integral_sql_1.getNetzQuery(integral_sql_1.I7Objects.NETZVARIANTEN, 0, 0, []));
+                for (const i7Data of result) {
+                    if (i7Data.art === 2) {
+                        const diagram = new __1.Diagram(__1.getUUID(i7Data.guid), i7Data.name, String(i7Data.id));
+                        diagram.orientation = __1.OrientationKind.negative;
+                        diagram.diagramStyle = this.cimModel.getDiagramStyle(__1.DIAGRAM_LAYOUT_TYPES.NODE_BREAKER);
+                        this.cimModel.addDiagram(diagram);
+                        this.integralID2UUID.set(i7Data.id, diagram.mrid);
+                    }
+                }
+            }
+            else {
+                console.log(`Tabelle ${integral_sql_1.Integral7TableNames.NETZVARIANTEN} ist nicht vorhanden.`);
+            }
+        });
+    }
+    setWireInfoProperties(object, data) {
+        object.r1 = +data.r1;
+        object.x1 = +data.x1;
+        object.c1 = new __1.CapacitancePerLength(data.c1, __1.UnitMultiplier.micro, __1.UnitSymbol.F);
+        object.r0 = new __1.ResistancePerLength(data.r1, __1.UnitMultiplier.none, __1.UnitSymbol.ohm);
+        object.x0 = new __1.ReactancePerLength(data.x1, __1.UnitMultiplier.none, __1.UnitSymbol.ohm);
+        object.c0 = new __1.CapacitancePerLength(data.c1, __1.UnitMultiplier.micro, __1.UnitSymbol.F);
+        object.ratedCurrent = +data.ir;
+    }
+    setACLineSegmentProperties(acLineSegment, data, psrTypeName) {
+        if (!acLineSegment.baseVoltage) {
+            let baseVoltage;
+            if (data.un && data.un > 0) {
+                baseVoltage = __1.createBaseVoltageIfNotExists(this.cimModel, data.un);
+            }
+            else {
+                baseVoltage = __1.createBaseVoltageIfNotExists(this.cimModel, 110);
+            }
+            acLineSegment.baseVoltage = baseVoltage;
+        }
+        if (data.laenge) {
+            acLineSegment.length = data.laenge;
+        }
+        else {
+        }
+        const assetType = this.cimModel.getWireInfoByName(data.nametyp);
+        if (data.r0 && data.r0 !== 0) {
+            acLineSegment.r0 = data.laenge <= 0 ? data.r0 : data.r0;
+        }
+        else {
+            if (assetType) {
+                acLineSegment.r0 = assetType.r0.value * acLineSegment.length;
+            }
+        }
+        if (data.x0 && data.x0 !== 0) {
+            acLineSegment.x0 = data.laenge <= 0 ? data.x0 : data.x0;
+        }
+        else {
+            if (assetType) {
+                acLineSegment.x0 = assetType.x0.value * 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 terminalUUID of acLineSegment.terminalsUUIDs) {
+            if (data.ir && data.ir !== 0) {
+                this.setConductingEquipmentCurrentLimit(acLineSegment.name, terminalUUID, data.ir);
+            }
+            else if (assetType && assetType.ratedCurrent && assetType.ratedCurrent !== 0) {
+                this.setConductingEquipmentCurrentLimit(acLineSegment.name, terminalUUID, assetType.ratedCurrent);
+            }
+            else {
+            }
+        }
+        const psrType = utils_1.createIfNotExitsPSRType(this.cimModel, psrTypeName);
+        acLineSegment.psrTypeUUID = psrType.mrid;
+    }
+    setConductingEquipmentCurrentLimit(name, terminalUUID, ir) {
+        const currentLimit = new __1.CurrentLimit(__1.generateUUID(), `${name}`);
+        this.cimModel.addCurrentLimit(currentLimit);
+        currentLimit.value = new __1.CurrentFlow(ir, __1.UnitMultiplier.none, __1.UnitSymbol.A);
+        const operationalLimitSet = new __1.OperationalLimitSet(__1.generateUUID(), `${name}`);
+        this.cimModel.addOperationalLimitSet(operationalLimitSet);
+        currentLimit.operationalLimitSetUUID = operationalLimitSet.mrid;
+        const operationalLimitType = this.getOperationalLimitType('patl');
+        currentLimit.operationalLimitTypeUUID = operationalLimitType.mrid;
+        operationalLimitSet.terminalUUID = terminalUUID;
+    }
+    getOperationalLimitType(name) {
+        let operationalLimitType = this.cimModel.getOperationalLimitTypeByName(name);
+        if (!operationalLimitType) {
+            operationalLimitType = new __1.OperationalLimitType(__1.generateUUID(), name);
+            operationalLimitType.direction = __1.OperationalLimitDirectionKind.absoluteValue;
+            operationalLimitType.limitType = __1.LimitTypeKind.patl;
+            this.cimModel.addOperationalLimitType(operationalLimitType);
+        }
+        return operationalLimitType;
+    }
+    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 __1.Voltage(data[ur], __1.UnitMultiplier.k, __1.UnitSymbol.V);
+        wicklung.tapActiv = utils_2.convertToBooleanI7(data[gestufte_seite]);
+        const tapChangerInfo = new TapChangerInfo_1.TapChangerInfo(__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];
+    }
+    convertSchemaBayElements(bay, diagram, saAusrichtung, deltaAusrichtung) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            for (const eqiup of bay.equipments) {
+                if (eqiup instanceof __1.Disconnector) {
+                    const disconnector = eqiup;
+                    for (const terminal of disconnector.terminals.values()) {
+                        const connectedCE = utils_schema_1.isConnectedTo(terminal.connectivityNode, 'BusbarSection');
+                        if (connectedCE && terminal.connectivityNode.diagramObjects.length > 0) {
+                            const diagramObjectSSAB = utils_schema_1.getDiagramObjectBelonginToDiagram(terminal.connectivityNode.diagramObjects, diagram.mrid);
+                            const diagramObjectBay = utils_schema_1.getDiagramObjectBelonginToDiagram(bay.diagramObjects, diagram.mrid);
+                            if (diagramObjectSSAB && diagramObjectBay) {
+                                const diagramObject = new __1.DiagramObject(__1.getUUID(''), 'SSAB Trenner');
+                                if (saAusrichtung === 0) {
+                                    const x = diagramObjectBay.diagramObjectPoints[0].xPosition + 16;
+                                    const y = diagramObjectSSAB.diagramObjectPoints[0].yPosition + 0.5;
+                                    const points = [new Point_1.Point(x, y)];
+                                    utils_schema_1.createDiagramObjectPoints(diagramObject, points);
+                                    eqiup.addDiagramObject(diagramObject);
+                                    diagramObject.identifiedObject = eqiup;
+                                    diagram.addDiagramObject(diagramObject);
+                                    diagramObject.diagram = diagram;
+                                }
+                            }
+                        }
+                        else {
+                        }
+                    }
+                }
+            }
+        });
+    }
+    writeHeaderStart(xmlWriter, profileURI) {
+        xmlWriter.startDocument('1.0', 'UTF-8');
+        xmlWriter.startElementNS(__1.RDF_XML.RDF_NS_PREFIX, 'RDF', __1.RDF_XML.RDF_NS);
+        utils_1.writeElementAttribute(xmlWriter, `xmlns:${__1.RDF_XML.RDF_NS_PREFIX}`, __1.RDF_XML.RDF_NS);
+        utils_1.writeElementAttribute(xmlWriter, `xmlns:${__1.RDF_XML.CIM_NS_PREFIX}`, __1.RDF_XML.CIM_NS_16);
+        utils_1.writeElementAttribute(xmlWriter, `xmlns:${__1.RDF_XML.ENTSOE_NS_PREFIX}`, __1.RDF_XML.ENTSOE_NS);
+        utils_1.writeElementAttribute(xmlWriter, `xmlns:${__1.RDF_XML.MD_NS_PREFIX}`, __1.RDF_XML.MD_NS);
+        if (profileURI === __1.RDF_XML.AMP_I7_PROFILE_URI) {
+            utils_1.writeElementAttribute(xmlWriter, `xmlns:${__1.RDF_XML.AMPRION_NS_PREFIX}`, __1.RDF_XML.AMPRION_NS);
+            utils_1.writeElementAttribute(xmlWriter, `xmlns:${__1.RDF_XML.IPS_NS_PREFIX}`, __1.RDF_XML.IPS_NS);
+            utils_1.writeElementAttribute(xmlWriter, `xmlns:${__1.RDF_XML.CAPE_NS_PREFIX}`, __1.RDF_XML.CAPE_NS);
+        }
+    }
+    writeHeaderEnd(xmlWriter) {
+        xmlWriter.endElement();
+        xmlWriter.endDocument();
+    }
+    objectToCIMXML(xmlWriter, values, profileName) {
+        for (const object of values.values()) {
+            object.toCIMXML(xmlWriter, profileName);
+        }
+    }
+    objectArrayToCIMXML(xmlWriter, values, profileName) {
+        for (const object of values) {
+            object.toCIMXML(xmlWriter, profileName);
+        }
+    }
+    checkMemoryObject(i7ID, cimObject) {
+        if (this.leitungAnschlussKnotenIDs.has(i7ID)) {
+            this.memoryObjects.set(i7ID, cimObject);
+        }
+    }
+    queryFunctionWrapper(query) {
+        return new Promise((resolve, reject) => {
+            this.queryFunction(query, (successResponse) => {
+                resolve(successResponse);
+            }, (errorResponse) => {
+                reject(errorResponse);
+            });
+        });
+    }
+    queryFunction(query, successCallback, errorCallback) {
+        this.mysqlConnection.query(query, (error, results, fields) => {
+            if (error)
+                errorCallback(error);
+            successCallback(results);
+        });
+    }
+    isTableAvailable(tableName) {
+        return this.availableTableNames.indexOf(tableName) > -1 ? true : false;
+    }
+    initDbConnection(mySqlConfig) {
+        this.mysqlConnection = mysql.createConnection({
+            host: mySqlConfig.host,
+            port: mySqlConfig.port,
+            database: mySqlConfig.database,
+            user: mySqlConfig.user,
+            password: mySqlConfig.password,
+        });
+    }
+    openConnection() {
+        this.mysqlConnection.connect();
+    }
+    closeConnection() {
+        this.mysqlConnection.end();
+    }
+}
+exports.ConverterIntegral7 = ConverterIntegral7;
+//# sourceMappingURL=ConverterIntegral7.js.map