@enervance/insight-cim-model 1.0.2 → 1.0.3

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

@@ -0,0 +1,3838 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DLConverterI7 = void 0;
+const constants_1 = require("../model/dl-utils/constants.js");
+const util_functions_1 = require("../model/dl-utils/util-functions.js");
+const DiagramObject_1 = require("../../../model/diagram/DiagramObject.js");
+const convert_graph_keys_1 = require("./dl-graphs/convert-graph-keys.js");
+const Diagram_1 = require("../../../model/diagram/Diagram.js");
+const parser_utils_1 = require("../../../utils2/parser.utils.js");
+const OrientationKind_1 = require("../../../model/diagram/OrientationKind.js");
+const DiagramStyle_1 = require("../../../model/diagram/DiagramStyle.js");
+const common_utils_1 = require("../../../utils2/common.utils.js");
+const cim_constants_1 = require("../../../constants/cim-constants.js");
+const cim_model_graph_1 = require("./dl-graphs/cim-model-graph.js");
+const db_object_graph_1 = require("./dl-graphs/db-object-graph.js");
+const DiagramObjectPoint_1 = require("../../../model/diagram/DiagramObjectPoint.js");
+const utils_schema_1 = require("../utils-schema.js");
+const BusbarSection_1 = require("../../../model/wires/BusbarSection.js");
+const Junction_1 = require("../../../model/wires/Junction.js");
+const cim_class_names_1 = require("../../../constants/cim-class-names.js");
+const util_create_1 = require("../../../util/util-create.js");
+class DLConverterI7 {
+    logger;
+    configUuid;
+    integralID2UUID;
+    static testmode = false;
+    config;
+    dbObjectGraph;
+    cimModelGraph;
+    exportedTerminalUUIDs;
+    exportedDiagramObjectsGraph = {};
+    diagramStyles = {
+        [cim_constants_1.DiagramLayoutTypes.NODE_BREAKER]: undefined
+    };
+    constructor(configUuid, logger, config) {
+        this.configUuid = configUuid;
+        this.logger = logger;
+        this.config = config;
+        this.dbObjectGraph = new db_object_graph_1.DbObjectGraph(convert_graph_keys_1.i7SchemaKeyDefinitions);
+        this.cimModelGraph = new cim_model_graph_1.CimModelGraph();
+        this.exportedTerminalUUIDs = new Set();
+        util_functions_1.DLUtilFunctions.setUuidNamespaces(this.configUuid);
+        const uuid = this.config?.generateUUID4 ? common_utils_1.CommonUtils.generateUUID() : common_utils_1.CommonUtils.generateUUIDv5(cim_class_names_1.ClassNames.DiagramStyle, this.configUuid, cim_constants_1.DiagramLayoutTypes.NODE_BREAKER);
+        this.diagramStyles[cim_constants_1.DiagramLayoutTypes.NODE_BREAKER] = new DiagramStyle_1.DiagramStyle(uuid, cim_constants_1.DiagramLayoutTypes.NODE_BREAKER);
+    }
+    addExportedDiagramObjectToGraph(variantennr, netzId, diagramObject) {
+        this.exportedDiagramObjectsGraph[variantennr] = this.exportedDiagramObjectsGraph[variantennr] ?? {};
+        this.exportedDiagramObjectsGraph[variantennr][netzId] = diagramObject;
+    }
+    getExportedDiagramObjectBy(variantennr, netzId) {
+        if (variantennr in this.exportedDiagramObjectsGraph) {
+            return this.exportedDiagramObjectsGraph[variantennr][netzId];
+        }
+        return undefined;
+    }
+    setDbObjectGraph(graph) {
+        this.dbObjectGraph = graph;
+    }
+    setCimModelGraph(graph) {
+        this.cimModelGraph = graph;
+    }
+    addCimObject(uuid, object, typeOfKey, dbKey) {
+        // todo remove call from test
+        // if (typeOfKey !== undefined && dbKey !== undefined) this.addRelation(typeOfKey, dbKey, uuid);
+        // this.cimModelGraph.addUnspecifiedObject(uuid, object);
+    }
+    /**
+     * convertNsgVariante
+     */
+    async convertNsgVariante(arg, tsoName) {
+        const diagram = new Diagram_1.Diagram((0, parser_utils_1.getUUID)(arg.guid), (0, util_create_1.createNotation)([arg.name, '_', tsoName], 32, true), String(arg.id));
+        diagram.orientation = OrientationKind_1.OrientationKind.negative;
+        diagram.diagramStyle = this.diagramStyles[cim_constants_1.DiagramLayoutTypes.NODE_BREAKER];
+        return diagram;
+    }
+    /**
+     * convertSchemaStandort
+     */
+    async convertSchemaStandort(arg) {
+    }
+    /**
+     * convertSchemaKnotenStandort
+     */
+    async convertSchemaKnotenStandort(nsgKnotenSo) {
+        const nsgStandort = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgstandort, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgKnotenSo.variantennr, id: nsgKnotenSo.nsgso });
+        if (nsgStandort === undefined)
+            return null;
+        const cimObjectUUID = this.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: nsgKnotenSo.knotenso }) ?? undefined;
+        const diagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+            xPosition: nsgStandort.xrel + nsgKnotenSo.xrel + 16,
+            yPosition: nsgStandort.yrel + nsgKnotenSo.yrel + 16,
+            diagramObjectName: 'Abzweig',
+            identifiedObjectUUID: cimObjectUUID
+        }, this.config);
+        // knotenso must be accessible via knotenzw-id
+        const netzSchlaufen = await this.dbObjectGraph.findByAttributes(convert_graph_keys_1.i7TableNames.netz_schlaufe, {
+            eknoten: { in: [nsgKnotenSo.knotenso] }
+        });
+        if (netzSchlaufen && netzSchlaufen.length > 0) {
+            for (const netzSchlaufe of netzSchlaufen) {
+                this.addExportedDiagramObjectToGraph(nsgKnotenSo.variantennr, netzSchlaufe.knotenzw, diagramObject);
+            }
+        }
+        this.addExportedDiagramObjectToGraph(nsgKnotenSo.variantennr, nsgKnotenSo.knotenso, diagramObject);
+        return diagramObject;
+    }
+    /**
+     * convertSchemaKnotenStandort
+     */
+    async convertSchemaKnotenHgue(nsgKnotenHgue) {
+        const nsgStandort = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgstandort, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgKnotenHgue.variantennr, id: nsgKnotenHgue.nsgso });
+        if (nsgStandort === undefined)
+            return null;
+        const cimObjectUUID = this.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: nsgKnotenHgue.knotenso }) ?? undefined;
+        const diagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+            xPosition: nsgStandort.xrel + nsgKnotenHgue.xrel + 16,
+            yPosition: nsgStandort.yrel + nsgKnotenHgue.yrel + 16,
+            diagramObjectName: 'Hgue-Knoten',
+            identifiedObjectUUID: cimObjectUUID
+        }, this.config);
+        // knotenso must be accessible via knotenzw-id
+        const netzSchlaufen = await this.dbObjectGraph.findByAttributes(convert_graph_keys_1.i7TableNames.netz_schlaufe, {
+            eknoten: { in: [nsgKnotenHgue.knotenso] }
+        });
+        if (netzSchlaufen && netzSchlaufen.length > 0) {
+            for (const netzSchlaufe of netzSchlaufen) {
+                this.addExportedDiagramObjectToGraph(nsgKnotenHgue.variantennr, netzSchlaufe.knotenzw, diagramObject);
+            }
+        }
+        this.addExportedDiagramObjectToGraph(nsgKnotenHgue.variantennr, nsgKnotenHgue.knotenso, diagramObject);
+        return diagramObject;
+    }
+    /**
+     * convertSchemaSchaltanlage
+     */
+    async convertSchemaSchaltanlage(arg) {
+    }
+    /**
+     * convertSchemaSchaltanlagenAbschnitte
+     */
+    async convertSchemaSchaltanlagenAbschnitte(arg) {
+        // const nsgSchaltanlage: NsgSchaltanlage = await this.dbObjectGraph.findObjectByKey(
+        //   i7TableNames.nsg_nsgschaltanlage,
+        //   i7SchemaKeyNames.VariantenNrIdKey, { variantennr: arg.variantennr, id: arg.nsgsa }
+        // );
+        //
+        // nsgSchaltanlage.nsgSaabschnitt = nsgSchaltanlage.nsgSaabschnitt ?? [];
+        // nsgSchaltanlage.nsgSaabschnitt.push(arg);
+    }
+    // async convertSchemaSammelschienenAbschnitte(arg: NsgSchaltanlagenabschnitt) {
+    async convertSchemaSammelschienenAbschnitte(arg) {
+        const netzSsabs = await this.dbObjectGraph.findAllByAttributes(convert_graph_keys_1.i7TableNames.netz_ssab, {
+            saabschnitt: arg.saabschnitt
+        });
+        const resultingDiagramObjects = [];
+        for (const netzSsab of netzSsabs) {
+            const diagramObjects = await this.convertSchemaSammelschienenAbschnitt(arg, netzSsab);
+            if (diagramObjects) {
+                resultingDiagramObjects.push(...diagramObjects);
+            }
+        }
+        return resultingDiagramObjects;
+    }
+    /**
+     * convertSchemaSammelschienenAbschnitt
+     */
+    async convertSchemaSammelschienenAbschnitt(nsgSaabschnitt, netzSsab) {
+        const nsgSchaltanlage = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgschaltanlage, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgSaabschnitt.variantennr, id: nsgSaabschnitt.nsgsa });
+        if (!nsgSchaltanlage)
+            return;
+        const leftUpperPointOfSsab = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.netz_ssab, netzSsab, nsgSaabschnitt.variantennr);
+        const length = await this.getLengthOfSammelschienenAbschnitt(nsgSaabschnitt);
+        const points = [];
+        let topLeft = new DiagramObjectPoint_1.DiagramObjectPoint();
+        let bottomRight = new DiagramObjectPoint_1.DiagramObjectPoint();
+        topLeft.xPosition = leftUpperPointOfSsab[0];
+        topLeft.yPosition = leftUpperPointOfSsab[1];
+        if (nsgSchaltanlage.ausrichtung % 2 === 0) {
+            bottomRight.xPosition = leftUpperPointOfSsab[0] + length * constants_1.NsgConstants.HORIZONTAL_OFFSET;
+            bottomRight.yPosition = leftUpperPointOfSsab[1];
+        }
+        else {
+            bottomRight.xPosition = leftUpperPointOfSsab[0];
+            bottomRight.yPosition = leftUpperPointOfSsab[1] + length * constants_1.NsgConstants.HORIZONTAL_OFFSET;
+        }
+        topLeft.sequenceNumber = 1;
+        bottomRight.sequenceNumber = 2;
+        points.push(topLeft, bottomRight);
+        const cimObjectUUID = this.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: netzSsab.id }) ?? undefined;
+        const connectivityNode = this.cimModelGraph.findObjectByUUID(cimObjectUUID);
+        let busbarSection = null;
+        let busbarSectionTerminal = null;
+        if (connectivityNode) {
+            for (const terminal of connectivityNode.terminals.values()) {
+                if (terminal.conductingEquipment instanceof BusbarSection_1.BusbarSection) {
+                    busbarSection = terminal.conductingEquipment;
+                    busbarSectionTerminal = terminal;
+                    break;
+                }
+            }
+        }
+        if (busbarSection && busbarSectionTerminal && !this.config?.busbarSectionAsConnectivityNode) {
+            // compute the position for the ConnectivityNode (the center of the BusbarSection)
+            const centerPosition = [
+                (topLeft.xPosition + bottomRight.xPosition) / 2,
+                (topLeft.yPosition + bottomRight.yPosition) / 2
+            ];
+            const doConnectivityNode = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(centerPosition[0], centerPosition[1], null);
+            doConnectivityNode.name = `NetzSsab CN ${netzSsab.id}`;
+            doConnectivityNode.identifiedObjectUUID = cimObjectUUID;
+            this.addExportedDiagramObjectToGraph(nsgSaabschnitt.variantennr, netzSsab.id, doConnectivityNode);
+            const doBusbarSection = new DiagramObject_1.DiagramObject(common_utils_1.CommonUtils.generateUUID(), `NetzSsab ${netzSsab.id}`);
+            doBusbarSection.identifiedObjectUUID = busbarSection.getUUID();
+            doBusbarSection.rotation = util_functions_1.DLUtilFunctions.getRotationBasedOnNsgSa(nsgSchaltanlage.ausrichtung);
+            (0, utils_schema_1.copyDiagramObjectPoints)(doBusbarSection, points);
+            this.exportedTerminalUUIDs.add(busbarSectionTerminal.getUUID());
+            const doBusbarSectionTerminal = this.createTerminalDiagramObjectFromPoints({
+                cePoints: [topLeft.xPosition, topLeft.yPosition], cnPoints: [...centerPosition],
+                terminalUuid: busbarSectionTerminal.getUUID()
+            });
+            return [doBusbarSection, doBusbarSectionTerminal, doConnectivityNode];
+        }
+        else {
+            const doBusbarSectionAsConnectivityNode = new DiagramObject_1.DiagramObject(common_utils_1.CommonUtils.generateUUID(), `NetzSsab CN ${netzSsab.id}`);
+            doBusbarSectionAsConnectivityNode.identifiedObjectUUID = cimObjectUUID;
+            doBusbarSectionAsConnectivityNode.rotation = util_functions_1.DLUtilFunctions.getRotationBasedOnNsgSa(nsgSchaltanlage.ausrichtung);
+            (0, utils_schema_1.copyDiagramObjectPoints)(doBusbarSectionAsConnectivityNode, points);
+            this.addExportedDiagramObjectToGraph(nsgSaabschnitt.variantennr, netzSsab.id, doBusbarSectionAsConnectivityNode);
+            return [doBusbarSectionAsConnectivityNode];
+        }
+    }
+    /**
+     * convertSchemaSchaltfeldElemente
+     */
+    async convertSchemaSchaltfeldElemente(nsgSchaltfeld) {
+        const resultingDiagramObjects = [];
+        // 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 nsgSaabschnitt = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgsaabschnitt, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgSchaltfeld.variantennr, id: nsgSchaltfeld.nsgsaa });
+        if (!nsgSaabschnitt)
+            return;
+        const nsgSchaltanlage = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgschaltanlage, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgSchaltfeld.variantennr, id: nsgSaabschnitt.nsgsa });
+        if (!nsgSchaltanlage)
+            return;
+        const nsgStandort = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgstandort, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgSchaltfeld.variantennr, id: nsgSchaltanlage.nsgso });
+        if (!nsgStandort)
+            return;
+        const netzSsabs = await this.dbObjectGraph.findAllByAttributes(convert_graph_keys_1.i7TableNames.netz_ssab, {
+            saabschnitt: nsgSaabschnitt.saabschnitt
+        });
+        let bayOrientation = nsgSchaltanlage.ausrichtung;
+        if (nsgSchaltfeld.deltaausrichtung === 1) {
+            bayOrientation = (bayOrientation + 2) % 4;
+        }
+        const netzSsabsIds = new Set(netzSsabs.map(arg => arg.id));
+        let schaltfeldOffset;
+        switch (nsgSchaltanlage.ausrichtung) {
+            case 0:
+            case 1:
+                schaltfeldOffset = nsgSchaltfeld.slotnummer * 16 + 8;
+                break;
+            case 2:
+            case 3:
+                schaltfeldOffset = (nsgSaabschnitt.laenge - nsgSchaltfeld.slotnummer - 1) * 16 + 8;
+                break;
+        }
+        const schaltfeldNodes = await this.getNodesOfSchaltfeld(nsgSchaltfeld);
+        const onSsabNodes = schaltfeldNodes.filter(elem => netzSsabsIds.has(elem.aknoten) || netzSsabsIds.has(elem.eknoten));
+        const onlySingleBusbarWithDisconnector = netzSsabs.length === 1 && schaltfeldNodes.length === 1;
+        const nodePointMap = new Map();
+        let lastSsabBeforeStackLeaving;
+        for (const onSsabNode of onSsabNodes) {
+            let position;
+            let netzSsab;
+            if (netzSsabsIds.has(onSsabNode.aknoten)) {
+                netzSsab = netzSsabs.find(netzSsab => netzSsab.id === onSsabNode.aknoten);
+                position = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.netz_ssab, netzSsab, nsgSchaltfeld.variantennr);
+            }
+            else if (netzSsabsIds.has(onSsabNode.eknoten)) {
+                netzSsab = netzSsabs.find(netzSsab => netzSsab.id === onSsabNode.eknoten);
+                position = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.netz_ssab, netzSsab, nsgSchaltfeld.variantennr);
+            }
+            if (lastSsabBeforeStackLeaving === undefined)
+                lastSsabBeforeStackLeaving = netzSsab;
+            let rotationValue = null;
+            switch (bayOrientation) {
+                case 0: // TOP
+                    rotationValue = 0;
+                    position[0] += schaltfeldOffset;
+                    if (onlySingleBusbarWithDisconnector)
+                        position[1] -= 8;
+                    break;
+                case 1: // RIGHT
+                    rotationValue = 90;
+                    position[1] += schaltfeldOffset;
+                    if (onlySingleBusbarWithDisconnector)
+                        position[0] += 8;
+                    break;
+                case 2: // BOTTOM
+                    rotationValue = 180;
+                    position[0] += schaltfeldOffset;
+                    if (onlySingleBusbarWithDisconnector)
+                        position[1] += 8;
+                    break;
+                case 3: // LEFT
+                    rotationValue = 270;
+                    position[1] += schaltfeldOffset;
+                    if (onlySingleBusbarWithDisconnector)
+                        position[0] -= 8;
+                    break;
+            }
+            // ConductingEquipment
+            nodePointMap.set(onSsabNode.id, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(position[0], position[1], rotationValue));
+        }
+        const leftUpperCornerOfBay = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgschaltfeld, nsgSchaltfeld);
+        const maxSsabPos = await this.getMaxPosOfSaabschnitt(nsgSaabschnitt);
+        const startPositionOfStack = [0, 0];
+        switch (bayOrientation) {
+            case 0: // TOP
+                startPositionOfStack[0] = leftUpperCornerOfBay[0] + 16;
+                startPositionOfStack[1] = leftUpperCornerOfBay[1] + (nsgSchaltfeld.hoehe - (maxSsabPos + 1) * 8) + 4;
+                break;
+            case 1: // RIGHT
+                startPositionOfStack[0] = leftUpperCornerOfBay[0] + ((maxSsabPos + 1) * 8) - 4;
+                startPositionOfStack[1] = leftUpperCornerOfBay[1] + 16;
+                break;
+            case 2: // BOTTOM
+                startPositionOfStack[0] = leftUpperCornerOfBay[0] + 16;
+                startPositionOfStack[1] = leftUpperCornerOfBay[1] + ((maxSsabPos + 1) * 8) - 4;
+                break;
+            case 3: // LEFT
+                startPositionOfStack[0] = leftUpperCornerOfBay[0] + (nsgSchaltfeld.hoehe - (maxSsabPos + 1) * 8) + 4;
+                startPositionOfStack[1] = leftUpperCornerOfBay[1] + 16;
+                break;
+        }
+        let prevNode = onSsabNodes[0];
+        let crtNode = schaltfeldNodes.find(arg => arg.aknoten === onSsabNodes[0].eknoten);
+        let position = [...startPositionOfStack];
+        let connectivityNodePosition = [...startPositionOfStack];
+        let rotationValue = null;
+        while (crtNode !== undefined) {
+            switch (bayOrientation) {
+                case 0: // TOP
+                    rotationValue = 0;
+                    position[1] -= 8;
+                    connectivityNodePosition[1] = position[1] + 4;
+                    break;
+                case 1: // RIGHT
+                    rotationValue = 90;
+                    position[0] += 8;
+                    connectivityNodePosition[0] = position[0] - 4;
+                    break;
+                case 2: // BOTTOM
+                    rotationValue = 180;
+                    position[1] += 8;
+                    connectivityNodePosition[1] = position[1] - 4;
+                    break;
+                case 3: // LEFT
+                    rotationValue = 270;
+                    position[0] -= 8;
+                    connectivityNodePosition[0] = position[0] + 4;
+                    break;
+            }
+            nodePointMap.set(crtNode.id, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(position[0], position[1], rotationValue));
+            nodePointMap.set(crtNode.aknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(connectivityNodePosition[0], connectivityNodePosition[1], null));
+            prevNode = crtNode;
+            crtNode = schaltfeldNodes.find(arg => arg.aknoten === crtNode.eknoten);
+        }
+        // BEGIN: Last ConnectivityNode
+        // Exportiere das ConnectivityNode/den Endpunkt des Schaltfeldes
+        if (prevNode !== undefined) {
+            switch (bayOrientation) {
+                case 0: // TOP
+                    position[1] = leftUpperCornerOfBay[1];
+                    break;
+                case 1: // RIGHT
+                    position[0] = leftUpperCornerOfBay[0] + nsgSchaltfeld.hoehe;
+                    break;
+                case 2: // BOTTOM
+                    position[1] = leftUpperCornerOfBay[1] + nsgSchaltfeld.hoehe;
+                    break;
+                case 3: // LEFT
+                    position[0] = leftUpperCornerOfBay[0];
+                    break;
+            }
+            nodePointMap.set(prevNode.eknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(position[0], position[1], null));
+            // END: Last ConnectivityNode
+            // if (!this.alreadyExported(nsgSchaltfeld.variantennr, nsgSchaltfeld.id)) {
+            //   resultingDiagramObjects.push(value);
+            //   this.addExportedDiagramObjectToGraph(nsgSchaltfeld.variantennr, nsgSchaltfeld.id, value);
+            // }
+        }
+        for (const nodePointEntry of nodePointMap.entries()) {
+            const key = nodePointEntry[0];
+            const value = nodePointEntry[1];
+            const cimObjectUUID = this.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: key }) ?? undefined;
+            value.identifiedObjectUUID = cimObjectUUID;
+            if (!this.alreadyExported(nsgSchaltfeld.variantennr, key)) {
+                resultingDiagramObjects.push(value);
+                this.addExportedDiagramObjectToGraph(nsgSchaltfeld.variantennr, key, value);
+            }
+        }
+        /* ---------- ---------- ---------- */
+        // BEGIN: Terminal-Export
+        for (const schaltfeldNode of schaltfeldNodes) {
+            let doBackwardConnectivityNode = nodePointMap.get(schaltfeldNode.aknoten);
+            if (netzSsabsIds.has(schaltfeldNode.aknoten)) {
+                doBackwardConnectivityNode = this.exportedDiagramObjectsGraph[nsgSchaltfeld.variantennr][schaltfeldNode.aknoten];
+            }
+            const doConductingEquipment = nodePointMap.get(schaltfeldNode.id);
+            const doForwardConnectivityNode = nodePointMap.get(schaltfeldNode.eknoten);
+            const dopBackwardConnectivityNode = doBackwardConnectivityNode.diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+            const dopConductingEquipment = doConductingEquipment.diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+            const dopForwardConnectivityNode = doForwardConnectivityNode.diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+            if (netzSsabsIds.has(schaltfeldNode.aknoten)) {
+                switch (bayOrientation) {
+                    case 0: // TOP
+                    case 2: // BOTTOM
+                        dopBackwardConnectivityNode[0] = dopConductingEquipment[0];
+                        break;
+                    case 1: // RIGHT
+                    case 3: // LEFT
+                        dopBackwardConnectivityNode[1] = dopConductingEquipment[1];
+                        break;
+                }
+            }
+            const backwardTerminalUUID = this.lookupTerminalUUID(schaltfeldNode.aknoten, schaltfeldNode.id);
+            if (!this.exportedTerminalUUIDs.has(backwardTerminalUUID)) {
+                this.exportedTerminalUUIDs.add(backwardTerminalUUID);
+                const terminalDiagramObject = this.createTerminalDiagramObjectFromPoints({
+                    cePoints: [...dopConductingEquipment], cnPoints: [...dopBackwardConnectivityNode],
+                    terminalUuid: backwardTerminalUUID
+                });
+                resultingDiagramObjects.push(terminalDiagramObject);
+            }
+            const forwardTerminalUUID = this.lookupTerminalUUID(schaltfeldNode.eknoten, schaltfeldNode.id);
+            if (!this.exportedTerminalUUIDs.has(forwardTerminalUUID)) {
+                this.exportedTerminalUUIDs.add(forwardTerminalUUID);
+                const terminalDiagramObject = this.createTerminalDiagramObjectFromPoints({
+                    cePoints: [...dopConductingEquipment], cnPoints: [...dopForwardConnectivityNode],
+                    terminalUuid: forwardTerminalUUID
+                });
+                resultingDiagramObjects.push(terminalDiagramObject);
+            }
+        }
+        // END: Terminal-Export
+        /* ---------- ---------- ---------- */
+        return resultingDiagramObjects;
+    }
+    /**
+     * convertSchemaTransformer2W
+     */
+    async convertSchemaTransformer2W(nsgTrafo2w) {
+        const nsgStandort = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgstandort, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgTrafo2w.variantennr, id: nsgTrafo2w.nsgso }, false);
+        if (!nsgStandort)
+            return null;
+        const netzTrafo2W = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.netz_trafo2w, convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: nsgTrafo2w.trafo2w });
+        if (!netzTrafo2W)
+            return;
+        const powerTransformerUUID = this.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: nsgTrafo2w.trafo2w }) ?? undefined;
+        let centerTransformer = [null, null];
+        let positionAnschlussanf = [null, null];
+        let positionAnschlussend = [null, null];
+        switch (nsgTrafo2w.ausrichtung) {
+            case 0: // (left) anschlussend <-00-> anschlussanf (right)
+                centerTransformer[0] = 24;
+                centerTransformer[1] = 16;
+                positionAnschlussanf[0] = 48;
+                positionAnschlussanf[1] = 16;
+                positionAnschlussend[0] = 0;
+                positionAnschlussend[1] = 16;
+                break;
+            case 1: // (top) anschlussend <-00-> anschlussanf (bottom)
+                centerTransformer[0] = 16;
+                centerTransformer[1] = 24;
+                positionAnschlussanf[0] = 16;
+                positionAnschlussanf[1] = 48;
+                positionAnschlussend[0] = 16;
+                positionAnschlussend[1] = 0;
+                break;
+            case 2: // (left) anschlussanf <-00-> anschlussend (right)
+                centerTransformer[0] = 24;
+                centerTransformer[1] = 16;
+                positionAnschlussanf[0] = 0;
+                positionAnschlussanf[1] = 16;
+                positionAnschlussend[0] = 48;
+                positionAnschlussend[1] = 16;
+                break;
+            case 3: // (top) anschlussanf <-00-> anschlussend (bottom)
+                centerTransformer[0] = 16;
+                centerTransformer[1] = 24;
+                positionAnschlussanf[0] = 16;
+                positionAnschlussanf[1] = 0;
+                positionAnschlussend[0] = 16;
+                positionAnschlussend[1] = 48;
+                break;
+        }
+        // rotation 0 means: <-00->
+        const powerTransformerDiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+            xPosition: centerTransformer[0],
+            yPosition: centerTransformer[1],
+            rotation: util_functions_1.DLUtilFunctions.getRotationBasedOnTrafo2W(nsgTrafo2w.ausrichtung),
+            diagramObjectName: `NetzTrafo ${netzTrafo2W.id}`,
+            identifiedObjectUUID: powerTransformerUUID
+        }, this.config);
+        const createdDiagramObjects = [];
+        createdDiagramObjects.push(powerTransformerDiagramObject);
+        let terminal1DiagramObject;
+        let powerTransformerEnd1TerminalUuid = this.lookupTransformerEndTerminalUUIDBy(powerTransformerUUID, netzTrafo2W.guid_w1, 1);
+        if (powerTransformerEnd1TerminalUuid) {
+            terminal1DiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                xPosition: positionAnschlussanf[0],
+                yPosition: positionAnschlussanf[1],
+                rotation: null,
+                diagramObjectName: 'Terminal 1',
+                identifiedObjectUUID: powerTransformerEnd1TerminalUuid
+            }, this.config);
+            createdDiagramObjects.push(terminal1DiagramObject);
+        }
+        let terminal2DiagramObject;
+        let powerTransformerEnd2TerminalUuid = this.lookupTransformerEndTerminalUUIDBy(powerTransformerUUID, netzTrafo2W.guid_w2, 2);
+        if (powerTransformerEnd2TerminalUuid) {
+            terminal2DiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                xPosition: positionAnschlussend[0],
+                yPosition: positionAnschlussend[1],
+                rotation: null,
+                diagramObjectName: 'Terminal 2',
+                identifiedObjectUUID: powerTransformerEnd2TerminalUuid
+            }, this.config);
+            createdDiagramObjects.push(terminal2DiagramObject);
+        }
+        for (const diagramObject of createdDiagramObjects) {
+            for (const diagramObjectPoint of diagramObject.diagramObjectPoints) {
+                diagramObjectPoint.xPosition += nsgTrafo2w.xrel;
+                diagramObjectPoint.yPosition += nsgTrafo2w.yrel;
+                diagramObjectPoint.xPosition += nsgStandort.xrel;
+                diagramObjectPoint.yPosition += nsgStandort.yrel;
+            }
+        }
+        const doAKnotenConnectivityNode = this.getExportedDiagramObjectBy(nsgTrafo2w.variantennr, netzTrafo2W.aknoten);
+        if (terminal1DiagramObject && doAKnotenConnectivityNode) {
+            const dopAKnotenConnectivityNode = doAKnotenConnectivityNode.diagramObjectPoints[0];
+            util_functions_1.DLUtilFunctions.copyAndPushDiagramObjectPoint(terminal1DiagramObject, dopAKnotenConnectivityNode, false);
+            this.adjustTransformerTerminalPositions(terminal1DiagramObject, powerTransformerDiagramObject);
+        }
+        const doEKnotenConnectivityNode = this.getExportedDiagramObjectBy(nsgTrafo2w.variantennr, netzTrafo2W.eknoten);
+        if (terminal2DiagramObject && doEKnotenConnectivityNode) {
+            const dopEKnotenConnectivityNode = doEKnotenConnectivityNode.diagramObjectPoints[0];
+            util_functions_1.DLUtilFunctions.copyAndPushDiagramObjectPoint(terminal2DiagramObject, dopEKnotenConnectivityNode, false);
+            this.adjustTransformerTerminalPositions(terminal2DiagramObject, powerTransformerDiagramObject);
+        }
+        return createdDiagramObjects;
+    }
+    /**
+     * convertSchemaTransformer3W
+     */
+    async convertSchemaTransformer3W(nsgTrafo3w) {
+        const nsgStandort = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgstandort, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgTrafo3w.variantennr, id: nsgTrafo3w.nsgso }, false);
+        if (!nsgStandort)
+            return null;
+        const netzTrafo3w = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.netz_trafo3w, convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: nsgTrafo3w.trafo3w });
+        if (!netzTrafo3w)
+            return null;
+        const powerTransformerUUID = this.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: nsgTrafo3w.trafo3w }) ?? undefined;
+        // Der relative Punkt des Transformators ist die linke obere Ecke bezogen auf die 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(nsgTrafo3w.ausrichtung) * 30 + 180) % 360) % 360,
+            diagramObjectName: 'PowerTransformer',
+            identifiedObjectUUID: powerTransformerUUID
+        }, this.config);
+        // 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(nsgTrafo3w.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(nsgTrafo3w.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 = nsgTrafo3w.orientierung_cw === 1;
+        const createdDiagramObjects = [];
+        createdDiagramObjects.push(powerTransformerDiagramObject);
+        let terminal1DiagramObject;
+        let powerTransformerEnd1TerminalUuid = this.lookupTransformerEndTerminalUUIDBy(powerTransformerUUID, netzTrafo3w.guid_w1, 1);
+        if (powerTransformerEnd1TerminalUuid) {
+            terminal1DiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                xPosition: rotationenGroup[exchangeGroup[1]][0],
+                yPosition: rotationenGroup[exchangeGroup[1]][1],
+                diagramObjectName: 'Terminal 1',
+                identifiedObjectUUID: powerTransformerEnd1TerminalUuid
+            }, this.config);
+            createdDiagramObjects.push(terminal1DiagramObject);
+        }
+        let terminal2DiagramObject;
+        let powerTransformerEnd2TerminalUuid = this.lookupTransformerEndTerminalUUIDBy(powerTransformerUUID, netzTrafo3w.guid_w2, 2);
+        if (powerTransformerEnd2TerminalUuid) {
+            terminal2DiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                xPosition: rotationenGroup[exchangeGroup[xMirroring ? 3 : 2]][0],
+                yPosition: rotationenGroup[exchangeGroup[xMirroring ? 3 : 2]][1],
+                diagramObjectName: 'Terminal 2',
+                identifiedObjectUUID: powerTransformerEnd2TerminalUuid
+            }, this.config);
+            createdDiagramObjects.push(terminal2DiagramObject);
+        }
+        let terminal3DiagramObject;
+        let powerTransformerEnd3TerminalUuid = this.lookupTransformerEndTerminalUUIDBy(powerTransformerUUID, netzTrafo3w.guid_w3, 3);
+        if (powerTransformerEnd3TerminalUuid) {
+            terminal3DiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                xPosition: rotationenGroup[exchangeGroup[xMirroring ? 2 : 3]][0],
+                yPosition: rotationenGroup[exchangeGroup[xMirroring ? 2 : 3]][1],
+                diagramObjectName: 'Terminal 3',
+                identifiedObjectUUID: powerTransformerEnd3TerminalUuid
+            }, this.config);
+            createdDiagramObjects.push(terminal3DiagramObject);
+        }
+        for (const diagramObject of createdDiagramObjects) {
+            for (const diagramObjectPoint of diagramObject.diagramObjectPoints) {
+                diagramObjectPoint.xPosition += nsgTrafo3w.xrel;
+                diagramObjectPoint.yPosition += nsgTrafo3w.yrel;
+                diagramObjectPoint.xPosition += nsgStandort.xrel;
+                diagramObjectPoint.yPosition += nsgStandort.yrel;
+            }
+        }
+        // if (nsgTrafo3w.orientierung_cw === 0) {
+        //   //      w1
+        //   //       0
+        //   // w2 <-0 0-> w3
+        const w1TypedResult = this.dbObjectGraph.findTypedFirstByKey(convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, {
+            variantennr: nsgTrafo3w.variantennr, id: nsgTrafo3w.anschluss_w1
+        });
+        if (terminal1DiagramObject && w1TypedResult) {
+            const w1ConnectivityNodePosition = await this.getConnectivityNodePositionFor(w1TypedResult.type, w1TypedResult.object);
+            util_functions_1.DLUtilFunctions.copyAndPushXYCoordinates(terminal1DiagramObject, w1ConnectivityNodePosition, false);
+            this.adjustTransformerTerminalPositions(terminal1DiagramObject, powerTransformerDiagramObject);
+            // } else {
+            //   const powerTransformer: PowerTransformer = this.cimModelGraph.findObjectByUUID(powerTransformerUUID);
+            //   console.log(powerTransformer)
+        }
+        const w2TypedResult = this.dbObjectGraph.findTypedFirstByKey(convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, {
+            variantennr: nsgTrafo3w.variantennr, id: nsgTrafo3w.anschluss_w2
+        });
+        if (terminal2DiagramObject && w2TypedResult) {
+            const w2ConnectivityNodePosition = await this.getConnectivityNodePositionFor(w2TypedResult.type, w2TypedResult.object);
+            util_functions_1.DLUtilFunctions.copyAndPushXYCoordinates(terminal2DiagramObject, w2ConnectivityNodePosition, false);
+            this.adjustTransformerTerminalPositions(terminal2DiagramObject, powerTransformerDiagramObject);
+            // } else {
+            //   const powerTransformer: PowerTransformer = this.cimModelGraph.findObjectByUUID(powerTransformerUUID);
+            //   console.log(powerTransformer)
+        }
+        const w3TypedResult = this.dbObjectGraph.findTypedFirstByKey(convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, {
+            variantennr: nsgTrafo3w.variantennr, id: nsgTrafo3w.anschluss_w3
+        });
+        if (terminal3DiagramObject && w3TypedResult) {
+            const w3ConnectivityNodePosition = await this.getConnectivityNodePositionFor(w3TypedResult.type, w3TypedResult.object);
+            util_functions_1.DLUtilFunctions.copyAndPushXYCoordinates(terminal3DiagramObject, w3ConnectivityNodePosition, false);
+            this.adjustTransformerTerminalPositions(terminal3DiagramObject, powerTransformerDiagramObject);
+            // } else {
+            //   const powerTransformer: PowerTransformer = this.cimModelGraph.findObjectByUUID(powerTransformerUUID);
+            //   console.log(powerTransformer)
+        }
+        return createdDiagramObjects;
+    }
+    lookupTransformerEndTerminalUUIDBy(powerTransformerUuid, powerTransformerEndUuid, endNumber) {
+        if (powerTransformerEndUuid) {
+            if (powerTransformerEndUuid.startsWith('_'))
+                powerTransformerEndUuid = powerTransformerEndUuid.substring(1);
+            let powerTransformerEnd = this.cimModelGraph.findObjectByUUID(powerTransformerEndUuid);
+            if (powerTransformerEnd)
+                return powerTransformerEnd.getTerminalUUID();
+            const powerTransformer = this.cimModelGraph.findObjectByUUID(powerTransformerUuid);
+            if (powerTransformer) {
+                powerTransformerEnd = powerTransformer.powerTransformerEnd.find(pte => pte.getUUID() === powerTransformerEndUuid);
+                if (powerTransformerEnd)
+                    return powerTransformerEnd.getTerminalUUID();
+            }
+        }
+        else {
+            const powerTransformer = this.cimModelGraph.findObjectByUUID(powerTransformerUuid);
+            if (powerTransformer) {
+                let powerTransformerEnd = powerTransformer.powerTransformerEnd.find(pte => pte.getEndNumber() === endNumber);
+                if (powerTransformerEnd)
+                    return powerTransformerEnd.getTerminalUUID();
+            }
+        }
+        return undefined;
+    }
+    /**
+     * getConnectivityNodePositionFor
+     */
+    async getConnectivityNodePositionFor(i7ObjectType, object) {
+        const leftUpperCorner = await this.getLeftUpperCornerOf(i7ObjectType, object);
+        if (i7ObjectType === convert_graph_keys_1.i7TableNames.nsg_nsgknotenso) {
+            return [leftUpperCorner[0] + 16, leftUpperCorner[1] + 16];
+        }
+        else if (i7ObjectType === convert_graph_keys_1.i7TableNames.nsg_nsgschaltfeld) {
+            const nsgSchaltfeld = object;
+            const nsgSaabschnitt = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgsaabschnitt, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgSchaltfeld.variantennr, id: nsgSchaltfeld.nsgsaa });
+            if (!nsgSaabschnitt)
+                return;
+            const nsgSchaltanlage = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgschaltanlage, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgSaabschnitt.variantennr, id: nsgSaabschnitt.nsgsa });
+            if (nsgSchaltanlage === undefined)
+                return;
+            let orientation = nsgSchaltanlage.ausrichtung;
+            if (nsgSchaltfeld.deltaausrichtung === 1) {
+                orientation = (orientation + 2) % 4;
+            }
+            switch (orientation) {
+                case 0: // TOP
+                    return [leftUpperCorner[0] + 16, leftUpperCorner[1]];
+                case 1: // RIGHT
+                    return [leftUpperCorner[0] + nsgSchaltfeld.hoehe, leftUpperCorner[1] + 16];
+                case 2: // BOTTOM
+                    return [leftUpperCorner[0] + 16, leftUpperCorner[1] + nsgSchaltfeld.hoehe];
+                case 3: // LEFT
+                    return [leftUpperCorner[0], leftUpperCorner[1] + 16];
+            }
+        }
+        return [null, null];
+    }
+    /**
+     * convertSchemaLeitung
+     */
+    async convertSchemaLeitung(nsgLeitung, splitLine = true) {
+        let netzLeitung;
+        netzLeitung = await this.dbObjectGraph.findObjectByKey([convert_graph_keys_1.i7TableNames.netz_ersatzlaengszweig], convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: nsgLeitung.leitung });
+        if (netzLeitung) {
+            return this.convertNsgErsatzlaengszweig(nsgLeitung, netzLeitung, splitLine);
+        }
+        netzLeitung = await this.dbObjectGraph.findObjectByKey([
+            convert_graph_keys_1.i7TableNames.netz_leitung, convert_graph_keys_1.i7TableNames.netz_hgueleitung, convert_graph_keys_1.i7TableNames.netz_streckenlast
+        ], convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: nsgLeitung.leitung });
+        if (!netzLeitung)
+            return null;
+        if (nsgLeitung.kopf_anf && nsgLeitung.kopf_end) {
+            // TODO: maybe export the positions of the 'kopf_anf' 'kopf_end'
+            return null;
+        }
+        if ('teilung' in netzLeitung) {
+            return this.convertNsgLeitungStreckenlast(nsgLeitung, netzLeitung, splitLine);
+        }
+        let generalNetzLeitung;
+        if ('anetzobjekt' in netzLeitung) {
+            generalNetzLeitung = {
+                id: netzLeitung.id,
+                bezeichner: netzLeitung.bezeichner,
+                kurzname: netzLeitung.kurzname,
+                aknoten: netzLeitung.anetzobjekt,
+                eknoten: netzLeitung.enetzobjekt,
+                aknotenzw: undefined, eknotenzw: undefined,
+                flakn3p: undefined, flekn3p: undefined
+            };
+        }
+        else {
+            generalNetzLeitung = netzLeitung;
+        }
+        const nsgLtgpunkte = await this.dbObjectGraph.findAllByAttributes(convert_graph_keys_1.i7TableNames.nsg_nsgltgpunkt, { nsgleitung: nsgLeitung.id, variantennr: nsgLeitung.variantennr });
+        // Manche Leitung beinhalten keine Zwischenpunkte, sondern verlaufen lediglich zwischen dem Start- und Endpunkt
+        // if (nsgLtgpunkte.length === 0) return;
+        const cimObjectUUID = this.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: nsgLeitung.leitung }) ?? undefined;
+        nsgLtgpunkte.sort((a, b) => a.pos - b.pos);
+        const diagramObject = new DiagramObject_1.DiagramObject();
+        diagramObject.name = `Leitung ${generalNetzLeitung.id}`;
+        diagramObject.identifiedObjectUUID = cimObjectUUID;
+        diagramObject.mrid = common_utils_1.CommonUtils.generateUUID();
+        diagramObject.rotation = null;
+        const relStartPos = await this.getRelPos(nsgLeitung, true);
+        if (relStartPos === null)
+            return null;
+        const relEndPos = await this.getRelPos(nsgLeitung, false);
+        if (relEndPos === null)
+            return null;
+        const leftUpperCornerStartPos = await this.getLeftUpperCornerOfUnspecified(nsgLeitung.variantennr, nsgLeitung.anschlussanf);
+        const leftUpperCornerEndPos = await this.getLeftUpperCornerOfUnspecified(nsgLeitung.variantennr, nsgLeitung.anschlussend);
+        for (let a = 0; a < nsgLtgpunkte.length; ++a) {
+            const nsgLtgpunkt = nsgLtgpunkte[a];
+            const diagramObjectPoint = new DiagramObjectPoint_1.DiagramObjectPoint();
+            diagramObjectPoint.mrid = common_utils_1.CommonUtils.generateUUID();
+            diagramObject.diagramObjectPoints.push(diagramObjectPoint);
+            diagramObjectPoint.diagramObject = diagramObject;
+            if (nsgLtgpunkt.userelpos === 1) {
+                if (nsgLtgpunkt.reltoanf === 1) {
+                    diagramObjectPoint.xPosition = leftUpperCornerStartPos[0] + nsgLtgpunkt.xrel;
+                    diagramObjectPoint.yPosition = leftUpperCornerStartPos[1] + nsgLtgpunkt.yrel;
+                }
+                else if (nsgLtgpunkt.reltoanf === 0) {
+                    diagramObjectPoint.xPosition = leftUpperCornerEndPos[0] + nsgLtgpunkt.xrel;
+                    diagramObjectPoint.yPosition = leftUpperCornerEndPos[1] + nsgLtgpunkt.yrel;
+                }
+            }
+            else {
+                diagramObjectPoint.xPosition = nsgLtgpunkt.xrel;
+                diagramObjectPoint.yPosition = nsgLtgpunkt.yrel;
+            }
+        }
+        /*
+        left:
+          m: => x
+          c: => y
+        right:
+          m: => x * (-1)
+          c: => y * (-1)
+        top:
+          m: => y
+          c: => x * (-1)
+        bottom:
+          m: => y * (-1)
+          c: => x
+         */
+        const firstDiagramObjectPoint = new DiagramObjectPoint_1.DiagramObjectPoint();
+        firstDiagramObjectPoint.mrid = common_utils_1.CommonUtils.generateUUID();
+        firstDiagramObjectPoint.xPosition = relStartPos[0]; // + xyOffsetFirstPoint[0];
+        firstDiagramObjectPoint.yPosition = relStartPos[1]; // + xyOffsetFirstPoint[1];
+        firstDiagramObjectPoint.diagramObject = diagramObject;
+        diagramObject.diagramObjectPoints.unshift(firstDiagramObjectPoint);
+        const lastDiagramObjectPoint = new DiagramObjectPoint_1.DiagramObjectPoint();
+        lastDiagramObjectPoint.mrid = common_utils_1.CommonUtils.generateUUID();
+        lastDiagramObjectPoint.xPosition = relEndPos[0]; // + xyOffsetLastPoint[0];
+        lastDiagramObjectPoint.yPosition = relEndPos[1]; // + xyOffsetLastPoint[1];
+        lastDiagramObjectPoint.diagramObject = diagramObject;
+        diagramObject.diagramObjectPoints.push(lastDiagramObjectPoint);
+        for (let a = 0; a < diagramObject.diagramObjectPoints.length; ++a) {
+            diagramObject.diagramObjectPoints[a].xPosition += 2;
+            diagramObject.diagramObjectPoints[a].yPosition += 2;
+            diagramObject.diagramObjectPoints[a].sequenceNumber = a + 1;
+        }
+        const resultingDiagramObjects = [];
+        const uuidsOfPlacedCimObject = new Set();
+        const netzLeitungsabschnitte = await this.dbObjectGraph.findAllByAttributes([convert_graph_keys_1.i7TableNames.netz_freileitungabschnitt, convert_graph_keys_1.i7TableNames.netz_kabelabschnitt], { leitung: nsgLeitung.leitung });
+        netzLeitungsabschnitte.sort((a, b) => a.pos - b.pos);
+        if (netzLeitungsabschnitte.length === 0) {
+            splitLine = false;
+        }
+        if (splitLine) {
+            /* ---------- ---------- ---------- */
+            // BEGIN: split the line into line segments
+            // const netzLeitungsabschnitte = await this.dbObjectGraph.findAllByAttributes(
+            //   [i7TableNames.netz_freileitungabschnitt, i7TableNames.netz_kabelabschnitt],
+            //   { leitung: nsgLeitung.leitung }
+            // );
+            // netzLeitungsabschnitte.sort((a, b) => a.pos - b.pos);
+            const segmentPercentages = [];
+            let completeLength = 0;
+            for (let a = 0; a < netzLeitungsabschnitte.length; ++a) {
+                completeLength += netzLeitungsabschnitte[a].laenge ?? 1;
+            }
+            // Berechne die Prozent-Anteile eines Leitungsabschnittes bezogen auf die Gesamtlänge
+            let crtLength = 0;
+            for (let a = 0; a < netzLeitungsabschnitte.length; ++a) {
+                // todo fix if 'laenge' is null (equals to a not-set length)
+                crtLength += netzLeitungsabschnitte[a].laenge ?? 1;
+                segmentPercentages.push(crtLength / completeLength);
+            }
+            const segments = util_functions_1.DLUtilFunctions.splitLineIntoLineSegments(segmentPercentages, diagramObject.diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition]));
+            for (let a = 0; a < segments.length; ++a) {
+                const thisSegmentUUID = this.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: netzLeitungsabschnitte[a].id }) ?? undefined;
+                const thisSegmentCimObject = this.cimModelGraph.findObjectByUUID(thisSegmentUUID);
+                const diagramObject = new DiagramObject_1.DiagramObject();
+                diagramObject.name = `Leitung ${generalNetzLeitung.id}`;
+                diagramObject.identifiedObjectUUID = thisSegmentUUID;
+                diagramObject.mrid = common_utils_1.CommonUtils.generateUUID();
+                diagramObject.rotation = null;
+                // for (const segment of segments[a]) {
+                for (const segmentPoint of segments[a]) {
+                    const diagramObjectPoint = new DiagramObjectPoint_1.DiagramObjectPoint();
+                    diagramObjectPoint.mrid = common_utils_1.CommonUtils.generateUUID();
+                    diagramObjectPoint.xPosition = segmentPoint[0];
+                    diagramObjectPoint.yPosition = segmentPoint[1];
+                    diagramObjectPoint.sequenceNumber = diagramObject.diagramObjectPoints.length + 1;
+                    diagramObjectPoint.diagramObject = diagramObject;
+                    diagramObject.diagramObjectPoints.push(diagramObjectPoint);
+                }
+                // }
+                resultingDiagramObjects.push(diagramObject);
+                if (a === 0) {
+                    // continue (will be added at the end)
+                }
+                else {
+                    if (thisSegmentCimObject) {
+                        // need to get the ConnectivityNode and the Terminal, which connects the current (this) with the prev segment
+                        const prevSegment = netzLeitungsabschnitte[a - 1];
+                        const prevSegmentUUID = this.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: prevSegment.id });
+                        const prevSegmentCimObject = this.cimModelGraph.findObjectByUUID(prevSegmentUUID);
+                        let connectivityNodeUUIDThisToPrev;
+                        let terminalUUIDThisToPrevConnectivityNode;
+                        for (const thisTerminal of thisSegmentCimObject.terminals.values()) {
+                            for (const prevTerminal of prevSegmentCimObject.terminals.values()) {
+                                if (prevTerminal.getConnectivityNodeUUID() === thisTerminal.getConnectivityNodeUUID()) {
+                                    connectivityNodeUUIDThisToPrev = prevTerminal.getConnectivityNodeUUID();
+                                    terminalUUIDThisToPrevConnectivityNode = thisTerminal.getUUID();
+                                    break;
+                                }
+                            }
+                            if (terminalUUIDThisToPrevConnectivityNode) {
+                                break;
+                            }
+                        }
+                        // place the ConnectivityNode (if not being placed cause => maybe a previous iteration has placed it)
+                        if (!uuidsOfPlacedCimObject.has(connectivityNodeUUIDThisToPrev)) {
+                            const doConnectivityNode = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                                xPosition: segments[a][0][0],
+                                yPosition: segments[a][0][1],
+                                diagramObjectName: `CN ${a} - Netz-Leitung ${generalNetzLeitung.id}`,
+                                identifiedObjectUUID: connectivityNodeUUIDThisToPrev
+                            }, this.config);
+                            resultingDiagramObjects.push(doConnectivityNode);
+                        }
+                        // place the terminal
+                        const doTerminal = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                            xPosition: segments[a][0][0],
+                            yPosition: segments[a][0][1],
+                            diagramObjectName: `T (Anf) ${a} - Netz-Leitung ${generalNetzLeitung.id}`,
+                            identifiedObjectUUID: terminalUUIDThisToPrevConnectivityNode
+                        }, this.config);
+                        resultingDiagramObjects.push(doTerminal);
+                        util_functions_1.DLUtilFunctions.copyAndPushXYCoordinates(doTerminal, segments[a][0], true);
+                    }
+                }
+                if (a === segments.length - 1) {
+                    // continue (will be added at the end)
+                }
+                else {
+                    if (thisSegmentCimObject) {
+                        // need to get the ConnectivityNode and the Terminal, which connects the current (this) with the next segment
+                        const nextSegment = netzLeitungsabschnitte[a + 1];
+                        const nextSegmentUUID = this.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: nextSegment.id });
+                        const nextSegmentCimObject = this.cimModelGraph.findObjectByUUID(nextSegmentUUID);
+                        let connectivityNodeUUIDThisToNext;
+                        let terminalUUIDThisToNextConnectivityNode;
+                        for (const thisTerminal of thisSegmentCimObject.terminals.values()) {
+                            for (const nextTerminal of nextSegmentCimObject.terminals.values()) {
+                                if (nextTerminal.getConnectivityNodeUUID() === thisTerminal.getConnectivityNodeUUID()) {
+                                    connectivityNodeUUIDThisToNext = nextTerminal.getConnectivityNodeUUID();
+                                    terminalUUIDThisToNextConnectivityNode = thisTerminal.getUUID();
+                                    break;
+                                }
+                            }
+                            if (terminalUUIDThisToNextConnectivityNode) {
+                                break;
+                            }
+                        }
+                        // place the ConnectivityNode (if not being placed cause => maybe a previous iteration has placed it)
+                        if (!uuidsOfPlacedCimObject.has(connectivityNodeUUIDThisToNext)) {
+                            const doConnectivityNode = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                                xPosition: segments[a][segments[a].length - 1][0],
+                                yPosition: segments[a][segments[a].length - 1][1],
+                                diagramObjectName: `CN ${a} - Netz-Leitung ${generalNetzLeitung.id}`,
+                                identifiedObjectUUID: connectivityNodeUUIDThisToNext
+                            }, this.config);
+                            resultingDiagramObjects.push(doConnectivityNode);
+                        }
+                        // place the terminal
+                        const doTerminal = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                            xPosition: segments[a][segments[a].length - 1][0],
+                            yPosition: segments[a][segments[a].length - 1][1],
+                            diagramObjectName: `T (End) ${a} - Netz-Leitung ${generalNetzLeitung.id}`,
+                            identifiedObjectUUID: terminalUUIDThisToNextConnectivityNode
+                        }, this.config);
+                        resultingDiagramObjects.push(doTerminal);
+                        util_functions_1.DLUtilFunctions.copyAndPushXYCoordinates(doTerminal, segments[a][segments[a].length - 1], true);
+                    }
+                }
+            }
+            // END: split the line into line segments
+            /* ---------- ---------- ---------- */
+        }
+        else {
+            resultingDiagramObjects.push(diagramObject);
+        }
+        /* ---------- ---------- ---------- */
+        // BEGIN: export the first terminal
+        // try {
+        const anschlussanfTypedResult = this.dbObjectGraph.findTypedFirstByKey(convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, {
+            variantennr: nsgLeitung.variantennr, id: nsgLeitung.anschlussanf
+        });
+        const aknotenTerminalUUID = this.lookupTerminalUUID(generalNetzLeitung.aknoten, generalNetzLeitung.id);
+        if (anschlussanfTypedResult && aknotenTerminalUUID) {
+            const connectivityNodePosition = await this.getConnectivityNodePositionFor(anschlussanfTypedResult.type, anschlussanfTypedResult.object);
+            const anfTerminalDiagramObject = this.createTerminalDiagramObjectFromPoints({
+                cePoints: [...connectivityNodePosition], cnPoints: [...connectivityNodePosition],
+                terminalUuid: aknotenTerminalUUID,
+                name: 'Terminal Leitung-Anf'
+            });
+            resultingDiagramObjects.push(anfTerminalDiagramObject);
+        }
+        const anschlussendTypedResult = this.dbObjectGraph.findTypedFirstByKey(convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, {
+            variantennr: nsgLeitung.variantennr, id: nsgLeitung.anschlussend
+        });
+        const eknotenTerminalUUID = this.lookupTerminalUUID(generalNetzLeitung.eknoten, generalNetzLeitung.id);
+        if (anschlussendTypedResult && eknotenTerminalUUID) {
+            const connectivityNodePosition = await this.getConnectivityNodePositionFor(anschlussendTypedResult.type, anschlussendTypedResult.object);
+            const endTerminalDiagramObject = this.createTerminalDiagramObjectFromPoints({
+                cePoints: [...connectivityNodePosition], cnPoints: [...connectivityNodePosition],
+                terminalUuid: eknotenTerminalUUID,
+                name: 'Terminal Leitung-End'
+            });
+            resultingDiagramObjects.push(endTerminalDiagramObject);
+        }
+        // } catch (e) {
+        // console.log(e)
+        // }
+        // END: export the last terminal
+        /* ---------- ---------- ---------- */
+        return resultingDiagramObjects;
+    }
+    /**
+     * convertSchemaLeitung
+     */
+    async convertNsgErsatzlaengszweig(nsgLeitung, netzErsatzlaengszweig, splitLine = true) {
+        if (nsgLeitung.kopf_anf && nsgLeitung.kopf_end) {
+            // TODO: maybe export the positions of the 'kopf_anf' 'kopf_end'
+            return null;
+        }
+        const nsgLtgpunkte = await this.dbObjectGraph.findAllByAttributes(convert_graph_keys_1.i7TableNames.nsg_nsgltgpunkt, { nsgleitung: nsgLeitung.id, variantennr: nsgLeitung.variantennr });
+        // Manche Leitung beinhalten keine Zwischenpunkte, sondern verlaufen lediglich zwischen dem Start- und Endpunkt
+        // if (nsgLtgpunkte.length === 0) return;
+        const cimObjectUUID = this.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: nsgLeitung.leitung }) ?? undefined;
+        nsgLtgpunkte.sort((a, b) => a.pos - b.pos);
+        const diagramObject = new DiagramObject_1.DiagramObject();
+        diagramObject.name = `Leitung ${netzErsatzlaengszweig.id}`;
+        diagramObject.identifiedObjectUUID = cimObjectUUID;
+        diagramObject.mrid = common_utils_1.CommonUtils.generateUUID();
+        diagramObject.rotation = null;
+        const relStartPos = await this.getRelPos(nsgLeitung, true);
+        if (relStartPos === null)
+            return null;
+        const relEndPos = await this.getRelPos(nsgLeitung, false);
+        if (relEndPos === null)
+            return null;
+        const leftUpperCornerStartPos = await this.getLeftUpperCornerOfUnspecified(nsgLeitung.variantennr, nsgLeitung.anschlussanf);
+        const leftUpperCornerEndPos = await this.getLeftUpperCornerOfUnspecified(nsgLeitung.variantennr, nsgLeitung.anschlussend);
+        for (let a = 0; a < nsgLtgpunkte.length; ++a) {
+            const nsgLtgpunkt = nsgLtgpunkte[a];
+            const diagramObjectPoint = new DiagramObjectPoint_1.DiagramObjectPoint();
+            diagramObjectPoint.mrid = common_utils_1.CommonUtils.generateUUID();
+            diagramObject.diagramObjectPoints.push(diagramObjectPoint);
+            diagramObjectPoint.diagramObject = diagramObject;
+            if (nsgLtgpunkt.userelpos === 1) {
+                if (nsgLtgpunkt.reltoanf === 1) {
+                    diagramObjectPoint.xPosition = leftUpperCornerStartPos[0] + nsgLtgpunkt.xrel;
+                    diagramObjectPoint.yPosition = leftUpperCornerStartPos[1] + nsgLtgpunkt.yrel;
+                }
+                else if (nsgLtgpunkt.reltoanf === 0) {
+                    diagramObjectPoint.xPosition = leftUpperCornerEndPos[0] + nsgLtgpunkt.xrel;
+                    diagramObjectPoint.yPosition = leftUpperCornerEndPos[1] + nsgLtgpunkt.yrel;
+                }
+            }
+            else {
+                diagramObjectPoint.xPosition = nsgLtgpunkt.xrel;
+                diagramObjectPoint.yPosition = nsgLtgpunkt.yrel;
+            }
+        }
+        /*
+        left:
+          m: => x
+          c: => y
+        right:
+          m: => x * (-1)
+          c: => y * (-1)
+        top:
+          m: => y
+          c: => x * (-1)
+        bottom:
+          m: => y * (-1)
+          c: => x
+         */
+        const firstDiagramObjectPoint = new DiagramObjectPoint_1.DiagramObjectPoint();
+        firstDiagramObjectPoint.mrid = common_utils_1.CommonUtils.generateUUID();
+        firstDiagramObjectPoint.xPosition = relStartPos[0]; // + xyOffsetFirstPoint[0];
+        firstDiagramObjectPoint.yPosition = relStartPos[1]; // + xyOffsetFirstPoint[1];
+        firstDiagramObjectPoint.diagramObject = diagramObject;
+        diagramObject.diagramObjectPoints.unshift(firstDiagramObjectPoint);
+        const lastDiagramObjectPoint = new DiagramObjectPoint_1.DiagramObjectPoint();
+        lastDiagramObjectPoint.mrid = common_utils_1.CommonUtils.generateUUID();
+        lastDiagramObjectPoint.xPosition = relEndPos[0]; // + xyOffsetLastPoint[0];
+        lastDiagramObjectPoint.yPosition = relEndPos[1]; // + xyOffsetLastPoint[1];
+        lastDiagramObjectPoint.diagramObject = diagramObject;
+        diagramObject.diagramObjectPoints.push(lastDiagramObjectPoint);
+        for (let a = 0; a < diagramObject.diagramObjectPoints.length; ++a) {
+            diagramObject.diagramObjectPoints[a].xPosition += 2;
+            diagramObject.diagramObjectPoints[a].yPosition += 2;
+            diagramObject.diagramObjectPoints[a].sequenceNumber = a + 1;
+        }
+        const resultingDiagramObjects = [];
+        const centerOfLine = util_functions_1.DLUtilFunctions.getLineCenterPoint(diagramObject.diagramObjectPoints);
+        const ersatzLaengszweigDiagramObject = new DiagramObject_1.DiagramObject();
+        ersatzLaengszweigDiagramObject.name = `Leitung ${netzErsatzlaengszweig.id}`;
+        ersatzLaengszweigDiagramObject.identifiedObjectUUID = cimObjectUUID;
+        ersatzLaengszweigDiagramObject.mrid = common_utils_1.CommonUtils.generateUUID();
+        ersatzLaengszweigDiagramObject.rotation = 90;
+        const centeredDiagramObjectPoint = new DiagramObjectPoint_1.DiagramObjectPoint();
+        centeredDiagramObjectPoint.mrid = common_utils_1.CommonUtils.generateUUID();
+        centeredDiagramObjectPoint.xPosition = centerOfLine.x;
+        centeredDiagramObjectPoint.yPosition = centerOfLine.y;
+        centeredDiagramObjectPoint.diagramObject = ersatzLaengszweigDiagramObject;
+        ersatzLaengszweigDiagramObject.diagramObjectPoints.unshift(centeredDiagramObjectPoint);
+        resultingDiagramObjects.push(ersatzLaengszweigDiagramObject);
+        // split the line in two parts
+        // assign the first half to the first terminal and the second half to the second terminal
+        const firstHalfPoints = [];
+        for (let a = 0; a <= centerOfLine.segmentStart; ++a) {
+            const diagramObjectPoint = diagramObject.diagramObjectPoints[a];
+            firstHalfPoints.push([diagramObjectPoint.getXPosition(), diagramObjectPoint.getYPosition()]);
+        }
+        firstHalfPoints.push([centeredDiagramObjectPoint.getXPosition(), centeredDiagramObjectPoint.getYPosition()]);
+        const secondHalfPoints = [];
+        secondHalfPoints.push([centeredDiagramObjectPoint.getXPosition(), centeredDiagramObjectPoint.getYPosition()]);
+        for (let a = centerOfLine.segmentEnd; a < diagramObject.diagramObjectPoints.length; ++a) {
+            const diagramObjectPoint = diagramObject.diagramObjectPoints[a];
+            secondHalfPoints.push([diagramObjectPoint.getXPosition(), diagramObjectPoint.getYPosition()]);
+        }
+        /* ---------- ---------- ---------- */
+        // BEGIN: export the first terminal
+        // try {
+        const anschlussanfTypedResult = this.dbObjectGraph.findTypedFirstByKey(convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, {
+            variantennr: nsgLeitung.variantennr, id: nsgLeitung.anschlussanf
+        });
+        const aknotenTerminalUUID = this.lookupTerminalUUID(netzErsatzlaengszweig.aknoten, netzErsatzlaengszweig.id);
+        if (anschlussanfTypedResult && aknotenTerminalUUID) {
+            const connectivityNodePosition = await this.getConnectivityNodePositionFor(anschlussanfTypedResult.type, anschlussanfTypedResult.object);
+            const anfTerminalDiagramObject = this.createTerminalDiagramObjectFromPoints({
+                // reversed, because otherwise the connectivityNode-Position and the centerPoint are directly "behind" each other
+                points: [...firstHalfPoints.reverse(), connectivityNodePosition],
+                terminalUuid: aknotenTerminalUUID,
+                name: 'Terminal Leitung-Anf'
+            });
+            resultingDiagramObjects.push(anfTerminalDiagramObject);
+        }
+        const anschlussendTypedResult = this.dbObjectGraph.findTypedFirstByKey(convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, {
+            variantennr: nsgLeitung.variantennr, id: nsgLeitung.anschlussend
+        });
+        const eknotenTerminalUUID = this.lookupTerminalUUID(netzErsatzlaengszweig.eknoten, netzErsatzlaengszweig.id);
+        if (anschlussendTypedResult && eknotenTerminalUUID) {
+            const connectivityNodePosition = await this.getConnectivityNodePositionFor(anschlussendTypedResult.type, anschlussendTypedResult.object);
+            const endTerminalDiagramObject = this.createTerminalDiagramObjectFromPoints({
+                points: [...secondHalfPoints, connectivityNodePosition],
+                terminalUuid: eknotenTerminalUUID,
+                name: 'Terminal Leitung-End'
+            });
+            resultingDiagramObjects.push(endTerminalDiagramObject);
+        }
+        // } catch (e) {
+        // console.log(e)
+        // }
+        // END: export the last terminal
+        /* ---------- ---------- ---------- */
+        return resultingDiagramObjects;
+    }
+    /**
+     * convertSchemaQuerzweig
+     */
+    async convertSchemaQuerzweig(nsgQuerzweig) {
+        const resultingDiagramObjects = [];
+        const typedResult = this.dbObjectGraph.findTypedFirstByKey(convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, {
+            variantennr: nsgQuerzweig.variantennr, id: nsgQuerzweig.bezugsobjekt
+        });
+        if (!typedResult)
+            return null;
+        const { type, object } = typedResult;
+        let xPosition = nsgQuerzweig.xrel + 8;
+        let yPosition = nsgQuerzweig.yrel + 8;
+        const querzweigWrapperObject = this.dbObjectGraph.findTypedFirstByKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, {
+            id: nsgQuerzweig.querzweig
+        });
+        if (!querzweigWrapperObject) {
+            return null;
+        }
+        if (querzweigWrapperObject.type === convert_graph_keys_1.i7TableNames.netz_hguekopfklassisch) {
+            xPosition += 8;
+            yPosition += 8;
+        }
+        else if (querzweigWrapperObject.type === convert_graph_keys_1.i7TableNames.netz_hguekopfvsc) {
+            xPosition += 8;
+            yPosition += 8;
+        }
+        const netzQuerzweig = querzweigWrapperObject.object;
+        if (type === convert_graph_keys_1.i7TableNames.nsg_nsgschaltfeld) {
+            const nsgSchaltfeld = object;
+            const leftUpperCornerOfSchaltfeld = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgschaltfeld, nsgSchaltfeld);
+            xPosition += leftUpperCornerOfSchaltfeld[0];
+            yPosition += leftUpperCornerOfSchaltfeld[1];
+        }
+        else {
+            return null;
+        }
+        const cimObjectUUID = this.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: nsgQuerzweig.querzweig }) ?? undefined;
+        const querzweigDiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+            xPosition: xPosition,
+            yPosition: yPosition,
+            rotation: util_functions_1.DLUtilFunctions.getRotationBasedOnQuerzweig(nsgQuerzweig.ausrichtung),
+            diagramObjectName: `DiagramObject ${nsgQuerzweig.querzweig}`,
+            identifiedObjectUUID: cimObjectUUID
+        }, this.config);
+        if (!this.alreadyExported(nsgQuerzweig.variantennr, nsgQuerzweig.querzweig)) {
+            this.addExportedDiagramObjectToGraph(nsgQuerzweig.variantennr, nsgQuerzweig.querzweig, querzweigDiagramObject);
+            resultingDiagramObjects.push(querzweigDiagramObject);
+        }
+        /* ---------- ---------- ---------- */
+        // BEGIN: Terminal-Export
+        const doBackwardConnectivityNode = this.exportedDiagramObjectsGraph[nsgQuerzweig.variantennr][netzQuerzweig.anschluss];
+        const dopBackwardConnectivityNode = doBackwardConnectivityNode.diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+        const dopConductingEquipment = querzweigDiagramObject.diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+        const backwardTerminalUUID = this.lookupTerminalUUID(netzQuerzweig.anschluss, nsgQuerzweig.querzweig);
+        if (!this.exportedTerminalUUIDs.has(backwardTerminalUUID)) {
+            this.exportedTerminalUUIDs.add(backwardTerminalUUID);
+            const terminalDiagramObject = this.createTerminalDiagramObjectFromPoints({
+                cePoints: [...dopConductingEquipment], cnPoints: [...dopBackwardConnectivityNode],
+                terminalUuid: backwardTerminalUUID
+            });
+            resultingDiagramObjects.push(terminalDiagramObject);
+        }
+        // END: Terminal-Export
+        /* ---------- ---------- ---------- */
+        return resultingDiagramObjects;
+    }
+    /**
+     * convertNsgLeitungStreckenlast
+     */
+    async convertNsgLeitungStreckenlast(nsgLeitung, netzStreckenlast, splitLine = true) {
+        const nsgLtgpunkte = await this.dbObjectGraph.findAllByAttributes(convert_graph_keys_1.i7TableNames.nsg_nsgltgpunkt, { nsgleitung: nsgLeitung.id, variantennr: nsgLeitung.variantennr });
+        // Manche Leitung beinhalten keine Zwischenpunkte, sondern verlaufen lediglich zwischen dem Start- und Endpunkt
+        // if (nsgLtgpunkte.length === 0) return;
+        const cimObjectUUID = this.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: nsgLeitung.leitung }) ?? undefined;
+        nsgLtgpunkte.sort((a, b) => a.pos - b.pos);
+        const diagramObject = new DiagramObject_1.DiagramObject();
+        diagramObject.name = `Streckenlast ${netzStreckenlast.id}`;
+        diagramObject.identifiedObjectUUID = cimObjectUUID;
+        diagramObject.mrid = common_utils_1.CommonUtils.generateUUID();
+        diagramObject.rotation = null;
+        const relStartPos = await this.getRelPos(nsgLeitung, true);
+        if (relStartPos === null)
+            return null;
+        const relEndPos = await this.getRelPos(nsgLeitung, false);
+        if (relEndPos === null)
+            return null;
+        const leftUpperCornerStartPos = await this.getLeftUpperCornerOfUnspecified(nsgLeitung.variantennr, nsgLeitung.anschlussanf);
+        const leftUpperCornerEndPos = await this.getLeftUpperCornerOfUnspecified(nsgLeitung.variantennr, nsgLeitung.anschlussend);
+        for (let a = 0; a < nsgLtgpunkte.length; ++a) {
+            const nsgLtgpunkt = nsgLtgpunkte[a];
+            const diagramObjectPoint = new DiagramObjectPoint_1.DiagramObjectPoint();
+            diagramObjectPoint.mrid = common_utils_1.CommonUtils.generateUUID();
+            diagramObject.diagramObjectPoints.push(diagramObjectPoint);
+            diagramObjectPoint.diagramObject = diagramObject;
+            if (nsgLtgpunkt.userelpos === 1) {
+                if (nsgLtgpunkt.reltoanf === 1) {
+                    diagramObjectPoint.xPosition = leftUpperCornerStartPos[0] + nsgLtgpunkt.xrel;
+                    diagramObjectPoint.yPosition = leftUpperCornerStartPos[1] + nsgLtgpunkt.yrel;
+                }
+                else if (nsgLtgpunkt.reltoanf === 0) {
+                    diagramObjectPoint.xPosition = leftUpperCornerEndPos[0] + nsgLtgpunkt.xrel;
+                    diagramObjectPoint.yPosition = leftUpperCornerEndPos[1] + nsgLtgpunkt.yrel;
+                }
+            }
+            else {
+                diagramObjectPoint.xPosition = nsgLtgpunkt.xrel;
+                diagramObjectPoint.yPosition = nsgLtgpunkt.yrel;
+            }
+        }
+        /*
+        left:
+          m: => x
+          c: => y
+        right:
+          m: => x * (-1)
+          c: => y * (-1)
+        top:
+          m: => y
+          c: => x * (-1)
+        bottom:
+          m: => y * (-1)
+          c: => x
+         */
+        const firstDiagramObjectPoint = new DiagramObjectPoint_1.DiagramObjectPoint();
+        firstDiagramObjectPoint.mrid = common_utils_1.CommonUtils.generateUUID();
+        firstDiagramObjectPoint.xPosition = relStartPos[0]; // + xyOffsetFirstPoint[0];
+        firstDiagramObjectPoint.yPosition = relStartPos[1]; // + xyOffsetFirstPoint[1];
+        firstDiagramObjectPoint.diagramObject = diagramObject;
+        diagramObject.diagramObjectPoints.unshift(firstDiagramObjectPoint);
+        const lastDiagramObjectPoint = new DiagramObjectPoint_1.DiagramObjectPoint();
+        lastDiagramObjectPoint.mrid = common_utils_1.CommonUtils.generateUUID();
+        lastDiagramObjectPoint.xPosition = relEndPos[0]; // + xyOffsetLastPoint[0];
+        lastDiagramObjectPoint.yPosition = relEndPos[1]; // + xyOffsetLastPoint[1];
+        lastDiagramObjectPoint.diagramObject = diagramObject;
+        diagramObject.diagramObjectPoints.push(lastDiagramObjectPoint);
+        for (let a = 0; a < diagramObject.diagramObjectPoints.length; ++a) {
+            diagramObject.diagramObjectPoints[a].xPosition += 2;
+            diagramObject.diagramObjectPoints[a].yPosition += 2;
+            diagramObject.diagramObjectPoints[a].sequenceNumber = a + 1;
+        }
+        const resultingDiagramObjects = [];
+        const uuidsOfPlacedCimObject = new Set();
+        const netzLeitungsabschnitte = await this.dbObjectGraph.findAllByAttributes([convert_graph_keys_1.i7TableNames.netz_freileitungabschnitt, convert_graph_keys_1.i7TableNames.netz_kabelabschnitt], { leitung: nsgLeitung.leitung });
+        netzLeitungsabschnitte.sort((a, b) => a.pos - b.pos);
+        if (netzLeitungsabschnitte.length === 0) {
+            splitLine = false;
+        }
+        if (splitLine) {
+            /* ---------- ---------- ---------- */
+            // BEGIN: split the line into line segments
+            // const netzLeitungsabschnitte = await this.dbObjectGraph.findAllByAttributes(
+            //   [i7TableNames.netz_freileitungabschnitt, i7TableNames.netz_kabelabschnitt],
+            //   { leitung: nsgLeitung.leitung }
+            // );
+            // netzLeitungsabschnitte.sort((a, b) => a.pos - b.pos);
+            const segmentPercentages = [];
+            let completeLength = 0;
+            for (let a = 0; a < netzLeitungsabschnitte.length; ++a) {
+                completeLength += netzLeitungsabschnitte[a].laenge ?? 1;
+            }
+            // Berechne die Prozent-Anteile eines Leitungsabschnittes bezogen auf die Gesamtlänge
+            let crtLength = 0;
+            for (let a = 0; a < netzLeitungsabschnitte.length; ++a) {
+                // todo fix if 'laenge' is null (equals to a not-set length)
+                crtLength += netzLeitungsabschnitte[a].laenge ?? 1;
+                segmentPercentages.push(crtLength / completeLength);
+            }
+            const segments = util_functions_1.DLUtilFunctions.splitLineIntoLineSegments(segmentPercentages, diagramObject.diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition]));
+            for (let a = 0; a < segments.length; ++a) {
+                const thisSegmentUUID = this.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: netzLeitungsabschnitte[a].id }) ?? undefined;
+                const thisSegmentCimObject = this.cimModelGraph.findObjectByUUID(thisSegmentUUID);
+                const diagramObject = new DiagramObject_1.DiagramObject();
+                diagramObject.name = `Leitung ${netzStreckenlast.id}`;
+                diagramObject.identifiedObjectUUID = thisSegmentUUID;
+                diagramObject.mrid = common_utils_1.CommonUtils.generateUUID();
+                diagramObject.rotation = null;
+                // for (const segment of segments[a]) {
+                for (const segmentPoint of segments[a]) {
+                    const diagramObjectPoint = new DiagramObjectPoint_1.DiagramObjectPoint();
+                    diagramObjectPoint.mrid = common_utils_1.CommonUtils.generateUUID();
+                    diagramObjectPoint.xPosition = segmentPoint[0];
+                    diagramObjectPoint.yPosition = segmentPoint[1];
+                    diagramObjectPoint.sequenceNumber = diagramObject.diagramObjectPoints.length + 1;
+                    diagramObjectPoint.diagramObject = diagramObject;
+                    diagramObject.diagramObjectPoints.push(diagramObjectPoint);
+                }
+                // }
+                resultingDiagramObjects.push(diagramObject);
+                if (a === 0) {
+                    // continue (will be added at the end)
+                }
+                else {
+                    if (thisSegmentCimObject) {
+                        // need to get the ConnectivityNode and the Terminal, which connects the current (this) with the prev segment
+                        const prevSegment = netzLeitungsabschnitte[a - 1];
+                        const prevSegmentUUID = this.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: prevSegment.id });
+                        const prevSegmentCimObject = this.cimModelGraph.findObjectByUUID(prevSegmentUUID);
+                        let connectivityNodeUUIDThisToPrev;
+                        let terminalUUIDThisToPrevConnectivityNode;
+                        for (const thisTerminal of thisSegmentCimObject.terminals.values()) {
+                            for (const prevTerminal of prevSegmentCimObject.terminals.values()) {
+                                if (prevTerminal.getConnectivityNodeUUID() === thisTerminal.getConnectivityNodeUUID()) {
+                                    connectivityNodeUUIDThisToPrev = prevTerminal.getConnectivityNodeUUID();
+                                    terminalUUIDThisToPrevConnectivityNode = thisTerminal.getUUID();
+                                    break;
+                                }
+                            }
+                            if (terminalUUIDThisToPrevConnectivityNode) {
+                                break;
+                            }
+                        }
+                        // place the ConnectivityNode (if not being placed cause => maybe a previous iteration has placed it)
+                        if (!uuidsOfPlacedCimObject.has(connectivityNodeUUIDThisToPrev)) {
+                            const doConnectivityNode = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                                xPosition: segments[a][0][0],
+                                yPosition: segments[a][0][1],
+                                diagramObjectName: `CN ${a} - Netz-Leitung ${netzStreckenlast.id}`,
+                                identifiedObjectUUID: connectivityNodeUUIDThisToPrev
+                            }, this.config);
+                            resultingDiagramObjects.push(doConnectivityNode);
+                        }
+                        // place the terminal
+                        const doTerminal = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                            xPosition: segments[a][0][0],
+                            yPosition: segments[a][0][1],
+                            diagramObjectName: `T (Anf) ${a} - Netz-Leitung ${netzStreckenlast.id}`,
+                            identifiedObjectUUID: terminalUUIDThisToPrevConnectivityNode
+                        }, this.config);
+                        resultingDiagramObjects.push(doTerminal);
+                        util_functions_1.DLUtilFunctions.copyAndPushXYCoordinates(doTerminal, segments[a][0], true);
+                    }
+                }
+                if (a === segments.length - 1) {
+                    // continue (will be added at the end)
+                }
+                else {
+                    if (thisSegmentCimObject) {
+                        // need to get the ConnectivityNode and the Terminal, which connects the current (this) with the next segment
+                        const nextSegment = netzLeitungsabschnitte[a + 1];
+                        const nextSegmentUUID = this.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: nextSegment.id });
+                        const nextSegmentCimObject = this.cimModelGraph.findObjectByUUID(nextSegmentUUID);
+                        let connectivityNodeUUIDThisToNext;
+                        let terminalUUIDThisToNextConnectivityNode;
+                        for (const thisTerminal of thisSegmentCimObject.terminals.values()) {
+                            for (const nextTerminal of nextSegmentCimObject.terminals.values()) {
+                                if (nextTerminal.getConnectivityNodeUUID() === thisTerminal.getConnectivityNodeUUID()) {
+                                    connectivityNodeUUIDThisToNext = nextTerminal.getConnectivityNodeUUID();
+                                    terminalUUIDThisToNextConnectivityNode = thisTerminal.getUUID();
+                                    break;
+                                }
+                            }
+                            if (terminalUUIDThisToNextConnectivityNode) {
+                                break;
+                            }
+                        }
+                        // place the ConnectivityNode (if not being placed cause => maybe a previous iteration has placed it)
+                        if (!uuidsOfPlacedCimObject.has(connectivityNodeUUIDThisToNext)) {
+                            const doConnectivityNode = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                                xPosition: segments[a][segments[a].length - 1][0],
+                                yPosition: segments[a][segments[a].length - 1][1],
+                                diagramObjectName: `CN ${a} - Netz-Leitung ${netzStreckenlast.id}`,
+                                identifiedObjectUUID: connectivityNodeUUIDThisToNext
+                            }, this.config);
+                            resultingDiagramObjects.push(doConnectivityNode);
+                        }
+                        // place the terminal
+                        const doTerminal = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                            xPosition: segments[a][segments[a].length - 1][0],
+                            yPosition: segments[a][segments[a].length - 1][1],
+                            diagramObjectName: `T (End) ${a} - Netz-Leitung ${netzStreckenlast.id}`,
+                            identifiedObjectUUID: terminalUUIDThisToNextConnectivityNode
+                        }, this.config);
+                        resultingDiagramObjects.push(doTerminal);
+                        util_functions_1.DLUtilFunctions.copyAndPushXYCoordinates(doTerminal, segments[a][segments[a].length - 1], true);
+                    }
+                }
+            }
+            // END: split the line into line segments
+            /* ---------- ---------- ---------- */
+        }
+        else {
+            resultingDiagramObjects.push(diagramObject);
+        }
+        const netzLeitungen = await this.dbObjectGraph.findAllByAttributes(convert_graph_keys_1.i7TableNames.netz_leitung, { streckenlast: netzStreckenlast.id });
+        if (netzLeitungen.length === 2) {
+            /* ---------- ---------- ---------- */
+            // BEGIN: export the first and last terminal
+            // try {
+            const anfId = netzLeitungen[0].eknoten === netzLeitungen[1].aknoten ? netzLeitungen[0].aknoten : netzLeitungen[0].eknoten;
+            const endId = netzLeitungen[0].aknoten === netzLeitungen[1].eknoten ? netzLeitungen[0].eknoten : netzLeitungen[0].aknoten;
+            const doAnfConnectivityNode = this.exportedDiagramObjectsGraph[nsgLeitung.variantennr][anfId];
+            const doEndConnectivityNode = this.exportedDiagramObjectsGraph[nsgLeitung.variantennr][endId];
+            const anschlussanfTypedResult = this.dbObjectGraph.findTypedFirstByKey(convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, {
+                variantennr: nsgLeitung.variantennr, id: nsgLeitung.anschlussend
+            });
+            const anschlussendTypedResult = this.dbObjectGraph.findTypedFirstByKey(convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, {
+                variantennr: nsgLeitung.variantennr, id: nsgLeitung.anschlussend
+            });
+            const aknotenTerminalUUID = this.lookupTerminalUUID(anfId, netzStreckenlast.id);
+            const eknotenTerminalUUID = this.lookupTerminalUUID(endId, netzStreckenlast.id);
+            if (anschlussanfTypedResult && aknotenTerminalUUID && doAnfConnectivityNode) {
+                const mappedPoint = [
+                    doAnfConnectivityNode.diagramObjectPoints[0].xPosition,
+                    doAnfConnectivityNode.diagramObjectPoints[0].yPosition
+                ];
+                const anfTerminalDiagramObject = this.createTerminalDiagramObjectFromPoints({
+                    cePoints: [...mappedPoint], cnPoints: [...mappedPoint],
+                    terminalUuid: aknotenTerminalUUID,
+                    name: 'Terminal Leitung-Anf'
+                });
+                resultingDiagramObjects.push(anfTerminalDiagramObject);
+            }
+            if (anschlussendTypedResult && eknotenTerminalUUID && doEndConnectivityNode) {
+                const mappedPoint = [
+                    doEndConnectivityNode.diagramObjectPoints[0].xPosition,
+                    doEndConnectivityNode.diagramObjectPoints[0].yPosition
+                ];
+                const endTerminalDiagramObject = this.createTerminalDiagramObjectFromPoints({
+                    cePoints: [...mappedPoint], cnPoints: [...mappedPoint],
+                    terminalUuid: eknotenTerminalUUID,
+                    name: 'Terminal Leitung-End'
+                });
+                resultingDiagramObjects.push(endTerminalDiagramObject);
+            }
+            // END: export the first and last terminal
+            /* ---------- ---------- ---------- */
+        }
+        else {
+            console.error(`Streckenlast-Error: Expected exactly two lines for the Terminal-Export, but got ${netzLeitungen.length}!`);
+        }
+        return resultingDiagramObjects;
+    }
+    /**
+     * convertSchemaQuerzweigqcont
+     */
+    async convertSchemaQuerzweigqzcont(nsgQuerzweigqzcont) {
+        const resultingDiagramObjects = [];
+        const typedResult = this.dbObjectGraph.findTypedFirstByKey(convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, {
+            variantennr: nsgQuerzweigqzcont.variantennr, id: nsgQuerzweigqzcont.bezugsobjekt
+        });
+        if (!typedResult)
+            return null;
+        const { type, object } = typedResult;
+        let xPosition = nsgQuerzweigqzcont.xrel + 8;
+        let yPosition = nsgQuerzweigqzcont.yrel + 8;
+        const nsgQuerzweigqzContelems = await this.dbObjectGraph.findAllByAttributes(convert_graph_keys_1.i7TableNames.nsg_nsgquerzweigqzcontelem, 
+        // 'constainer' is correct!
+        { constainer: nsgQuerzweigqzcont.id, variantennr: nsgQuerzweigqzcont.variantennr });
+        // if (!querzweigWrapperObject) {
+        //   return null;
+        // }
+        //
+        // if (querzweigWrapperObject.type === i7TableNames.netz_hguekopfklassisch) {
+        //   xPosition += 8;
+        //   yPosition += 8;
+        // } else if (querzweigWrapperObject.type === i7TableNames.netz_hguekopfvsc) {
+        //   xPosition += 8;
+        //   yPosition += 8;
+        // }
+        if (type === convert_graph_keys_1.i7TableNames.nsg_nsgschaltfeld) {
+            const nsgSchaltfeld = object;
+            const leftUpperCornerOfSchaltfeld = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgschaltfeld, nsgSchaltfeld);
+            xPosition += leftUpperCornerOfSchaltfeld[0];
+            yPosition += leftUpperCornerOfSchaltfeld[1];
+        }
+        else {
+            return null;
+        }
+        for (const nsgQuerzweigqzContelem of nsgQuerzweigqzContelems) {
+            const querzweigWrapperObject = this.dbObjectGraph.findTypedFirstByKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, {
+                id: nsgQuerzweigqzContelem.querzweig
+            });
+            const netzQuerzweig = querzweigWrapperObject.object;
+            const cimObjectUUID = this.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: nsgQuerzweigqzContelem.querzweig }) ?? undefined;
+            const querzweigDiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                xPosition: xPosition,
+                yPosition: yPosition,
+                rotation: util_functions_1.DLUtilFunctions.getRotationBasedOnQuerzweig(nsgQuerzweigqzcont.ausrichtung),
+                diagramObjectName: `DiagramObject ${nsgQuerzweigqzcont.querzweig}`,
+                identifiedObjectUUID: cimObjectUUID
+            }, this.config);
+            this.addExportedDiagramObjectToGraph(nsgQuerzweigqzcont.variantennr, nsgQuerzweigqzcont.querzweig, querzweigDiagramObject);
+            resultingDiagramObjects.push(querzweigDiagramObject);
+            /* ---------- ---------- ---------- */
+            // BEGIN: Terminal-Export
+            const doBackwardConnectivityNode = this.exportedDiagramObjectsGraph[nsgQuerzweigqzContelem.variantennr][netzQuerzweig.anschluss];
+            const dopBackwardConnectivityNode = doBackwardConnectivityNode.diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+            const dopConductingEquipment = querzweigDiagramObject.diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+            const backwardTerminalUUID = this.lookupTerminalUUID(netzQuerzweig.anschluss, nsgQuerzweigqzContelem.querzweig);
+            if (!this.exportedTerminalUUIDs.has(backwardTerminalUUID)) {
+                this.exportedTerminalUUIDs.add(backwardTerminalUUID);
+                const terminalDiagramObject = this.createTerminalDiagramObjectFromPoints({
+                    cePoints: [...dopConductingEquipment], cnPoints: [...dopBackwardConnectivityNode],
+                    terminalUuid: backwardTerminalUUID
+                });
+                resultingDiagramObjects.push(terminalDiagramObject);
+            }
+            // END: Terminal-Export
+            /* ---------- ---------- ---------- */
+        }
+        return resultingDiagramObjects;
+    }
+    /**
+     * convertSchemaNsgLKupplungRss
+     */
+    async convertSchemaNsgLKupplungRss(nsgLKupplungRss) {
+        const resultingDiagramObjects = [];
+        const netzLKupplung = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.netz_lkupplung, convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: nsgLKupplungRss.lkupplung });
+        if (!netzLKupplung)
+            return;
+        const nsgSaabschnittAnf = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgsaabschnitt, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgLKupplungRss.variantennr, id: nsgLKupplungRss.nsgsaa_anf });
+        if (!nsgSaabschnittAnf)
+            return;
+        const nsgSaabschnittEnd = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgsaabschnitt, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgLKupplungRss.variantennr, id: nsgLKupplungRss.nsgsaa_end });
+        if (!nsgSaabschnittEnd)
+            return;
+        const nsgSchaltanlage = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgschaltanlage, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgLKupplungRss.variantennr, id: nsgSaabschnittAnf.nsgsa });
+        if (!nsgSchaltanlage)
+            return;
+        const coordsSlotAnf = await this.getLeftUpperCornerOfLKupplungRssElement(nsgLKupplungRss, { slot_anf: true });
+        const coordsSelf = await this.getLeftUpperCornerOfLKupplungRssElement(nsgLKupplungRss, { self: true });
+        const coordsSlotEnd = await this.getLeftUpperCornerOfLKupplungRssElement(nsgLKupplungRss, { slot_end: true });
+        let coordsSelfAnfDock;
+        let coordsSelfEndDock;
+        let coordsSelfCenter;
+        switch (nsgLKupplungRss.ausrichtung) {
+            case 0:
+                coordsSelfAnfDock = [coordsSelf[0] + 16, coordsSelf[1] + 8];
+                coordsSelfCenter = [coordsSelf[0] + 8, coordsSelf[1] + 8];
+                coordsSelfEndDock = [coordsSelf[0], coordsSelf[1] + 8];
+                break;
+            case 1:
+                coordsSelfAnfDock = [coordsSelf[0] + 8, coordsSelf[1] + 16];
+                coordsSelfCenter = [coordsSelf[0] + 8, coordsSelf[1] + 8];
+                coordsSelfEndDock = [coordsSelf[0] + 8, coordsSelf[1]];
+                break;
+            case 2:
+                coordsSelfAnfDock = [coordsSelf[0], coordsSelf[1] + 8];
+                coordsSelfCenter = [coordsSelf[0] + 8, coordsSelf[1] + 8];
+                coordsSelfEndDock = [coordsSelf[0] + 16, coordsSelf[1] + 8];
+                break;
+            case 3:
+                coordsSelfAnfDock = [coordsSelf[0] + 8, coordsSelf[1]];
+                coordsSelfCenter = [coordsSelf[0] + 8, coordsSelf[1] + 8];
+                coordsSelfEndDock = [coordsSelf[0] + 8, coordsSelf[1] + 16];
+                break;
+        }
+        let bendnodeOfAnf;
+        let bendnodeOfEnd;
+        switch (nsgSchaltanlage.ausrichtung) {
+            case 0:
+            case 2:
+                coordsSlotAnf[0] += 16;
+                coordsSlotAnf[1] += 12;
+                coordsSlotEnd[0] += 16;
+                coordsSlotEnd[1] += 12;
+                bendnodeOfAnf = [coordsSlotAnf[0], coordsSelfAnfDock[1]];
+                bendnodeOfEnd = [coordsSlotEnd[0], coordsSelfEndDock[1]];
+                break;
+            case 1:
+            case 3:
+                coordsSlotAnf[0] += 12;
+                coordsSlotAnf[1] += 16;
+                coordsSlotEnd[0] += 12;
+                coordsSlotEnd[1] += 16;
+                bendnodeOfAnf = [coordsSelfAnfDock[0], coordsSlotAnf[1]];
+                bendnodeOfEnd = [coordsSelfEndDock[0], coordsSlotEnd[1]];
+                break;
+        }
+        const netzSsabs = await this.dbObjectGraph.findByAttributes(convert_graph_keys_1.i7TableNames.netz_ssab, {
+            saabschnitt: {
+                in: [nsgSaabschnittAnf.saabschnitt, nsgSaabschnittEnd.saabschnitt]
+            }
+        });
+        const lkupplungNodes = await this.getNodesOfLKupplung(netzLKupplung);
+        const netzSsabsIds = new Set(netzSsabs.map(arg => arg.id));
+        const ssabConnectedNodes = lkupplungNodes.filter(elem => netzSsabsIds.has(elem.aknoten) || netzSsabsIds.has(elem.eknoten));
+        const nodePointMap = new Map();
+        if (lkupplungNodes.length === 1 && netzSsabsIds.has(lkupplungNodes[0].aknoten) && netzSsabsIds.has(lkupplungNodes[0].eknoten)) {
+            const rotationValue = 360 - (nsgLKupplungRss.ausrichtung + 1 % 4) * 90;
+            const ssabConnectedNode = ssabConnectedNodes[0];
+            const aKnotenSsab = netzSsabs.find(arg => arg.id === ssabConnectedNode.aknoten);
+            const eKnotenSsab = netzSsabs.find(arg => arg.id === ssabConnectedNode.eknoten);
+            switch (nsgSchaltanlage.ausrichtung) {
+                case 0:
+                case 2:
+                    coordsSlotAnf[1] += aKnotenSsab.pos * 8;
+                    coordsSlotEnd[1] += eKnotenSsab.pos * 8;
+                    break;
+                case 1:
+                case 3:
+                    coordsSlotAnf[0] += aKnotenSsab.pos * 8;
+                    coordsSlotEnd[0] += eKnotenSsab.pos * 8;
+                    break;
+            }
+            if (await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.netz_sestarr3p, convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: ssabConnectedNode.id })) {
+                // cause 'starre Verbindungen' are modelled as junctions, there must be two points extracted
+                // those two points are equal to the connectivity node positions and the rotation value is unnecessary
+                const aKnotenPosition = [...coordsSlotAnf];
+                const eKnotenPosition = [...coordsSlotEnd];
+                const junctionCoordinates = [coordsSelfAnfDock, coordsSelfEndDock];
+                nodePointMap.set(ssabConnectedNode.id, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoints(junctionCoordinates, null));
+                nodePointMap.set(ssabConnectedNode.aknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(aKnotenPosition[0], aKnotenPosition[1], null));
+                nodePointMap.set(ssabConnectedNode.eknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(eKnotenPosition[0], eKnotenPosition[1], null));
+            }
+            else {
+                const aKnotenPosition = [...coordsSlotAnf];
+                const eKnotenPosition = [...coordsSlotEnd];
+                const switchCoordinates = [...coordsSelfCenter];
+                nodePointMap.set(ssabConnectedNode.id, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(switchCoordinates[0], switchCoordinates[1], rotationValue));
+                nodePointMap.set(ssabConnectedNode.aknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(aKnotenPosition[0], aKnotenPosition[1], null));
+                nodePointMap.set(ssabConnectedNode.eknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(eKnotenPosition[0], eKnotenPosition[1], null));
+            }
+            const terminalAnfUUID = this.lookupTerminalUUID(ssabConnectedNode.aknoten, ssabConnectedNode.id);
+            // if (!this.exportedTerminalUUIDs.has(terminalAnfUUID)) {
+            this.exportedTerminalUUIDs.add(terminalAnfUUID);
+            const terminalAnfDiagramObject = this.createTerminalDiagramObjectFromPoints({
+                points: [coordsSelfAnfDock, bendnodeOfAnf, coordsSlotAnf],
+                terminalUuid: terminalAnfUUID
+            });
+            resultingDiagramObjects.push(terminalAnfDiagramObject);
+            // }
+            const terminalEndUUID = this.lookupTerminalUUID(ssabConnectedNode.eknoten, ssabConnectedNode.id);
+            // if (!this.exportedTerminalUUIDs.has(terminalEndUUID)) {
+            this.exportedTerminalUUIDs.add(terminalEndUUID);
+            const terminalEndDiagramObject = this.createTerminalDiagramObjectFromPoints({
+                points: [coordsSelfEndDock, bendnodeOfEnd, coordsSlotEnd],
+                terminalUuid: terminalEndUUID
+            });
+            resultingDiagramObjects.push(terminalEndDiagramObject);
+            // }
+        }
+        else if (lkupplungNodes.length === 2 &&
+            (netzSsabsIds.has(lkupplungNodes[0].aknoten) || netzSsabsIds.has(lkupplungNodes[0].eknoten)) &&
+            (netzSsabsIds.has(lkupplungNodes[1].aknoten) || netzSsabsIds.has(lkupplungNodes[1].eknoten))) {
+            let aKnotenSsabNode;
+            let aKnotenSsabId;
+            let eKnotenSsabNode;
+            let eKnotenSsabId;
+            let inbetweenNodeId;
+            if (netzSsabsIds.has(lkupplungNodes[0].aknoten)) {
+                aKnotenSsabId = lkupplungNodes[0].aknoten;
+                aKnotenSsabNode = lkupplungNodes[0];
+                eKnotenSsabId = lkupplungNodes[1].eknoten;
+                eKnotenSsabNode = lkupplungNodes[1];
+                inbetweenNodeId = lkupplungNodes[1].aknoten;
+            }
+            else {
+                aKnotenSsabId = lkupplungNodes[1].aknoten;
+                aKnotenSsabNode = lkupplungNodes[1];
+                eKnotenSsabId = lkupplungNodes[0].eknoten;
+                eKnotenSsabNode = lkupplungNodes[0];
+                inbetweenNodeId = lkupplungNodes[0].aknoten;
+            }
+            const aKnotenSsab = netzSsabs.find(arg => arg.id === aKnotenSsabNode.aknoten);
+            const eKnotenSsab = netzSsabs.find(arg => arg.id === eKnotenSsabNode.eknoten);
+            switch (nsgSchaltanlage.ausrichtung) {
+                case 0:
+                case 2:
+                    coordsSlotAnf[1] += aKnotenSsab.pos * 8;
+                    coordsSlotEnd[1] += eKnotenSsab.pos * 8;
+                    break;
+                case 1:
+                case 3:
+                    coordsSlotAnf[0] += aKnotenSsab.pos * 8;
+                    coordsSlotEnd[0] += eKnotenSsab.pos * 8;
+                    break;
+            }
+            const aKnotenPosition = [...coordsSlotAnf];
+            const eKnotenPosition = [...coordsSlotEnd];
+            let rotationValue;
+            switch (nsgSchaltanlage.ausrichtung) {
+                case 0:
+                case 2:
+                    rotationValue = 0;
+                    break;
+                case 1:
+                case 3:
+                    rotationValue = 270;
+                    break;
+            }
+            nodePointMap.set(aKnotenSsabNode.aknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(aKnotenPosition[0], aKnotenPosition[1], null));
+            const terminalAnfUUID = this.lookupTerminalUUID(aKnotenSsabNode.aknoten, aKnotenSsabNode.id);
+            // if (!this.exportedTerminalUUIDs.has(terminalAnfUUID)) {
+            this.exportedTerminalUUIDs.add(terminalAnfUUID);
+            const terminalAnfDiagramObject = this.createTerminalDiagramObjectFromPoints({
+                points: [aKnotenPosition, aKnotenPosition],
+                terminalUuid: terminalAnfUUID
+            });
+            resultingDiagramObjects.push(terminalAnfDiagramObject);
+            // }
+            nodePointMap.set(aKnotenSsabNode.id, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(aKnotenPosition[0], aKnotenPosition[1], rotationValue));
+            const terminalAnfInbetweenUUID = this.lookupTerminalUUID(inbetweenNodeId, aKnotenSsabNode.id);
+            // if (!this.exportedTerminalUUIDs.has(terminalAnfInbetweenUUID)) {
+            this.exportedTerminalUUIDs.add(terminalAnfInbetweenUUID);
+            const terminalAnfInbetweenDiagramObject = this.createTerminalDiagramObjectFromPoints({
+                points: [aKnotenPosition, bendnodeOfAnf, coordsSelfCenter],
+                terminalUuid: terminalAnfInbetweenUUID
+            });
+            resultingDiagramObjects.push(terminalAnfInbetweenDiagramObject);
+            // }
+            nodePointMap.set(inbetweenNodeId, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(coordsSelfCenter[0], coordsSelfCenter[1], null));
+            const terminalEndInbetweenUUID = this.lookupTerminalUUID(inbetweenNodeId, eKnotenSsabNode.id);
+            // if (!this.exportedTerminalUUIDs.has(terminalEndInbetweenUUID)) {
+            this.exportedTerminalUUIDs.add(terminalEndInbetweenUUID);
+            const terminalndInbetweenDiagramObject = this.createTerminalDiagramObjectFromPoints({
+                points: [eKnotenPosition, bendnodeOfEnd, coordsSelfCenter],
+                terminalUuid: terminalEndInbetweenUUID
+            });
+            resultingDiagramObjects.push(terminalndInbetweenDiagramObject);
+            // }
+            nodePointMap.set(eKnotenSsabNode.id, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(eKnotenPosition[0], eKnotenPosition[1], rotationValue));
+            const terminalEndUUID = this.lookupTerminalUUID(eKnotenSsabNode.eknoten, eKnotenSsabNode.id);
+            // if (!this.exportedTerminalUUIDs.has(terminalEndUUID)) {
+            this.exportedTerminalUUIDs.add(terminalEndUUID);
+            const terminalEndDiagramObject = this.createTerminalDiagramObjectFromPoints({
+                points: [eKnotenPosition, eKnotenPosition],
+                terminalUuid: terminalEndUUID
+            });
+            resultingDiagramObjects.push(terminalEndDiagramObject);
+            // }
+            nodePointMap.set(eKnotenSsabNode.eknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(eKnotenPosition[0], eKnotenPosition[1], null));
+        }
+        else {
+            for (const ssabConnectedNode of ssabConnectedNodes) {
+                const idOfSsab = netzSsabsIds.has(ssabConnectedNode.aknoten) ? ssabConnectedNode.aknoten : ssabConnectedNode.eknoten;
+                const leftUpperCornerOfSsab = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.netz_ssab, netzSsabs.find(arg => arg.id === idOfSsab), nsgLKupplungRss.variantennr);
+                // needed to get the correct behaviour for universal couplings
+                const breakerNode = lkupplungNodes.find(arg => arg.aknoten === ssabConnectedNode.eknoten);
+                if (netzSsabsIds.has(ssabConnectedNode.aknoten) && breakerNode) {
+                    // place on 'left' side of the coupling-field (but at the end of the busbar)
+                    let rotationValue;
+                    const position = [null, null];
+                    const aKnotenPosition = [null, null]; // connectivity node to busbar
+                    switch (nsgSchaltanlage.ausrichtung) {
+                        case 0: // left to right
+                            position[0] = coordsSlotAnf[0];
+                            position[1] = leftUpperCornerOfSsab[1];
+                            rotationValue = 0;
+                            aKnotenPosition[0] = coordsSlotAnf[0];
+                            aKnotenPosition[1] = leftUpperCornerOfSsab[1];
+                            break;
+                        case 1: // top to bottom
+                            position[0] = leftUpperCornerOfSsab[0];
+                            position[1] = coordsSlotAnf[1];
+                            rotationValue = 270;
+                            aKnotenPosition[0] = leftUpperCornerOfSsab[0];
+                            aKnotenPosition[1] = coordsSlotAnf[1];
+                            break;
+                        case 2: // right to left
+                            position[0] = coordsSlotAnf[0];
+                            position[1] = leftUpperCornerOfSsab[1];
+                            rotationValue = 0;
+                            aKnotenPosition[0] = coordsSlotAnf[0];
+                            aKnotenPosition[1] = leftUpperCornerOfSsab[1];
+                            break;
+                        case 3: // bottom to top
+                            position[0] = leftUpperCornerOfSsab[0];
+                            position[1] = coordsSlotAnf[1];
+                            rotationValue = 270;
+                            aKnotenPosition[0] = leftUpperCornerOfSsab[0];
+                            aKnotenPosition[1] = coordsSlotAnf[1];
+                            break;
+                    }
+                    nodePointMap.set(ssabConnectedNode.id, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(position[0], position[1], rotationValue));
+                    nodePointMap.set(ssabConnectedNode.aknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(aKnotenPosition[0], aKnotenPosition[1], null));
+                }
+                else {
+                    // place on 'right' side of the coupling-field (but at the start of the busbar)
+                    let rotationValue;
+                    const position = [null, null];
+                    const eKnotenPosition = [null, null]; // connectivity node to busbar
+                    switch (nsgSchaltanlage.ausrichtung) {
+                        case 0: // left to right
+                            position[0] = coordsSlotEnd[0];
+                            position[1] = leftUpperCornerOfSsab[1];
+                            rotationValue = 0;
+                            eKnotenPosition[0] = coordsSlotEnd[0];
+                            eKnotenPosition[1] = leftUpperCornerOfSsab[1];
+                            break;
+                        case 1: // top to bottom
+                            position[0] = leftUpperCornerOfSsab[0];
+                            position[1] = coordsSlotEnd[1];
+                            rotationValue = 270;
+                            eKnotenPosition[0] = leftUpperCornerOfSsab[0];
+                            eKnotenPosition[1] = coordsSlotEnd[1];
+                            break;
+                        case 2: // right to left
+                            position[0] = coordsSlotEnd[0];
+                            position[1] = leftUpperCornerOfSsab[1];
+                            rotationValue = 0;
+                            eKnotenPosition[0] = coordsSlotEnd[0];
+                            eKnotenPosition[1] = leftUpperCornerOfSsab[1];
+                            break;
+                        case 3: // bottom to top
+                            position[0] = leftUpperCornerOfSsab[0];
+                            position[1] = coordsSlotEnd[1];
+                            rotationValue = 270;
+                            eKnotenPosition[0] = leftUpperCornerOfSsab[0];
+                            eKnotenPosition[1] = coordsSlotEnd[1];
+                            break;
+                    }
+                    nodePointMap.set(ssabConnectedNode.id, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(position[0], position[1], rotationValue));
+                    nodePointMap.set(
+                    // needed to get the correct behaviour for universal couplings
+                    netzSsabsIds.has(ssabConnectedNode.aknoten) ? ssabConnectedNode.aknoten : ssabConnectedNode.eknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(eKnotenPosition[0], eKnotenPosition[1], null));
+                }
+            }
+            if (ssabConnectedNodes.length > 2) {
+                // universal-coupling ==> breaker must be placed 'on top' of the coupling
+                const startSsabConnectedNode = lkupplungNodes.filter(elem => netzSsabsIds.has(elem.aknoten));
+                // if (startSsabConnectedNode.length === 1 && !nodePointMap.has(startSsabConnectedNode[0].eknoten)) {
+                const breakerNode = lkupplungNodes.find(arg => arg.aknoten === startSsabConnectedNode[0].eknoten || arg.eknoten === startSsabConnectedNode[0].eknoten);
+                const rotationValue = 360 - (nsgLKupplungRss.ausrichtung + 1 % 4) * 90;
+                nodePointMap.set(breakerNode.id, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(coordsSelfCenter[0], coordsSelfCenter[1], rotationValue));
+                nodePointMap.set(breakerNode.aknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(bendnodeOfAnf[0], bendnodeOfAnf[1], null));
+                nodePointMap.set(breakerNode.eknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(bendnodeOfEnd[0], bendnodeOfEnd[1], null));
+            }
+            else {
+                const startSsabConnectedNode = lkupplungNodes.filter(elem => netzSsabsIds.has(elem.aknoten));
+                if (startSsabConnectedNode.length === 1 && !nodePointMap.has(startSsabConnectedNode[0].eknoten)) {
+                    const centeredNode = lkupplungNodes.find(arg => arg.aknoten === startSsabConnectedNode[0].eknoten);
+                    const rotationValue = 360 - (nsgLKupplungRss.ausrichtung + 1 % 4) * 90;
+                    nodePointMap.set(centeredNode.id, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(coordsSelfCenter[0], coordsSelfCenter[1], rotationValue));
+                    nodePointMap.set(centeredNode.aknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(bendnodeOfAnf[0], bendnodeOfAnf[1], null));
+                    nodePointMap.set(centeredNode.eknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(bendnodeOfEnd[0], bendnodeOfEnd[1], null));
+                }
+            }
+            /* ---------- ---------- ---------- */
+            // BEGIN: Terminal-Export
+            for (const lkupplungNode of lkupplungNodes) {
+                const doBackwardConnectivityNode = nodePointMap.get(lkupplungNode.aknoten);
+                const doConductingEquipment = nodePointMap.get(lkupplungNode.id);
+                const doForwardConnectivityNode = nodePointMap.get(lkupplungNode.eknoten);
+                const dopBackwardConnectivityNode = doBackwardConnectivityNode?.diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+                const dopsConductingEquipment = doConductingEquipment?.diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition]);
+                const dopForwardConnectivityNode = doForwardConnectivityNode?.diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+                if (!dopBackwardConnectivityNode || !dopsConductingEquipment || !dopForwardConnectivityNode)
+                    continue;
+                const backwardTerminalUUID = this.lookupTerminalUUID(lkupplungNode.aknoten, lkupplungNode.id);
+                // if (!this.exportedTerminalUUIDs.has(backwardTerminalUUID)) {
+                this.exportedTerminalUUIDs.add(backwardTerminalUUID);
+                const terminalbackwardDiagramObject = this.createTerminalDiagramObjectFromPoints({
+                    cePoints: dopsConductingEquipment[0], cnPoints: dopBackwardConnectivityNode,
+                    terminalUuid: backwardTerminalUUID
+                });
+                resultingDiagramObjects.push(terminalbackwardDiagramObject);
+                // }
+                const forwardTerminalUUID = this.lookupTerminalUUID(lkupplungNode.eknoten, lkupplungNode.id);
+                // if (!this.exportedTerminalUUIDs.has(forwardTerminalUUID)) {
+                this.exportedTerminalUUIDs.add(forwardTerminalUUID);
+                const terminalforwardDiagramObject = this.createTerminalDiagramObjectFromPoints({
+                    cePoints: dopsConductingEquipment[dopsConductingEquipment.length - 1], cnPoints: dopForwardConnectivityNode,
+                    terminalUuid: forwardTerminalUUID
+                });
+                resultingDiagramObjects.push(terminalforwardDiagramObject);
+                // }
+            }
+            // END: Terminal-Export
+            /* ---------- ---------- ---------- */
+        }
+        for (const nodePointEntry of nodePointMap.entries()) {
+            const key = nodePointEntry[0];
+            const value = nodePointEntry[1];
+            const cimObjectUUID = this.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: key }) ?? undefined;
+            value.identifiedObjectUUID = cimObjectUUID;
+            if (!this.alreadyExported(nsgLKupplungRss.variantennr, key)) {
+                resultingDiagramObjects.push(value);
+                // this.addExportedDiagramObjectToGraph(nsgLKupplungRss.variantennr, key, value) // todo check if this causes problems
+            }
+        }
+        return resultingDiagramObjects;
+    }
+    /**
+     * getRelPos
+     */
+    async getRelPos(nsgLeitung, aknoten) {
+        // const netzLeitung = await this.dbObjectGraph.findObjectByKey(i7TableNames.netz_leitung,
+        //   i7SchemaKeyNames.IdOnlyKey, { id: nsgLeitung.leitung }
+        // );
+        // if (!netzLeitung) return;
+        const idOfNsgKnoten = aknoten ? nsgLeitung.anschlussanf : nsgLeitung.anschlussend;
+        const typedResult = this.dbObjectGraph.findTypedFirstByKey(convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, {
+            variantennr: nsgLeitung.variantennr, id: idOfNsgKnoten
+        });
+        if (!typedResult)
+            return null;
+        const { type, object } = typedResult;
+        if (type === convert_graph_keys_1.i7TableNames.nsg_nsgknotenso) {
+            const relPos = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgknotenso, object);
+            return [relPos[0] + 32 / 2 - 2, relPos[1] + 32 / 2 - 2];
+        }
+        else if (type === convert_graph_keys_1.i7TableNames.nsg_nsgknotenhgue) {
+            const relPos = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgknotenhgue, object);
+            return [relPos[0] + 32 / 2 - 2, relPos[1] + 32 / 2 - 2];
+        }
+        else if (type === convert_graph_keys_1.i7TableNames.nsg_nsgschaltfeld) {
+            const nsgSchaltfeld = object;
+            const nsgSaabschnitt = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgsaabschnitt, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgSchaltfeld.variantennr, id: nsgSchaltfeld.nsgsaa });
+            if (!nsgSaabschnitt)
+                return;
+            const nsgSchaltanlage = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgschaltanlage, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgSaabschnitt.variantennr, id: nsgSaabschnitt.nsgsa });
+            if (nsgSchaltanlage === undefined)
+                return;
+            const nsgStandort = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgstandort, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgSchaltanlage.variantennr, id: nsgSchaltanlage.nsgso });
+            if (!nsgStandort)
+                return;
+            let orientation = nsgSchaltanlage.ausrichtung;
+            if (nsgSchaltfeld.deltaausrichtung === 1) {
+                orientation = (orientation + 2) % 4;
+            }
+            const relPos = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgschaltfeld, nsgSchaltfeld);
+            switch (orientation) {
+                case 0: // TOP
+                    relPos[0] += 16;
+                    break;
+                case 1: // RIGHT
+                    relPos[0] += nsgSchaltfeld.hoehe;
+                    relPos[1] += 16;
+                    break;
+                case 2: // BOTTOM
+                    relPos[0] += 16;
+                    relPos[1] += nsgSchaltfeld.hoehe;
+                    break;
+                case 3: // LEFT
+                    relPos[1] += 16;
+                    break;
+            }
+            relPos[0] -= 2;
+            relPos[1] -= 2;
+            return relPos;
+        }
+        else if (type === convert_graph_keys_1.i7TableNames.nsg_nsgquerzweig) {
+            const relPos = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgquerzweig, object);
+            return [relPos[0] + 32 / 2 - 2, relPos[1] + 32 / 2 - 2];
+        }
+        return [];
+    }
+    /**
+     * convertSchemaKpfeld
+     */
+    async convertSchemaKpfeld(nsgKpfeld) {
+        const resultingDiagramObjects = [];
+        const nsgSaabschnitt = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgsaabschnitt, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgKpfeld.variantennr, id: nsgKpfeld.nsgsaa }, false);
+        if (!nsgSaabschnitt)
+            return;
+        const nsgSchaltanlage = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgschaltanlage, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgKpfeld.variantennr, id: nsgSaabschnitt.nsgsa }, false);
+        if (!nsgSchaltanlage)
+            return;
+        const nsgStandort = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgstandort, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgKpfeld.variantennr, id: nsgSchaltanlage.nsgso }, false);
+        if (!nsgStandort)
+            return;
+        const netzSsabs = await this.dbObjectGraph.findAllByAttributes(convert_graph_keys_1.i7TableNames.netz_ssab, {
+            saabschnitt: nsgSaabschnitt.saabschnitt
+        });
+        let couplerOrientation = nsgSchaltanlage.ausrichtung;
+        if (nsgKpfeld.deltaausrichtung === 1) {
+            couplerOrientation = (couplerOrientation + 2) % 4;
+        }
+        const leftUpperCornerOfCoupler = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgkpfeld, nsgKpfeld);
+        const kpfeldNodes = await this.getNodesOfKpfeld(nsgKpfeld);
+        let containsLeistungsschalter = false;
+        let leistungsschalterNode = null;
+        for (const kpfeldNode of kpfeldNodes) {
+            if (!containsLeistungsschalter) {
+                leistungsschalterNode = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.netz_leistungsschalter, convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: kpfeldNode.id }, false);
+                if (leistungsschalterNode) {
+                    containsLeistungsschalter = true;
+                }
+            }
+        }
+        const netzSsabsIds = new Set(netzSsabs.map(arg => arg.id));
+        const maxSsabPos = await this.getMaxPosOfSaabschnitt(nsgSaabschnitt);
+        const nodePointMap = new Map();
+        if (containsLeistungsschalter) {
+            const onSsabNodes = kpfeldNodes.filter(elem => netzSsabsIds.has(elem.aknoten) || netzSsabsIds.has(elem.eknoten));
+            // first: place the disconnectors (and the connectivity nodes) on the busbar sections
+            for (const onSsabNode of onSsabNodes) {
+                const idOfSsab = netzSsabsIds.has(onSsabNode.aknoten) ? onSsabNode.aknoten : onSsabNode.eknoten;
+                const leftUpperCornerOfSsab = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.netz_ssab, netzSsabs.find(arg => arg.id === idOfSsab), nsgKpfeld.variantennr);
+                const nextNode = kpfeldNodes.find(arg => arg.aknoten === onSsabNode.eknoten);
+                let rotationValue;
+                let shiftOffset = 4;
+                // um universalkupplungen korrekt zu platzieren, müssen die Disconnectoren untereinander platziert werden,
+                // die auf den Leistungsschalter zeigen (bezogen auf aknoten)
+                if (nextNode && await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.netz_leistungsschalter, convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: nextNode.id }, false)) {
+                    // on 'left' side
+                    shiftOffset = 4;
+                }
+                else {
+                    // on 'right' side
+                    shiftOffset = 28;
+                }
+                const position = [null, null];
+                switch (couplerOrientation) {
+                    case 0: // TOP
+                        position[0] = leftUpperCornerOfCoupler[0] + shiftOffset;
+                        position[1] = leftUpperCornerOfSsab[1];
+                        rotationValue = 0;
+                        break;
+                    case 1: // RIGHT
+                        position[0] = leftUpperCornerOfSsab[0];
+                        position[1] = leftUpperCornerOfCoupler[1] + shiftOffset;
+                        rotationValue = 90;
+                        break;
+                    case 2: // BOTTOM
+                        position[0] = leftUpperCornerOfCoupler[0] + shiftOffset;
+                        position[1] = leftUpperCornerOfSsab[1];
+                        rotationValue = 180;
+                        break;
+                    case 3: // LEFT
+                        position[0] = leftUpperCornerOfSsab[0];
+                        position[1] = leftUpperCornerOfCoupler[1] + shiftOffset;
+                        rotationValue = 270;
+                        break;
+                }
+                nodePointMap.set(onSsabNode.id, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(position[0], position[1], rotationValue));
+                nodePointMap.set(idOfSsab, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(position[0], position[1], null));
+            }
+            // Leistungsschalter noch platzieren
+            // const crtNode = leistungsschalterNode; //kpfeldNodes.find(arg => arg.aknoten === onSsabNodes[0].eknoten);
+            let rotationValue = null;
+            const position = [...leftUpperCornerOfCoupler];
+            const cn1Position = [...leftUpperCornerOfCoupler];
+            const cn2Position = [...leftUpperCornerOfCoupler];
+            switch (couplerOrientation) {
+                case 0: // TOP
+                    position[0] += 16;
+                    position[1] = leftUpperCornerOfCoupler[1] + 4;
+                    rotationValue = 90;
+                    cn1Position[0] = leftUpperCornerOfCoupler[0] + 4;
+                    cn1Position[1] = position[1];
+                    cn2Position[0] = leftUpperCornerOfCoupler[0] + 28;
+                    cn2Position[1] = position[1];
+                    break;
+                case 1: // RIGHT
+                    position[0] = ((maxSsabPos + 1) * 8) + leftUpperCornerOfCoupler[0] + 4;
+                    position[1] += 16;
+                    rotationValue = 180;
+                    cn1Position[0] = position[0];
+                    cn1Position[1] = leftUpperCornerOfCoupler[1] + 4;
+                    cn2Position[0] = position[0];
+                    cn2Position[1] = leftUpperCornerOfCoupler[1] + 28;
+                    break;
+                case 2: // BOTTOM
+                    position[0] += 16;
+                    position[1] = ((maxSsabPos + 1) * 8) + leftUpperCornerOfCoupler[1] + 4;
+                    rotationValue = 90;
+                    cn1Position[0] = leftUpperCornerOfCoupler[0] + 4;
+                    cn1Position[1] = position[1];
+                    cn2Position[0] = leftUpperCornerOfCoupler[0] + 28;
+                    cn2Position[1] = position[1];
+                    break;
+                case 3: // LEFT
+                    position[0] = leftUpperCornerOfCoupler[0] + 4;
+                    position[1] += 16;
+                    rotationValue = 180;
+                    cn1Position[0] = position[0];
+                    cn1Position[1] = leftUpperCornerOfCoupler[1] + 4;
+                    cn2Position[0] = position[0];
+                    cn2Position[1] = leftUpperCornerOfCoupler[1] + 28;
+                    break;
+            }
+            nodePointMap.set(leistungsschalterNode.id, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(position[0], position[1], rotationValue));
+            nodePointMap.set(leistungsschalterNode.aknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(cn1Position[0], cn1Position[1], null));
+            nodePointMap.set(leistungsschalterNode.eknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(cn2Position[0], cn2Position[1], null));
+            /* ---------- ---------- ---------- */
+            // BEGIN: Terminal-Export
+            for (const kpfeldNode of kpfeldNodes) {
+                const doBackwardConnectivityNode = nodePointMap.get(kpfeldNode.aknoten);
+                const doConductingEquipment = nodePointMap.get(kpfeldNode.id);
+                const doForwardConnectivityNode = nodePointMap.get(kpfeldNode.eknoten);
+                const dopBackwardConnectivityNode = doBackwardConnectivityNode.diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+                const dopConductingEquipment = doConductingEquipment.diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+                const dopForwardConnectivityNode = doForwardConnectivityNode.diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+                const backwardTerminalUUID = this.lookupTerminalUUID(kpfeldNode.aknoten, kpfeldNode.id);
+                if (!this.exportedTerminalUUIDs.has(backwardTerminalUUID)) {
+                    this.exportedTerminalUUIDs.add(backwardTerminalUUID);
+                    const terminalDiagramObject = this.createTerminalDiagramObjectFromPoints({
+                        cePoints: [...dopConductingEquipment], cnPoints: [...dopBackwardConnectivityNode],
+                        terminalUuid: backwardTerminalUUID
+                    });
+                    resultingDiagramObjects.push(terminalDiagramObject);
+                }
+                const forwardTerminalUUID = this.lookupTerminalUUID(kpfeldNode.eknoten, kpfeldNode.id);
+                if (!this.exportedTerminalUUIDs.has(forwardTerminalUUID)) {
+                    this.exportedTerminalUUIDs.add(forwardTerminalUUID);
+                    const terminalDiagramObject = this.createTerminalDiagramObjectFromPoints({
+                        cePoints: [...dopConductingEquipment], cnPoints: [...dopForwardConnectivityNode],
+                        terminalUuid: forwardTerminalUUID
+                    });
+                    resultingDiagramObjects.push(terminalDiagramObject);
+                }
+            }
+            // END: Terminal-Export
+            /* ---------- ---------- ---------- */
+        }
+        else {
+            // case: cross-coupling without breaker
+            let prevNode;
+            let crtNode = kpfeldNodes.filter(elem => netzSsabsIds.has(elem.aknoten))[0];
+            const offsetValue = 32 / (kpfeldNodes.length + 1);
+            let rotationValue = null;
+            const positionFirstSsabNode = [0, 0];
+            const leftUpperPosOfAKnotenSsab = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.netz_ssab, netzSsabs.find(arg => arg.id === crtNode.aknoten), nsgKpfeld.variantennr);
+            switch (couplerOrientation) {
+                case 0: // TOP
+                    positionFirstSsabNode[0] = leftUpperCornerOfCoupler[0] + 4;
+                    positionFirstSsabNode[1] = leftUpperPosOfAKnotenSsab[1];
+                    break;
+                case 1: // RIGHT
+                    positionFirstSsabNode[0] = leftUpperPosOfAKnotenSsab[0];
+                    positionFirstSsabNode[1] = leftUpperCornerOfCoupler[1] + 4;
+                    break;
+                case 2: // BOTTOM
+                    positionFirstSsabNode[0] = leftUpperCornerOfCoupler[0] + 4;
+                    positionFirstSsabNode[1] = leftUpperPosOfAKnotenSsab[1];
+                    break;
+                case 3: // LEFT
+                    positionFirstSsabNode[0] = leftUpperPosOfAKnotenSsab[0];
+                    positionFirstSsabNode[1] = leftUpperCornerOfCoupler[1] + 4;
+                    break;
+            }
+            nodePointMap.set(crtNode.aknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(positionFirstSsabNode[0], positionFirstSsabNode[1], null));
+            const position = [...leftUpperCornerOfCoupler];
+            while (crtNode !== undefined) {
+                switch (couplerOrientation) {
+                    case 0: // TOP
+                        position[0] += offsetValue;
+                        position[1] = leftUpperCornerOfCoupler[1] + 4;
+                        rotationValue = 90;
+                        break;
+                    case 1: // RIGHT
+                        position[0] = ((maxSsabPos + 1) * 8) + leftUpperCornerOfCoupler[0] + 4;
+                        position[1] += offsetValue;
+                        rotationValue = 0;
+                        break;
+                    case 2: // BOTTOM
+                        position[0] += offsetValue;
+                        position[1] = ((maxSsabPos + 1) * 8) + leftUpperCornerOfCoupler[1] + 4;
+                        rotationValue = 90;
+                        break;
+                    case 3: // LEFT
+                        position[0] = leftUpperCornerOfCoupler[0] + 4;
+                        position[1] += offsetValue;
+                        rotationValue = 0;
+                        break;
+                }
+                nodePointMap.set(crtNode.id, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(position[0], position[1], rotationValue));
+                const positionConnectivityNode = [...position];
+                switch (couplerOrientation) {
+                    case 0: // TOP
+                        positionConnectivityNode[0] += (offsetValue / 2);
+                        break;
+                    case 1: // RIGHT
+                        positionConnectivityNode[1] += (offsetValue / 2);
+                        break;
+                    case 2: // BOTTOM
+                        positionConnectivityNode[0] += (offsetValue / 2);
+                        break;
+                    case 3: // LEFT
+                        positionConnectivityNode[1] += (offsetValue / 2);
+                        break;
+                }
+                nodePointMap.set(crtNode.eknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(positionConnectivityNode[0], positionConnectivityNode[1], null));
+                prevNode = crtNode;
+                crtNode = kpfeldNodes.find(arg => arg.aknoten === crtNode.eknoten);
+            }
+            // replace the last "ConnectivityNode"
+            const positionLastSsabNode = [0, 0];
+            const leftUpperPosOfEKnotenSsab = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.netz_ssab, netzSsabs.find(arg => arg.id === prevNode.eknoten), nsgKpfeld.variantennr);
+            switch (couplerOrientation) {
+                case 0: // TOP
+                    positionLastSsabNode[0] = leftUpperCornerOfCoupler[0] + 28;
+                    positionLastSsabNode[1] = leftUpperPosOfEKnotenSsab[1];
+                    break;
+                case 1: // RIGHT
+                    positionLastSsabNode[0] = leftUpperPosOfEKnotenSsab[0];
+                    positionLastSsabNode[1] = leftUpperCornerOfCoupler[1] + 28;
+                    break;
+                case 2: // BOTTOM
+                    positionLastSsabNode[0] = leftUpperCornerOfCoupler[0] + 28;
+                    positionLastSsabNode[1] = leftUpperPosOfEKnotenSsab[1];
+                    break;
+                case 3: // LEFT
+                    positionLastSsabNode[0] = leftUpperPosOfEKnotenSsab[0];
+                    positionLastSsabNode[1] = leftUpperCornerOfCoupler[1] + 28;
+                    break;
+            }
+            nodePointMap.set(prevNode.eknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(positionLastSsabNode[0], positionLastSsabNode[1], null));
+            /* ---------- ---------- ---------- */
+            // BEGIN: Terminal-Export
+            for (const kpfeldNode of kpfeldNodes) {
+                const doBackwardConnectivityNode = nodePointMap.get(kpfeldNode.aknoten);
+                const doConductingEquipment = nodePointMap.get(kpfeldNode.id);
+                const doForwardConnectivityNode = nodePointMap.get(kpfeldNode.eknoten);
+                const dopBackwardConnectivityNode = doBackwardConnectivityNode.diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+                const dopConductingEquipment = doConductingEquipment.diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+                const dopForwardConnectivityNode = doForwardConnectivityNode.diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+                let backwardTerminalPoints;
+                if (netzSsabsIds.has(kpfeldNode.aknoten)) {
+                    // insert a bend node
+                    const bendNode = [null, null];
+                    switch (couplerOrientation) {
+                        case 0: // TOP
+                        case 2: // BOTTOM
+                            bendNode[0] = dopBackwardConnectivityNode[0];
+                            bendNode[1] = dopConductingEquipment[1];
+                            break;
+                        case 1: // RIGHT
+                        case 3: // LEFT
+                            bendNode[0] = dopConductingEquipment[0];
+                            bendNode[1] = dopBackwardConnectivityNode[1];
+                            break;
+                    }
+                    backwardTerminalPoints = [[...dopConductingEquipment], bendNode, [...dopBackwardConnectivityNode]];
+                }
+                else {
+                    backwardTerminalPoints = [[...dopConductingEquipment], [...dopBackwardConnectivityNode]];
+                }
+                const backwardTerminalUUID = this.lookupTerminalUUID(kpfeldNode.aknoten, kpfeldNode.id);
+                if (!this.exportedTerminalUUIDs.has(backwardTerminalUUID)) {
+                    this.exportedTerminalUUIDs.add(backwardTerminalUUID);
+                    const terminalDiagramObject = this.createTerminalDiagramObjectFromPoints({
+                        points: backwardTerminalPoints,
+                        terminalUuid: backwardTerminalUUID
+                    });
+                    resultingDiagramObjects.push(terminalDiagramObject);
+                }
+                let forwardTerminalPoints;
+                if (netzSsabsIds.has(kpfeldNode.eknoten)) {
+                    // insert a bend node
+                    const bendNode = [null, null];
+                    switch (couplerOrientation) {
+                        case 0: // TOP
+                        case 2: // BOTTOM
+                            bendNode[0] = dopForwardConnectivityNode[0];
+                            bendNode[1] = dopConductingEquipment[1];
+                            break;
+                        case 1: // RIGHT
+                        case 3: // LEFT
+                            bendNode[0] = dopConductingEquipment[0];
+                            bendNode[1] = dopForwardConnectivityNode[1];
+                            break;
+                    }
+                    forwardTerminalPoints = [[...dopConductingEquipment], bendNode, [...dopForwardConnectivityNode]];
+                }
+                else {
+                    forwardTerminalPoints = [[...dopConductingEquipment], [...dopForwardConnectivityNode]];
+                }
+                const forwardTerminalUUID = this.lookupTerminalUUID(kpfeldNode.eknoten, kpfeldNode.id);
+                if (!this.exportedTerminalUUIDs.has(forwardTerminalUUID)) {
+                    this.exportedTerminalUUIDs.add(forwardTerminalUUID);
+                    const terminalDiagramObject = this.createTerminalDiagramObjectFromPoints({
+                        points: forwardTerminalPoints,
+                        terminalUuid: forwardTerminalUUID
+                    });
+                    resultingDiagramObjects.push(terminalDiagramObject);
+                }
+            }
+            // END: Terminal-Export
+            /* ---------- ---------- ---------- */
+        }
+        for (const nodePointEntry of nodePointMap.entries()) {
+            const key = nodePointEntry[0];
+            const value = nodePointEntry[1];
+            const cimObjectUUID = this.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: key }) ?? undefined;
+            value.identifiedObjectUUID = cimObjectUUID;
+            if (!this.alreadyExported(nsgKpfeld.variantennr, key)) {
+                resultingDiagramObjects.push(value);
+                // this.addExportedDiagramObjectToGraph(nsgKpfeld.variantennr, key, value) // todo check if this causes problems
+            }
+        }
+        return resultingDiagramObjects;
+    }
+    /**
+     * convertSchemaLKupplung
+     */
+    async convertSchemaLKupplung(nsgLKupplung, netzLKupplung) {
+        const resultingDiagramObjects = [];
+        const nsgSaabschnitt = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgsaabschnitt, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgLKupplung.variantennr, id: nsgLKupplung.nsgsaa }, false);
+        if (!nsgSaabschnitt)
+            return;
+        const nsgSchaltanlage = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgschaltanlage, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgLKupplung.variantennr, id: nsgSaabschnitt.nsgsa }, false);
+        if (!nsgSchaltanlage)
+            return;
+        const nsgStandort = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgstandort, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgLKupplung.variantennr, id: nsgSchaltanlage.nsgso }, false);
+        if (!nsgStandort)
+            return;
+        const nsgSaabschnittAnf = await this.dbObjectGraph.findFirstByAttributes(convert_graph_keys_1.i7TableNames.nsg_nsgsaabschnitt, { variantennr: nsgLKupplung.variantennr, saabschnitt: netzLKupplung.saa_anf });
+        if (!nsgSaabschnittAnf)
+            return;
+        const nsgSaabschnittEnd = await this.dbObjectGraph.findFirstByAttributes(convert_graph_keys_1.i7TableNames.nsg_nsgsaabschnitt, { variantennr: nsgLKupplung.variantennr, saabschnitt: netzLKupplung.saa_end });
+        if (!nsgSaabschnittEnd)
+            return;
+        const netzSsabs = await this.dbObjectGraph.findByAttributes(convert_graph_keys_1.i7TableNames.netz_ssab, {
+            saabschnitt: {
+                in: [nsgSaabschnittAnf.saabschnitt, nsgSaabschnittEnd.saabschnitt]
+            }
+        });
+        const lkupplungNodes = await this.getNodesOfLKupplung(netzLKupplung);
+        const netzSsabsIds = new Set(netzSsabs.map(arg => arg.id));
+        const ssabConnectedNodes = lkupplungNodes.filter(elem => netzSsabsIds.has(elem.aknoten) || netzSsabsIds.has(elem.eknoten));
+        const nodePointMap = new Map();
+        if (lkupplungNodes.length === 1 && netzSsabsIds.has(lkupplungNodes[0].aknoten) && netzSsabsIds.has(lkupplungNodes[0].eknoten)) {
+            const ssabConnectedNode = ssabConnectedNodes[0];
+            if (await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.netz_sestarr3p, convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: ssabConnectedNode.id })) {
+                const leftUpperCornerOfAKnotenSsab = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.netz_ssab, netzSsabs.find(arg => arg.id === ssabConnectedNode.aknoten), nsgLKupplung.variantennr);
+                const sizeOfAKnotenSsab = await this.getLengthOfSammelschienenAbschnitt(nsgSaabschnittAnf);
+                const leftUpperCornerOfEKnotenSsab = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.netz_ssab, netzSsabs.find(arg => arg.id === ssabConnectedNode.eknoten), nsgLKupplung.variantennr);
+                const sizeOfEKnotenSsab = await this.getLengthOfSammelschienenAbschnitt(nsgSaabschnittEnd);
+                // cause 'starre Verbindungen' are modelled as junctions, there must be two points extracted
+                // those two points are equals to the connectivity node positions and the rotation value is unnecessary
+                const aKnotenPosition = [null, null];
+                const eKnotenPosition = [null, null];
+                switch (nsgSchaltanlage.ausrichtung) {
+                    case 0: // left to right
+                        aKnotenPosition[0] = leftUpperCornerOfAKnotenSsab[0] + (sizeOfAKnotenSsab) * 16;
+                        aKnotenPosition[1] = leftUpperCornerOfAKnotenSsab[1];
+                        eKnotenPosition[0] = leftUpperCornerOfEKnotenSsab[0];
+                        eKnotenPosition[1] = leftUpperCornerOfEKnotenSsab[1];
+                        break;
+                    case 1: // top to bottom
+                        aKnotenPosition[0] = leftUpperCornerOfAKnotenSsab[0];
+                        aKnotenPosition[1] = leftUpperCornerOfAKnotenSsab[1] + (sizeOfAKnotenSsab) * 16;
+                        eKnotenPosition[0] = leftUpperCornerOfEKnotenSsab[0];
+                        eKnotenPosition[1] = leftUpperCornerOfEKnotenSsab[1];
+                        break;
+                    case 2: // right to left
+                        aKnotenPosition[0] = leftUpperCornerOfAKnotenSsab[0];
+                        aKnotenPosition[1] = leftUpperCornerOfAKnotenSsab[1];
+                        eKnotenPosition[0] = leftUpperCornerOfEKnotenSsab[0] + (sizeOfEKnotenSsab) * 16;
+                        eKnotenPosition[1] = leftUpperCornerOfEKnotenSsab[1];
+                        break;
+                    case 3: // bottom to top
+                        aKnotenPosition[0] = leftUpperCornerOfAKnotenSsab[0];
+                        aKnotenPosition[1] = leftUpperCornerOfAKnotenSsab[1];
+                        eKnotenPosition[0] = leftUpperCornerOfEKnotenSsab[0];
+                        eKnotenPosition[1] = leftUpperCornerOfEKnotenSsab[1] + (sizeOfEKnotenSsab) * 16;
+                        break;
+                }
+                const junctionCoordinates = [[...aKnotenPosition], [...eKnotenPosition]];
+                nodePointMap.set(ssabConnectedNode.id, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoints(junctionCoordinates, null));
+                nodePointMap.set(ssabConnectedNode.aknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(aKnotenPosition[0], aKnotenPosition[1], null));
+                nodePointMap.set(ssabConnectedNode.eknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(eKnotenPosition[0], eKnotenPosition[1], null));
+            }
+            else {
+                const leftUpperCornerOfAKnotenSsab = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.netz_ssab, netzSsabs.find(arg => arg.id === ssabConnectedNode.aknoten), nsgLKupplung.variantennr);
+                const sizeOfAKnotenSsab = await this.getLengthOfSammelschienenAbschnitt(nsgSaabschnittAnf);
+                const leftUpperCornerOfEKnotenSsab = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.netz_ssab, netzSsabs.find(arg => arg.id === ssabConnectedNode.eknoten), nsgLKupplung.variantennr);
+                const sizeOfEKnotenSsab = await this.getLengthOfSammelschienenAbschnitt(nsgSaabschnittEnd);
+                const aKnotenPosition = [null, null];
+                const eKnotenPosition = [null, null];
+                switch (nsgSchaltanlage.ausrichtung) {
+                    case 0: // left to right
+                        aKnotenPosition[0] = leftUpperCornerOfAKnotenSsab[0] + (sizeOfAKnotenSsab) * 16;
+                        aKnotenPosition[1] = leftUpperCornerOfAKnotenSsab[1];
+                        eKnotenPosition[0] = leftUpperCornerOfEKnotenSsab[0];
+                        eKnotenPosition[1] = leftUpperCornerOfEKnotenSsab[1];
+                        break;
+                    case 1: // top to bottom
+                        aKnotenPosition[0] = leftUpperCornerOfAKnotenSsab[0];
+                        aKnotenPosition[1] = leftUpperCornerOfAKnotenSsab[1] + (sizeOfAKnotenSsab) * 16;
+                        eKnotenPosition[0] = leftUpperCornerOfEKnotenSsab[0];
+                        eKnotenPosition[1] = leftUpperCornerOfEKnotenSsab[1];
+                        break;
+                    case 2: // right to left
+                        aKnotenPosition[0] = leftUpperCornerOfAKnotenSsab[0];
+                        aKnotenPosition[1] = leftUpperCornerOfAKnotenSsab[1];
+                        eKnotenPosition[0] = leftUpperCornerOfEKnotenSsab[0] + (sizeOfEKnotenSsab) * 16;
+                        eKnotenPosition[1] = leftUpperCornerOfEKnotenSsab[1];
+                        break;
+                    case 3: // bottom to top
+                        aKnotenPosition[0] = leftUpperCornerOfAKnotenSsab[0];
+                        aKnotenPosition[1] = leftUpperCornerOfAKnotenSsab[1];
+                        eKnotenPosition[0] = leftUpperCornerOfEKnotenSsab[0];
+                        eKnotenPosition[1] = leftUpperCornerOfEKnotenSsab[1] + (sizeOfEKnotenSsab) * 16;
+                        break;
+                }
+                const position = [
+                    (aKnotenPosition[0] + eKnotenPosition[0]) / 2,
+                    (aKnotenPosition[1] + eKnotenPosition[1]) / 2
+                ];
+                let rotationValue = Math.atan2(eKnotenPosition[1] - aKnotenPosition[1], eKnotenPosition[0] - aKnotenPosition[0]);
+                rotationValue = ((rotationValue * 180) / Math.PI) + 90;
+                nodePointMap.set(ssabConnectedNode.id, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(position[0], position[1], rotationValue));
+                nodePointMap.set(ssabConnectedNode.aknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(aKnotenPosition[0], aKnotenPosition[1], null));
+                nodePointMap.set(ssabConnectedNode.eknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(eKnotenPosition[0], eKnotenPosition[1], null));
+            }
+        }
+        else if (lkupplungNodes.length === 2 &&
+            (netzSsabsIds.has(lkupplungNodes[0].aknoten) || netzSsabsIds.has(lkupplungNodes[0].eknoten)) &&
+            (netzSsabsIds.has(lkupplungNodes[1].aknoten) || netzSsabsIds.has(lkupplungNodes[1].eknoten))) {
+            let aKnotenSsabNode;
+            let aKnotenSsabId;
+            let eKnotenSsabNode;
+            let eKnotenSsabId;
+            let inbetweenNodeId;
+            if (netzSsabsIds.has(lkupplungNodes[0].aknoten)) {
+                aKnotenSsabId = lkupplungNodes[0].aknoten;
+                aKnotenSsabNode = lkupplungNodes[0];
+                eKnotenSsabId = lkupplungNodes[1].eknoten;
+                eKnotenSsabNode = lkupplungNodes[1];
+                inbetweenNodeId = lkupplungNodes[1].aknoten;
+            }
+            else {
+                aKnotenSsabId = lkupplungNodes[1].aknoten;
+                aKnotenSsabNode = lkupplungNodes[1];
+                eKnotenSsabId = lkupplungNodes[0].eknoten;
+                eKnotenSsabNode = lkupplungNodes[0];
+                inbetweenNodeId = lkupplungNodes[0].aknoten;
+            }
+            const leftUpperCornerOfAKnotenSsab = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.netz_ssab, netzSsabs.find(arg => arg.id === aKnotenSsabId), nsgLKupplung.variantennr);
+            const sizeOfAKnotenSsab = await this.getLengthOfSammelschienenAbschnitt(nsgSaabschnittAnf);
+            const leftUpperCornerOfEKnotenSsab = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.netz_ssab, netzSsabs.find(arg => arg.id === eKnotenSsabId), nsgLKupplung.variantennr);
+            const sizeOfEKnotenSsab = await this.getLengthOfSammelschienenAbschnitt(nsgSaabschnittEnd);
+            const aKnotenPosition = [null, null];
+            const eKnotenPosition = [null, null];
+            switch (nsgSchaltanlage.ausrichtung) {
+                case 0: // left to right
+                    aKnotenPosition[0] = leftUpperCornerOfAKnotenSsab[0] + (sizeOfAKnotenSsab) * 16;
+                    aKnotenPosition[1] = leftUpperCornerOfAKnotenSsab[1];
+                    eKnotenPosition[0] = leftUpperCornerOfEKnotenSsab[0];
+                    eKnotenPosition[1] = leftUpperCornerOfEKnotenSsab[1];
+                    break;
+                case 1: // top to bottom
+                    aKnotenPosition[0] = leftUpperCornerOfAKnotenSsab[0];
+                    aKnotenPosition[1] = leftUpperCornerOfAKnotenSsab[1] + (sizeOfAKnotenSsab) * 16;
+                    eKnotenPosition[0] = leftUpperCornerOfEKnotenSsab[0];
+                    eKnotenPosition[1] = leftUpperCornerOfEKnotenSsab[1];
+                    break;
+                case 2: // right to left
+                    aKnotenPosition[0] = leftUpperCornerOfAKnotenSsab[0];
+                    aKnotenPosition[1] = leftUpperCornerOfAKnotenSsab[1];
+                    eKnotenPosition[0] = leftUpperCornerOfEKnotenSsab[0] + (sizeOfEKnotenSsab) * 16;
+                    eKnotenPosition[1] = leftUpperCornerOfEKnotenSsab[1];
+                    break;
+                case 3: // bottom to top
+                    aKnotenPosition[0] = leftUpperCornerOfAKnotenSsab[0];
+                    aKnotenPosition[1] = leftUpperCornerOfAKnotenSsab[1];
+                    eKnotenPosition[0] = leftUpperCornerOfEKnotenSsab[0];
+                    eKnotenPosition[1] = leftUpperCornerOfEKnotenSsab[1] + (sizeOfEKnotenSsab) * 16;
+                    break;
+            }
+            const connectionVector2 = [
+                eKnotenPosition[0] - aKnotenPosition[0],
+                eKnotenPosition[1] - aKnotenPosition[1]
+            ];
+            const offsetVector = [
+                connectionVector2[0] / 4,
+                connectionVector2[1] / 4
+            ];
+            const ce1Position = [
+                aKnotenPosition[0] + offsetVector[0],
+                aKnotenPosition[1] + offsetVector[1]
+            ];
+            const cnCe1Ce2Position = [
+                aKnotenPosition[0] + offsetVector[0] * 2,
+                aKnotenPosition[1] + offsetVector[1] * 2
+            ];
+            const ce2Position = [
+                aKnotenPosition[0] + offsetVector[0] * 3,
+                aKnotenPosition[1] + offsetVector[1] * 3
+            ];
+            let rotationValue = Math.atan2(connectionVector2[1], connectionVector2[0]);
+            rotationValue = ((rotationValue * 180) / Math.PI) + 90;
+            nodePointMap.set(aKnotenSsabNode.aknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(aKnotenPosition[0], aKnotenPosition[1], null));
+            nodePointMap.set(aKnotenSsabNode.id, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(ce1Position[0], ce1Position[1], rotationValue));
+            nodePointMap.set(inbetweenNodeId, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(cnCe1Ce2Position[0], cnCe1Ce2Position[1], null));
+            nodePointMap.set(eKnotenSsabNode.id, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(ce2Position[0], ce2Position[1], rotationValue));
+            nodePointMap.set(eKnotenSsabNode.eknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(eKnotenPosition[0], eKnotenPosition[1], null));
+        }
+        else {
+            for (const ssabConnectedNode of ssabConnectedNodes) {
+                const idOfSsab = netzSsabsIds.has(ssabConnectedNode.aknoten) ? ssabConnectedNode.aknoten : ssabConnectedNode.eknoten;
+                const leftUpperCornerOfSsab = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.netz_ssab, netzSsabs.find(arg => arg.id === idOfSsab), nsgLKupplung.variantennr);
+                // needed to get the correct behaviour for universal couplings
+                const breakerNode = lkupplungNodes.find(arg => arg.aknoten === ssabConnectedNode.eknoten);
+                if (netzSsabsIds.has(ssabConnectedNode.aknoten) && breakerNode) {
+                    // place on 'left' side of the coupling-field (but at the end of the busbar)
+                    const sizeOfSsab = await this.getLengthOfSammelschienenAbschnitt(nsgSaabschnittAnf);
+                    let rotationValue;
+                    const position = [null, null];
+                    const aKnotenPosition = [null, null]; // connectivity node to busbar
+                    switch (nsgSchaltanlage.ausrichtung) {
+                        case 0: // left to right
+                            position[0] = leftUpperCornerOfSsab[0] + (sizeOfSsab) * 16 + 4;
+                            position[1] = leftUpperCornerOfSsab[1];
+                            rotationValue = 90;
+                            aKnotenPosition[0] = leftUpperCornerOfSsab[0] + (sizeOfSsab) * 16;
+                            aKnotenPosition[1] = leftUpperCornerOfSsab[1];
+                            break;
+                        case 1: // top to bottom
+                            position[0] = leftUpperCornerOfSsab[0];
+                            position[1] = leftUpperCornerOfSsab[1] + (sizeOfSsab) * 16 + 4;
+                            rotationValue = 180;
+                            aKnotenPosition[0] = leftUpperCornerOfSsab[0];
+                            aKnotenPosition[1] = leftUpperCornerOfSsab[1] + (sizeOfSsab) * 16;
+                            break;
+                        case 2: // right to left
+                            position[0] = leftUpperCornerOfSsab[0] - 4;
+                            position[1] = leftUpperCornerOfSsab[1];
+                            rotationValue = 270;
+                            aKnotenPosition[0] = leftUpperCornerOfSsab[0];
+                            aKnotenPosition[1] = leftUpperCornerOfSsab[1];
+                            break;
+                        case 3: // bottom to top
+                            position[0] = leftUpperCornerOfSsab[0];
+                            position[1] = leftUpperCornerOfSsab[1] - 4;
+                            rotationValue = 0;
+                            aKnotenPosition[0] = leftUpperCornerOfSsab[0];
+                            aKnotenPosition[1] = leftUpperCornerOfSsab[1];
+                            break;
+                    }
+                    nodePointMap.set(ssabConnectedNode.id, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(position[0], position[1], rotationValue));
+                    nodePointMap.set(ssabConnectedNode.aknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(aKnotenPosition[0], aKnotenPosition[1], null));
+                }
+                else {
+                    // place on 'right' side of the coupling-field (but at the start of the busbar)
+                    const sizeOfSsab = await this.getLengthOfSammelschienenAbschnitt(nsgSaabschnittEnd);
+                    let rotationValue;
+                    const position = [null, null];
+                    const eKnotenPosition = [null, null]; // connectivity node to busbar
+                    switch (nsgSchaltanlage.ausrichtung) {
+                        case 0: // left to right
+                            position[0] = leftUpperCornerOfSsab[0] - 4;
+                            position[1] = leftUpperCornerOfSsab[1];
+                            rotationValue = 90;
+                            eKnotenPosition[0] = leftUpperCornerOfSsab[0];
+                            eKnotenPosition[1] = leftUpperCornerOfSsab[1];
+                            break;
+                        case 1: // top to bottom
+                            position[0] = leftUpperCornerOfSsab[0];
+                            position[1] = leftUpperCornerOfSsab[1] - 4;
+                            rotationValue = 180;
+                            eKnotenPosition[0] = leftUpperCornerOfSsab[0];
+                            eKnotenPosition[1] = leftUpperCornerOfSsab[1];
+                            break;
+                        case 2: // right to left
+                            position[0] = leftUpperCornerOfSsab[0] + (sizeOfSsab) * 16 + 4;
+                            position[1] = leftUpperCornerOfSsab[1];
+                            rotationValue = 270;
+                            eKnotenPosition[0] = leftUpperCornerOfSsab[0] + (sizeOfSsab) * 16;
+                            eKnotenPosition[1] = leftUpperCornerOfSsab[1];
+                            break;
+                        case 3: // bottom to top
+                            position[0] = leftUpperCornerOfSsab[0];
+                            position[1] = leftUpperCornerOfSsab[1] + (sizeOfSsab) * 16 + 4;
+                            rotationValue = 0;
+                            eKnotenPosition[0] = leftUpperCornerOfSsab[0];
+                            eKnotenPosition[1] = leftUpperCornerOfSsab[1] + (sizeOfSsab) * 16;
+                            break;
+                    }
+                    nodePointMap.set(ssabConnectedNode.id, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(position[0], position[1], rotationValue));
+                    nodePointMap.set(
+                    // needed to get the correct behaviour for universal couplings
+                    netzSsabsIds.has(ssabConnectedNode.aknoten) ? ssabConnectedNode.aknoten : ssabConnectedNode.eknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(eKnotenPosition[0], eKnotenPosition[1], null));
+                }
+            }
+            if (ssabConnectedNodes.length > 2) {
+                // universal-coupling ==> breaker must be placed 'on top' of the coupling
+                const leftUpperCornerOfLKupplung = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsglkupplung, nsgLKupplung);
+                const startSsabConnectedNode = lkupplungNodes.filter(elem => netzSsabsIds.has(elem.aknoten));
+                // if (startSsabConnectedNode.length === 1 && !nodePointMap.has(startSsabConnectedNode[0].eknoten)) {
+                const breakerNode = lkupplungNodes.find(arg => arg.aknoten === startSsabConnectedNode[0].eknoten || arg.eknoten === startSsabConnectedNode[0].eknoten);
+                let rotationValue = null;
+                const breakerPosition = [...leftUpperCornerOfLKupplung];
+                let cn1Position;
+                let cn2Position;
+                switch (nsgSchaltanlage.ausrichtung) {
+                    case 0: // left to right
+                        rotationValue = 90;
+                        breakerPosition[0] += (nsgLKupplung.laenge / 2) * 16;
+                        breakerPosition[1] -= 4;
+                        cn1Position = [leftUpperCornerOfLKupplung[0] + 4, breakerPosition[1]];
+                        cn2Position = [leftUpperCornerOfLKupplung[0] + nsgLKupplung.laenge * 16 - 4, breakerPosition[1]];
+                        break;
+                    case 1: // top to bottom
+                        rotationValue = 180;
+                        breakerPosition[0] -= 4;
+                        breakerPosition[1] += (nsgLKupplung.laenge / 2) * 16;
+                        cn1Position = [breakerPosition[0], leftUpperCornerOfLKupplung[1] + 4];
+                        cn2Position = [breakerPosition[0], leftUpperCornerOfLKupplung[1] + nsgLKupplung.laenge * 16 - 4];
+                        break;
+                    case 2: // right to left
+                        rotationValue = 270;
+                        breakerPosition[0] += (nsgLKupplung.laenge / 2) * 16;
+                        breakerPosition[1] -= 4;
+                        cn1Position = [leftUpperCornerOfLKupplung[0] + nsgLKupplung.laenge * 16 - 4, breakerPosition[1]];
+                        cn2Position = [leftUpperCornerOfLKupplung[0] + 4, breakerPosition[1]];
+                        break;
+                    case 3: // bottom to top
+                        rotationValue = 0;
+                        breakerPosition[0] -= 4;
+                        breakerPosition[1] += (nsgLKupplung.laenge / 2) * 16;
+                        cn1Position = [breakerPosition[0], leftUpperCornerOfLKupplung[1] + nsgLKupplung.laenge * 16 - 4];
+                        cn2Position = [breakerPosition[0], leftUpperCornerOfLKupplung[1] + 4];
+                        break;
+                }
+                nodePointMap.set(breakerNode.id, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(breakerPosition[0], breakerPosition[1], rotationValue));
+                nodePointMap.set(breakerNode.aknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(cn1Position[0], cn1Position[1], null));
+                nodePointMap.set(breakerNode.eknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(cn2Position[0], cn2Position[1], null));
+            }
+            else {
+                const startSsabConnectedNode = lkupplungNodes.filter(elem => netzSsabsIds.has(elem.aknoten));
+                if (startSsabConnectedNode.length === 1 && !nodePointMap.has(startSsabConnectedNode[0].eknoten)) {
+                    const centeredNode = lkupplungNodes.find(arg => arg.aknoten === startSsabConnectedNode[0].eknoten);
+                    const leftNode = startSsabConnectedNode[0];
+                    const rightNode = lkupplungNodes.find(arg => arg.aknoten === centeredNode.eknoten);
+                    const position = [null, null];
+                    let cn1Position;
+                    let cn2Position;
+                    switch (nsgSchaltanlage.ausrichtung) {
+                        case 0: // left to right
+                            cn1Position = nodePointMap.get(leftNode.id).diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+                            cn2Position = nodePointMap.get(rightNode.id).diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+                            cn1Position[0] += 4;
+                            cn2Position[0] -= 4;
+                            break;
+                        case 1: // top to bottom
+                            cn1Position = nodePointMap.get(leftNode.id).diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+                            cn2Position = nodePointMap.get(rightNode.id).diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+                            cn1Position[1] += 4;
+                            cn2Position[1] -= 4;
+                            break;
+                        case 2: // right to left
+                            cn1Position = nodePointMap.get(leftNode.id).diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+                            cn2Position = nodePointMap.get(rightNode.id).diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+                            cn1Position[0] -= 4;
+                            cn2Position[0] += 4;
+                            break;
+                        case 3: // bottom to top
+                            cn1Position = nodePointMap.get(leftNode.id).diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+                            cn2Position = nodePointMap.get(rightNode.id).diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+                            cn1Position[1] -= 4;
+                            cn2Position[1] += 4;
+                            break;
+                    }
+                    position[0] = (cn1Position[0] + cn2Position[0]) / 2;
+                    position[1] = (cn1Position[1] + cn2Position[1]) / 2;
+                    let rotationValue = Math.atan2(cn2Position[1] - cn1Position[1], cn2Position[0] - cn1Position[0]);
+                    rotationValue = ((rotationValue * 180) / Math.PI) + 90;
+                    nodePointMap.set(centeredNode.id, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(position[0], position[1], rotationValue));
+                    nodePointMap.set(centeredNode.aknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(cn1Position[0], cn1Position[1], null));
+                    nodePointMap.set(centeredNode.eknoten, util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(cn2Position[0], cn2Position[1], null));
+                }
+            }
+        }
+        /* ---------- ---------- ---------- */
+        // BEGIN: Terminal-Export
+        for (const lkupplungNode of lkupplungNodes) {
+            const doBackwardConnectivityNode = nodePointMap.get(lkupplungNode.aknoten);
+            const doConductingEquipment = nodePointMap.get(lkupplungNode.id);
+            const doForwardConnectivityNode = nodePointMap.get(lkupplungNode.eknoten);
+            const dopBackwardConnectivityNode = doBackwardConnectivityNode?.diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+            const dopsConductingEquipment = doConductingEquipment?.diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition]);
+            const dopForwardConnectivityNode = doForwardConnectivityNode?.diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+            if (!dopBackwardConnectivityNode || !dopsConductingEquipment || !dopForwardConnectivityNode)
+                continue;
+            const backwardTerminalUUID = this.lookupTerminalUUID(lkupplungNode.aknoten, lkupplungNode.id);
+            if (!this.exportedTerminalUUIDs.has(backwardTerminalUUID)) {
+                this.exportedTerminalUUIDs.add(backwardTerminalUUID);
+                const terminalDiagramObject = this.createTerminalDiagramObjectFromPoints({
+                    cePoints: dopsConductingEquipment[0], cnPoints: dopBackwardConnectivityNode,
+                    terminalUuid: backwardTerminalUUID
+                });
+                resultingDiagramObjects.push(terminalDiagramObject);
+            }
+            const forwardTerminalUUID = this.lookupTerminalUUID(lkupplungNode.eknoten, lkupplungNode.id);
+            if (!this.exportedTerminalUUIDs.has(forwardTerminalUUID)) {
+                this.exportedTerminalUUIDs.add(forwardTerminalUUID);
+                const terminalDiagramObject = this.createTerminalDiagramObjectFromPoints({
+                    cePoints: dopsConductingEquipment[dopsConductingEquipment.length - 1], cnPoints: dopForwardConnectivityNode,
+                    terminalUuid: forwardTerminalUUID
+                });
+                resultingDiagramObjects.push(terminalDiagramObject);
+            }
+        }
+        // END: Terminal-Export
+        /* ---------- ---------- ---------- */
+        for (const nodePointEntry of nodePointMap.entries()) {
+            const key = nodePointEntry[0];
+            const value = nodePointEntry[1];
+            const cimObjectUUID = this.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: key }) ?? undefined;
+            value.identifiedObjectUUID = cimObjectUUID;
+            if (!this.alreadyExported(nsgLKupplung.variantennr, key)) {
+                resultingDiagramObjects.push(value);
+                // this.addExportedDiagramObjectToGraph(nsgLKupplung.variantennr, key, value) // todo check if this causes problems
+            }
+        }
+        return resultingDiagramObjects;
+    }
+    /**
+     * convertSchemaLDrossel
+     */
+    async convertSchemaLDrossel(nsgLDrossel) {
+        const resultingDiagramObjects = [];
+        const leftUpperCornerOfNsgLDrossel = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgldrossel, nsgLDrossel);
+        const ldrossel = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.netz_ldrossel, convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: nsgLDrossel.ldrossel });
+        if (!ldrossel)
+            return null;
+        const pos = [...leftUpperCornerOfNsgLDrossel];
+        const anfPos = [...leftUpperCornerOfNsgLDrossel];
+        const endPos = [...leftUpperCornerOfNsgLDrossel];
+        const shiftValue = this.config.shiftSeriesCompensator ? 12 : 0;
+        switch (nsgLDrossel.ausrichtung) {
+            case 0: // <-- anschlussend || anschlussanf -->
+                pos[0] += 24;
+                pos[1] += 16;
+                anfPos[0] += 48 - shiftValue;
+                anfPos[1] += 16;
+                endPos[0] += 0 + shiftValue;
+                endPos[1] += 16;
+                break;
+            case 1:
+                pos[0] += 16;
+                pos[1] += 24;
+                anfPos[0] += 16;
+                anfPos[1] += 48 - shiftValue;
+                endPos[0] += 16;
+                endPos[1] += 0 + shiftValue;
+                break;
+            case 2:
+                pos[0] += 24;
+                pos[1] += 16;
+                anfPos[0] += 0 + shiftValue;
+                anfPos[1] += 16;
+                endPos[0] += 48 - shiftValue;
+                endPos[1] += 16;
+                break;
+            case 3:
+                pos[0] += 16;
+                pos[1] += 24;
+                anfPos[0] += 16;
+                anfPos[1] += 0 + shiftValue;
+                endPos[0] += 16;
+                endPos[1] += 48 - shiftValue;
+                break;
+        }
+        const cimObjectUUID = this.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: nsgLDrossel.ldrossel }) ?? undefined;
+        const doLDrossel = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+            xPosition: pos[0],
+            yPosition: pos[1],
+            rotation: util_functions_1.DLUtilFunctions.getRotationBasedOnQuerzweig(nsgLDrossel.ausrichtung),
+            diagramObjectName: `DiagramObject ${nsgLDrossel.ldrossel}`,
+            identifiedObjectUUID: cimObjectUUID
+        }, this.config);
+        if (!this.alreadyExported(nsgLDrossel.variantennr, nsgLDrossel.id)) {
+            this.addExportedDiagramObjectToGraph(nsgLDrossel.variantennr, nsgLDrossel.id, doLDrossel);
+            resultingDiagramObjects.push(doLDrossel);
+        }
+        /* ---------- ---------- ---------- */
+        // BEGIN: Terminal-Export
+        const anschlussanfTypedResult = this.dbObjectGraph.findTypedFirstByKey(convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, {
+            variantennr: nsgLDrossel.variantennr, id: nsgLDrossel.anschlussanf
+        });
+        const anfTerminalUUID = this.lookupTerminalUUID(ldrossel.aknoten, nsgLDrossel.ldrossel);
+        if (anschlussanfTypedResult && anfTerminalUUID) {
+            if (!this.exportedTerminalUUIDs.has(anfTerminalUUID)) {
+                const connectivityNodePosition = await this.getConnectivityNodePositionFor(anschlussanfTypedResult.type, anschlussanfTypedResult.object);
+                this.exportedTerminalUUIDs.add(anfTerminalUUID);
+                const terminalDiagramObject = this.createTerminalDiagramObjectFromPoints({
+                    cePoints: anfPos, cnPoints: connectivityNodePosition,
+                    terminalUuid: anfTerminalUUID
+                });
+                resultingDiagramObjects.push(terminalDiagramObject);
+            }
+        }
+        const anschlussendTypedResult = this.dbObjectGraph.findTypedFirstByKey(convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, {
+            variantennr: nsgLDrossel.variantennr, id: nsgLDrossel.anschlussend
+        });
+        const endTerminalUUID = this.lookupTerminalUUID(ldrossel.eknoten, nsgLDrossel.ldrossel);
+        if (anschlussendTypedResult && endTerminalUUID) {
+            if (!this.exportedTerminalUUIDs.has(endTerminalUUID)) {
+                const connectivityNodePosition = await this.getConnectivityNodePositionFor(anschlussendTypedResult.type, anschlussendTypedResult.object);
+                this.exportedTerminalUUIDs.add(endTerminalUUID);
+                const terminalDiagramObject = this.createTerminalDiagramObjectFromPoints({
+                    cePoints: endPos, cnPoints: connectivityNodePosition,
+                    terminalUuid: endTerminalUUID
+                });
+                resultingDiagramObjects.push(terminalDiagramObject);
+            }
+        }
+        // const doEndConnectivityNode = this.exportedDiagramObjectsGraph[nsgLKondensator.variantennr][nsgLKondensator.anschlussend];
+        // const dopEndConnectivityNode = doEndConnectivityNode.diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+        //
+        // const endTerminalUUID = this.lookupTerminalUUID(nsgLKondensator.anschlussend, nsgLKondensator.id);
+        // if (!this.exportedTerminalUUIDs.has(endTerminalUUID)) {
+        //   this.exportedTerminalUUIDs.add(endTerminalUUID);
+        //   const terminalDiagramObject = DLUtilFunctions.createDiagramObjectWithPoints(
+        //     [[...dopEndConnectivityNode], [...endPos]], null
+        //   );
+        //   terminalDiagramObject.identifiedObjectUUID = endTerminalUUID;
+        //   resultingDiagramObjects.push(terminalDiagramObject);
+        // }
+        // END: Terminal-Export
+        /* ---------- ---------- ---------- */
+        return resultingDiagramObjects;
+    }
+    /**
+     * convertSchemaLKondensator
+     */
+    async convertSchemaLKondensator(nsgLKondensator) {
+        const resultingDiagramObjects = [];
+        const leftUpperCornerOfNsgLKondensator = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsglkondensator, nsgLKondensator);
+        const lkondensator = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.netz_lkondensator, convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: nsgLKondensator.lkondensator });
+        if (!lkondensator)
+            return null;
+        const pos = [...leftUpperCornerOfNsgLKondensator];
+        const anfPos = [...leftUpperCornerOfNsgLKondensator];
+        const endPos = [...leftUpperCornerOfNsgLKondensator];
+        switch (nsgLKondensator.ausrichtung) {
+            case 0: // <-- anschlussend || anschlussanf -->
+                pos[0] += 24;
+                pos[1] += 16;
+                anfPos[0] += 48;
+                anfPos[1] += 16;
+                endPos[0] += 0;
+                endPos[1] += 16;
+                break;
+            case 1:
+                pos[0] += 16;
+                pos[1] += 24;
+                anfPos[0] += 16;
+                anfPos[1] += 48;
+                endPos[0] += 0;
+                endPos[1] += 16;
+                break;
+            case 2:
+                pos[0] += 24;
+                pos[1] += 16;
+                anfPos[0] += 0;
+                anfPos[1] += 16;
+                endPos[0] += 48;
+                endPos[1] += 16;
+                break;
+            case 3:
+                pos[0] += 16;
+                pos[1] += 24;
+                anfPos[0] += 0;
+                anfPos[1] += 16;
+                endPos[0] += 16;
+                endPos[1] += 48;
+                break;
+        }
+        const cimObjectUUID = this.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: nsgLKondensator.lkondensator }) ?? undefined;
+        const doLKondensator = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+            xPosition: pos[0],
+            yPosition: pos[1],
+            rotation: util_functions_1.DLUtilFunctions.getRotationBasedOnQuerzweig(nsgLKondensator.ausrichtung),
+            diagramObjectName: `DiagramObject ${nsgLKondensator.lkondensator}`,
+            identifiedObjectUUID: cimObjectUUID
+        }, this.config);
+        if (!this.alreadyExported(nsgLKondensator.variantennr, nsgLKondensator.id)) {
+            this.addExportedDiagramObjectToGraph(nsgLKondensator.variantennr, nsgLKondensator.id, doLKondensator);
+            resultingDiagramObjects.push(doLKondensator);
+        }
+        /* ---------- ---------- ---------- */
+        // BEGIN: Terminal-Export
+        const anschlussanfTypedResult = this.dbObjectGraph.findTypedFirstByKey(convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, {
+            variantennr: nsgLKondensator.variantennr, id: nsgLKondensator.anschlussanf
+        });
+        const anfTerminalUUID = this.lookupTerminalUUID(lkondensator.aknoten, nsgLKondensator.lkondensator);
+        if (anschlussanfTypedResult && anfTerminalUUID) {
+            if (!this.exportedTerminalUUIDs.has(anfTerminalUUID)) {
+                const connectivityNodePosition = await this.getConnectivityNodePositionFor(anschlussanfTypedResult.type, anschlussanfTypedResult.object);
+                this.exportedTerminalUUIDs.add(anfTerminalUUID);
+                const terminalDiagramObject = this.createTerminalDiagramObjectFromPoints({
+                    cePoints: anfPos, cnPoints: connectivityNodePosition,
+                    terminalUuid: anfTerminalUUID
+                });
+                resultingDiagramObjects.push(terminalDiagramObject);
+            }
+        }
+        const anschlussendTypedResult = this.dbObjectGraph.findTypedFirstByKey(convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, {
+            variantennr: nsgLKondensator.variantennr, id: nsgLKondensator.anschlussend
+        });
+        const endTerminalUUID = this.lookupTerminalUUID(lkondensator.eknoten, nsgLKondensator.lkondensator);
+        if (anschlussendTypedResult && endTerminalUUID) {
+            if (!this.exportedTerminalUUIDs.has(endTerminalUUID)) {
+                const connectivityNodePosition = await this.getConnectivityNodePositionFor(anschlussendTypedResult.type, anschlussendTypedResult.object);
+                this.exportedTerminalUUIDs.add(endTerminalUUID);
+                const terminalDiagramObject = this.createTerminalDiagramObjectFromPoints({
+                    cePoints: endPos, cnPoints: connectivityNodePosition,
+                    terminalUuid: endTerminalUUID
+                });
+                resultingDiagramObjects.push(terminalDiagramObject);
+            }
+        }
+        // const doEndConnectivityNode = this.exportedDiagramObjectsGraph[nsgLKondensator.variantennr][nsgLKondensator.anschlussend];
+        // const dopEndConnectivityNode = doEndConnectivityNode.diagramObjectPoints.map(arg => [arg.xPosition, arg.yPosition])[0];
+        //
+        // const endTerminalUUID = this.lookupTerminalUUID(nsgLKondensator.anschlussend, nsgLKondensator.id);
+        // if (!this.exportedTerminalUUIDs.has(endTerminalUUID)) {
+        //   this.exportedTerminalUUIDs.add(endTerminalUUID);
+        //   const terminalDiagramObject = DLUtilFunctions.createDiagramObjectWithPoints(
+        //     [[...dopEndConnectivityNode], [...endPos]], null
+        //   );
+        //   terminalDiagramObject.identifiedObjectUUID = endTerminalUUID;
+        //   resultingDiagramObjects.push(terminalDiagramObject);
+        // }
+        // END: Terminal-Export
+        /* ---------- ---------- ---------- */
+        return resultingDiagramObjects;
+    }
+    /**
+     * convertSchemaStpschiene
+     */
+    async convertSchemaStpschiene(nsgStpschiene) {
+        const leftUpperCornerOfNsgStpschiene = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgstpschiene, nsgStpschiene);
+        const length = nsgStpschiene.laenge;
+        const points = [];
+        let topLeft = new DiagramObjectPoint_1.DiagramObjectPoint();
+        let bottomRight = new DiagramObjectPoint_1.DiagramObjectPoint();
+        topLeft.xPosition = leftUpperCornerOfNsgStpschiene[0];
+        topLeft.yPosition = leftUpperCornerOfNsgStpschiene[1];
+        if (nsgStpschiene.ausrichtung % 2 === 0) {
+            bottomRight.xPosition = leftUpperCornerOfNsgStpschiene[0] + length * constants_1.NsgConstants.HORIZONTAL_OFFSET;
+            bottomRight.yPosition = leftUpperCornerOfNsgStpschiene[1];
+            topLeft.yPosition += 4;
+            bottomRight.yPosition += 4;
+        }
+        else {
+            bottomRight.xPosition = leftUpperCornerOfNsgStpschiene[0];
+            bottomRight.yPosition = leftUpperCornerOfNsgStpschiene[1] + length * constants_1.NsgConstants.HORIZONTAL_OFFSET;
+            topLeft.xPosition += 4;
+            bottomRight.xPosition += 4;
+        }
+        topLeft.sequenceNumber = 1;
+        bottomRight.sequenceNumber = 2;
+        points.push(topLeft, bottomRight);
+        const cimObjectUUID = this.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: nsgStpschiene.stpschiene }) ?? undefined;
+        const connectivityNode = this.cimModelGraph.findObjectByUUID(cimObjectUUID);
+        let junction = null;
+        let junctionTerminal = null;
+        if (connectivityNode) {
+            for (const terminal of connectivityNode.terminals.values()) {
+                if (terminal.conductingEquipment instanceof Junction_1.Junction) {
+                    junction = terminal.conductingEquipment;
+                    junctionTerminal = terminal;
+                    break;
+                }
+            }
+        }
+        if (junction && junctionTerminal && !this.config?.busbarSectionAsConnectivityNode) {
+            // compute the position for the ConnectivityNode (the center of the BusbarSection)
+            const centerPosition = [
+                (topLeft.xPosition + bottomRight.xPosition) / 2,
+                (topLeft.yPosition + bottomRight.yPosition) / 2
+            ];
+            const doConnectivityNode = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint(centerPosition[0], centerPosition[1], null);
+            doConnectivityNode.name = `Stpschiene CN ${nsgStpschiene.stpschiene}`;
+            doConnectivityNode.identifiedObjectUUID = cimObjectUUID;
+            this.addExportedDiagramObjectToGraph(nsgStpschiene.variantennr, nsgStpschiene.id, doConnectivityNode);
+            const doJunction = new DiagramObject_1.DiagramObject(common_utils_1.CommonUtils.generateUUID(), `Stpschiene ${nsgStpschiene.id}`);
+            doJunction.identifiedObjectUUID = junction.getUUID();
+            doJunction.rotation = util_functions_1.DLUtilFunctions.getRotationBasedOnNsgSa(nsgStpschiene.ausrichtung);
+            (0, utils_schema_1.copyDiagramObjectPoints)(doJunction, points);
+            this.exportedTerminalUUIDs.add(junctionTerminal.getUUID());
+            const doJunctionTerminal = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoints([[topLeft.xPosition, topLeft.yPosition], [...centerPosition]], null);
+            doJunctionTerminal.identifiedObjectUUID = junctionTerminal.getUUID();
+            return [doJunction, doJunctionTerminal, doConnectivityNode];
+        }
+        else {
+            const doBusbarSectionAsConnectivityNode = new DiagramObject_1.DiagramObject(common_utils_1.CommonUtils.generateUUID(), `Stpschiene CN ${nsgStpschiene.id}`);
+            doBusbarSectionAsConnectivityNode.identifiedObjectUUID = cimObjectUUID;
+            doBusbarSectionAsConnectivityNode.rotation = util_functions_1.DLUtilFunctions.getRotationBasedOnNsgSa(nsgStpschiene.ausrichtung);
+            (0, utils_schema_1.copyDiagramObjectPoints)(doBusbarSectionAsConnectivityNode, points);
+            this.addExportedDiagramObjectToGraph(nsgStpschiene.variantennr, nsgStpschiene.id, doBusbarSectionAsConnectivityNode);
+            return [doBusbarSectionAsConnectivityNode];
+        }
+    }
+    /**
+     * convertSchemaStpknoten
+     */
+    async convertSchemaStpknoten(nsgStpknoten) {
+        const resultingDiagramObjects = [];
+        let leftUpperCornerOfNsgStpknoten = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgstpknoten, nsgStpknoten);
+        const coords = [...leftUpperCornerOfNsgStpknoten];
+        switch (nsgStpknoten.ausrichtung) {
+            case 0:
+            case 2:
+                coords[0] += 8;
+                coords[1] += 16;
+                break;
+            case 1:
+            case 3:
+                coords[0] += 16;
+                coords[1] += 8;
+                break;
+        }
+        const cimObjectUUID = this.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: nsgStpknoten.knoten }) ?? undefined;
+        const doStpknoten = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+            xPosition: coords[0],
+            yPosition: coords[1],
+            diagramObjectName: 'NsgStpknoten',
+            identifiedObjectUUID: cimObjectUUID
+        }, this.config);
+        this.addExportedDiagramObjectToGraph(nsgStpknoten.variantennr, nsgStpknoten.id, doStpknoten);
+        resultingDiagramObjects.push(doStpknoten);
+        // // TODO grounding
+        // // check, if there is a ground that must be exported either
+        // const netzKnoten1pelem = await this.dbObjectGraph.findFirstByAttributes(i7TableNames.netz_knoten1pelem, {
+        //   id: nsgStpknoten.knoten
+        // });
+        //
+        // if (netzKnoten1pelem && netzKnoten1pelem.geerdet === 1) {
+        //
+        // }
+        return resultingDiagramObjects;
+    }
+    /**
+     * convertSchemaStpimpedanz
+     */
+    async convertSchemaStpimpedanz(nsgStpimpedanz) {
+        const resultingDiagramObjects = [];
+        let leftUpperCornerOfNsgStpimpedanz = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgstpimpedanz, nsgStpimpedanz);
+        const coords = [...leftUpperCornerOfNsgStpimpedanz];
+        /* width and height by orientation zero */
+        const width = 32;
+        const height = 16;
+        switch (nsgStpimpedanz.ausrichtung) {
+            case 0:
+            case 2:
+                coords[0] += (width / 2);
+                coords[1] += (height / 2);
+                break;
+            case 1:
+            case 3:
+                coords[0] += (height / 2);
+                coords[1] += (width / 2);
+                break;
+        }
+        const cimObjectUUID = this.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: nsgStpimpedanz.kdrossel }) ?? undefined;
+        const doStpknoten = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+            xPosition: coords[0],
+            yPosition: coords[1],
+            diagramObjectName: 'NsgStpknoten',
+            identifiedObjectUUID: cimObjectUUID
+        }, this.config);
+        this.addExportedDiagramObjectToGraph(nsgStpimpedanz.variantennr, nsgStpimpedanz.id, doStpknoten);
+        resultingDiagramObjects.push(doStpknoten);
+        return resultingDiagramObjects;
+    }
+    /**
+     * convertSchemaStpschaltfeld
+     */
+    async convertSchemaStpschaltfeldElemente(nsgStpschaltfeld) {
+        const resultingDiagramObjects = [];
+        const leftUpperCornerOfNsgStpSchaltfeld = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgstpschaltfeld, nsgStpschaltfeld);
+        const nsgStpschiene = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgstpschiene, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, {
+            variantennr: nsgStpschaltfeld.variantennr,
+            id: nsgStpschaltfeld.nsgstpschiene
+        });
+        if (!nsgStpschiene)
+            return;
+        if (nsgStpschaltfeld.schaltfeld !== undefined) {
+            const schaltelement1pelem = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.netz_schaltelement1pelem, convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: nsgStpschaltfeld.schaltfeld });
+            let bayOrientation = nsgStpschiene.ausrichtung;
+            if (nsgStpschaltfeld.deltaausrichtung === 1) {
+                bayOrientation = (bayOrientation + 2) % 4;
+            }
+            let rotationValue = null;
+            const coordsEquipment = [...leftUpperCornerOfNsgStpSchaltfeld];
+            const coordsConnectivityNodeBusbarSection = [...leftUpperCornerOfNsgStpSchaltfeld];
+            const coordsConnectivityNodeBayEnd = [...leftUpperCornerOfNsgStpSchaltfeld];
+            switch (bayOrientation) {
+                case 0: // TOP
+                    rotationValue = 0;
+                    coordsEquipment[0] += 8;
+                    coordsEquipment[1] += 12;
+                    coordsConnectivityNodeBayEnd[0] += 8;
+                    // coordsConnectivityNodeBayEnd[1];
+                    coordsConnectivityNodeBusbarSection[0] += 8;
+                    coordsConnectivityNodeBusbarSection[1] += 20;
+                    break;
+                case 1: // RIGHT
+                    rotationValue = 90;
+                    coordsEquipment[0] += 12;
+                    coordsEquipment[1] += 8;
+                    coordsConnectivityNodeBayEnd[0] += 24;
+                    coordsConnectivityNodeBayEnd[1] += 8;
+                    coordsConnectivityNodeBusbarSection[0] += 4;
+                    coordsConnectivityNodeBusbarSection[1] += 8;
+                    break;
+                case 2: // BOTTOM
+                    rotationValue = 180;
+                    coordsEquipment[0] += 8;
+                    coordsEquipment[1] += 12;
+                    coordsConnectivityNodeBayEnd[0] += 8;
+                    coordsConnectivityNodeBayEnd[1] += 24;
+                    coordsConnectivityNodeBusbarSection[0] += 8;
+                    coordsConnectivityNodeBusbarSection[1] += 4;
+                    break;
+                case 3: // LEFT
+                    rotationValue = 270;
+                    coordsEquipment[0] += 12;
+                    coordsEquipment[1] += 8;
+                    // coordsConnectivityNodeBayEnd[0];
+                    coordsConnectivityNodeBayEnd[1] += 8;
+                    coordsConnectivityNodeBusbarSection[0] += 20;
+                    coordsConnectivityNodeBusbarSection[1] += 8;
+                    break;
+            }
+            const equipmentUUID = this.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: schaltelement1pelem.id }) ?? undefined;
+            const doEquipment = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                xPosition: coordsEquipment[0],
+                yPosition: coordsEquipment[1],
+                rotation: rotationValue,
+                diagramObjectName: `NsgStpschaltfeld-Node ${schaltelement1pelem.id}`,
+                identifiedObjectUUID: equipmentUUID
+            }, this.config);
+            const connectivityNodeBayEndUUID = this.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: schaltelement1pelem.eknoten }) ?? undefined;
+            const doConnectivityNodeBayEnd = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoint2({
+                xPosition: coordsConnectivityNodeBayEnd[0],
+                yPosition: coordsConnectivityNodeBayEnd[1],
+                diagramObjectName: `ConnectivityNodeBayEnd ${schaltelement1pelem.eknoten}`,
+                identifiedObjectUUID: connectivityNodeBayEndUUID
+            }, this.config);
+            const doTerminal1 = this.createTerminalDiagramObjectFromPoints({
+                cePoints: [...coordsConnectivityNodeBusbarSection], cnPoints: [...coordsEquipment],
+                terminalUuid: this.lookupTerminalUUID(schaltelement1pelem.aknoten, schaltelement1pelem.id)
+            });
+            resultingDiagramObjects.push(doTerminal1);
+            const doTerminal2 = this.createTerminalDiagramObjectFromPoints({
+                cePoints: [...coordsConnectivityNodeBayEnd], cnPoints: [...coordsEquipment],
+                terminalUuid: this.lookupTerminalUUID(schaltelement1pelem.eknoten, schaltelement1pelem.id)
+            });
+            resultingDiagramObjects.push(doTerminal2);
+            // this.addExportedDiagramObjectToGraph(nsgStpschaltfeld.variantennr, nsgStpschaltfeld.id, doStpknoten);
+            resultingDiagramObjects.push(doEquipment);
+            resultingDiagramObjects.push(doConnectivityNodeBayEnd);
+        }
+        return resultingDiagramObjects;
+    }
+    // /**
+    //  * convertSchemaStp*-Terminals
+    //  */
+    // async convertSchemaStpTerminals(nsgStpknoten: NsgStpknoten): Promise<DiagramObject[]> {
+    //   const resultingDiagramObjects: DiagramObject[] = [];
+    //
+    //   const cimObjectUUID = this.getCimObjectIdFromDbKey(
+    //     i7SchemaKeyNames.IdOnlyKey, { id: nsgStpknoten.knoten }
+    //   ) ?? undefined;
+    //
+    //   const doConnectivityNode = this.exportedDiagramObjectsGraph[nsgStpknoten.variantennr][nsgStpknoten.id];
+    //   const connectivityNode: ConnectivityNode = this.cimModelGraph.findObjectByUUID(doConnectivityNode.getIdentifiedObjectUUID());
+    //
+    //   if (connectivityNode !== undefined) {
+    //     for (const terminal of connectivityNode.terminals.values()) {
+    //       if (this.exportedTerminalUUIDs.has(terminal.getUUID())) continue;
+    //
+    //       const ceUUID = terminal.getConductingEquipmentUUID();
+    //
+    //       const ceDbKeys = this.getDbKeyDbFromCimObjectId(ceUUID);
+    //
+    //       if (ceDbKeys.VariantenNrIdKey) {
+    //         const ceDbKey = ceDbKeys.VariantenNrIdKey;
+    //         const doConductingEquipment = this.exportedDiagramObjectsGraph[ceDbKey.variantennr][ceDbKey.id];
+    //
+    //
+    //       } else if (ceDbKeys.IdOnlyKey) {
+    //
+    //       }
+    //     }
+    //
+    //   } else {
+    //     console.log(cimObjectUUID)
+    //   }
+    //
+    //
+    //   return resultingDiagramObjects;
+    // }
+    /* ---------- ---------- ---------- ---------- ---------- */
+    //
+    // utility functions
+    //
+    /* ---------- ---------- ---------- ---------- ---------- */
+    async getLeftUpperCornerOfUnspecified(variantennr, id) {
+        const { type, object } = this.dbObjectGraph.findTypedFirstByKey(convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, {
+            variantennr, id
+        });
+        if (type === convert_graph_keys_1.i7TableNames.nsg_nsgknotenso) {
+            return await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgknotenso, object);
+        }
+        else if (type === convert_graph_keys_1.i7TableNames.nsg_nsgknotenhgue) {
+            return await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgknotenhgue, object);
+        }
+        else if (type === convert_graph_keys_1.i7TableNames.nsg_nsgschaltfeld) {
+            return await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgschaltfeld, object);
+        }
+        else if (type === convert_graph_keys_1.i7TableNames.nsg_nsgquerzweig) {
+            return await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgquerzweig, object);
+        }
+    }
+    async getLeftUpperCornerOf(i7ObjectType, object, variantennr) {
+        if (i7ObjectType === convert_graph_keys_1.i7TableNames.nsg_nsgknotenso) {
+            const nsgKnotenSo = object;
+            const nsgStandort = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgstandort, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgKnotenSo.variantennr, id: nsgKnotenSo.nsgso });
+            if (!nsgStandort)
+                return;
+            return [nsgStandort.xrel + nsgKnotenSo.xrel, nsgStandort.yrel + nsgKnotenSo.yrel];
+        }
+        else if (i7ObjectType === convert_graph_keys_1.i7TableNames.nsg_nsgknotenhgue) {
+            const nsgKnotenHgue = object;
+            const nsgStandort = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgstandort, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgKnotenHgue.variantennr, id: nsgKnotenHgue.nsgso });
+            if (!nsgStandort)
+                return;
+            return [nsgStandort.xrel + nsgKnotenHgue.xrel, nsgStandort.yrel + nsgKnotenHgue.yrel];
+        }
+        else if (i7ObjectType === convert_graph_keys_1.i7TableNames.nsg_nsgstandort) {
+            /* ---------- ---------- ---------- */
+            /* NsgStandort */
+            /* ---------- ---------- ---------- */
+            const nsgStandort = object;
+            return [nsgStandort.xrel, nsgStandort.yrel];
+        }
+        else if (i7ObjectType === convert_graph_keys_1.i7TableNames.nsg_nsgschaltanlage) {
+            /* ---------- ---------- ---------- */
+            /* NsgSchaltanlage */
+            /* ---------- ---------- ---------- */
+            const nsgSchaltanlage = object;
+            const nsgStandort = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgstandort, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgSchaltanlage.variantennr, id: nsgSchaltanlage.nsgso });
+            if (!nsgStandort)
+                return;
+            const coords = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgstandort, nsgStandort);
+            coords[0] += nsgSchaltanlage.xrel;
+            coords[1] += nsgSchaltanlage.yrel;
+            return coords;
+        }
+        else if (i7ObjectType === convert_graph_keys_1.i7TableNames.nsg_nsgsaabschnitt) {
+            /* ---------- ---------- ---------- */
+            /* NsgSaabschnitt */
+            /* ---------- ---------- ---------- */
+            const nsgSaabschnitt = object;
+            const nsgSchaltanlage = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgschaltanlage, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgSaabschnitt.variantennr, id: nsgSaabschnitt.nsgsa });
+            if (!nsgSchaltanlage)
+                return;
+            // add the i7-offset for a NsgSaabschnitt in x-direction
+            const nsgSaabschnittCoords = [0, 0];
+            nsgSaabschnittCoords[0] += nsgSaabschnitt.nslots * 16;
+            const sizeOfSchaltanlage = await this.getSizeOfSchaltanlage(nsgSchaltanlage);
+            util_functions_1.DLUtilFunctions.rotatePoint(nsgSaabschnittCoords, -90 * nsgSchaltanlage.ausrichtung);
+            if (nsgSchaltanlage.ausrichtung === 2) {
+                nsgSaabschnittCoords[0] += (sizeOfSchaltanlage - nsgSaabschnitt.laenge) * constants_1.NsgConstants.HORIZONTAL_OFFSET;
+            }
+            else if (nsgSchaltanlage.ausrichtung === 3) {
+                nsgSaabschnittCoords[1] += (sizeOfSchaltanlage - nsgSaabschnitt.laenge) * constants_1.NsgConstants.HORIZONTAL_OFFSET;
+            }
+            const nsgSchaltanlageCoords = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgschaltanlage, nsgSchaltanlage);
+            return util_functions_1.DLUtilFunctions.add(nsgSaabschnittCoords, nsgSchaltanlageCoords, nsgSchaltanlage.ausrichtung % 2 === 0 ? [8, 0] : [0, 8]);
+        }
+        else if (i7ObjectType === convert_graph_keys_1.i7TableNames.nsg_nsgschaltfeld || i7ObjectType === convert_graph_keys_1.i7TableNames.nsg_nsgkpfeld) {
+            /* ---------- ---------- ---------- */
+            /* NsgSchaltfeld or NsgKpfeld */
+            /* ---------- ---------- ---------- */
+            // Important! The difference between a bay and a coupler is the slot-number related offset
+            // the slot-number related offset of the bay must be adjusted by an offset of -8 related to the orientation
+            // the slot-number related offset of the coupler matches exactly
+            const nsgSchaltfeld = object;
+            const nsgSaabschnitt = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgsaabschnitt, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgSchaltfeld.variantennr, id: nsgSchaltfeld.nsgsaa });
+            if (!nsgSaabschnitt)
+                return;
+            const nsgSchaltanlage = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgschaltanlage, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgSaabschnitt.variantennr, id: nsgSaabschnitt.nsgsa });
+            if (nsgSchaltanlage === undefined)
+                return;
+            //
+            // const nsgStandort = await this.dbObjectGraph.findObjectByKey(i7TableNames.nsg_nsgstandort,
+            //   i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgSchaltanlage.variantennr, id: nsgSchaltanlage.nsgso }
+            // );
+            // if (!nsgStandort) return;
+            const leftUpperCornerOfNsgSaabschnitt = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgsaabschnitt, nsgSaabschnitt);
+            let orientation = nsgSchaltanlage.ausrichtung;
+            if (nsgSchaltfeld.deltaausrichtung === 1) {
+                orientation = (orientation + 2) % 4;
+            }
+            let position = [...leftUpperCornerOfNsgSaabschnitt];
+            let schaltfeldOffset;
+            switch (nsgSchaltanlage.ausrichtung) {
+                case 0:
+                case 1:
+                    schaltfeldOffset = nsgSchaltfeld.slotnummer * 16;
+                    break;
+                case 2:
+                case 3:
+                    schaltfeldOffset = (nsgSaabschnitt.laenge - nsgSchaltfeld.slotnummer - 1) * 16;
+                    if (i7ObjectType === convert_graph_keys_1.i7TableNames.nsg_nsgkpfeld)
+                        schaltfeldOffset -= 16;
+                    break;
+            }
+            const maxSsabPos = await this.getMaxPosOfSaabschnitt(nsgSaabschnitt);
+            switch (orientation) {
+                case 0: // TOP
+                    position[0] += (i7ObjectType === convert_graph_keys_1.i7TableNames.nsg_nsgkpfeld) ? schaltfeldOffset : schaltfeldOffset - 8;
+                    position[1] -= nsgSchaltfeld.hoehe - ((maxSsabPos + 1) * 8);
+                    break;
+                case 1: // RIGHT
+                    position[1] += (i7ObjectType === convert_graph_keys_1.i7TableNames.nsg_nsgkpfeld) ? schaltfeldOffset : schaltfeldOffset - 8;
+                    break;
+                case 2: // BOTTOM
+                    position[0] += (i7ObjectType === convert_graph_keys_1.i7TableNames.nsg_nsgkpfeld) ? schaltfeldOffset : schaltfeldOffset - 8;
+                    break;
+                case 3: // LEFT
+                    position[0] -= nsgSchaltfeld.hoehe - ((maxSsabPos + 1) * 8);
+                    position[1] += (i7ObjectType === convert_graph_keys_1.i7TableNames.nsg_nsgkpfeld) ? schaltfeldOffset : schaltfeldOffset - 8;
+                    break;
+            }
+            return position;
+        }
+        else if (i7ObjectType === convert_graph_keys_1.i7TableNames.nsg_nsglkupplung) {
+            /* ---------- ---------- ---------- */
+            /* NsgLKupplung */
+            /* ---------- ---------- ---------- */
+            const nsgLKupplung = object;
+            const nsgSaabschnitt = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgsaabschnitt, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgLKupplung.variantennr, id: nsgLKupplung.nsgsaa });
+            if (!nsgSaabschnitt)
+                return;
+            const leftUpperCornerOfNsgSaabschnitt = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgsaabschnitt, nsgSaabschnitt);
+            const nsgSchaltanlage = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgschaltanlage, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgSaabschnitt.variantennr, id: nsgSaabschnitt.nsgsa });
+            if (nsgSchaltanlage === undefined)
+                return;
+            let position = [...leftUpperCornerOfNsgSaabschnitt];
+            switch (nsgSchaltanlage.ausrichtung) {
+                case 0: // left-to-right
+                    position[0] -= nsgLKupplung.laenge * 16;
+                    break;
+                case 1: // top-to-bottom
+                    position[1] -= nsgLKupplung.laenge * 16;
+                    break;
+                case 2: // right-to-left
+                    position[0] += (await this.getLengthOfSammelschienenAbschnitt(nsgSaabschnitt)) * 16;
+                    break;
+                case 3: // bottom-to-top
+                    position[1] += (await this.getLengthOfSammelschienenAbschnitt(nsgSaabschnitt)) * 16;
+                    break;
+            }
+            return position;
+        }
+        else if (i7ObjectType === convert_graph_keys_1.i7TableNames.netz_ssab) {
+            /* ---------- ---------- ---------- */
+            /* NetzSsab */
+            /* ---------- ---------- ---------- */
+            const netzSsab = object;
+            const nsgSaabschnitt = await this.dbObjectGraph.findFirstByAttributes(convert_graph_keys_1.i7TableNames.nsg_nsgsaabschnitt, { variantennr, saabschnitt: netzSsab.saabschnitt });
+            if (nsgSaabschnitt === undefined)
+                return;
+            const nsgSchaltanlage = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgschaltanlage, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgSaabschnitt.variantennr, id: nsgSaabschnitt.nsgsa });
+            if (!nsgSchaltanlage)
+                return;
+            // add the i7-offset for a NsgSaabschnitt in x-direction
+            const nsgSaabschnittCoords = [0, 0];
+            nsgSaabschnittCoords[0] += nsgSaabschnitt.nslots * 16;
+            const sizeOfSchaltanlage = await this.getSizeOfSchaltanlage(nsgSchaltanlage);
+            util_functions_1.DLUtilFunctions.rotatePoint(nsgSaabschnittCoords, -90 * nsgSchaltanlage.ausrichtung);
+            if (nsgSchaltanlage.ausrichtung === 0) {
+                nsgSaabschnittCoords[1] += 4 + netzSsab.pos * 8;
+                // const maxSsabPos = await this.getMaxPosOfSaabschnitt(nsgSaabschnitt);
+                // nsgSaabschnittCoords[0] += 4 + ((maxSsabPos - netzSsab.pos) * 8);
+            }
+            else if (nsgSchaltanlage.ausrichtung === 1) {
+                const maxSsabPos = await this.getMaxPosOfSaabschnitt(nsgSaabschnitt);
+                nsgSaabschnittCoords[0] += 4 + ((maxSsabPos - netzSsab.pos) * 8);
+            }
+            else if (nsgSchaltanlage.ausrichtung === 2) {
+                const maxSsabPos = await this.getMaxPosOfSaabschnitt(nsgSaabschnitt);
+                nsgSaabschnittCoords[1] += 4 + ((maxSsabPos - netzSsab.pos) * 8);
+                nsgSaabschnittCoords[0] += (sizeOfSchaltanlage - nsgSaabschnitt.laenge) * constants_1.NsgConstants.HORIZONTAL_OFFSET;
+            }
+            else if (nsgSchaltanlage.ausrichtung === 3) {
+                nsgSaabschnittCoords[0] += 4 + netzSsab.pos * 8;
+                nsgSaabschnittCoords[1] += (sizeOfSchaltanlage - nsgSaabschnitt.laenge) * constants_1.NsgConstants.HORIZONTAL_OFFSET;
+            }
+            const nsgSchaltanlageCoords = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgschaltanlage, nsgSchaltanlage);
+            return util_functions_1.DLUtilFunctions.add(nsgSaabschnittCoords, nsgSchaltanlageCoords, nsgSchaltanlage.ausrichtung % 2 === 0 ? [8, 0] : [0, 8]);
+        }
+        else if (i7ObjectType === convert_graph_keys_1.i7TableNames.nsg_nsgstpschiene) {
+            /* ---------- ---------- ---------- */
+            /* NsgStpschiene */
+            /* ---------- ---------- ---------- */
+            const nsgStpschiene = object;
+            const nsgStandort = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgstandort, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgStpschiene.variantennr, id: nsgStpschiene.nsgso });
+            if (!nsgStandort)
+                return;
+            const coords = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgstandort, nsgStandort);
+            coords[0] += nsgStpschiene.xrel;
+            coords[1] += nsgStpschiene.yrel;
+            return coords;
+        }
+        else if (i7ObjectType === convert_graph_keys_1.i7TableNames.nsg_nsgtrafo2w || i7ObjectType === convert_graph_keys_1.i7TableNames.nsg_nsgtrafo3w) {
+            /* ---------- ---------- ---------- */
+            /* NsgTrafo{2w|3w}*/
+            /* ---------- ---------- ---------- */
+            const nsgTrafo = object;
+            const nsgStandort = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgstandort, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgTrafo.variantennr, id: nsgTrafo.nsgso });
+            if (!nsgStandort)
+                return;
+            const leftUpperCornerOfNsgSo = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgstandort, nsgStandort);
+            leftUpperCornerOfNsgSo[0] += nsgTrafo.xrel;
+            leftUpperCornerOfNsgSo[1] += nsgTrafo.yrel;
+            return leftUpperCornerOfNsgSo;
+        }
+        else if (i7ObjectType === convert_graph_keys_1.i7TableNames.nsg_nsgstpschaltfeld) {
+            /* ---------- ---------- ---------- */
+            /* NsgStpschaltfeld */
+            /* ---------- ---------- ---------- */
+            const nsgStpschaltfeld = object;
+            const nsgStpschiene = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgstpschiene, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, {
+                variantennr: nsgStpschaltfeld.variantennr,
+                id: nsgStpschaltfeld.nsgstpschiene
+            });
+            if (!nsgStpschiene)
+                return;
+            const leftUpperCornerOfNsgStpschiene = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgstpschiene, nsgStpschiene);
+            let orientation = nsgStpschiene.ausrichtung;
+            if (nsgStpschaltfeld.deltaausrichtung === 1) {
+                orientation = (orientation + 2) % 4;
+            }
+            let position = [...leftUpperCornerOfNsgStpschiene];
+            let schaltfeldOffset;
+            switch (nsgStpschiene.ausrichtung) {
+                case 0:
+                case 1:
+                    schaltfeldOffset = nsgStpschaltfeld.slotnummer * 16;
+                    break;
+                case 2:
+                case 3:
+                    schaltfeldOffset = (nsgStpschiene.laenge - nsgStpschaltfeld.slotnummer - 1) * 16;
+                    break;
+            }
+            switch (orientation) {
+                case 0: // TOP
+                    position[0] += schaltfeldOffset;
+                    position[1] -= nsgStpschaltfeld.hoehe - 8;
+                    break;
+                case 1: // RIGHT
+                    position[1] += schaltfeldOffset;
+                    break;
+                case 2: // BOTTOM
+                    position[0] += schaltfeldOffset;
+                    break;
+                case 3: // LEFT
+                    position[0] -= nsgStpschaltfeld.hoehe - 8;
+                    position[1] += schaltfeldOffset;
+                    break;
+            }
+            return position;
+        }
+        else if (i7ObjectType === convert_graph_keys_1.i7TableNames.nsg_nsgstpknoten) {
+            /* ---------- ---------- ---------- */
+            /* NsgStpknoten */
+            /* ---------- ---------- ---------- */
+            const nsgStpknoten = object;
+            let leftUpperCornerOfNsgTrafo;
+            const nsgTrafo2w = this.dbObjectGraph.findFirstByAttributes(convert_graph_keys_1.i7TableNames.nsg_nsgtrafo2w, {
+                anschlussanf_stp: nsgStpknoten.id,
+                anschlussend_stp: nsgStpknoten.id
+            }, true);
+            if (!nsgTrafo2w) {
+                const nsgTrafo3w = this.dbObjectGraph.findFirstByAttributes(convert_graph_keys_1.i7TableNames.nsg_nsgtrafo3w, {
+                    anschlussanfw1: nsgStpknoten.id,
+                    anschlussanfw2: nsgStpknoten.id,
+                    anschlussanfw3: nsgStpknoten.id
+                }, true);
+                if (!nsgTrafo3w)
+                    return;
+                leftUpperCornerOfNsgTrafo = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgtrafo3w, nsgTrafo3w);
+            }
+            else {
+                leftUpperCornerOfNsgTrafo = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgtrafo2w, nsgTrafo2w);
+            }
+            if (!leftUpperCornerOfNsgTrafo)
+                return;
+            leftUpperCornerOfNsgTrafo[0] += nsgStpknoten.xrel;
+            leftUpperCornerOfNsgTrafo[1] += nsgStpknoten.yrel;
+            return leftUpperCornerOfNsgTrafo;
+        }
+        else if (i7ObjectType === convert_graph_keys_1.i7TableNames.nsg_nsgstpimpedanz) {
+            /* ---------- ---------- ---------- */
+            /* NsgStpimpedanz */
+            /* ---------- ---------- ---------- */
+            const nsgStpimpedanz = object;
+            const nsgStpschaltfeld = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgstpschaltfeld, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, {
+                variantennr: nsgStpimpedanz.variantennr,
+                id: nsgStpimpedanz.anschluss
+            });
+            if (!nsgStpschaltfeld)
+                return;
+            const coords = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgstpschaltfeld, nsgStpschaltfeld);
+            coords[0] += nsgStpimpedanz.xrel;
+            coords[1] += nsgStpimpedanz.yrel;
+            return coords;
+        }
+        else if (i7ObjectType === convert_graph_keys_1.i7TableNames.nsg_nsgldrossel) {
+            /* ---------- ---------- ---------- */
+            /* NsgLDrossel */
+            /* ---------- ---------- ---------- */
+            const nsgLDrossel = object;
+            const nsgStandort = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgstandort, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgLDrossel.variantennr, id: nsgLDrossel.nsgso });
+            if (!nsgStandort)
+                return;
+            const leftUpperCornerOfNsgSo = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgstandort, nsgStandort);
+            leftUpperCornerOfNsgSo[0] += nsgLDrossel.xrel;
+            leftUpperCornerOfNsgSo[1] += nsgLDrossel.yrel;
+            return leftUpperCornerOfNsgSo;
+        }
+        else if (i7ObjectType === convert_graph_keys_1.i7TableNames.nsg_nsglkondensator) {
+            /* ---------- ---------- ---------- */
+            /* NsgLKondensator */
+            /* ---------- ---------- ---------- */
+            const nsgLKondensator = object;
+            const nsgStandort = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgstandort, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgLKondensator.variantennr, id: nsgLKondensator.nsgso });
+            if (!nsgStandort)
+                return;
+            const leftUpperCornerOfNsgSo = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgstandort, nsgStandort);
+            leftUpperCornerOfNsgSo[0] += nsgLKondensator.xrel;
+            leftUpperCornerOfNsgSo[1] += nsgLKondensator.yrel;
+            return leftUpperCornerOfNsgSo;
+        }
+        else if (i7ObjectType === convert_graph_keys_1.i7TableNames.nsg_nsgquerzweig) {
+            /* ---------- ---------- ---------- */
+            /* NsgQuerzweig */
+            /* ---------- ---------- ---------- */
+            const nsgQuerzweig = object;
+            const typedResult = this.dbObjectGraph.findTypedFirstByKey(convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, {
+                variantennr: nsgQuerzweig.variantennr, id: nsgQuerzweig.bezugsobjekt
+            });
+            if (!typedResult)
+                return null;
+            const { type, object: resultObject } = typedResult;
+            let xPosition = nsgQuerzweig.xrel;
+            let yPosition = nsgQuerzweig.yrel;
+            if (type === convert_graph_keys_1.i7TableNames.nsg_nsgschaltfeld) {
+                const nsgSchaltfeld = resultObject;
+                const leftUpperCornerOfSchaltfeld = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgschaltfeld, nsgSchaltfeld);
+                return [xPosition + leftUpperCornerOfSchaltfeld[0], yPosition + leftUpperCornerOfSchaltfeld[1]];
+            }
+            else {
+                return [undefined, undefined];
+            }
+        }
+        return [undefined, undefined];
+    }
+    async getLeftUpperCornerOfLKupplungRssElement(nsgLKupplungRss, cornerOf) {
+        if (cornerOf.slot_anf || cornerOf.slot_end) {
+            /* ---------- ---------- ---------- */
+            /* slot_anf || slot_end*/
+            /* ---------- ---------- ---------- */
+            const nsgSaabschnittId = cornerOf.slot_anf ? nsgLKupplungRss.nsgsaa_anf : nsgLKupplungRss.nsgsaa_end;
+            const slotIndex = cornerOf.slot_anf ? nsgLKupplungRss.slot_anf : nsgLKupplungRss.slot_end;
+            const nsgSaabschnitt = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgsaabschnitt, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgLKupplungRss.variantennr, id: nsgSaabschnittId });
+            if (!nsgSaabschnitt)
+                return;
+            const leftUpperCornerOfNsgSaabschnitt = await this.getLeftUpperCornerOf(convert_graph_keys_1.i7TableNames.nsg_nsgsaabschnitt, nsgSaabschnitt);
+            const nsgSchaltanlage = await this.dbObjectGraph.findObjectByKey(convert_graph_keys_1.i7TableNames.nsg_nsgschaltanlage, convert_graph_keys_1.i7SchemaKeyNames.VariantenNrIdKey, { variantennr: nsgSaabschnitt.variantennr, id: nsgSaabschnitt.nsgsa });
+            if (!nsgSchaltanlage)
+                return;
+            switch (nsgSchaltanlage.ausrichtung) {
+                case 0:
+                    leftUpperCornerOfNsgSaabschnitt[0] += slotIndex * 16 - 8;
+                    leftUpperCornerOfNsgSaabschnitt[1] -= 8;
+                    break;
+                case 1:
+                    leftUpperCornerOfNsgSaabschnitt[0] -= 8;
+                    leftUpperCornerOfNsgSaabschnitt[1] += slotIndex * 16 - 8;
+                    break;
+                case 2:
+                    leftUpperCornerOfNsgSaabschnitt[0] += (nsgSaabschnitt.laenge - slotIndex - 1) * 16 - 8;
+                    leftUpperCornerOfNsgSaabschnitt[1] -= 8;
+                    break;
+                case 3:
+                    leftUpperCornerOfNsgSaabschnitt[0] -= 8;
+                    leftUpperCornerOfNsgSaabschnitt[1] += (nsgSaabschnitt.laenge - slotIndex - 1) * 16 - 8;
+                    break;
+            }
+            return leftUpperCornerOfNsgSaabschnitt;
+        }
+        else if (cornerOf.self) {
+            /* ---------- ---------- ---------- */
+            /* self */
+            /* ---------- ---------- ---------- */
+            const leftUpperCornerOfSlotAnf = await this.getLeftUpperCornerOfLKupplungRssElement(nsgLKupplungRss, { slot_anf: true });
+            return [leftUpperCornerOfSlotAnf[0] + nsgLKupplungRss.xrel, leftUpperCornerOfSlotAnf[1] + nsgLKupplungRss.yrel];
+        }
+        return [undefined, undefined];
+    }
+    async getNodesOfSchaltfeld(arg) {
+        return await this.dbObjectGraph.findAllByAttributes([
+            convert_graph_keys_1.i7TableNames.netz_leistungsschalter,
+            convert_graph_keys_1.i7TableNames.netz_trenner3p,
+            convert_graph_keys_1.i7TableNames.netz_trennerfi3p,
+            convert_graph_keys_1.i7TableNames.netz_sestarr3p
+        ], { seliste: arg.schaltfeld });
+    }
+    async getNodesOfKpfeld(arg) {
+        return await this.dbObjectGraph.findAllByAttributes([
+            convert_graph_keys_1.i7TableNames.netz_leistungsschalter,
+            convert_graph_keys_1.i7TableNames.netz_trenner3p,
+            convert_graph_keys_1.i7TableNames.netz_trennerfi3p,
+            convert_graph_keys_1.i7TableNames.netz_sestarr3p
+        ], { seliste: arg.kpfeld });
+    }
+    async getNodesOfLKupplung(arg) {
+        return await this.dbObjectGraph.findAllByAttributes([
+            convert_graph_keys_1.i7TableNames.netz_leistungsschalter,
+            convert_graph_keys_1.i7TableNames.netz_trenner3p,
+            convert_graph_keys_1.i7TableNames.netz_trennerfi3p,
+            convert_graph_keys_1.i7TableNames.netz_sestarr3p
+        ], { seliste: arg.id });
+    }
+    /** */
+    async getSizeOfSchaltanlage(arg) {
+        let sizeOfSchaltanlage = 0;
+        const nsgSaabschnitte = await this.dbObjectGraph.findAllByAttributes(convert_graph_keys_1.i7TableNames.nsg_nsgsaabschnitt, {
+            variantennr: arg.variantennr, nsgsa: arg.id
+        });
+        for (const tempNsgSaab of nsgSaabschnitte) {
+            sizeOfSchaltanlage = sizeOfSchaltanlage < (tempNsgSaab.nslots + tempNsgSaab.laenge) ? (tempNsgSaab.nslots + tempNsgSaab.laenge) : sizeOfSchaltanlage;
+        }
+        return sizeOfSchaltanlage;
+    }
+    async getMaxPosOfSaabschnitt(nsgSaabschnitt) {
+        const netzSsabs = await this.dbObjectGraph.findAllByAttributes(convert_graph_keys_1.i7TableNames.netz_ssab, {
+            saabschnitt: nsgSaabschnitt.saabschnitt
+        });
+        let maxSsabPos = netzSsabs[0].pos;
+        for (let a = 1; a < netzSsabs.length; ++a) {
+            if (netzSsabs[a].pos > maxSsabPos)
+                maxSsabPos = netzSsabs[a].pos;
+        }
+        return maxSsabPos;
+    }
+    async getLengthOfSammelschienenAbschnitt(nsgSaab) {
+        const maxLengthOfKuppelfeld = await this.getMaxLengthOfKuppelfeld({
+            id: nsgSaab.id,
+            variantennr: nsgSaab.variantennr
+        });
+        const maxLengthOfSchaltfeld = await this.getMaxLengthOfSchaltfeld({
+            id: nsgSaab.id,
+            variantennr: nsgSaab.variantennr
+        });
+        return Math.max(maxLengthOfKuppelfeld, maxLengthOfSchaltfeld, nsgSaab.laenge);
+    }
+    async getMaxLengthOfKuppelfeld(schaltanlagenabschnittKey) {
+        const nsgKpFelder = (await this.dbObjectGraph.getAllObjectsOfTable(convert_graph_keys_1.i7TableNames.nsg_nsgkpfeld)).filter(nsgKpFeld => nsgKpFeld.nsgsaa === schaltanlagenabschnittKey.id
+            && nsgKpFeld.variantennr === schaltanlagenabschnittKey.variantennr
+            && (nsgKpFeld.eingeblendet === 1 || (nsgKpFeld.eingeblendet === null && nsgKpFeld.angezeigt === 1)));
+        let nsgKpFeldMaxSlotnummer = nsgKpFelder.length > 0 ? nsgKpFelder[0].slotnummer : undefined;
+        for (let a = 1; a < nsgKpFelder.length; ++a) {
+            const nsgKpFeld = nsgKpFelder[a];
+            if (nsgKpFeldMaxSlotnummer < nsgKpFeld.slotnummer) {
+                nsgKpFeldMaxSlotnummer = nsgKpFeld.slotnummer;
+            }
+        }
+        return nsgKpFeldMaxSlotnummer ? nsgKpFeldMaxSlotnummer + 1 : 0;
+    }
+    async getMaxLengthOfSchaltfeld(schaltanlagenabschnittKey) {
+        const nsgSchaltfelder = (await this.dbObjectGraph.getAllObjectsOfTable(convert_graph_keys_1.i7TableNames.nsg_nsgschaltfeld)).filter(nsgSchaltfeld => nsgSchaltfeld.nsgsaa === schaltanlagenabschnittKey.id
+            && nsgSchaltfeld.variantennr === schaltanlagenabschnittKey.variantennr
+            && (nsgSchaltfeld.eingeblendet === 1 || (nsgSchaltfeld.eingeblendet === null && nsgSchaltfeld.angezeigt === 1)));
+        let nsgSchaltfeldMaxSlotnummer = nsgSchaltfelder.length > 0 ? nsgSchaltfelder[0].slotnummer : undefined;
+        for (let a = 1; a < nsgSchaltfelder.length; ++a) {
+            const nsgSchaltfeld = nsgSchaltfelder[a];
+            if (nsgSchaltfeldMaxSlotnummer < nsgSchaltfeld.slotnummer) {
+                nsgSchaltfeldMaxSlotnummer = nsgSchaltfeld.slotnummer;
+            }
+        }
+        return nsgSchaltfeldMaxSlotnummer ? nsgSchaltfeldMaxSlotnummer + 1 : 0;
+    }
+    lookupTerminalUUID(connectivityNodeI7ID, conductingEquipmentI7ID) {
+        if (DLConverterI7.testmode) {
+            return common_utils_1.CommonUtils.generateUUID();
+        }
+        const connectivityNodeUUID = this.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: connectivityNodeI7ID });
+        const conductingEquipmentUUID = this.getCimObjectIdFromDbKey(convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey, { id: conductingEquipmentI7ID });
+        if (!connectivityNodeUUID || !conductingEquipmentUUID) {
+            return null;
+        }
+        const connectivityNode = this.cimModelGraph.findObjectByUUID(connectivityNodeUUID);
+        // const conductingEquipment = this.cimModelGraph.findObjectByUUID(conductingEquipmentUUID) as ConductingEquipment;
+        // if (!connectivityNode || !conductingEquipment) return null;
+        if (!connectivityNode)
+            return null;
+        if (connectivityNode.terminals !== undefined) {
+            const cnTerminals = [...connectivityNode.terminals.values()];
+            for (const cnTerminal of cnTerminals) {
+                if (cnTerminal.getConductingEquipmentUUID() === conductingEquipmentUUID) {
+                    const terminalUUID = cnTerminal.getUUID();
+                    return terminalUUID !== undefined ? terminalUUID : null;
+                }
+            }
+        }
+        // try a brute-force terminal lookup for dc terminals / pcc terminals
+        const bruteForcedTerminalUUID = this.cimModelGraph.findTerminalUUID(conductingEquipmentUUID, connectivityNodeUUID);
+        return bruteForcedTerminalUUID !== undefined ? bruteForcedTerminalUUID : null;
+    }
+    /**
+     * returns three Uuids if those two ConductingEquipments are connected with each other
+     * result is either [Terminal-UUID, ConnectivityNode-UUID, Terminal-UUID] or []
+     */
+    findConnectionAsUuidsBetweenTwoConductingEquipments(args) {
+        const conductingEquipment1 = this.cimModelGraph.findObjectByUUID(args.conductingEquipment1Uuid);
+        const conductingEquipment2 = this.cimModelGraph.findObjectByUUID(args.conductingEquipment2Uuid);
+        if (!conductingEquipment1 || !conductingEquipment2) {
+            return [];
+        }
+        if (conductingEquipment1.terminals !== undefined) {
+            const ce1Terminals = [...conductingEquipment1.terminals.values()];
+            for (const ce1Terminal of ce1Terminals) {
+                const connectivityNode = this.cimModelGraph.findObjectByUUID(ce1Terminal.getConnectivityNodeUUID());
+                if (connectivityNode.terminals !== undefined) {
+                    const cnTerminals = [...connectivityNode.terminals.values()];
+                    for (const cnTerminal of cnTerminals) {
+                        const tempConductingEquipmentUuid = cnTerminal.getConductingEquipmentUUID();
+                        if (tempConductingEquipmentUuid === args.conductingEquipment2Uuid) {
+                            return [ce1Terminal.getUUID(), connectivityNode.getUUID(), cnTerminal.getUUID()];
+                        }
+                    }
+                }
+            }
+        }
+        return [];
+    }
+    adjustTransformerTerminalPositions(terminalDiagramObject, transformerDiagramObject) {
+        if (terminalDiagramObject.diagramObjectPoints.length === 2 && transformerDiagramObject.diagramObjectPoints.length === 1) {
+            const firstDiagramObjectPoint = terminalDiagramObject.diagramObjectPoints[0];
+            const secondDiagramObjectPoint = terminalDiagramObject.diagramObjectPoints[1];
+            if (firstDiagramObjectPoint.xPosition === secondDiagramObjectPoint.xPosition
+                && firstDiagramObjectPoint.yPosition === secondDiagramObjectPoint.yPosition) {
+                const v1 = [firstDiagramObjectPoint.xPosition, firstDiagramObjectPoint.yPosition];
+                const v2 = [transformerDiagramObject.diagramObjectPoints[0].xPosition, transformerDiagramObject.diagramObjectPoints[0].yPosition];
+                const v = [v2[0] - v1[0], v2[1] - v1[1]];
+                const lengthOfV = util_functions_1.DLUtilFunctions.euclideanMetric(v2, v1);
+                util_functions_1.DLUtilFunctions.inplaceNormalize(v);
+                firstDiagramObjectPoint.xPosition += v[0] * (lengthOfV * 0.3);
+                firstDiagramObjectPoint.yPosition += v[1] * (lengthOfV * 0.3);
+            }
+        }
+    }
+    createTerminalDiagramObjectFromPoints(args) {
+        if (args.points) {
+            const terminalDiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoints([...args.points], null);
+            terminalDiagramObject.identifiedObjectUUID = args.terminalUuid;
+            if (args.name)
+                terminalDiagramObject.name = args.name;
+            return terminalDiagramObject;
+        }
+        else {
+            const terminalDiagramObject = util_functions_1.DLUtilFunctions.createDiagramObjectWithPoints([[...args.cePoints], [...args.cnPoints]], null);
+            terminalDiagramObject.identifiedObjectUUID = args.terminalUuid;
+            if (args.name)
+                terminalDiagramObject.name = args.name;
+            return terminalDiagramObject;
+        }
+    }
+    alreadyExported(variantenNr, netzId) {
+        if (variantenNr in this.exportedDiagramObjectsGraph) {
+            if (netzId in this.exportedDiagramObjectsGraph[variantenNr]) {
+                return this.exportedDiagramObjectsGraph[variantenNr][netzId] !== undefined;
+            }
+        }
+        return false;
+    }
+    linkIntegralId2UUIDMap(integralID2UUID) {
+        this.integralID2UUID = integralID2UUID;
+    }
+    getCimObjectIdFromDbKey(typeOfKey, dbKey) {
+        if (typeOfKey === convert_graph_keys_1.i7SchemaKeyNames.IdOnlyKey) {
+            return this.integralID2UUID.get(dbKey.id);
+        }
+        else {
+            throw Error('Optimierung ging nach hinten los!');
+        }
+    }
+}
+exports.DLConverterI7 = DLConverterI7;
+//# sourceMappingURL=dl-converter-i7.js.map