@enervance/insight-cim-model 0.0.61 → 0.0.63

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

@@ -0,0 +1,1427 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DLConverterI7 = void 0;
+const integral_sql_1 = require("../sql/integral.sql");
+const Diagram_1 = require("../../../model/diagram/Diagram");
+const utils_1 = require("../../../util/utils");
+const OrientationKind_1 = require("../../../model/diagram/OrientationKind");
+const cim_constants_1 = require("../../../constants/cim-constants");
+const DiagramStyle_1 = require("../../../model/diagram/DiagramStyle");
+const perf_hooks_1 = require("perf_hooks");
+const util_functions_1 = require("../model/dl-utils/util-functions");
+const constants_1 = require("../model/dl-utils/constants");
+const DiagramObject_1 = require("../../../model/diagram/DiagramObject");
+const DiagramObjectPoint_1 = require("../../../model/diagram/DiagramObjectPoint");
+const utils_schema_1 = require("../utils-schema");
+const data_types_1 = require("./db/data.types");
+const ConnectivityNode_1 = require("../../../model/core/ConnectivityNode");
+const ConductingEquipment_1 = require("../../../model/core/ConductingEquipment");
+const BusbarSection_1 = require("../../../model/wires/BusbarSection");
+const ACLineSegment_1 = require("../../../model/wires/ACLineSegment");
+const ModelContainer_1 = require("../../../model-container/model/ModelContainer");
+class DLConverterI7 {
+    /** key: VariantenNr (integral7) | value: corresponding diagram */
+    static variantenNr2Diagram = new Map();
+    /** key: Data-Type | value: Array of JSON-stringified I7SchemaKeyObjects */
+    static type2i7IDs = new Map();
+    /** key: JSON-stringified I7SchemaKeyObject | value: CimUUIDsEntry */
+    static i7ID2cimUUIDs = new Map();
+    /** key: JSON-stringified I7SchemaKeyObject | value: Data-Type */
+    static i7ID2Type = new Map();
+    /** key: JSON-stringified I7SchemaKeyObject | value: schema database object (integral) */
+    static i7ID2DbNsgObject = new Map();
+    /** key: uuid of cim-net object or diagram object | value: JSON-stringified I7SchemaKeyObject */
+    static cimUUID2i7ID = new Map();
+    static cimUUID2Object = new Map();
+    static cimUUID2DiagramObject = new Map();
+    i7TableName2Table;
+    mysqlController;
+    logger;
+    activeDiagram;
+    inputArgs;
+    /** key: JSON-stringified I7SchemaKeyObject | value: schema database object (integral) */
+    static i7ID2DbNsgObjectInFrame = new Map();
+    /** this flag is being used for testings, so that the data is not being purged and can be simply checked afterwards */
+    static purgeData = true;
+    static cimModelObjects = new ModelContainer_1.ModelContainer();
+    constructor() {
+    }
+    static addCimObjects(...objs) {
+        for (const obj of objs) {
+            DLConverterI7.cimUUID2Object.set(obj.getUUID(), obj);
+            if (obj instanceof DiagramObject_1.DiagramObject) {
+                DLConverterI7.cimUUID2Object.set(obj.getIdentifiedObjectUUID(), obj);
+                DLConverterI7.cimUUID2DiagramObject.set(obj.getUUID(), obj);
+                DLConverterI7.cimUUID2DiagramObject.set(obj.getIdentifiedObjectUUID(), obj);
+            }
+        }
+    }
+    static getCimObjectByUUID(uuid) {
+        return DLConverterI7.cimUUID2Object.get(uuid);
+    }
+    static getDiagramObjectByUUID(uuid) {
+        return DLConverterI7.cimUUID2DiagramObject.get(uuid);
+    }
+    static createSchemaKeyObject(arg) {
+        return JSON.stringify(arg);
+    }
+    static parseSchemaKeyObject(key) {
+        return JSON.parse(key);
+    }
+    static addIDsRelationMapping(i7ID, cimUUIDs) {
+        DLConverterI7.i7ID2cimUUIDs.set(i7ID, cimUUIDs);
+        if (cimUUIDs.identifiedObjectUUID) {
+            DLConverterI7.cimUUID2i7ID.set(cimUUIDs.identifiedObjectUUID, i7ID);
+        }
+        if (cimUUIDs.diagramObjectUUID) {
+            DLConverterI7.cimUUID2i7ID.set(cimUUIDs.diagramObjectUUID, i7ID);
+        }
+    }
+    static addID2TypeMapping(i7ID, tpe) {
+        DLConverterI7.i7ID2Type.set(i7ID, tpe);
+        if (!DLConverterI7.type2i7IDs.has(tpe)) {
+            DLConverterI7.type2i7IDs.set(tpe, []);
+        }
+        DLConverterI7.type2i7IDs.get(tpe).push(i7ID);
+    }
+    static addID2DbNsgObjectMapping(i7ID, dbNsgObject) {
+        DLConverterI7.i7ID2DbNsgObject.set(i7ID, dbNsgObject);
+        DLConverterI7.i7ID2DbNsgObjectInFrame.set(i7ID, dbNsgObject);
+    }
+    static getDbNsgObjectByID(i7ID) {
+        return DLConverterI7.i7ID2DbNsgObject.get(i7ID);
+    }
+    cleanUp() {
+        DLConverterI7.i7ID2DbNsgObjectInFrame.clear();
+        DLConverterI7.variantenNr2Diagram.clear();
+        // TODO cleanup every relevant map
+        if (!DLConverterI7.purgeData)
+            return;
+        // i7ID2cimUUIDs no clear cause of: lines
+        // i7ID2DbNsgObject no clear cause of: lines
+        // i7ID2Type no clear cause of: lines
+        DLConverterI7.type2i7IDs.clear();
+        DLConverterI7.cimUUID2i7ID.clear();
+        DLConverterI7.cimUUID2Object.clear();
+    }
+    prepare(mysqlController, logger) {
+        this.mysqlController = mysqlController;
+        this.logger = logger;
+    }
+    static getI7ID2DiagramObjectMap() {
+        const i7ID2DiagramObjectMap = new Map();
+        for (const i7ID2cimUUIDsEntry of DLConverterI7.i7ID2cimUUIDs.entries()) {
+            const diagramObject = DLConverterI7.cimUUID2DiagramObject.get(i7ID2cimUUIDsEntry[1].diagramObjectUUID);
+            i7ID2DiagramObjectMap.set(i7ID2cimUUIDsEntry[0], diagramObject);
+        }
+        return i7ID2DiagramObjectMap;
+    }
+    addCimObjects2Model(cimModel) {
+        for (const entry of DLConverterI7.cimUUID2Object.entries()) {
+            if (entry[1] instanceof Diagram_1.Diagram) {
+                cimModel.addDiagram(entry[1]);
+            }
+            else if (entry[1] instanceof DiagramObject_1.DiagramObject) {
+                cimModel.addDiagramObject(entry[1]);
+            }
+        }
+    }
+    async convert(availableTablesWithColumnNames, onlyEingeblendet, args) {
+        this.inputArgs = args;
+        this.inputArgs.objects.forEach((value, key) => DLConverterI7.cimModelObjects.objects.set(key, value));
+        this.i7TableName2Table = new Map();
+        availableTablesWithColumnNames.forEach((value, key) => {
+            this.i7TableName2Table.set(key, { tableName: key, columnNames: value });
+        });
+        await this.runAndLogPerformance(this.convertNsgVarianten);
+        let a = 0;
+        for (const entry of DLConverterI7.variantenNr2Diagram.entries()) {
+            ++a;
+            const variantenNr = entry[0];
+            this.activeDiagram = entry[1];
+            this.logger.debug(`Starte Konvertierung von Schema ${variantenNr} [${a}/${DLConverterI7.variantenNr2Diagram.size}]`);
+            console.log(`Starte Konvertierung von Schema ${variantenNr} [${a}/${DLConverterI7.variantenNr2Diagram.size}]`);
+            const startTime = perf_hooks_1.performance.now();
+            const ret_val = await this.convertSchemaStandorte(variantenNr, onlyEingeblendet, args.standortIDs);
+            this.logger.debug(`convertSchemaStandorte ${(perf_hooks_1.performance.now() - startTime) / 1000} seconds`);
+            console.log(`convertSchemaStandorte ${(perf_hooks_1.performance.now() - startTime) / 1000} seconds`);
+            if (ret_val) {
+                await this.runAndLogPerformance(this.convertSchemaStandorte, variantenNr, onlyEingeblendet, args.standortIDs);
+                await this.runAndLogPerformance(this.convertSchemaKnotenSo, variantenNr, onlyEingeblendet, args.knotenSoIDs);
+                await this.runAndLogPerformance(this.convertSchemaSchaltanlage, variantenNr, onlyEingeblendet, args.schaltanlagenIDs);
+                await this.runAndLogPerformance(this.convertSchemaSchaltanlagenAbschnitte, variantenNr, onlyEingeblendet, args.schaltanlagenAbschnittIDs);
+                await this.runAndLogPerformance(this.convertSchemaSammelschienenAbschnitte, variantenNr, onlyEingeblendet, args.schaltanlagenAbschnittIDs);
+                await this.runAndLogPerformance(this.convertSchemaSchaltfeldElemente, variantenNr, onlyEingeblendet, args.schaltfeldIDs);
+                await this.runAndLogPerformance(this.convertSchemaQuerkupplungen, variantenNr, onlyEingeblendet, args.querkupplungIDs);
+                await this.runAndLogPerformance(this.convertSchemaLaengskupplungen, variantenNr, onlyEingeblendet, args.laengskupplungIDs);
+                await this.runAndLogPerformance(this.convertSchemaTransformatoren2W, variantenNr, onlyEingeblendet, args.powerTransformers);
+                await this.runAndLogPerformance(this.convertSchemaTransformatoren3W, variantenNr, onlyEingeblendet, args.powerTransformers);
+                await this.runAndLogPerformance(this.convertSchemaLeitungen, variantenNr, onlyEingeblendet);
+                await this.runAndLogPerformance(this.convertSchemaQuerzweige, variantenNr, onlyEingeblendet);
+                await this.runAndLogPerformance(this.convertSchemaTerminals);
+            }
+        }
+    }
+    async convertNsgVarianten() {
+        if (this.isTableAvailable(integral_sql_1.Integral7TableNames.NETZVARIANTEN)) {
+            const result = await this.mysqlController.execQuery((0, integral_sql_1.getI7Query)(integral_sql_1.I7Objects.NETZVARIANTEN, this.getAvailableColumnNames(integral_sql_1.Integral7TableNames.NETZVARIANTEN), [2]));
+            for (const i7Data of result) {
+                const diagram = new Diagram_1.Diagram((0, utils_1.getUUID)(i7Data.guid), i7Data.name, String(i7Data.id));
+                diagram.orientation = OrientationKind_1.OrientationKind.negative;
+                diagram.diagramStyle = new DiagramStyle_1.DiagramStyle((0, utils_1.generateUUID)(), cim_constants_1.DIAGRAM_LAYOUT_TYPES.NODE_BREAKER);
+                DLConverterI7.addCimObjects(diagram);
+                DLConverterI7.variantenNr2Diagram.set(i7Data.id, diagram);
+            }
+        }
+        else {
+            this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.NETZVARIANTEN} ist nicht vorhanden.`);
+        }
+    }
+    /** Register the NsgObject and perform a type mapping. Returns a SchemaKeyObject*/
+    static registerNsgObjectAndGetSchemaKay(i7Data, type, keyObject) {
+        const schemaObjKey = DLConverterI7.createSchemaKeyObject(keyObject === undefined ?
+            { i7ID: i7Data.id, variantenNr: i7Data.variantennr }
+            : keyObject);
+        DLConverterI7.addID2TypeMapping(schemaObjKey, type);
+        DLConverterI7.addID2DbNsgObjectMapping(schemaObjKey, i7Data);
+        return schemaObjKey;
+    }
+    async convertSchemaStandorte(variantenNr, onlyEingeblendet, standortIDs) {
+        if (this.isTableAvailable(integral_sql_1.Integral7TableNames.NSG_STANDORT) && standortIDs.length > 0) {
+            const result = await this.mysqlController.execQuery((0, integral_sql_1.getI7Query)(integral_sql_1.I7Objects.NSG_STANDORT, this.getAvailableColumnNames(integral_sql_1.Integral7TableNames.NSG_STANDORT), standortIDs));
+            const filteredResults = util_functions_1.DLUtilFunctions.filterByVariantenNrOnlyEingeblendet(result, variantenNr, onlyEingeblendet);
+            for (const i7Data of filteredResults) {
+                DLConverterI7.registerNsgObjectAndGetSchemaKay(i7Data, data_types_1.DataTypes.NSG_STANDORT);
+            }
+            return filteredResults.length > 0;
+        }
+        return false;
+    }
+    async convertSchemaKnotenSo(variantenNr, onlyEingeblendet, knotenSoIDs) {
+        if (this.isTableAvailable(integral_sql_1.Integral7TableNames.NSG_KNOTEN_SO) && knotenSoIDs.length > 0) {
+            const result = await this.mysqlController.execQuery((0, integral_sql_1.getI7Query)(integral_sql_1.I7Objects.NSG_KNOTEN_SO, this.getAvailableColumnNames(integral_sql_1.Integral7TableNames.NSG_KNOTEN_SO), knotenSoIDs));
+            const filteredResults = util_functions_1.DLUtilFunctions.filterByVariantenNrOnlyEingeblendet(result, variantenNr, onlyEingeblendet);
+            for (const i7Data of filteredResults) {
+                const schemaObjKey = DLConverterI7.registerNsgObjectAndGetSchemaKay(i7Data, integral_sql_1.Integral7TableNames.NSG_KNOTEN_SO);
+                const nsgStandortObjKey = DLConverterI7.createSchemaKeyObject({ i7ID: i7Data.nsgso, variantenNr });
+                const nsgStandort = DLConverterI7.getDbNsgObjectByID(nsgStandortObjKey);
+                if (nsgStandort === undefined) {
+                    continue;
+                }
+                const cimObjectUUID = this.inputArgs.integralID2UUID.get(i7Data.knotenso);
+                const width = constants_1.NsgConstants.KNOTENSO_WIDTH;
+                const height = constants_1.NsgConstants.KNOTENSO_HEIGHT;
+                const xParentRel = nsgStandort.xrel;
+                const yParentRel = nsgStandort.yrel;
+                const diagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                    xPosition: xParentRel + i7Data.xrel + (width / 2),
+                    yPosition: yParentRel + i7Data.yrel + (height / 2),
+                    diagramObjectName: 'Abzweig',
+                    identifiedObjectUUID: cimObjectUUID,
+                    diagramUUID: this.activeDiagram.getUUID()
+                });
+                DLConverterI7.addIDsRelationMapping(schemaObjKey, {
+                    identifiedObjectUUID: cimObjectUUID,
+                    diagramObjectUUID: diagramObject.getUUID()
+                });
+                DLConverterI7.addCimObjects(diagramObject);
+            }
+        }
+        else {
+            this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.NSG_KNOTEN_SO} ist nicht vorhanden.`);
+        }
+    }
+    async convertSchemaSchaltanlage(variantenNr, onlyEingeblendet, schaltanlagenIDs) {
+        if (this.isTableAvailable(integral_sql_1.Integral7TableNames.NSG_SCHALTANLAGE) && schaltanlagenIDs.length > 0) {
+            const result = await this.mysqlController.execQuery((0, integral_sql_1.getI7Query)(integral_sql_1.I7Objects.NSG_SCHALTANLAGE, this.getAvailableColumnNames(integral_sql_1.Integral7TableNames.NSG_SCHALTANLAGE), schaltanlagenIDs));
+            const filteredResults = util_functions_1.DLUtilFunctions.filterByVariantenNrOnlyEingeblendet(result, variantenNr, onlyEingeblendet);
+            for (const i7Data of filteredResults) {
+                DLConverterI7.registerNsgObjectAndGetSchemaKay(i7Data, integral_sql_1.Integral7TableNames.NSG_SCHALTANLAGE);
+            }
+        }
+        else {
+            this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.NSG_SCHALTANLAGE} ist nicht vorhanden.`);
+        }
+    }
+    async convertSchemaSchaltanlagenAbschnitte(variantenNr, onlyEingeblendet, schaltanlagenabschnittIDs) {
+        if (this.isTableAvailable(integral_sql_1.Integral7TableNames.NSG_SCHALTANLAGENABSCHNITT) && schaltanlagenabschnittIDs.length > 0) {
+            const result = await this.mysqlController.execQuery((0, integral_sql_1.getI7Query)(integral_sql_1.I7Objects.NSG_SCHALTANLAGENABSCHNITT, this.getAvailableColumnNames(integral_sql_1.Integral7TableNames.NSG_SCHALTANLAGENABSCHNITT), schaltanlagenabschnittIDs));
+            const filteredResults = util_functions_1.DLUtilFunctions.filterByVariantenNrOnlyEingeblendet(result, variantenNr, onlyEingeblendet);
+            for (const i7Data of filteredResults) {
+                const schemaObjKey = DLConverterI7.registerNsgObjectAndGetSchemaKay(i7Data, integral_sql_1.Integral7TableNames.NSG_SCHALTANLAGENABSCHNITT);
+                const nsgSchaltanlageObjKey = DLConverterI7.createSchemaKeyObject({ i7ID: i7Data.nsgsa, variantenNr });
+                const nsgSchaltanlage = DLConverterI7.getDbNsgObjectByID(nsgSchaltanlageObjKey);
+                if (nsgSchaltanlage) {
+                    if (nsgSchaltanlage.saabschnittIDs === undefined) {
+                        nsgSchaltanlage.saabschnittIDs = [];
+                    }
+                    nsgSchaltanlage.saabschnittIDs.push(schemaObjKey);
+                    if (nsgSchaltanlage.nsgSaabs === undefined) {
+                        nsgSchaltanlage.nsgSaabs = [];
+                    }
+                    nsgSchaltanlage.nsgSaabs.push(i7Data);
+                }
+            }
+        }
+        else {
+            this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.NSG_SCHALTANLAGENABSCHNITT} ist nicht vorhanden.`);
+        }
+    }
+    async convertSchemaSammelschienenAbschnitte(variantenNr, onlyEingeblendet, schaltanlagenabschnittIDs) {
+        if (schaltanlagenabschnittIDs.length <= 0)
+            return;
+        /* Hinweis: => eingeblendet - ausgeblendet
+        Die wahre Länge eines SSAbschnitts steht nicht in dem Längenattribut 'nsg_nsgsaab.laenge'
+        sondern muss über die nsg_nsgschaltfeld-Tabelle ermittelt werden.
+        Der Längen-Wert von 'nsg_nsgsaab.laenge' bezieht sich auf die Länge mit allen eingeblendeten Attributen
+         */
+        const isEingeblendet = 1;
+        /* BEGIN: Select-Statement zum ermitteln der maximalen Slotnummer bezogen auf spezifische Schaltanlagen und Schaltfelder */
+        let sqlSelectGroupedMaxSlotSf = `SELECT nsgsaa AS nsgsaa, max(slotnummer) + 1 AS laenge
+                                     FROM nsg_nsgschaltfeld
+                                     WHERE ((${(0, integral_sql_1.getWhereIDs)('nsgsaa', schaltanlagenabschnittIDs).join(' OR ')}))`;
+        if (onlyEingeblendet) {
+            sqlSelectGroupedMaxSlotSf += ` AND (eingeblendet = ${isEingeblendet} OR (eingeblendet IS NULL AND angezeigt = ${isEingeblendet}))`;
+        }
+        sqlSelectGroupedMaxSlotSf += ` GROUP BY nsgsaa`;
+        const resultsMaxSlotsSf = await this.mysqlController.execQuery(sqlSelectGroupedMaxSlotSf);
+        const mappedResultsMaxSlotsSf = new Map(resultsMaxSlotsSf.map(value => [value.nsgsaa, value.laenge]));
+        /* END: Schaltfelder-SQL (max slotnummer) */
+        /* BEGIN: Select-Statement zum ermitteln der maximalen Slotnummer bezogen auf spezifische Schaltanlagen und Kuppelfelder */
+        let sqlSelectGroupedMaxSlotKpF = `SELECT nsgsaa AS nsgsaa, max(slotnummer) + 1 AS laenge
+                                      FROM nsg_nsgkpfeld
+                                      WHERE ((${(0, integral_sql_1.getWhereIDs)('nsgsaa', schaltanlagenabschnittIDs).join(' OR ')}))`;
+        if (onlyEingeblendet) {
+            sqlSelectGroupedMaxSlotKpF += ` AND (eingeblendet = ${isEingeblendet} OR (eingeblendet IS NULL AND angezeigt = ${isEingeblendet}))`;
+        }
+        sqlSelectGroupedMaxSlotKpF += ` GROUP BY nsgsaa`;
+        const resultsMaxSlotsKpF = await this.mysqlController.execQuery(sqlSelectGroupedMaxSlotKpF);
+        const mappedResultsMaxSlotsKpF = new Map(resultsMaxSlotsKpF.map(value => [value.nsgsaa, value.laenge]));
+        /* END: Kuppelfelder-SQL (max slotnummer) */
+        const sqlStatement = `SELECT nsg_nsgsaab.variantennr,
+              nsg_nsgsaab.id,
+              nsg_nsgsaab.laenge AS laenge,
+              nsg_nsgsaab.nslots,
+              nsg_nsgsaab.saabschnitt,
+              nsg_nsgsaab.nsgsa,
+              nsg_nsgsaab.angezeigt,
+              nsg_nsgsaab.eingeblendet,
+              nsg_nsgsaab.nsglkp,
+              netz_ssab.pos      AS posSSAB,
+              netz_ssab.id       AS idSSAB
+       FROM netz_ssab
+                LEFT JOIN nsg_nsgsaabschnitt AS nsg_nsgsaab ON nsg_nsgsaab.saabschnitt = netz_ssab.saabschnitt
+       WHERE (${(0, integral_sql_1.getWhereIDs)('nsg_nsgsaab.saabschnitt', schaltanlagenabschnittIDs).join(' OR ')});`;
+        const queryResults = await this.mysqlController.execQuery(sqlStatement);
+        queryResults.forEach(value => {
+            value.laenge = Math.max((mappedResultsMaxSlotsSf.get(value.id) || 0), (mappedResultsMaxSlotsKpF.get(value.id) || 0), value.laenge);
+        });
+        const filteredResults = util_functions_1.DLUtilFunctions.filterByVariantenNrOnlyEingeblendet(queryResults, variantenNr, onlyEingeblendet);
+        for (const i7Data of filteredResults) {
+            const schemaObjKey = DLConverterI7.registerNsgObjectAndGetSchemaKay(i7Data, data_types_1.DataTypes.NSG_SSAB, { i7ID: i7Data.idSSAB, variantenNr, additionalIDs: [i7Data.nsgsa] });
+            const nsgSchaltanlageObjKey = DLConverterI7.createSchemaKeyObject({ i7ID: i7Data.nsgsa, variantenNr });
+            const nsgSa = DLConverterI7.getDbNsgObjectByID(nsgSchaltanlageObjKey);
+            if (nsgSa === undefined)
+                continue;
+            const nsgStandortObjKey = DLConverterI7.createSchemaKeyObject({ i7ID: nsgSa.nsgso, variantenNr });
+            const nsgSo = DLConverterI7.getDbNsgObjectByID(nsgStandortObjKey);
+            // Standort ist vermutlich ausgeblendet und daher undefined. Exportiere deshalb die Sammelschienen bezogen auf die Schaltanlage auch nicht
+            if (nsgSo === undefined)
+                continue;
+            // Sammelschienen sind in einem Grid angeordnet basierend auf den Positionswerten in
+            // der Netz-Abschnitts- und -Sammelschienentabelle
+            const leftOffset = i7Data.nslots * constants_1.NsgConstants.HORIZONTAL_OFFSET;
+            const topOffset = i7Data.posSSAB * constants_1.NsgConstants.VERTICAL_OFFSET;
+            const ssabLength = i7Data.laenge * constants_1.NsgConstants.HORIZONTAL_OFFSET;
+            let pointTopLeft = new DiagramObjectPoint_1.DiagramObjectPoint(leftOffset, topOffset, 1);
+            let pointBottomRight = new DiagramObjectPoint_1.DiagramObjectPoint(leftOffset + ssabLength, topOffset, 2);
+            // let pointTopLeft = new DiagramObjectPoint(0, topOffset, 1);
+            // let pointBottomRight = new DiagramObjectPoint(ssabLength, topOffset, 2);
+            let saabShiftOffset = 0;
+            for (const tempNsgSaab of nsgSa.nsgSaabs) {
+                saabShiftOffset = saabShiftOffset < (tempNsgSaab.nslots + tempNsgSaab.laenge) ? (tempNsgSaab.nslots + tempNsgSaab.laenge) : saabShiftOffset;
+            }
+            // Extrahiere Punkte
+            const points = [];
+            points.push(pointTopLeft, pointBottomRight);
+            // Variablen für das eventuelle Shiften basierend auf SA-Ausrichtung
+            for (const p of points) {
+                util_functions_1.DLUtilFunctions.rotateDiagramObjectPoint(p, -90 * nsgSa.ausrichtung);
+                p.xPosition += nsgSo.xrel + nsgSa.xrel + (nsgSa.ausrichtung === 2 ? saabShiftOffset * constants_1.NsgConstants.HORIZONTAL_OFFSET : 0);
+                p.yPosition += nsgSo.yrel + nsgSa.yrel + (nsgSa.ausrichtung === 3 ? saabShiftOffset * constants_1.NsgConstants.HORIZONTAL_OFFSET : 0);
+            }
+            // Erstelle CIM-Objekte
+            const cimObjectUUID = this.inputArgs.integralID2UUID.get(i7Data.idSSAB);
+            const diagramObject = new DiagramObject_1.DiagramObject((0, utils_1.generateUUID)(), 'SSAB Diagram');
+            diagramObject.diagramUUID = this.activeDiagram.getUUID();
+            diagramObject.identifiedObjectUUID = cimObjectUUID;
+            diagramObject.rotation = util_functions_1.DLUtilFunctions.getRotationBasedOnNsgSa(nsgSa.ausrichtung);
+            (0, utils_schema_1.copyDiagramObjectPoints)(diagramObject, points);
+            DLConverterI7.addIDsRelationMapping(schemaObjKey, {
+                identifiedObjectUUID: cimObjectUUID,
+                diagramObjectUUID: diagramObject.getUUID()
+            });
+            DLConverterI7.addCimObjects(diagramObject);
+            const nsgSAABObjKey = DLConverterI7.createSchemaKeyObject({ i7ID: i7Data.id, variantenNr });
+            const nsgSAAB = DLConverterI7.getDbNsgObjectByID(nsgSAABObjKey);
+            if (nsgSAAB.nsgSsabs === undefined) {
+                nsgSAAB.nsgSsabs = [];
+            }
+            nsgSAAB.nsgSsabs.push(i7Data);
+        }
+    }
+    async convertSchemaSchaltfeldElemente(variantenNr, onlyEingeblendet, schaltfeldIDs) {
+        if (this.isTableAvailable(integral_sql_1.Integral7TableNames.NSG_SCHALTFELD) && schaltfeldIDs.length > 0) {
+            /* Pruefe anhand der Tabellennamen, ob die relevanten Tabellen verfuegbar sind */
+            const i7relevantTables = [
+                integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.LEISTUNGSSCHALTER],
+                integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.TRENNER_3P],
+                integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.TRENNERFI_3P],
+                integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.KNOTEN_STARR]
+            ];
+            const i7checkedTables = this.filterTablesByAvailability(i7relevantTables);
+            const i7knotenBeziehungen = await this.mysqlController.execQuery((0, integral_sql_1.getI7KnotenBeziehungenQuery)(i7checkedTables, schaltfeldIDs));
+            const queryStr = (0, integral_sql_1.getI7Query)(integral_sql_1.I7Objects.NSG_SCHALTFELD, this.getAvailableColumnNames(integral_sql_1.Integral7TableNames.NSG_SCHALTFELD), schaltfeldIDs);
+            const resultsNsgSchaltfeld = await this.mysqlController.execQuery(queryStr);
+            const filteredResultsNsgSchaltfeld = util_functions_1.DLUtilFunctions.filterByVariantenNrOnlyEingeblendet(resultsNsgSchaltfeld, variantenNr, onlyEingeblendet);
+            for (const i7Data of filteredResultsNsgSchaltfeld) {
+                DLConverterI7.registerNsgObjectAndGetSchemaKay(i7Data, integral_sql_1.Integral7TableNames.NSG_SCHALTFELD);
+                // Es kann vorkommen, dass der Standort einer Sammelschiene bzw. einer Schaltanlage nicht eingeblendet ist.
+                // Dadurch wird die Sammelschiene bzw. die Schaltanlage nicht exportiert und deshalb existiert das Referenz-Objekt nsgSSAB nicht
+                // Das Schaltfeld kann somit ebenfalls nicht exportiert werden und wird übersprungen
+                const nsgSaabObjKey = DLConverterI7.createSchemaKeyObject({ i7ID: i7Data.nsgsaa, variantenNr });
+                const nsgSAAB = DLConverterI7.getDbNsgObjectByID(nsgSaabObjKey);
+                if (nsgSAAB === undefined)
+                    continue;
+                const nsgSchaltanlageObjKey = DLConverterI7.createSchemaKeyObject({ i7ID: nsgSAAB.nsgsa, variantenNr });
+                const nsgSchaltanlage = DLConverterI7.getDbNsgObjectByID(nsgSchaltanlageObjKey);
+                if (nsgSchaltanlage === undefined)
+                    continue;
+                const nsgStandortObjKey = DLConverterI7.createSchemaKeyObject({ i7ID: nsgSchaltanlage.nsgso, variantenNr });
+                const nsgStandort = DLConverterI7.getDbNsgObjectByID(nsgStandortObjKey);
+                if (nsgStandort === undefined)
+                    continue;
+                // Sammlung der Knoten anhand der i7IDs mit deren Punkten
+                const nodePointMap = new Map();
+                const schaltfeldLeftOffset = i7Data.slotnummer * constants_1.NsgConstants.HORIZONTAL_OFFSET;
+                /*
+                Deltaausrichtung steht in Beziehung zur Schaltanlagen-Ausrichtung gemäß:
+                -> Schaltanlagen-Ausrichtung = 0 => Schaltanlage ist horizontal nach rechts platziert
+                => Deltaausrichtung = 0 => Schaltfeld ist nach oben ausgerichtet
+                => Deltaausrichtung = 1 => Schaltfeld ist nach unten ausgerichten
+        
+                Schaltfelder werden mit der Schaltanlagen-Ausrichtungen gedreht
+                 */
+                const schaltfeldDeltaausrichtung = i7Data.deltaausrichtung;
+                // Extrahiere nur die relevanten Knoten, die sich in dem aktuellen Schaltfeld befinden
+                const schaltfeldI7KnotenBeziehungen = i7knotenBeziehungen.filter(elem => elem.seliste === i7Data.schaltfeld);
+                let shiftFromBusbar = false;
+                if (schaltfeldI7KnotenBeziehungen.length == 1) {
+                    shiftFromBusbar = true;
+                }
+                const ssabs = this.inputArgs.integralSchaltfelder.get(i7Data.schaltfeld).saabschnitt.ssab;
+                const maxSSabPos = Math.max(...ssabs.map(ssab => ssab.pos));
+                const onSSabNodes = schaltfeldI7KnotenBeziehungen.filter(elem => ssabs.find(ssab => ssab.id === elem.aknoten) !== undefined);
+                const xPos = schaltfeldLeftOffset + (constants_1.NsgConstants.HORIZONTAL_OFFSET / 2);
+                let lastNode = undefined;
+                for (const node of onSSabNodes) {
+                    const nsgSSABObjKey = DLConverterI7.createSchemaKeyObject({
+                        i7ID: node.aknoten,
+                        variantenNr,
+                        additionalIDs: [nsgSAAB.nsgsa]
+                    });
+                    const nsgSsab = DLConverterI7.getDbNsgObjectByID(nsgSSABObjKey);
+                    const ssabYPos = nsgSsab.posSSAB * constants_1.NsgConstants.VERTICAL_OFFSET;
+                    // Starte yStackPos bei 1 und ssabOffset daher bei 0, wenn schaltfeldDeltaausrichtung = 0
+                    let yStackPos = 1;
+                    let prevNode = null;
+                    let crtNode = node;
+                    while (crtNode) {
+                        if (nodePointMap.get(crtNode.id) === undefined) {
+                            // Initiale Werte sind: x => Schaltfeld Position; y => Sammelschienen Position
+                            // let xPos = schaltfeldLeftOffset + (NsgConstants.HORIZONTAL_OFFSET / 2);
+                            let yPos = ssabYPos;
+                            // Falls der Knoten ein initialer Knoten ist, hängt er mit einer Sammelschiene zusammen und muss anders platziert werden
+                            if (crtNode === node) {
+                                yPos += shiftFromBusbar ? (schaltfeldDeltaausrichtung === 0 ? -1 : 1) * constants_1.NsgConstants.VERTICAL_OFFSET : 0;
+                            }
+                            else {
+                                const ssabOffset = schaltfeldDeltaausrichtung === 0 ? 0 : maxSSabPos;
+                                yPos = ((schaltfeldDeltaausrichtung === 0 ? -1 : 1) * (yStackPos) + ssabOffset) * constants_1.NsgConstants.VERTICAL_OFFSET;
+                                yStackPos += 1;
+                            }
+                            nodePointMap.set(crtNode.id, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(xPos, yPos, schaltfeldDeltaausrichtung * 180));
+                            // BEGIN: ConnectivityNode-Support
+                            // Platziere die ConnectivityNodes (abgesehen von denjenigen, die auf eine Sammelschiene verweisen)
+                            const aKnotenUUID = this.inputArgs.integralID2UUID.get(crtNode.aknoten);
+                            if (!DLConverterI7.cimUUID2Object.has(aKnotenUUID) && !nodePointMap.has(crtNode.aknoten)) {
+                                let prevNodeY = (prevNode !== null && nodePointMap.get(prevNode.id) !== undefined) ? nodePointMap.get(prevNode.id).diagramObjectPoints[0].yPosition : 0;
+                                let yPosAKnoten;
+                                if (prevNode === node) {
+                                    yPosAKnoten = yPos - ((schaltfeldDeltaausrichtung === 0 ? -1 : 1) * constants_1.NsgConstants.VERTICAL_OFFSET) / 2;
+                                }
+                                else {
+                                    yPosAKnoten = (yPos - prevNodeY) / 2 + prevNodeY;
+                                }
+                                nodePointMap.set(crtNode.aknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(xPos, yPosAKnoten));
+                            }
+                            // END: ConnectivityNode-Support
+                        }
+                        lastNode = crtNode;
+                        prevNode = crtNode;
+                        crtNode = schaltfeldI7KnotenBeziehungen.find(elem => elem.aknoten === crtNode.eknoten);
+                    }
+                }
+                // BEGIN: ConnectivityNode-Support
+                // Exportiere das ConnectivityNode/den Endpunkt des Schaltfeldes
+                const lastEKnotenUUID = this.inputArgs.integralID2UUID.get(lastNode.eknoten);
+                if (!DLConverterI7.cimUUID2Object.has(lastEKnotenUUID) && !nodePointMap.has(lastNode.eknoten)) {
+                    const yPos = (schaltfeldDeltaausrichtung === 0 ? -1 : 1) * (i7Data.hoehe);
+                    const heightAdjustement = schaltfeldDeltaausrichtung === 0 ? (constants_1.NsgConstants.VERTICAL_OFFSET * (maxSSabPos + 1)) : 0;
+                    nodePointMap.set(lastNode.eknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(xPos, yPos + heightAdjustement));
+                }
+                i7Data.lastNodeID = lastNode.eknoten;
+                i7Data.lastNodeCimUUID = lastEKnotenUUID;
+                i7Data.orientation = nsgSchaltanlage.ausrichtung;
+                if (i7Data.deltaausrichtung === 1) {
+                    i7Data.orientation = (i7Data.orientation + 2) % 4;
+                }
+                // END: ConnectivityNode-Support
+                // BEGIN: Terminal-Support
+                // for (const node of onSSabNodes) {
+                //   let crtNode = node;
+                //   while (crtNode) {
+                //     let aKnotenPos: DiagramObjectPoint = undefined;
+                //     if (crtNode === node) {
+                //       const nsgSSABObjKey = DLConverterI7.createSchemaKeyObject(node.aknoten, variantenNr, nsgSaab.nsgsa);
+                //       const nsgSsab: NsgSSAB = DLConverterI7.requestDbNsgObjectByID(nsgSSABObjKey);
+                //       aKnotenPos = new DiagramObjectPoint(xPos, nsgSsab.posSSAB * NsgConstants.VERTICAL_OFFSET);
+                //     }
+                //     DLUtilFunctions.exportTerminals(crtNode, nodePointMap, uuidPointsMap, cimModel, this.integralID2UUID, aKnotenPos);
+                //
+                //     crtNode = schaltfeldI7KnotenBeziehungen.find(elem => elem.aknoten === crtNode.eknoten);
+                //   }
+                // }
+                // END: Terminal-Support
+                // 0 1 2 3 (clockwise rotation)
+                for (const nodePointEntry of nodePointMap.entries()) {
+                    const i7ID = nodePointEntry[0];
+                    const diagramObject = nodePointEntry[1];
+                    if (DLConverterI7.cimUUID2Object.has(diagramObject.getUUID()))
+                        continue;
+                    const cimObjectUUID = this.inputArgs.integralID2UUID.get(i7ID);
+                    diagramObject.identifiedObjectUUID = cimObjectUUID;
+                    diagramObject.rotation = util_functions_1.DLUtilFunctions.getRotationBasedOnNsgSaNsgSf(nsgSchaltanlage.ausrichtung, schaltfeldDeltaausrichtung);
+                    diagramObject.diagramUUID = this.activeDiagram.getUUID();
+                    const schemaObjKey = DLConverterI7.createSchemaKeyObject({ i7ID, variantenNr, additionalIDs: [i7Data.id] });
+                    DLConverterI7.addID2TypeMapping(schemaObjKey, data_types_1.DataTypes.NSG_NODE);
+                    DLConverterI7.addIDsRelationMapping(schemaObjKey, {
+                        identifiedObjectUUID: cimObjectUUID,
+                        diagramObjectUUID: diagramObject.getUUID()
+                    });
+                    DLConverterI7.addCimObjects(diagramObject);
+                }
+                util_functions_1.DLUtilFunctions.rotateAndShiftBasedOnNsgSAA(nsgStandort, nsgSchaltanlage, nsgSAAB, [...nodePointMap.values()], true);
+            }
+        }
+    }
+    async convertSchemaQuerkupplungen(variantenNr, onlyEingeblendet, querkupplungIDs) {
+        if (this.isTableAvailable(integral_sql_1.Integral7TableNames.NSG_QUERKUPPLUNG) && querkupplungIDs.length > 0) {
+            const i7relevantTables = [
+                integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.LEISTUNGSSCHALTER],
+                integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.TRENNER_3P],
+                integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.TRENNERFI_3P],
+                integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.KNOTEN_STARR]
+            ];
+            const i7checkedTables = this.filterTablesByAvailability(i7relevantTables);
+            const i7knotenBeziehungen = await this.mysqlController.execQuery((0, integral_sql_1.getI7KnotenBeziehungenQuery)(i7checkedTables, querkupplungIDs));
+            const resultsNsgKpFeld = await this.mysqlController.execQuery((0, integral_sql_1.getI7Query)(integral_sql_1.I7Objects.NSG_QUERKUPPLUNG, this.getAvailableColumnNames(integral_sql_1.Integral7TableNames.NSG_QUERKUPPLUNG), querkupplungIDs));
+            const filteredResultsNsgKpFeld = util_functions_1.DLUtilFunctions.filterByVariantenNrOnlyEingeblendet(resultsNsgKpFeld, variantenNr, onlyEingeblendet);
+            for (const i7Data of filteredResultsNsgKpFeld) {
+                DLConverterI7.registerNsgObjectAndGetSchemaKay(i7Data, integral_sql_1.Integral7TableNames.NSG_QUERKUPPLUNG);
+                const kpFeldLeftOffset = i7Data.slotnummer * constants_1.NsgConstants.HORIZONTAL_OFFSET;
+                const kpFeldDeltaausrichtung = i7Data.deltaausrichtung;
+                // Extrahiere nur die relevanten Knoten, die sich in der aktuellen Querkupplung befinden
+                const kpFeldI7KnotenBeziehungen = i7knotenBeziehungen.filter(elem => elem.seliste === i7Data.kpfeld);
+                const nsgSAABObjKey = DLConverterI7.createSchemaKeyObject({ i7ID: i7Data.nsgsaa, variantenNr });
+                const nsgSAAB = DLConverterI7.getDbNsgObjectByID(nsgSAABObjKey);
+                if (nsgSAAB === undefined)
+                    continue;
+                const nsgSchaltanlageObjKey = DLConverterI7.createSchemaKeyObject({ i7ID: nsgSAAB.nsgsa, variantenNr });
+                const nsgSchaltanlage = DLConverterI7.getDbNsgObjectByID(nsgSchaltanlageObjKey);
+                if (nsgSchaltanlage === undefined)
+                    continue;
+                const nsgStandortObjKey = DLConverterI7.createSchemaKeyObject({ i7ID: nsgSchaltanlage.nsgso, variantenNr });
+                const nsgStandort = DLConverterI7.getDbNsgObjectByID(nsgStandortObjKey);
+                if (nsgStandort === undefined)
+                    continue;
+                // Ermittle die relevanten SSabIDs
+                const relevantSSabIDs = new Set();
+                nsgSAAB.nsgSsabs.forEach(arg => relevantSSabIDs.add(arg.idSSAB));
+                const ssabKeyIDs = DLConverterI7.type2i7IDs.get(data_types_1.DataTypes.NSG_SSAB);
+                const nsgSSABs = new Map();
+                for (const ssabKeyID of ssabKeyIDs) {
+                    const nsgSSAB = DLConverterI7.i7ID2DbNsgObject.get(ssabKeyID);
+                    nsgSSABs.set(nsgSSAB.idSSAB, nsgSSAB);
+                }
+                const placedCIMObjectUUIDs = new Set(DLConverterI7.cimUUID2Object.keys());
+                const nodePointMap = util_functions_1.DLUtilFunctions.placeKupplung(kpFeldI7KnotenBeziehungen, relevantSSabIDs, nsgSSABs, this.inputArgs.integralID2UUID, placedCIMObjectUUIDs, kpFeldDeltaausrichtung, kpFeldLeftOffset, false, this.inputArgs.objects);
+                for (const nodePointEntry of nodePointMap.entries()) {
+                    const key = nodePointEntry[0];
+                    const value = nodePointEntry[1];
+                    if (DLConverterI7.cimUUID2Object.has(value.getUUID()))
+                        continue;
+                    const cimObjectUUID = this.inputArgs.integralID2UUID.get(key);
+                    value.identifiedObjectUUID = cimObjectUUID;
+                    value.rotation += (util_functions_1.DLUtilFunctions.getRotationBasedOnNsgSa(nsgSchaltanlage.ausrichtung) - 90 + 720);
+                    value.rotation = value.rotation % 360;
+                    value.diagramUUID = this.activeDiagram.getUUID();
+                    const schemaObjKey = DLConverterI7.createSchemaKeyObject({
+                        i7ID: key,
+                        variantenNr,
+                        additionalIDs: [i7Data.id]
+                    });
+                    DLConverterI7.addID2TypeMapping(schemaObjKey, data_types_1.DataTypes.NSG_NODE);
+                    DLConverterI7.addIDsRelationMapping(schemaObjKey, {
+                        identifiedObjectUUID: cimObjectUUID,
+                        diagramObjectUUID: value.getUUID()
+                    });
+                    DLConverterI7.addCimObjects(value);
+                }
+                util_functions_1.DLUtilFunctions.rotateAndShiftBasedOnNsgSAA(nsgStandort, nsgSchaltanlage, nsgSAAB, [...nodePointMap.values()], true);
+            }
+        }
+    }
+    async convertSchemaLaengskupplungen(variantenNr, onlyEingeblendet, laengskupplungIDs) {
+        // const ssabKeyIDs = DLConverterI7.type2i7IDs.get(DataTypes.NSG_SSAB);
+        // if (ssabKeyIDs === undefined) {
+        //   return;
+        // }
+        //
+        // const nsgSSABIDs = new Set<number>();
+        // for (const ssabKeyID of ssabKeyIDs) {
+        //   const nsgSSAB = DLConverterI7.i7ID2DbNsgObject.get(ssabKeyID) as NsgSSAB;
+        //   nsgSSABIDs.add(nsgSSAB.idSSAB);
+        // }
+        const saabKeyIDs = DLConverterI7.type2i7IDs.get(integral_sql_1.Integral7TableNames.NSG_SCHALTANLAGENABSCHNITT);
+        if (saabKeyIDs === undefined) {
+            return;
+        }
+        const nsgSAABIDs = new Set();
+        for (const saabKeyID of saabKeyIDs) {
+            const nsgSAAB = DLConverterI7.i7ID2DbNsgObject.get(saabKeyID);
+            nsgSAABIDs.add(nsgSAAB.id);
+        }
+        // Die Längskupplungen werden primär mittels der Netz-Tabelle (netz_lkupplung) exportiert und nicht über die NSG-Tabelle (nsg_nsglkupplung)
+        if (this.isTableAvailable(integral_sql_1.Integral7TableNames.NSG_LAENGSKUPPLUNG) && laengskupplungIDs.length > 0 && saabKeyIDs.length > 0) {
+            const i7relevantTables = [
+                integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.LEISTUNGSSCHALTER],
+                integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.TRENNER_3P],
+                integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.TRENNERFI_3P],
+                integral_sql_1.Integral7TableNames[integral_sql_1.I7Objects.KNOTEN_STARR]
+            ];
+            const i7checkedTables = this.filterTablesByAvailability(i7relevantTables);
+            const i7knotenBeziehungen = await this.mysqlController.execQuery((0, integral_sql_1.getI7KnotenBeziehungenQuery)(i7checkedTables, laengskupplungIDs));
+            const resultsNsgLKupplung = await this.mysqlController.execQuery((0, integral_sql_1.getI7Query)(integral_sql_1.I7Objects.NSG_LAENGSKUPPLUNG, this.getAvailableColumnNames(integral_sql_1.Integral7TableNames.NSG_LAENGSKUPPLUNG), [...nsgSAABIDs.values()]));
+            const filteredResultsNsgLKupplung = util_functions_1.DLUtilFunctions.filterByVariantenNrOnlyEingeblendet(resultsNsgLKupplung, variantenNr, onlyEingeblendet);
+            for (const i7Data of filteredResultsNsgLKupplung) {
+                DLConverterI7.registerNsgObjectAndGetSchemaKay(i7Data, integral_sql_1.Integral7TableNames.NSG_LAENGSKUPPLUNG);
+                const nsgSAABObjKey = DLConverterI7.createSchemaKeyObject({ i7ID: i7Data.nsgsaa, variantenNr });
+                const nsgSAAB = DLConverterI7.getDbNsgObjectByID(nsgSAABObjKey);
+                if (nsgSAAB === undefined)
+                    continue;
+                const nsgSchaltanlageObjKey = DLConverterI7.createSchemaKeyObject({ i7ID: nsgSAAB.nsgsa, variantenNr });
+                const nsgSchaltanlage = DLConverterI7.getDbNsgObjectByID(nsgSchaltanlageObjKey);
+                if (nsgSchaltanlage === undefined)
+                    continue;
+                const nsgStandortObjKey = DLConverterI7.createSchemaKeyObject({ i7ID: nsgSchaltanlage.nsgso, variantenNr });
+                const nsgStandort = DLConverterI7.getDbNsgObjectByID(nsgStandortObjKey);
+                if (nsgStandort === undefined)
+                    continue;
+                // Sammlung der Knoten, um die CIM-UUID auf die zugehörigen Punkte zu referenzieren
+                //  const uuidPointsMap: Map<string, DiagramObject> = new Map();
+                const nodePointMap = new Map();
+                // Einer NSG-Längskupplung können mehrere Netz-Längskupplungen zugeordnet sein
+                const netzLaengskupplungsObjs = [...this.inputArgs.integralLaengskupplungen.values()].filter(elem => elem.schaltanlagenID === nsgSchaltanlage.schaltanlage);
+                for (const netzLaengskupplungObj of netzLaengskupplungsObjs) {
+                    const lKupplungI7KnotenBeziehungen = i7knotenBeziehungen.filter(elem => elem.seliste === netzLaengskupplungObj.id);
+                    const relevantSsabIDs = new Set();
+                    const nsgSSABs = new Map();
+                    nsgSchaltanlage.nsgSaabs.forEach(iNsgSAAB => iNsgSAAB.nsgSsabs.forEach(iNsgSsab => {
+                        relevantSsabIDs.add(iNsgSsab.idSSAB);
+                        nsgSSABs.set(iNsgSsab.idSSAB, iNsgSsab);
+                    }));
+                    // nsgSAAB.nsgSsabs.forEach(arg => relevantSSabIDs.add(arg.idSSAB));
+                    // const ssabKeyIDs = DLConverterI7.type2i7IDs.get(DataTypes.NSG_SSAB);
+                    // const nsgSSABs = new Map<number, NsgSSAB>();
+                    // for (const ssabKeyID of ssabKeyIDs) {
+                    //   const nsgSSAB = DLConverterI7.i7ID2DbNsgObject.get(ssabKeyID) as NsgSSAB;
+                    //   nsgSSABs.set(nsgSSAB.idSSAB, nsgSSAB);
+                    // }
+                    const placedCIMObjectUUIDs = new Set(DLConverterI7.cimUUID2Object.keys());
+                    const tempNodePointMap = util_functions_1.DLUtilFunctions.placeKupplung(lKupplungI7KnotenBeziehungen, relevantSsabIDs, nsgSSABs, this.inputArgs.integralID2UUID, placedCIMObjectUUIDs, 0, 0, true, this.inputArgs.objects);
+                    tempNodePointMap.forEach((value, key) => nodePointMap.set(key, value));
+                }
+                for (const nodePointEntry of nodePointMap.entries()) {
+                    const key = nodePointEntry[0];
+                    const value = nodePointEntry[1];
+                    if (DLConverterI7.cimUUID2Object.has(value.getUUID()))
+                        continue;
+                    const cimObjectUUID = this.inputArgs.integralID2UUID.get(key);
+                    value.identifiedObjectUUID = cimObjectUUID;
+                    if (value.rotation === undefined) {
+                        value.rotation = util_functions_1.DLUtilFunctions.getRotationBasedOnNsgSa(nsgSchaltanlage.ausrichtung);
+                    }
+                    else {
+                        value.rotation += util_functions_1.DLUtilFunctions.getRotationBasedOnNsgSa(nsgSchaltanlage.ausrichtung);
+                    }
+                    value.diagramUUID = this.activeDiagram.getUUID();
+                    const schemaObjKey = DLConverterI7.createSchemaKeyObject({
+                        i7ID: key,
+                        variantenNr,
+                        additionalIDs: [i7Data.id]
+                    });
+                    DLConverterI7.addID2TypeMapping(schemaObjKey, data_types_1.DataTypes.NSG_NODE);
+                    DLConverterI7.addIDsRelationMapping(schemaObjKey, {
+                        identifiedObjectUUID: cimObjectUUID,
+                        diagramObjectUUID: value.getUUID()
+                    });
+                    DLConverterI7.addCimObjects(value);
+                }
+                util_functions_1.DLUtilFunctions.rotateAndShiftBasedOnNsgSAA(nsgStandort, nsgSchaltanlage, nsgSAAB, [...nodePointMap.values()]);
+                //
+                // uuidPointsMap.forEach((entryDiagramObject, key) => {
+                //   if (entryDiagramObject.rotation === undefined) {
+                //     entryDiagramObject.rotation = DLUtilFunctions.getRotationBasedOnNsgSa(nsgSchaltanlage.ausrichtung);
+                //   } else {
+                //     entryDiagramObject.rotation += DLUtilFunctions.getRotationBasedOnNsgSa(nsgSchaltanlage.ausrichtung);
+                //   }
+                // });
+                //
+                // DLUtilFunctions.rotateShiftAddBasedOnNsgSAA(cimModel, integral7, variantenNr, i7Data.nsgsaa, uuidPointsMap);
+                /*
+                // for testing
+                for (const entry of uuidPointsMap.entries()) {
+                  const i7IDs = this.UUID2Integral7ID.get(entry[0]);
+                  if (i7IDs && i7IDs.filter(value => {
+                    return value === 1235 || value === 1236 || value === 1239
+                  }).length > 0) {
+                    console.log(i7IDs)
+                  }
+                }
+                */
+            }
+        }
+    }
+    async convertSchemaTransformatoren2W(variantenNr, onlyEingeblendet, powerTransformers) {
+        const nsgStandortKeyIDs = DLConverterI7.type2i7IDs.get(data_types_1.DataTypes.NSG_STANDORT);
+        if (nsgStandortKeyIDs === undefined) {
+            return;
+        }
+        const nsgStandortIDs = new Set();
+        for (const nsgStandortKeyID of nsgStandortKeyIDs) {
+            const nsgStandort = DLConverterI7.i7ID2DbNsgObject.get(nsgStandortKeyID);
+            nsgStandortIDs.add(nsgStandort.id);
+        }
+        if (this.isTableAvailable(integral_sql_1.Integral7TableNames.NSG_TRAFO2W) && nsgStandortIDs.size > 0) {
+            // Da TrafoIDs nicht im Integral7Model hinterlegt werden, Trafos auf Basis der NsgSO-IDs ermitteln (äuqivalent zu Netz-Trafo2W)
+            const results = await this.mysqlController.execQuery((0, integral_sql_1.getI7Query)(integral_sql_1.I7Objects.NSG_TRAFO2W, this.getAvailableColumnNames(integral_sql_1.Integral7TableNames.NSG_TRAFO2W), [...nsgStandortIDs.values()]));
+            const filteredResults = util_functions_1.DLUtilFunctions.filterByVariantenNrOnlyEingeblendet(results, variantenNr, onlyEingeblendet);
+            for (const i7Data of filteredResults) {
+                const schemaObjKey = DLConverterI7.registerNsgObjectAndGetSchemaKay(i7Data, data_types_1.DataTypes.NSG_TRAFO2W);
+                const nsgStandortObjKey = DLConverterI7.createSchemaKeyObject({ i7ID: i7Data.nsgso, variantenNr });
+                const nsgSo = DLConverterI7.getDbNsgObjectByID(nsgStandortObjKey);
+                if (nsgSo === undefined)
+                    continue;
+                // es wird davon ausgegangen, dass das Terminal 1 = anschlussanf zugeordnet ist
+                // und Terminal 2 = anschlussend zugeordnet ist
+                const powerTransformerUUID = this.inputArgs.integralID2UUID.get(i7Data.trafo2w);
+                const powerTransformer = powerTransformers.get(powerTransformerUUID);
+                if (powerTransformer === undefined)
+                    continue;
+                const terminal1 = powerTransformer.powerTransformerEnd[0]?.terminal;
+                const terminal2 = powerTransformer.powerTransformerEnd[1]?.terminal;
+                const powerTransformerDiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                    xPosition: constants_1.NsgConstants.TRAFO2W_WIDTH / 2,
+                    yPosition: constants_1.NsgConstants.TRAFO2W_HEIGHT / 2,
+                    rotation: util_functions_1.DLUtilFunctions.getRotationBasedOnTrafo2W(i7Data.ausrichtung),
+                    diagramObjectName: 'DiagramObject',
+                    identifiedObjectUUID: powerTransformerUUID,
+                    diagramUUID: this.activeDiagram.getUUID()
+                });
+                const createdDiagramObjects = [];
+                createdDiagramObjects.push(powerTransformerDiagramObject);
+                let terminal1DiagramObject;
+                if (terminal1 !== undefined) {
+                    terminal1DiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                        xPosition: 0,
+                        yPosition: constants_1.NsgConstants.TRAFO2W_HEIGHT / 2,
+                        diagramObjectName: 'DiagramObject',
+                        identifiedObjectUUID: terminal1.getUUID(),
+                        diagramUUID: this.activeDiagram.getUUID()
+                    });
+                    createdDiagramObjects.push(terminal1DiagramObject);
+                }
+                let terminal2DiagramObject;
+                if (terminal2 !== undefined) {
+                    terminal2DiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                        xPosition: constants_1.NsgConstants.TRAFO2W_WIDTH,
+                        yPosition: constants_1.NsgConstants.TRAFO2W_HEIGHT / 2,
+                        diagramObjectName: 'DiagramObject',
+                        identifiedObjectUUID: terminal2.getUUID(),
+                        diagramUUID: this.activeDiagram.getUUID()
+                    });
+                    createdDiagramObjects.push(terminal2DiagramObject);
+                }
+                for (const diagramObject of createdDiagramObjects) {
+                    for (const diagramObjectPoint of diagramObject.diagramObjectPoints) {
+                        util_functions_1.DLUtilFunctions.rotateDiagramObjectPoint(diagramObjectPoint, 90 * i7Data.ausrichtung);
+                        // cause of i7 uses the top-left corner as the default (0,0), the points need to be adjusted after the
+                        // rotation (if negative coordinates occur, they can be flipped into the positive side)
+                        diagramObjectPoint.xPosition = Math.abs(diagramObjectPoint.xPosition);
+                        diagramObjectPoint.yPosition = Math.abs(diagramObjectPoint.yPosition);
+                        diagramObjectPoint.xPosition += i7Data.xrel;
+                        diagramObjectPoint.yPosition += i7Data.yrel;
+                        diagramObjectPoint.xPosition += nsgSo.xrel;
+                        diagramObjectPoint.yPosition += nsgSo.yrel;
+                    }
+                }
+                // add the second DiagramObjectPoints to the DiagramObjects of the terminals (this will then result in the
+                // connection between the PowerTransformerEnd and the ConnectivityNode)
+                if (terminal1 !== undefined) {
+                    const connectivityNodeDiagramObject = DLConverterI7.cimUUID2DiagramObject.get(terminal1.getConnectivityNodeUUID());
+                    if (connectivityNodeDiagramObject !== undefined) {
+                        util_functions_1.DLUtilFunctions.copyAndPushDiagramObjectPoint(terminal1DiagramObject, connectivityNodeDiagramObject.diagramObjectPoints[0]);
+                    }
+                }
+                if (terminal2 !== undefined) {
+                    const connectivityNodeDiagramObject = DLConverterI7.cimUUID2DiagramObject.get(terminal2.getConnectivityNodeUUID());
+                    if (connectivityNodeDiagramObject !== undefined) {
+                        util_functions_1.DLUtilFunctions.copyAndPushDiagramObjectPoint(terminal2DiagramObject, connectivityNodeDiagramObject.diagramObjectPoints[0]);
+                    }
+                }
+                DLConverterI7.addIDsRelationMapping(schemaObjKey, {
+                    identifiedObjectUUID: powerTransformerUUID,
+                    diagramObjectUUID: powerTransformerDiagramObject.getUUID()
+                });
+                DLConverterI7.addCimObjects(powerTransformerDiagramObject);
+            }
+        }
+        else {
+            this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.NSG_TRAFO2W} ist nicht vorhanden.`);
+        }
+    }
+    async convertSchemaTransformatoren3W(variantenNr, onlyEingeblendet, powerTransformers) {
+        const nsgStandortKeyIDs = DLConverterI7.type2i7IDs.get(data_types_1.DataTypes.NSG_STANDORT);
+        if (nsgStandortKeyIDs === undefined) {
+            return;
+        }
+        const nsgStandortIDs = new Set();
+        const netzStandortIDs = new Set();
+        for (const nsgStandortKeyID of nsgStandortKeyIDs) {
+            const nsgStandort = DLConverterI7.i7ID2DbNsgObject.get(nsgStandortKeyID);
+            nsgStandortIDs.add(nsgStandort.id);
+            netzStandortIDs.add(nsgStandort.standort);
+        }
+        if (this.isTableAvailable(integral_sql_1.Integral7TableNames.NSG_TRAFO3W) && nsgStandortIDs.size > 0) {
+            // Da TrafoIDs nicht im Integral7Model hinterlegt werden, Trafos auf Basis der NsgSO-IDs ermitteln (äuqivalent zu Netz-Trafo2W)
+            const results = await this.mysqlController.execQuery((0, integral_sql_1.getI7Query)(integral_sql_1.I7Objects.NSG_TRAFO3W, this.getAvailableColumnNames(integral_sql_1.Integral7TableNames.NSG_TRAFO3W), [...nsgStandortIDs.values()]));
+            const filteredResults = util_functions_1.DLUtilFunctions.filterByVariantenNrOnlyEingeblendet(results, variantenNr, onlyEingeblendet);
+            const netzTrafoResults = await this.mysqlController.execQuery((0, integral_sql_1.getI7Query)(integral_sql_1.I7Objects.TRAFO3W, this.getAvailableColumnNames(integral_sql_1.Integral7TableNames.TRAFO3W), [...netzStandortIDs.values()]));
+            const netzTrafos = new Map(netzTrafoResults.map(obj => [obj.id, obj]));
+            for (const i7Data of filteredResults) {
+                const schemaObjKey = DLConverterI7.registerNsgObjectAndGetSchemaKay(i7Data, data_types_1.DataTypes.NSG_TRAFO3W);
+                const nsgStandortObjKey = DLConverterI7.createSchemaKeyObject({ i7ID: i7Data.nsgso, variantenNr });
+                const nsgSo = DLConverterI7.getDbNsgObjectByID(nsgStandortObjKey);
+                if (nsgSo === undefined)
+                    continue;
+                const powerTransformerUUID = this.inputArgs.integralID2UUID.get(i7Data.trafo3w);
+                const powerTransformer = powerTransformers.get(powerTransformerUUID);
+                if (powerTransformer === undefined)
+                    continue;
+                // Ermittle die default-Zuordnung der Enden zu den Terminals der PowerTransformerEnds
+                const trafo3wNetz = netzTrafos.get(i7Data.trafo3w);
+                if (trafo3wNetz === undefined)
+                    continue;
+                const pteW1 = this.inputArgs.powerTransformerEnds.get(this.inputArgs.integralID2UUID.get(trafo3wNetz.trafowicklung3w1));
+                const pteW2 = this.inputArgs.powerTransformerEnds.get(this.inputArgs.integralID2UUID.get(trafo3wNetz.trafowicklung3w2));
+                const pteW3 = this.inputArgs.powerTransformerEnds.get(this.inputArgs.integralID2UUID.get(trafo3wNetz.trafowicklung3w3));
+                // Der relative Punkt des Transformators ist die linke obere Ecke bezogen auf die Umrandungs-Bounding-Box
+                const trafoDiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(constants_1.NsgConstants.TRAFO3W_WIDTH / 2, constants_1.NsgConstants.TRAFO3W_HEIGHT / 2);
+                const powerTransformerDiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                    xPosition: trafoDiagramObject.diagramObjectPoints[0].xPosition,
+                    yPosition: trafoDiagramObject.diagramObjectPoints[0].yPosition,
+                    rotation: (360 - (constants_1.NsgConstants.TAFO3W_RotationOrder.indexOf(i7Data.ausrichtung) * 30 + 180) % 360) % 360,
+                    diagramObjectName: 'DiagramObject',
+                    identifiedObjectUUID: powerTransformerUUID,
+                    diagramUUID: this.activeDiagram.getUUID()
+                });
+                // Ermittle die Auswechslung der Enden
+                const exchangeGroups = constants_1.NsgConstants.TRAFO3W_ExchangeGroups;
+                let exchangeGroup = undefined;
+                for (const key of Object.keys(exchangeGroups)) {
+                    if (exchangeGroups[key].indexOf(i7Data.ausrichtung) !== -1) {
+                        exchangeGroup = constants_1.NsgConstants.TRAFO3W_ExchangeMap[key];
+                        break;
+                    }
+                }
+                // Ermittle die 'default'-Positionen der Enden ohne Berücksichtigung der Auswechslungen
+                const rotationenGroups = constants_1.NsgConstants.TRAFO3W_RotationGroups;
+                let rotationenGroup = undefined;
+                for (const key of Object.keys(rotationenGroups)) {
+                    if (rotationenGroups[key].indexOf(i7Data.ausrichtung) !== -1) {
+                        rotationenGroup = constants_1.NsgConstants.TRAFO3W_RotationGroup2Positions[key];
+                        break;
+                    }
+                }
+                // Falls eine x-Spiegelung vorliegt, tausche die Werte der Enden 2 und 3 miteinander
+                const xMirroring = i7Data.orientierung_cw === 1;
+                const createdDiagramObjects = [];
+                createdDiagramObjects.push(powerTransformerDiagramObject);
+                let terminal1DiagramObject;
+                if (pteW1?.terminal !== undefined) {
+                    const coords = rotationenGroup[exchangeGroup[1]];
+                    terminal1DiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                        xPosition: coords[0],
+                        yPosition: coords[1],
+                        diagramObjectName: 'DiagramObject',
+                        identifiedObjectUUID: pteW1.terminal.getUUID(),
+                        diagramUUID: this.activeDiagram.getUUID()
+                    });
+                    createdDiagramObjects.push(terminal1DiagramObject);
+                }
+                let terminal2DiagramObject;
+                if (pteW2?.terminal !== undefined) {
+                    const coords = rotationenGroup[exchangeGroup[xMirroring ? 3 : 2]];
+                    terminal2DiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                        xPosition: coords[0],
+                        yPosition: coords[1],
+                        diagramObjectName: 'DiagramObject',
+                        identifiedObjectUUID: pteW2.terminal.getUUID(),
+                        diagramUUID: this.activeDiagram.getUUID()
+                    });
+                    createdDiagramObjects.push(terminal2DiagramObject);
+                }
+                let terminal3DiagramObject;
+                if (pteW3?.terminal !== undefined) {
+                    const coords = rotationenGroup[exchangeGroup[xMirroring ? 2 : 3]];
+                    terminal3DiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                        xPosition: coords[0],
+                        yPosition: coords[1],
+                        diagramObjectName: 'DiagramObject',
+                        identifiedObjectUUID: pteW3.terminal.getUUID(),
+                        diagramUUID: this.activeDiagram.getUUID()
+                    });
+                    createdDiagramObjects.push(terminal3DiagramObject);
+                }
+                for (const diagramObject of createdDiagramObjects) {
+                    for (const diagramObjectPoint of diagramObject.diagramObjectPoints) {
+                        diagramObjectPoint.xPosition += i7Data.xrel;
+                        diagramObjectPoint.yPosition += i7Data.yrel;
+                        diagramObjectPoint.xPosition += nsgSo.xrel;
+                        diagramObjectPoint.yPosition += nsgSo.yrel;
+                    }
+                }
+                if (pteW1?.terminal !== undefined) {
+                    const connectivityNodeDiagramObject = DLConverterI7.cimUUID2DiagramObject.get(pteW1.terminal.getConnectivityNodeUUID());
+                    if (connectivityNodeDiagramObject !== undefined) {
+                        util_functions_1.DLUtilFunctions.copyAndPushDiagramObjectPoint(terminal1DiagramObject, connectivityNodeDiagramObject.diagramObjectPoints[0]);
+                    }
+                }
+                if (pteW2?.terminal !== undefined) {
+                    const connectivityNodeDiagramObject = DLConverterI7.cimUUID2DiagramObject.get(pteW2.terminal.getConnectivityNodeUUID());
+                    if (connectivityNodeDiagramObject !== undefined) {
+                        util_functions_1.DLUtilFunctions.copyAndPushDiagramObjectPoint(terminal2DiagramObject, connectivityNodeDiagramObject.diagramObjectPoints[0]);
+                    }
+                }
+                if (pteW3?.terminal !== undefined) {
+                    const connectivityNodeDiagramObject = DLConverterI7.cimUUID2DiagramObject.get(pteW3.terminal.getConnectivityNodeUUID());
+                    if (connectivityNodeDiagramObject !== undefined) {
+                        util_functions_1.DLUtilFunctions.copyAndPushDiagramObjectPoint(terminal3DiagramObject, connectivityNodeDiagramObject.diagramObjectPoints[0]);
+                    }
+                }
+                DLConverterI7.addIDsRelationMapping(schemaObjKey, {
+                    identifiedObjectUUID: powerTransformerUUID,
+                    diagramObjectUUID: powerTransformerDiagramObject.getUUID()
+                });
+                DLConverterI7.addCimObjects(powerTransformerDiagramObject);
+            }
+        }
+        else {
+            this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.NSG_TRAFO3W} ist nicht vorhanden.`);
+        }
+    }
+    async convertSchemaLeitungen(variantenNr, onlyEingeblendet) {
+        if (this.inputArgs.integralLeitungen === undefined) {
+            this.inputArgs.integralLeitungen = new Map();
+        }
+        if (this.inputArgs.integralHgueLeitungen === undefined) {
+            this.inputArgs.integralHgueLeitungen = new Map();
+        }
+        const leitungIDs = [...this.inputArgs.integralLeitungen.keys(), ...this.inputArgs.integralHgueLeitungen.keys()];
+        if (this.isTableAvailable(integral_sql_1.Integral7TableNames.NSG_LEITUNG) && this.isTableAvailable(integral_sql_1.Integral7TableNames.NSG_LEITUNGSPUNKT) && leitungIDs.length > 0) {
+            const leitungResults = await this.mysqlController.execQuery((0, integral_sql_1.getI7Query)(integral_sql_1.I7Objects.NSG_LEITUNG, this.getAvailableColumnNames(integral_sql_1.Integral7TableNames.NSG_LEITUNG), leitungIDs));
+            let filteredLeitungResults = util_functions_1.DLUtilFunctions.filterByVariantenNrOnlyEingeblendet(leitungResults, variantenNr, onlyEingeblendet);
+            const nsgLeitungIDs = filteredLeitungResults.map(elem => elem.id);
+            if (nsgLeitungIDs.length > 0) {
+                const leitungspktResults = await this.mysqlController.execQuery((0, integral_sql_1.getI7Query)(integral_sql_1.I7Objects.NSG_LEITUNGSPUNKT, this.getAvailableColumnNames(integral_sql_1.Integral7TableNames.NSG_LEITUNGSPUNKT), nsgLeitungIDs));
+                let filteredLeitungspktResults = util_functions_1.DLUtilFunctions.filterByVariantenNrOnlyEingeblendet(leitungspktResults, variantenNr, onlyEingeblendet);
+                for (const i7Data of filteredLeitungResults) {
+                    const schemaObjKey = DLConverterI7.createSchemaKeyObject({ i7ID: i7Data.id, variantenNr });
+                    DLConverterI7.addID2TypeMapping(schemaObjKey, data_types_1.DataTypes.NSG_LEITUNG);
+                    const isACLine = this.inputArgs.integralLeitungen.get(i7Data.leitung);
+                    const isErsatzlaengszweig = false;
+                    let netzLeitungsObject;
+                    if (isACLine) {
+                        const netzLeitung = this.inputArgs.integralLeitungen.get(i7Data.leitung);
+                        if (netzLeitung !== undefined) {
+                            netzLeitungsObject = {
+                                id: netzLeitung.id,
+                                aknotenid: netzLeitung.aknotenid,
+                                eknotenid: netzLeitung.eknotenid
+                            };
+                        }
+                    }
+                    else {
+                        const netzHgueLeitung = this.inputArgs.integralHgueLeitungen.get(i7Data.leitung);
+                        if (netzHgueLeitung !== undefined) {
+                            netzLeitungsObject = {
+                                id: netzHgueLeitung.id,
+                                aknotenid: netzHgueLeitung.anetzobjekt,
+                                eknotenid: netzHgueLeitung.enetzobjekt
+                            };
+                        }
+                    }
+                    if (netzLeitungsObject === undefined)
+                        continue;
+                    const anfSchemaTypeObjKey = DLConverterI7.createSchemaKeyObject({ i7ID: i7Data.anschlussanf, variantenNr });
+                    let anfNsgObject = DLConverterI7.getDbNsgObjectByID(anfSchemaTypeObjKey);
+                    let anfSchemaType = DLConverterI7.i7ID2Type.get(anfSchemaTypeObjKey);
+                    let anfDiagramObject;
+                    if (anfSchemaType === integral_sql_1.Integral7TableNames.NSG_SCHALTFELD) {
+                        const nsgSchaltfeld = anfNsgObject;
+                        if (nsgSchaltfeld === undefined)
+                            continue;
+                        anfDiagramObject = DLConverterI7.cimUUID2DiagramObject.get(nsgSchaltfeld.lastNodeCimUUID);
+                    }
+                    else if (anfSchemaType === data_types_1.DataTypes.NSG_NODE) {
+                        const aKnotenCimObjectUUID = this.inputArgs.integralID2UUID.get(netzLeitungsObject.aknotenid);
+                        anfDiagramObject = DLConverterI7.cimUUID2DiagramObject.get(aKnotenCimObjectUUID);
+                    }
+                    else {
+                        let anfUUIDEntry = DLConverterI7.i7ID2cimUUIDs.get(anfSchemaTypeObjKey);
+                        if (anfUUIDEntry === undefined)
+                            continue;
+                        anfDiagramObject = DLConverterI7.cimUUID2DiagramObject.get(anfUUIDEntry.identifiedObjectUUID);
+                    }
+                    const endSchemaTypeObjKey = DLConverterI7.createSchemaKeyObject({ i7ID: i7Data.anschlussend, variantenNr });
+                    let endNsgObject = DLConverterI7.getDbNsgObjectByID(endSchemaTypeObjKey);
+                    let endSchemaType = DLConverterI7.i7ID2Type.get(endSchemaTypeObjKey);
+                    let endDiagramObject;
+                    if (endSchemaType === integral_sql_1.Integral7TableNames.NSG_SCHALTFELD) {
+                        const nsgSchaltfeld = endNsgObject;
+                        if (nsgSchaltfeld === undefined)
+                            continue;
+                        endDiagramObject = DLConverterI7.cimUUID2DiagramObject.get(nsgSchaltfeld.lastNodeCimUUID);
+                    }
+                    else if (endSchemaType === data_types_1.DataTypes.NSG_NODE) {
+                        const eKnotenCimObjectUUID = this.inputArgs.integralID2UUID.get(netzLeitungsObject.eknotenid);
+                        endDiagramObject = DLConverterI7.cimUUID2DiagramObject.get(eKnotenCimObjectUUID);
+                    }
+                    else {
+                        let endUUIDEntry = DLConverterI7.i7ID2cimUUIDs.get(endSchemaTypeObjKey);
+                        if (endUUIDEntry === undefined)
+                            continue;
+                        endDiagramObject = DLConverterI7.cimUUID2DiagramObject.get(endUUIDEntry.identifiedObjectUUID);
+                    }
+                    let tempDiagramObjectPoints = [];
+                    let tempAnfDiagramObject = anfDiagramObject;
+                    let tempEndDiagramObject = endDiagramObject;
+                    // Ausschließlich dann exportieren, wenn Anfang und Ende innerhalb des aktuellen Frames liegen
+                    if (tempAnfDiagramObject === undefined || tempEndDiagramObject === undefined)
+                        continue;
+                    tempDiagramObjectPoints.push({
+                        xPosition: tempAnfDiagramObject.diagramObjectPoints[0].xPosition,
+                        yPosition: tempAnfDiagramObject.diagramObjectPoints[0].yPosition
+                    });
+                    // Ermittle nur die Leitungspunkte, die mit der aktuell im Kontext befindlichen Leitung verknüpft sind
+                    const relevantLeitungspkts = filteredLeitungspktResults.filter(elem => elem.nsgleitung === i7Data.id).sort((a, b) => a.pos - b.pos);
+                    for (let a = 0; a < relevantLeitungspkts.length; a++) {
+                        const nsgLeitungspkt = relevantLeitungspkts[a];
+                        if (nsgLeitungspkt.userelpos === 1 && nsgLeitungspkt.reltoanf === 1) {
+                            const tempDiagramObjectPoint = {
+                                xPosition: tempAnfDiagramObject.diagramObjectPoints[0].xPosition,
+                                yPosition: tempAnfDiagramObject.diagramObjectPoints[0].yPosition
+                            };
+                            const tempOffsetArray = util_functions_1.DLUtilFunctions.getXYOffsetFromRelCM(anfSchemaType, anfNsgObject, i7Data.anschlussanf, nsgLeitungspkt);
+                            tempDiagramObjectPoint.xPosition += tempOffsetArray[0];
+                            tempDiagramObjectPoint.yPosition += tempOffsetArray[1];
+                            tempDiagramObjectPoints.push(tempDiagramObjectPoint);
+                        }
+                        else if (nsgLeitungspkt.userelpos === 1 && nsgLeitungspkt.reltoanf === 0) {
+                            const tempDiagramObjectPoint = {
+                                xPosition: tempEndDiagramObject.diagramObjectPoints[0].xPosition,
+                                yPosition: tempEndDiagramObject.diagramObjectPoints[0].yPosition
+                            };
+                            const tempOffsetArray = util_functions_1.DLUtilFunctions.getXYOffsetFromRelCM(endSchemaType, endNsgObject, i7Data.anschlussend, nsgLeitungspkt);
+                            tempDiagramObjectPoint.xPosition += tempOffsetArray[0];
+                            tempDiagramObjectPoint.yPosition += tempOffsetArray[1];
+                            tempDiagramObjectPoints.push(tempDiagramObjectPoint);
+                        }
+                        else {
+                            tempDiagramObjectPoints.push({ xPosition: nsgLeitungspkt.xrel, yPosition: nsgLeitungspkt.yrel });
+                        }
+                    }
+                    tempDiagramObjectPoints.push({
+                        xPosition: tempEndDiagramObject.diagramObjectPoints[0].xPosition,
+                        yPosition: tempEndDiagramObject.diagramObjectPoints[0].yPosition
+                    });
+                    // Zuweisung
+                    if (isACLine) {
+                        const netzLeitungCimObj = this.inputArgs.lines.get(this.inputArgs.integralID2UUID.get(netzLeitungsObject.id));
+                        // Teile die komplette Leitung auf die ACLineSegmente auf [es kann sein, dass die Leitung sich aus mehreren ACLineSegments
+                        // zusammensetzt und dann soll prozentual die komplette Leitung auf die ACLineSegmente aufgeteilt werden (ggfs. werden dabei
+                        // neue DiagramObjectPoints erzeugt)
+                        const cableAvailable = this.isTableAvailable(integral_sql_1.Integral7TableNames.KABEL);
+                        const overheadAvailable = this.isTableAvailable(integral_sql_1.Integral7TableNames.FREILEITUNG);
+                        let type = integral_sql_1.I7Objects.STROMKREISABSCHNITT;
+                        if (cableAvailable && overheadAvailable) {
+                            type = integral_sql_1.I7Objects.STROMKREISABSCHNITT_KABEL_FREILEITUNG;
+                        }
+                        else if (cableAvailable) {
+                            type = integral_sql_1.I7Objects.STROMKREISABSCHNITT_KABEL;
+                        }
+                        else if (overheadAvailable) {
+                            type = integral_sql_1.I7Objects.STROMKREISABSCHNITT_FREILEITUNG;
+                        }
+                        // TODO quickfix for parameter 'availableColumnNames'
+                        const leitungStromkreisabschnitt = await this.mysqlController.execQuery((0, integral_sql_1.getI7Query)(type, ['leitung', 'laenge', 'pos', 'typ'], [netzLeitungsObject.id]));
+                        leitungStromkreisabschnitt.sort((a, b) => a.pos - b.pos);
+                        const acSegmentPercentages = [];
+                        let completeLength = 0;
+                        for (let a = 0; a < leitungStromkreisabschnitt.length; ++a) {
+                            completeLength += leitungStromkreisabschnitt[a].laenge;
+                        }
+                        let crtLength = 0;
+                        // Berechne die Prozent-Anteile eines Leitungsabschnittes bezogen auf die Gesamtlänge
+                        for (let a = 0; a < leitungStromkreisabschnitt.length; ++a) {
+                            crtLength += leitungStromkreisabschnitt[a].laenge;
+                            acSegmentPercentages.push(crtLength / completeLength);
+                        }
+                        const eqUUIDs = netzLeitungCimObj.equipments.map(value => value.getUUID());
+                        const resultingDiagramObjects = util_functions_1.DLUtilFunctions.convertACLineSegment(completeLength, acSegmentPercentages, eqUUIDs, tempDiagramObjectPoints);
+                        for (const diagramObject of resultingDiagramObjects) {
+                            diagramObject.diagramUUID = this.activeDiagram.getUUID();
+                        }
+                        // DLConverterI7.addIDsRelationMapping(schemaObjKey, {
+                        //   identifiedObjectUUID: querzweigObjectUUID,
+                        //   diagramObjectUUID: querzweigDiagramObject.getUUID()
+                        // });
+                        DLConverterI7.addCimObjects(...resultingDiagramObjects);
+                        // DLConverterI7.addIDsRelationMapping(schemaObjKey, {
+                        //   identifiedObjectUUID: querzweigObjectUUID,
+                        //   diagramObjectUUID: querzweigDiagramObject.getUUID()
+                        // });
+                        // DLConverterI7.addCimObjects(querzweigDiagramObject);
+                    }
+                    else if (isErsatzlaengszweig) {
+                    }
+                    else {
+                        const netzLeitungCimObj = this.inputArgs.objects.get(this.inputArgs.integralID2UUID.get(netzLeitungsObject.id));
+                        const diagramObject = new DiagramObject_1.DiagramObject((0, utils_1.generateUUID)());
+                        diagramObject.diagramUUID = this.activeDiagram.getUUID();
+                        diagramObject.identifiedObjectUUID = this.inputArgs.integralID2UUID.get(netzLeitungsObject.id);
+                        // diagramObject.setDiagram(diagram);
+                        // diagram.addDiagramObject(diagramObject);
+                        // diagramObject.setIdentifiedObjectUUID();
+                        if (netzLeitungCimObj !== undefined) {
+                            diagramObject.name = 'DiagramObj ' + (netzLeitungCimObj.shortName ?? '');
+                        }
+                        else {
+                            diagramObject.name = 'DiagramObj HGUE-Leitung';
+                        }
+                        for (let idx = 0; idx < tempDiagramObjectPoints.length; ++idx) {
+                            const diagramObjectPoint = new DiagramObjectPoint_1.DiagramObjectPoint(tempDiagramObjectPoints[idx].xPosition, tempDiagramObjectPoints[idx].yPosition, idx + 1);
+                            diagramObjectPoint.mrid = (0, utils_1.generateUUID)();
+                            diagramObjectPoint.diagramObject = diagramObject;
+                            diagramObject.addDiagramObjectPoint(diagramObjectPoint);
+                            // this.activeDiagram.addDiagramObject(diagramObject);
+                        }
+                        DLConverterI7.addCimObjects(diagramObject);
+                    }
+                    const clonedAnfDiagramObject = util_functions_1.DLUtilFunctions.cloneDiagramObject(anfDiagramObject);
+                    clonedAnfDiagramObject.diagramUUID = this.activeDiagram.getUUID();
+                    const clonedEndDiagramObject = util_functions_1.DLUtilFunctions.cloneDiagramObject(endDiagramObject);
+                    clonedEndDiagramObject.diagramUUID = this.activeDiagram.getUUID();
+                    DLConverterI7.addCimObjects(clonedAnfDiagramObject, clonedEndDiagramObject);
+                }
+            }
+        }
+        else {
+            this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.NSG_LEITUNG} oder ${integral_sql_1.Integral7TableNames.NSG_LEITUNGSPUNKT} ist nicht vorhanden.`);
+        }
+    }
+    async convertSchemaQuerzweige(variantenNr, onlyEingeblendet) {
+        const whereIDs = [...DLConverterI7.i7ID2DbNsgObjectInFrame.keys()].map(arg => DLConverterI7.parseSchemaKeyObject(arg).i7ID);
+        // const whereIDs = [...integral7.i7SchemaID2Type.keys()].map(value => DLUtilFunctions.parseSchemaKey(value).id);
+        if (this.isTableAvailable(integral_sql_1.Integral7TableNames.NSG_QUERZWEIG) && whereIDs.length > 0) {
+            const results = await this.mysqlController.execQuery((0, integral_sql_1.getI7Query)(integral_sql_1.I7Objects.NSG_QUERZWEIG, this.getAvailableColumnNames(integral_sql_1.Integral7TableNames.NSG_QUERZWEIG), whereIDs));
+            let filteredResults = util_functions_1.DLUtilFunctions.filterByVariantenNrOnlyEingeblendet(results, variantenNr, onlyEingeblendet);
+            for (const i7Data of filteredResults) {
+                const schemaObjKey = DLConverterI7.registerNsgObjectAndGetSchemaKay(i7Data, data_types_1.DataTypes.NSG_QUERZWEIG);
+                const referenceObjKey = DLConverterI7.createSchemaKeyObject({ i7ID: i7Data.bezugsobjekt, variantenNr });
+                const referenceObjType = DLConverterI7.i7ID2Type.get(referenceObjKey);
+                const referenceObj = DLConverterI7.getDbNsgObjectByID(referenceObjKey);
+                let refXPos = 0;
+                let refYPos = 0;
+                let xPos = i7Data.xrel;
+                let yPos = i7Data.yrel;
+                let refCNNodeUUID = undefined;
+                // const querzweigType = this.inputArgs.integralID2Type.get(i7Data.querzweig);
+                // if (querzweigType === undefined) {
+                //   continue; //ignore Querzweig if querzweigType is not defined.
+                // }
+                let nsgQuerzweigWidth;
+                let nsgQuerzweigHeight;
+                // if (querzweigType === Integral7TableNames.HGUE_KOPFSTATION_VSC || querzweigType === Integral7TableNames.HGUE_KOPFSTATION_KLASSISCH) {
+                //   nsgQuerzweigWidth = NsgConstants.HGUE_QUERZWEIG_OBJ_WIDTH;
+                //   nsgQuerzweigHeight = NsgConstants.HGUE_QUERZWEIG_OBJ_HEIGHT;
+                // } else {
+                nsgQuerzweigWidth = constants_1.NsgConstants.QUERZWEIG_OBJ_WIDTH;
+                nsgQuerzweigHeight = constants_1.NsgConstants.QUERZWEIG_OBJ_HEIGHT;
+                // }
+                if (referenceObjType === integral_sql_1.Integral7TableNames.NSG_SCHALTFELD) {
+                    const nsgSchaltfeld = referenceObj;
+                    refCNNodeUUID = nsgSchaltfeld.lastNodeCimUUID;
+                    const referenceDiagramObject = DLConverterI7.cimUUID2DiagramObject.get(nsgSchaltfeld.lastNodeCimUUID);
+                    if (referenceDiagramObject === undefined)
+                        continue;
+                    refXPos = referenceDiagramObject.diagramObjectPoints[0].xPosition;
+                    refYPos = referenceDiagramObject.diagramObjectPoints[0].yPosition;
+                    xPos += refXPos;
+                    yPos += refYPos;
+                    // additional positioning needed based on the orientation of the bay
+                    switch (nsgSchaltfeld.orientation) {
+                        case 3: // Left-Direction
+                            xPos += nsgQuerzweigWidth / 2;
+                            yPos -= nsgQuerzweigHeight / 2;
+                            break;
+                        case 0: // Top-Direction
+                            xPos -= nsgQuerzweigWidth / 2;
+                            yPos += nsgQuerzweigHeight / 2;
+                            break;
+                        case 1: // Right-Direction
+                            xPos += nsgQuerzweigWidth / 2;
+                            yPos -= nsgQuerzweigHeight / 2;
+                            // subtract width of bay from x coordinate
+                            xPos -= nsgSchaltfeld.hoehe;
+                            break;
+                        case 2: // Bottom-Direction
+                            xPos -= nsgQuerzweigWidth / 2;
+                            yPos += nsgQuerzweigHeight / 2;
+                            // subtract width from y coordinate
+                            yPos -= nsgSchaltfeld.hoehe;
+                            break;
+                    }
+                }
+                else if (referenceObjType === integral_sql_1.Integral7TableNames.NSG_KNOTEN_SO) {
+                    // xrel and yrel points to the bottom right of the element
+                    refCNNodeUUID = DLConverterI7.i7ID2cimUUIDs.get(referenceObjKey).identifiedObjectUUID;
+                    const referenceDiagramObject = DLConverterI7.cimUUID2DiagramObject.get(refCNNodeUUID);
+                    if (referenceDiagramObject === undefined)
+                        continue;
+                    refXPos = referenceDiagramObject.diagramObjectPoints[0].xPosition;
+                    refYPos = referenceDiagramObject.diagramObjectPoints[0].yPosition;
+                    xPos += refXPos;
+                    yPos += refYPos;
+                    xPos -= nsgQuerzweigWidth / 2;
+                    yPos -= nsgQuerzweigHeight / 2;
+                }
+                else {
+                    this.logger.info(`unhandled reference type '${referenceObjType}' for id ${i7Data.bezugsobjekt} (nsg_nsgquerzweig.id ${i7Data.id})!`);
+                    continue;
+                }
+                const querzweigObjectUUID = this.inputArgs.integralID2UUID.get(i7Data.querzweig);
+                const querzweigDiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                    xPosition: xPos,
+                    yPosition: yPos,
+                    rotation: util_functions_1.DLUtilFunctions.getRotationBasedOnQuerzweig(i7Data.ausrichtung),
+                    diagramObjectName: 'DiagramObject',
+                    identifiedObjectUUID: querzweigObjectUUID,
+                    diagramUUID: this.activeDiagram.getUUID()
+                });
+                DLConverterI7.addIDsRelationMapping(schemaObjKey, {
+                    identifiedObjectUUID: querzweigObjectUUID,
+                    diagramObjectUUID: querzweigDiagramObject.getUUID()
+                });
+                DLConverterI7.addCimObjects(querzweigDiagramObject);
+            }
+        }
+        else {
+            this.logger.debug(`Tabelle ${integral_sql_1.Integral7TableNames.NSG_QUERZWEIG} ist nicht vorhanden.`);
+        }
+    }
+    convertSchemaTerminals() {
+        const exportedTerminals = new Set();
+        for (const diagramObject of DLConverterI7.cimUUID2DiagramObject.values()) {
+            const identifiedObject = this.inputArgs.objects.get(diagramObject.getIdentifiedObjectUUID());
+            if (identifiedObject instanceof ConnectivityNode_1.ConnectivityNode) {
+                identifiedObject.terminals.forEach(terminal => this.convertTerminal(terminal, exportedTerminals));
+            }
+            else if (identifiedObject instanceof ConductingEquipment_1.ConductingEquipment) {
+                identifiedObject.terminals.forEach(terminal => this.convertTerminal(terminal, exportedTerminals));
+            }
+        }
+    }
+    convertTerminal(terminal, exportedTerminals) {
+        if (exportedTerminals.has(terminal.getUUID()))
+            return;
+        exportedTerminals.add(terminal.getUUID());
+        const connectivityNodeUUID = terminal.getConnectivityNodeUUID();
+        const connectivityNode = this.inputArgs.objects.get(connectivityNodeUUID);
+        const conductingEquipmentUUID = terminal.getConductingEquipmentUUID();
+        const conductingEquipment = this.inputArgs.objects.get(conductingEquipmentUUID);
+        if (connectivityNode === undefined || conductingEquipment === undefined)
+            return;
+        const cnDiagramObject = DLConverterI7.getDiagramObjectByUUID(connectivityNodeUUID); //connectivityNode.getDiagramObjects()?.filter(arg => arg.diagramUUID === this.activeDiagram.getUUID())[0];
+        const ceDiagramObject = DLConverterI7.getDiagramObjectByUUID(conductingEquipmentUUID); //conductingEquipment.getDiagramObjects()?.filter(arg => arg.diagramUUID === this.activeDiagram.getUUID())[0];
+        if (cnDiagramObject === undefined || ceDiagramObject === undefined)
+            return;
+        const terminalDiagramObject = new DiagramObject_1.DiagramObject((0, utils_1.generateUUID)());
+        terminalDiagramObject.identifiedObjectUUID = terminal.getUUID();
+        terminalDiagramObject.diagramUUID = this.activeDiagram.getUUID();
+        const cnTerminals = [...connectivityNode.terminals.values()];
+        let isBusbarSectionConnectivityNode = false;
+        for (let a = 0; a < cnTerminals.length && !isBusbarSectionConnectivityNode; ++a) {
+            const possibleBusbarSectionObject = this.inputArgs.objects.get(cnTerminals[a].getConductingEquipmentUUID());
+            if (possibleBusbarSectionObject instanceof BusbarSection_1.BusbarSection) {
+                isBusbarSectionConnectivityNode = true;
+            }
+        }
+        /* BEGIN: check whether ConductingEquipment needs a specific pre-extraction of a single DiagramObjectPoint */
+        const ceDiagramObjectPoint = new DiagramObjectPoint_1.DiagramObjectPoint();
+        ceDiagramObjectPoint.mrid = (0, utils_1.generateUUID)();
+        if (conductingEquipment instanceof ACLineSegment_1.ACLineSegment) {
+            // in case of a BusbarSection, the DiagramObject of a ConnectivityNode contains multiple DiagramObjectPoints
+            // therefore use the center-point of the BusbarSection as a reference point
+            const cnCenterPoint = util_functions_1.DLUtilFunctions.getCenterOfPoints(cnDiagramObject.diagramObjectPoints);
+            // determine the nearest ACLineSegment-DiagramObjectPoint to the ConnectivityNode-DiagramObjectPoint
+            let closestDiagramObjectPoint = ceDiagramObject.diagramObjectPoints[0];
+            let dist = util_functions_1.DLUtilFunctions.lengthOfVector([
+                closestDiagramObjectPoint.xPosition - cnCenterPoint[0],
+                closestDiagramObjectPoint.yPosition - cnCenterPoint[1]
+            ]);
+            for (let a = 1; a < ceDiagramObject.diagramObjectPoints.length; ++a) {
+                const distToCheck = util_functions_1.DLUtilFunctions.lengthOfVector([
+                    ceDiagramObject.diagramObjectPoints[a].xPosition - cnCenterPoint[0],
+                    ceDiagramObject.diagramObjectPoints[a].yPosition - cnCenterPoint[1]
+                ]);
+                if (distToCheck < dist) {
+                    closestDiagramObjectPoint = ceDiagramObject.diagramObjectPoints[a];
+                    dist = distToCheck;
+                }
+            }
+            ceDiagramObjectPoint.xPosition = closestDiagramObjectPoint.xPosition;
+            ceDiagramObjectPoint.yPosition = closestDiagramObjectPoint.yPosition;
+        }
+        else {
+            ceDiagramObjectPoint.xPosition = ceDiagramObject.diagramObjectPoints[0].xPosition;
+            ceDiagramObjectPoint.yPosition = ceDiagramObject.diagramObjectPoints[0].yPosition;
+        }
+        /* END: check whether ConductingEquipment needs a specific pre-extraction of a single DiagramObjectPoint */
+        if (isBusbarSectionConnectivityNode) {
+            // special case for busbarSections
+            this.convertBusbarSectionCNTerminal(terminalDiagramObject, cnDiagramObject, ceDiagramObjectPoint);
+        }
+        else {
+            // default case:
+            ceDiagramObjectPoint.diagramObject = terminalDiagramObject;
+            terminalDiagramObject.diagramObjectPoints.push(ceDiagramObjectPoint);
+            const diagramObjectPoint2 = new DiagramObjectPoint_1.DiagramObjectPoint();
+            diagramObjectPoint2.mrid = (0, utils_1.generateUUID)();
+            diagramObjectPoint2.xPosition = cnDiagramObject.diagramObjectPoints[0].xPosition;
+            diagramObjectPoint2.yPosition = cnDiagramObject.diagramObjectPoints[0].yPosition;
+            diagramObjectPoint2.diagramObject = terminalDiagramObject;
+            terminalDiagramObject.diagramObjectPoints.push(diagramObjectPoint2);
+        }
+        for (let a = 0; a < terminalDiagramObject.diagramObjectPoints.length; ++a) {
+            terminalDiagramObject.diagramObjectPoints[a].sequenceNumber = (a + 1);
+        }
+        DLConverterI7.addCimObjects(terminalDiagramObject);
+    }
+    convertBusbarSectionCNTerminal(terminalDiagramObject, cnDiagramObject, ceDiagramObjectPoint) {
+        // determine the point, which fits best
+        // the one of three possible points will be taken that has the shortest vector
+        const dopCE = ceDiagramObjectPoint;
+        const dop1BusbarSection = new DiagramObjectPoint_1.DiagramObjectPoint();
+        dop1BusbarSection.mrid = (0, utils_1.generateUUID)();
+        dop1BusbarSection.xPosition = cnDiagramObject.diagramObjectPoints[0].xPosition;
+        dop1BusbarSection.yPosition = cnDiagramObject.diagramObjectPoints[0].yPosition;
+        const dop2BusbarSection = new DiagramObjectPoint_1.DiagramObjectPoint();
+        dop2BusbarSection.mrid = (0, utils_1.generateUUID)();
+        dop2BusbarSection.xPosition = cnDiagramObject.diagramObjectPoints[1].xPosition;
+        dop2BusbarSection.yPosition = cnDiagramObject.diagramObjectPoints[1].yPosition;
+        const tempVec = util_functions_1.DLUtilFunctions.vec2([dop1BusbarSection.xPosition, dop1BusbarSection.yPosition], [dop2BusbarSection.xPosition, dop2BusbarSection.yPosition], [dopCE.xPosition, dopCE.yPosition]);
+        const dist1 = util_functions_1.DLUtilFunctions.distanceVector2Line(tempVec, [dopCE.xPosition, dopCE.yPosition], [dop1BusbarSection.xPosition, dop1BusbarSection.yPosition]);
+        const dist2 = util_functions_1.DLUtilFunctions.distanceVector2Line(tempVec, [dopCE.xPosition, dopCE.yPosition], [dop2BusbarSection.xPosition, dop2BusbarSection.yPosition]);
+        terminalDiagramObject.diagramObjectPoints.push(dopCE);
+        dopCE.diagramObject = terminalDiagramObject;
+        if (util_functions_1.DLUtilFunctions.isNegativeOrZero(dist1) === util_functions_1.DLUtilFunctions.isNegativeOrZero(dist2)) {
+            // choice 1 or 2: dopCE is left or right in relation to the BusbarSection-line
+            const distDopCEdop1BS = util_functions_1.DLUtilFunctions.lengthOfVector([dopCE.xPosition - dop1BusbarSection.xPosition, dopCE.yPosition - dop1BusbarSection.yPosition]);
+            const distDopCEdop2BS = util_functions_1.DLUtilFunctions.lengthOfVector([dopCE.xPosition - dop2BusbarSection.xPosition, dopCE.yPosition - dop2BusbarSection.yPosition]);
+            const distDop1BSdop2BS = util_functions_1.DLUtilFunctions.lengthOfVector([dop1BusbarSection.xPosition - dop2BusbarSection.xPosition, dop1BusbarSection.yPosition - dop2BusbarSection.yPosition]);
+            if (Math.abs(distDopCEdop1BS + distDopCEdop2BS - distDop1BSdop2BS) < util_functions_1.DLUtilFunctions.EPSILON) {
+                // dopCE is on busbar line
+                const dopIntersection = new DiagramObjectPoint_1.DiagramObjectPoint();
+                dopIntersection.mrid = (0, utils_1.generateUUID)();
+                dopIntersection.xPosition = dopCE.xPosition;
+                dopIntersection.yPosition = dopCE.yPosition;
+                terminalDiagramObject.diagramObjectPoints.push(dopIntersection);
+                dopIntersection.diagramObject = terminalDiagramObject;
+            }
+            else {
+                if (distDopCEdop1BS < distDopCEdop2BS) {
+                    terminalDiagramObject.diagramObjectPoints.push(dop1BusbarSection);
+                    dop1BusbarSection.diagramObject = terminalDiagramObject;
+                }
+                else {
+                    terminalDiagramObject.diagramObjectPoints.push(dop2BusbarSection);
+                    dop2BusbarSection.diagramObject = terminalDiagramObject;
+                }
+            }
+        }
+        else {
+            // choice 3: the intersection of the busbar and the perpendicular vector to the conductingEquipment
+            const dopIntersection = new DiagramObjectPoint_1.DiagramObjectPoint();
+            dopIntersection.mrid = (0, utils_1.generateUUID)();
+            dopIntersection.xPosition = tempVec[0];
+            dopIntersection.yPosition = tempVec[1];
+            terminalDiagramObject.diagramObjectPoints.push(dopIntersection);
+            dopIntersection.diagramObject = terminalDiagramObject;
+        }
+    }
+    filterTablesByAvailability(relevantTables) {
+        let filteredRelevantTables = [];
+        for (const relevantTable of relevantTables) {
+            if (this.isTableAvailable(relevantTable)) {
+                filteredRelevantTables.push(relevantTable);
+            }
+        }
+        return filteredRelevantTables;
+    }
+    isTableAvailable(tableName) {
+        return this.i7TableName2Table.has(tableName);
+    }
+    getAvailableColumnNames(tableName) {
+        return this.i7TableName2Table.get(tableName).columnNames;
+    }
+    async runAndLogPerformance(func, ...args) {
+        const startTime = perf_hooks_1.performance.now();
+        await func.apply(this, args);
+        this.logger.debug(`${func.name} ${(perf_hooks_1.performance.now() - startTime) / 1000} seconds`);
+        console.log(`${func.name} ${(perf_hooks_1.performance.now() - startTime) / 1000} seconds`);
+    }
+}
+exports.DLConverterI7 = DLConverterI7;
+//# sourceMappingURL=dl-converter-i7.js.map