@enervance/insight-cim-model 0.0.1

package/src/converter/integral7/ConverterIntegral7.ts

@@ -0,0 +1,3508 @@
+import {
+  ACLineSegment,
+  ApparentPower, BaseVoltage,
+  Bay,
+  Breaker,
+  BusbarSection,
+  CableInfo,
+  CapacitancePerLength,
+  ConnectivityNode,
+  createBaseVoltageIfNotExists,
+  createConnection,
+  createGeoregion,
+  createSvStatus,
+  CurrentFlow,
+  CurrentLimit,
+  CurveData,
+  CurveStyle,
+  Diagram,
+  DIAGRAM_LAYOUT_TYPES,
+  DiagramObject,
+  DiagramObjectPoint,
+  Disconnector,
+  EnergyConsumer,
+  EnergySource,
+  EquipmentContainer,
+  generateUUID,
+  GeneratingUnit,
+  GeneratorControlSource,
+  GeographicalRegion,
+  getUUID,
+  IConnectivityNode,
+  IdentifiedObject,
+  IIdentifiedObject,
+  Junction,
+  LimitTypeKind,
+  Line,
+  Model,
+  NuclearGeneratingUnit,
+  OperationalLimitDirectionKind,
+  OperationalLimitSet,
+  OperationalLimitType,
+  OrientationKind,
+  OverheadWireInfo,
+  PhaseCode,
+  PowerTransformer,
+  PowerTransformer2WInfo,
+  PowerTransformer3WInfo,
+  PowerTransformerEnd,
+  RDF_XML,
+  ReactancePerLength,
+  ReactiveCapabilityCurve,
+  RegulatingControl,
+  RegulatingControlModeKind,
+  ResistancePerLength,
+  SolarGeneratingUnit,
+  SubGeographicalRegion,
+  Substation,
+  SynchronousMachine,
+  SynchronousMachineKind,
+  Terminal,
+  ThermalGeneratingUnit,
+  TransformerEndInfo,
+  UnitMultiplier,
+  UnitSymbol,
+  Voltage,
+  VoltageLevel,
+  WindGeneratingUnit,
+  WindGenUnitKind,
+  WireInfo
+} from '../..';
+import * as mysql from 'mysql';
+import {
+  Abzweig,
+  Anlage,
+  AnlagenAbschnitt,
+  Belastung,
+  Einspeisung,
+  Generator,
+  Georegion,
+  KnotenKf,
+  KnotenLk,
+  Laengskupplung,
+  Leistungsschalter,
+  LeitungStk,
+  Netzvarianten,
+  NsgKnotenSo,
+  NsgSA,
+  NsgSAAB,
+  NsgSchaltfeld,
+  NsgStandort,
+  Querkupplung,
+  Schaltfeld,
+  SchaltfeldKnoten,
+  Schlaufe,
+  Ssab,
+  Standort,
+  StarrerKnoten,
+  Stk,
+  StkTyp,
+  Subgeoregion,
+  Trafo2w,
+  Trafo3w,
+  Trafo3wWicklung,
+  Trenner3p
+} from './model/interfaces';
+import {
+  createIfNotExitsGeoregionByName,
+  createIfNotExitsPSRType,
+  createIfNotExitsSubGeoregionByName,
+  writeElementAttribute,
+} from '../../util/utils';
+import {
+  BELASTUNG_PRAEFIX,
+  EINSPEISUNG_PRAEFIX,
+  GENERATOR_PRAEFIX,
+  KNOTEN_STANDORT_PRAEFIX,
+  LEITUNG_PRAEFIX,
+  MITTIGER_PUNKT,
+  SAMMELSCHIENENABSCHNITT_PRAEFIX,
+  SCHALTFELD_PRAEFIX,
+  STANDORT_PRAEFIX,
+  TRAFO2WPRAEFIX_PRAEFIX,
+  TRAFO3WPRAEFIX_PRAEFIX
+} from './config/integral-prefix';
+import {
+  calculateB,
+  calculateG,
+  calculateR,
+  calculateX,
+  convertToBooleanI7,
+  createTapChanger,
+  createTempDirPath,
+  createWriteStreamPromise,
+  determineEquipmentContainer,
+  generateFuelType,
+  getActiveReactivePower,
+  getDescription,
+  getLine,
+  getLineByAttribute,
+  getName,
+  getNumber,
+  getPkrTrafo,
+  getPSRType,
+  getSchaltgruppe,
+  getSchaltgruppeAngleClock,
+  getSrTrafo,
+  getTerminalUn,
+  getTrafoIleer,
+  getTrafoPleer,
+  getUkrTrafo,
+  getUrTrafo,
+  putUUIDtoI7Ids,
+  ueberpruefeZeichenkette,
+  writeZipFile
+} from './utils';
+import { calculateImpedanzenTrafo3W } from './utils-trafo3w';
+import { FUEL_TYPE_CONFIG } from './config/generation-unit-fuel-types';
+import { getNetzQuery, I7Objects, Integral7TableNames } from './sql/integral.sql';
+import { MySQL, Status } from './config/db-config';
+import path from "path";
+import fs from "fs";
+
+import XMLWriter from 'xml-writer';
+import JSZip from 'jszip';
+import { StandortImpl } from './model/integral/Standort';
+import { SchaltanlageImpl } from './model/integral/Schaltanlage';
+import { SchaltanlagenabschnittImpl } from './model/integral/Schaltanlagenabschnitt';
+import { StandortNsgImpl } from './model/integral/StandortNsg';
+import { SchaltanlageNsgImpl } from './model/integral/SchaltanlageNSG';
+import { SchaltanlagenabschnittNsg } from './model/integral/SchaltanlagenabschnittNsg';
+import { Point } from './model/integral/Point';
+import { createDiagramObjectPoints, getDiagramObjectBelonginToDiagram, isConnectedTo } from './utils-schema';
+import { SchaltfeldImpl } from './model/integral/Schaltfeld';
+import { SchaltfeldNsgImpl } from './model/integral/SchaltfeldNsg';
+import { KnotenSoImpl } from './model/integral/KnotenSo';
+import { KnotenSoNsg } from './model/integral/KnotenSoNsg';
+import { LeitungImpl } from './model/integral/Leitung';
+import { TapChangerInfo } from '../../model/assetinfo/TapChangerInfo';
+import { AMPRIONBay } from '../../model/extensions/amprion/core/AMPRIONBay';
+import { AMPRIONConnectivityNode } from '../../model/extensions/amprion/core/AMPRIONConnectivityNode';
+
+export class ConverterIntegral7 {
+  mysqlConnection: mysql.Connection;
+  cimModel: Model;
+
+  /** Das Array hält die verfügbaren Tabellennamen in der Projektdatenbank.
+   *  Integral 7 legt die Tabellen keine leeren Tabellen an.
+   *  Das heißt: wenn es keine Typinformation für Kabel gepflegt sind, dann existiert keine Tabelle in der Datenbank*/
+  availableTableNames: string[];
+
+  /** Speichert die Zuordnung der Integral7 ID zu CIM UUID */
+  private readonly integralID2UUID = new Map<number, string>();
+  /** Speichert die Zuordnung der CIM UUID zu Integral7 ID */
+  private readonly UUID2IntegralID = new Map<string, number[]>();
+
+
+  standortAnzahl: number;
+  leitungsAnzahl: number;
+  trafo2WAnzahl: number;
+  trafo3WAnzahl: number;
+  /** Begrenzt die Anzahl der abgefragten Daten aus der DB
+   * Limit wird anhand der Stationenanzahl berechent
+   * default Wert: x */
+  limit: number = 100;
+
+
+  /** Integral 7 Datenmodell für die Schemakonvertierung */
+  integralStandorte = new Map<number, StandortImpl>();
+  integralSchaltanlagen = new Map<number, SchaltanlageImpl>();
+  integralSchaltanlagenAbschnitte = new Map<number, SchaltanlagenabschnittImpl>();
+  integralSchaltfelder = new Map<number, SchaltfeldImpl>();
+
+  integralKnotenSo = new Map<number, KnotenSoImpl>();
+
+  integralNsgStandort: Map<number, StandortNsgImpl> = new Map();
+  integralNsgSchaltanlage: Map<number, SchaltanlageNsgImpl> = new Map();
+  integralNsgSchaltanlagenabschnitt: Map<number, SchaltanlagenabschnittNsg> = new Map();
+  integralNsgSchaltfelder = new Map<number, SchaltfeldNsgImpl>();
+
+  integralNsgKnotenSo = new Map<number, KnotenSoNsg>();
+
+  integralLeitungen: Map<number, LeitungImpl> = new Map();
+
+  /** Integral 7 IDs for blockweise Verarbeitung SQLs */
+  schaltfeldIDs = [];
+  querkupplungIDs = [];
+  laengskupplungIDs = [];
+  knotenSoIDs = [];
+  knotenSfIDs = [];
+  leitungsIDs = [];
+  trafo2WIDs = [];
+
+  /** CIM Objekte, die zur Laufzeit im Speicher bleiben.
+   * Sie werden zur Erstellung der Topologie verwendet. */
+  /** Schlaufen werden als Terminals mit Schaltzustand abgebildet. */
+  memoryObjects: Map<number, IdentifiedObject> = new Map();
+  /** IDs von Leitungsachnlussknoten
+   * Die IDs werden zur Bestimmung der im Speicher zu haltenden Objekte (ConnectivityNodes, Terminals) herangezogen. */
+  leitungAnschlussKnotenIDs = new Set();
+
+  /** Für Leitungen sind nicht immer Spannungen gepflegt.
+   * Diese Map speichert die Zuordnung von Knoten (CN) zu der jeweiligen Spannung
+   * Key -> CN UUID -> Basevoltage */
+  knotenSpannung = new Map<string, BaseVoltage>();
+
+  constructor() {
+    this.cimModel = new Model();
+    this.availableTableNames = [];
+  }
+
+  async init(mySqlConfig: MySQL): Promise<Status> {
+
+    return new Promise(async (resolve, reject) => {
+      try {
+        this.initDbConnection(mySqlConfig);
+        this.openConnection();
+        await this.getAvailableTableNames(mySqlConfig.database);
+        this.standortAnzahl = await this.queryObjectCount(Integral7TableNames.STANDORT);
+        this.leitungsAnzahl = await this.queryObjectCount(Integral7TableNames.LEITUNG);
+        this.trafo2WAnzahl = await this.queryObjectCount(Integral7TableNames.TRAFO2W);
+        this.trafo3WAnzahl = await this.queryObjectCount(Integral7TableNames.TRAFO3W);
+        await this.queryAnschlussIDs();
+        resolve({status: 'successful', message: 'ok'});
+      } catch (e) {
+        reject({status: 'error', message: e.toString()});
+      }
+    });
+  }
+
+  async start(): Promise<Status> {
+
+    return new Promise(async (resolve, reject) => {
+      try {
+
+        const tempDirPath = await createTempDirPath() as string;
+
+        /** EQ Profile */
+        const filePathEQ = path.join(tempDirPath, 'eq.xml');
+        const writeStreamEQ = fs.createWriteStream(filePathEQ);
+        const xmlWriterEQ = new XMLWriter(true, (string, encoding) => {
+          writeStreamEQ.write(string, encoding);
+        });
+        this.writeHeaderStart(xmlWriterEQ);
+        const modelEQUUID = generateUUID();
+        const profiles = [RDF_XML.EQ_CORE_PROFILE_URI, RDF_XML.EQ_SC_PROFILE_URI, RDF_XML.EQ_OPER_PROFILE_URI];
+        this.cimModel.toCIMXML(xmlWriterEQ, modelEQUUID, profiles, undefined, RDF_XML.AMP_MAS);
+
+        /** DL Profile */
+        const filePathDL = path.join(tempDirPath, 'dl.xml');
+        const writeStreamDL = fs.createWriteStream(filePathDL);
+        const xmlWriterDL = new XMLWriter(true, (string, encoding) => {
+          writeStreamDL.write(string, encoding);
+        });
+        this.writeHeaderStart(xmlWriterDL);
+        const modelDLUUID = generateUUID();
+        const profilesDl = [RDF_XML.DL_OPER_PROFILE_URI];
+        this.cimModel.toCIMXML(xmlWriterDL, modelDLUUID, profilesDl, [modelEQUUID], RDF_XML.AMP_MAS);
+
+        /** SSH Profile */
+        const filePathSSH = path.join(tempDirPath, 'ssh.xml');
+        const writeStreamSSH = fs.createWriteStream(filePathSSH);
+        const xmlWriterSSH = new XMLWriter(true, (string, encoding) => {
+          writeStreamSSH.write(string, encoding);
+        });
+        this.writeHeaderStart(xmlWriterSSH);
+        const modelSSHUUID = generateUUID();
+        const profilesSSH = [RDF_XML.SSH_OPER_PROFILE_URI];
+        this.cimModel.toCIMXML(xmlWriterSSH, modelSSHUUID, profilesSSH, [modelEQUUID], RDF_XML.AMP_MAS);
+
+        /** SV Profile */
+        const filePathSV = path.join(tempDirPath, 'sv.xml');
+        const writeStreamSV = fs.createWriteStream(filePathSV);
+        const xmlWriterSV = new XMLWriter(true, (string, encoding) => {
+          writeStreamSV.write(string, encoding);
+        });
+        this.writeHeaderStart(xmlWriterSV);
+        const modelSVUUID = generateUUID();
+        const profilesSV = [RDF_XML.SV_OPER_PROFILE_URI];
+        this.cimModel.toCIMXML(xmlWriterSV, modelSVUUID, profilesSV, [modelEQUUID, modelSSHUUID], RDF_XML.AMP_MAS);
+
+
+        /** Amprion I7 Profile */
+        const filePathAmpI7 = path.join(tempDirPath, 'AMP_I7.xml');
+        const writeStreamAmpI7 = fs.createWriteStream(filePathAmpI7);
+        const xmlWriterAmpI7 = new XMLWriter(true, (string, encoding) => {
+          writeStreamAmpI7.write(string, encoding);
+        });
+        this.writeHeaderStart(xmlWriterAmpI7, RDF_XML.AMP_I7_PROFILE_URI);
+        const modelAmpI7UUID = generateUUID();
+        const profilesAmpI7UUID = [RDF_XML.AMP_I7_PROFILE_URI];
+        this.cimModel.toCIMXML(xmlWriterAmpI7, modelAmpI7UUID, profilesAmpI7UUID, [modelEQUUID], RDF_XML.AMP_MAS);
+
+
+        /**------------------------------------------------------------------------------*/
+        const restCount = this.standortAnzahl < this.limit ? this.standortAnzahl : (this.standortAnzahl % this.limit);
+        const intervalCount = (this.standortAnzahl - restCount) / this.limit;
+        const numberOfIntervals = restCount > 0 ? intervalCount + 1 : intervalCount;
+        /** Frage die IDs von Leitungsabschnitten*/
+
+        await this.convertGeoRegionen();
+        await this.convertSubGeoRegionen();
+        await this.convertStromkreise();
+        await this.convertBetriebsmitteltypenLeitung();
+        await this.convertBetriebsmitteltypenTrafo();
+
+        await this.convertNetzvarianten();
+
+        this.objectToCIMXML(xmlWriterEQ, this.cimModel.geographicalRegions, RDF_XML.PROFILE_EQ);
+
+        this.objectToCIMXML(xmlWriterEQ, this.cimModel.subgeographicalRegions, RDF_XML.PROFILE_EQ);
+
+        this.objectToCIMXML(xmlWriterEQ, this.cimModel.lines, RDF_XML.PROFILE_EQ);
+
+        this.objectToCIMXML(xmlWriterDL, this.cimModel.diagrams, RDF_XML.PROFILE_DL);
+        this.objectArrayToCIMXML(xmlWriterDL, this.cimModel.diagramStyles, RDF_XML.PROFILE_DL);
+
+
+        for (let i = 0; i < numberOfIntervals; i++) {
+          const offset = i * this.limit;
+          const currentLimit = (i + 1 === numberOfIntervals && restCount > 0) ? restCount : this.limit;
+
+          /** Start EQUIPMENT CONTAINER */
+
+          /** Standort -> Substation */
+          //console.log(`Standorte currentLimit = ${currentLimit} offset = ${offset}`);
+          await this.convertStandorte(currentLimit, offset);
+          const standortIDs = [...this.integralStandorte.keys()];
+
+          // if (offset >=0) console.log(`9082->${this.integralID2UUID.get(9082)} convertStandorte offset = ${offset}`);
+
+          /** Schaltanlagen -> VoltageLevels */
+          //console.log(`Schaltanlagen currentLimit = ${currentLimit} offset = ${offset}`);
+          await this.covertSchaltanlagen(standortIDs);
+          const schaltanlagenIDs = [...this.integralSchaltanlagen.keys()];
+
+          //if (offset >=0) console.log(`9082->${this.integralID2UUID.get(9082)} covertSchaltanlagen offset = ${offset}`);
+
+          /** Schaltanlagenabschnitte -> Mappen auf bereits erstelltes VoltageLevel-Objekt (Schaltanlage) */
+          //console.log(`SAAB currentLimit = ${currentLimit} offset = ${offset}`);
+          if (schaltanlagenIDs.length > 0) {
+            await this.convertSchaltanlagenAbschnitte(schaltanlagenIDs);
+          }
+          const schaltanlagenAbschnittIDs = [...this.integralSchaltanlagenAbschnitte.keys()];
+
+          // if (offset >=0) console.log(`9082->${this.integralID2UUID.get(9082)} convertSchaltanlagenAbschnitte offset = ${offset}`);
+          /** Schaltfelder -> Bay */
+          //console.log(`Bay currentLimit = ${currentLimit} offset = ${offset}`);
+          if (schaltanlagenAbschnittIDs.length > 0) {
+            await this.convertSchaltfelder(schaltanlagenAbschnittIDs);
+          }
+          this.schaltfeldIDs = [...this.integralSchaltfelder.keys()];
+          //if (offset >=0) console.log(`9082->${this.integralID2UUID.get(9082)} convertSchaltfelder offset = ${offset}`);
+
+          /** Querkupplungen -> Bay */
+          //console.log(`QK currentLimit = ${currentLimit} offset = ${offset}`);
+          if (schaltanlagenAbschnittIDs.length > 0) {
+            await this.convertQuerkupplungen(schaltanlagenAbschnittIDs);
+          }
+          //if (offset >=0) console.log(`9082->${this.integralID2UUID.get(9082)} Querkupplungen offset = ${offset}`);
+
+          /** Laegskupplungen -> Bay */
+          //console.log(`LK currentLimit = ${currentLimit} offset = ${offset}`);
+          if (schaltanlagenIDs.length > 0) {
+            await this.convertLaegskupplungen(schaltanlagenIDs);
+          }
+          //if (offset >=0) console.log(`9082->${this.integralID2UUID.get(9082)} Laegskupplungen offset = ${offset}`);
+          /** Stromkreise s.o.*/
+          /** Ende EQUIPMENT CONTAINER */
+
+
+          /** START Integral 7 Knoten  */
+          /** Abzweigpunkte KnotenSo -> */
+          //console.log(`KnotenSo currentLimit = ${currentLimit} offset = ${offset}`);
+          await this.convertKnotenSo(standortIDs);
+          const knotenSoIDs = [...this.integralKnotenSo.keys()];
+          //if (offset >=0) console.log(`9082->${this.integralID2UUID.get(9082)} convertKnotenSo offset = ${offset}`);
+          /** KnotenSf */
+          //console.log(`KnotenSf currentLimit = ${currentLimit} offset = ${offset}`);
+          if (this.schaltfeldIDs.length > 0) {
+            await this.convertKnotenSf(this.schaltfeldIDs);
+          }
+          //if (offset === 4800 || offset === 4900) console.log(`9082->${this.integralID2UUID.get(9082)} KnotenSf offset = ${offset}`);
+          /** Querkupplungen Knoten */
+          //console.log(`Kf currentLimit = ${currentLimit} offset = ${offset}`);
+          if (this.querkupplungIDs.length > 0) {
+            await this.convertKnotenKf(this.querkupplungIDs);
+          }
+          //if (offset === 4800 || offset === 4900) console.log(`9082->${this.integralID2UUID.get(9082)} Querkupplungen Knoten offset = ${offset}`);
+          /** Laegskupplungen Knoten */
+          //console.log(`Lk currentLimit = ${currentLimit} offset = ${offset}`);
+          if (this.laengskupplungIDs.length > 0) {
+            await this.convertKnotenLk(this.laengskupplungIDs);
+          }
+          //if (offset === 4800 || offset === 4900) console.log(`9082->${this.integralID2UUID.get(9082)} Laegskupplungen Knoten offset = ${offset}`);
+          /** Schlaufen */
+          //console.log(`Schlaufe currentLimit = ${currentLimit} offset = ${offset}`);
+          if (knotenSoIDs.length > 0) {
+            await this.convertSchlaufen(knotenSoIDs);
+          }
+          //if (offset === 4800 || offset === 4900) console.log(`9082->${this.integralID2UUID.get(9082)} Schlaufen offset = ${offset}`);
+          /** Ende Integral 7 Knoten  */
+
+
+          /** START CONDUCTING EQUIPMENT  */
+
+          /** Sammelschienenabschnitte -> BusbarSections */
+          //console.log(`SSAB currentLimit = ${currentLimit} offset = ${offset}`);
+          if (schaltanlagenAbschnittIDs.length > 0) {
+            await this.convertSammelschienenAbschnitte(schaltanlagenAbschnittIDs);
+          }
+          //if (offset === 4800 || offset === 4900) console.log(`9082->${this.integralID2UUID.get(9082)} Sammelschienenabschnitte offset = ${offset}`);
+          /** Belastungen -> EnergyConsumer */
+          //console.log(`Last currentLimit = ${currentLimit} offset = ${offset}`);
+          if (knotenSoIDs.length > 0 || this.knotenSfIDs.length > 0) {
+            await this.convertBelastungen([...knotenSoIDs, ...this.knotenSfIDs]);
+          }
+          //if (offset === 4800 || offset === 4900) console.log(`9082->${this.integralID2UUID.get(9082)} convertBelastungen offset = ${offset}`);
+
+          /** Einspeisungen -> EnergySources */
+          //console.log(`EEG currentLimit = ${currentLimit} offset = ${offset}`);
+          if (knotenSoIDs.length > 0 || this.knotenSfIDs.length > 0) {
+            await this.convertEinspeisungen([...knotenSoIDs, ...this.knotenSfIDs]);
+          }
+          //if (offset === 4800 || offset === 4900) console.log(`9082->${this.integralID2UUID.get(9082)} Einspeisungen offset = ${offset}`);
+
+          /** Generatoren -> SynchronousMachine */
+          //console.log(`Gen currentLimit = ${currentLimit} offset = ${offset}`);
+          if (knotenSoIDs.length > 0 || this.knotenSfIDs.length > 0) {
+            await this.convertGeneratoren([...knotenSoIDs, ...this.knotenSfIDs]);
+          }
+          // if (offset === 4800 || offset === 4900) console.log(`9082->${this.integralID2UUID.get(9082)} Generatoren offset = ${offset}`);
+
+          /** starre Anschluesse als Junction. Sammelschienen müssen zuertst konvertiert werden*/
+            //console.log(`Starr currentLimit = ${currentLimit} offset = ${offset}`);
+          const containerStarreVerbindungen = [...this.schaltfeldIDs, ...this.querkupplungIDs, ...this.laengskupplungIDs];
+          if (containerStarreVerbindungen.length > 0) {
+            await this.convertStarreVerbindungen(containerStarreVerbindungen);
+          }
+          // if (offset === 4800 || offset === 4900) console.log(`9082->${this.integralID2UUID.get(9082)} containerStarreVerbindungen offset = ${offset}`);
+
+          //console.log(`Trennschalter 3f`);
+          if (containerStarreVerbindungen.length > 0) {
+            await this.convertTrenner3f(containerStarreVerbindungen);
+          }
+          //if (offset === 4800 || offset === 4900) console.log(`9082->${this.integralID2UUID.get(9082)} convertTrenner3f offset = ${offset}`);
+
+          //console.log(`Trennschalter Fi 3f`);
+          if (containerStarreVerbindungen.length > 0) {
+            await this.convertTrennerFi3f(containerStarreVerbindungen);
+          }
+          //if (offset === 4800 || offset === 4900) console.log(`9082->${this.integralID2UUID.get(9082)} convertTrennerFi3f offset = ${offset}`);
+
+          //console.log(`Leistungsschalter`);
+          if (containerStarreVerbindungen.length > 0) {
+            await this.convertLeistungsschalter(containerStarreVerbindungen);
+          }
+          //if (offset === 1800 || offset === 1900) console.log(`32716->${this.integralID2UUID.get(32716)} convertLeistungsschalter offset = ${offset}`);
+
+          // await this.convertTrafo3W(standortIDs);
+          /** Ende CONDUCTING EQUIPMENT  */
+
+          /** Schema konvertieren */
+          //console.log(`Schema currentLimit = ${currentLimit} offset = ${offset}`);
+          await this.convertSchemaStandorte(standortIDs);
+          //if (offset === 1800 || offset === 1900) console.log(`32716->${this.integralID2UUID.get(32716)} convertSchemaStandorte offset = ${offset}`);
+          if (knotenSoIDs.length > 0) {
+            await this.convertSchemaKnotenSo(knotenSoIDs);
+          }
+          //if (offset > 0) console.log(`32716->${this.integralID2UUID.get(32716)} convertSchemaKnotenSo offset = ${offset}`);
+
+          if (schaltanlagenIDs.length > 0) {
+            await this.convertSchemaSchaltanlage(schaltanlagenIDs);
+          }
+          // if (offset > 0) console.log(`32716->${this.integralID2UUID.get(32716)} convertSchemaSchaltanlage offset = ${offset}`);
+
+          if (schaltanlagenAbschnittIDs.length > 0) {
+            await this.convertSchemaSchaltanlagenAbschnitte(schaltanlagenAbschnittIDs);
+          }
+          // if (offset > 0) console.log(`32716->${this.integralID2UUID.get(32716)} convertSchemaSchaltanlagenAbschnitte offset = ${offset}`);
+
+          await this.convertSchemaSammelschienenAbschnitte();
+          // if (offset > 0) console.log(`32716->${this.integralID2UUID.get(32716)} convertSchemaSammelschienenAbschnitte offset = ${offset}`);
+
+          if (this.schaltfeldIDs.length > 0) {
+            await this.convertSchemaSchaltfelder(this.schaltfeldIDs);
+          }
+          // if (offset > 0) console.log(`32716->${this.integralID2UUID.get(32716)} convertSchemaSchaltfelder offset = ${offset}`);
+
+          /** Export EQ */
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.substations, RDF_XML.PROFILE_EQ);
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.voltageLevels, RDF_XML.PROFILE_EQ);
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.bays, RDF_XML.PROFILE_EQ);
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.busbarSections, RDF_XML.PROFILE_EQ);
+
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.powerTransformer, RDF_XML.PROFILE_EQ);
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.junctions, RDF_XML.PROFILE_EQ);
+
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.energyConsumers, RDF_XML.PROFILE_EQ);
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.energySources, RDF_XML.PROFILE_EQ);
+
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.disconnectors, RDF_XML.PROFILE_EQ);
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.breakers, RDF_XML.PROFILE_EQ);
+
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.synchronousMachine, RDF_XML.PROFILE_EQ);
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.generatingUnit, RDF_XML.PROFILE_EQ);
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.thermalGeneratingUnit, RDF_XML.PROFILE_EQ);
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.nuclearGeneratingUnit, RDF_XML.PROFILE_EQ);
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.hydroGeneratingUnit, RDF_XML.PROFILE_EQ);
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.windGeneratingUnit, RDF_XML.PROFILE_EQ);
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.solarGeneratingUnit, RDF_XML.PROFILE_EQ);
+
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.regulatingControl, RDF_XML.PROFILE_EQ);
+          this.objectArrayToCIMXML(xmlWriterEQ, this.cimModel.fossilFuel, RDF_XML.PROFILE_EQ);
+
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.reactiveCapabilityCurve, RDF_XML.PROFILE_EQ);
+          this.objectArrayToCIMXML(xmlWriterEQ, this.cimModel.curveData, RDF_XML.PROFILE_EQ);
+
+
+          // this.objectToCIMXML(xmlWriterEQ, this.cimModel.operationalLimitTypes, RDF_XML.PROFILE_EQ);
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.operationalLimitSets, RDF_XML.PROFILE_EQ);
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.currentLimits, RDF_XML.PROFILE_EQ);
+
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.connectivityNodes, RDF_XML.PROFILE_EQ);
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.terminals, RDF_XML.PROFILE_EQ);
+
+
+          /** Export DL */
+          this.objectToCIMXML(xmlWriterDL, this.cimModel.diagramObjects, RDF_XML.PROFILE_DL);
+
+          /** Export SV */
+          this.objectToCIMXML(xmlWriterSSH, this.cimModel.energyConsumers, RDF_XML.PROFILE_SSH);
+          // this.objectToCIMXML(xmlWriterSSH, this.cimModel.energyConsumers, RDF_XML.PROFILE_SSH);
+          this.objectToCIMXML(xmlWriterSSH, this.cimModel.energySources, RDF_XML.PROFILE_SSH);
+          this.objectToCIMXML(xmlWriterSSH, this.cimModel.terminals, RDF_XML.PROFILE_SSH);
+
+          this.objectToCIMXML(xmlWriterSSH, this.cimModel.disconnectors, RDF_XML.PROFILE_SSH);
+          this.objectToCIMXML(xmlWriterSSH, this.cimModel.breakers, RDF_XML.PROFILE_SSH);
+
+          this.objectArrayToCIMXML(xmlWriterSV, this.cimModel.svStatus, RDF_XML.PROFILE_SV);
+          this.objectArrayToCIMXML(xmlWriterSV, this.cimModel.svTapSteps, RDF_XML.PROFILE_SV);
+
+          /** Export AMP I7 */
+          this.objectToCIMXML(xmlWriterAmpI7, this.cimModel.bays, RDF_XML.PROFILE_AMPI7);
+          this.objectToCIMXML(xmlWriterAmpI7, this.cimModel.connectivityNodes, RDF_XML.PROFILE_AMPI7);
+
+          this.cimModel.substations.clear();
+          this.cimModel.voltageLevels.clear();
+          this.cimModel.bays.clear();
+          this.cimModel.busbarSections.clear();
+
+          this.cimModel.disconnectors.clear();
+          this.cimModel.breakers.clear();
+
+          this.cimModel.energyConsumers.clear();
+          this.cimModel.energySources.clear();
+
+          this.cimModel.synchronousMachine.clear();
+          this.cimModel.generatingUnit.clear();
+          this.cimModel.thermalGeneratingUnit.clear();
+          this.cimModel.nuclearGeneratingUnit.clear();
+          this.cimModel.hydroGeneratingUnit.clear();
+          this.cimModel.windGeneratingUnit.clear();
+          this.cimModel.solarGeneratingUnit.clear();
+
+          this.cimModel.regulatingControl.clear();
+          this.cimModel.reactiveCapabilityCurve.clear();
+
+          this.cimModel.junctions.clear();
+
+          this.cimModel.curveData.length = 0;
+          this.cimModel.fossilFuel.length = 0;
+
+
+          this.cimModel.connectivityNodes.clear();
+          this.cimModel.terminals.clear();
+          this.cimModel.diagramObjects.clear();
+          this.cimModel.objects.clear();
+
+
+          this.cimModel.svStatus.length = 0;
+          this.cimModel.svTapSteps.length = 0;
+
+
+          this.querkupplungIDs.length = 0;
+          this.laengskupplungIDs.length = 0;
+          this.knotenSoIDs.length = 0;
+          this.knotenSfIDs.length = 0;
+          this.knotenSfIDs.length = 0;
+
+          /** Integral 7 Modell leeren*/
+          this.integralStandorte.clear();
+          this.integralSchaltanlagen.clear();
+          this.integralSchaltanlagenAbschnitte.clear();
+          this.integralSchaltfelder.clear();
+          this.integralKnotenSo.clear();
+
+          this.integralNsgStandort.clear();
+          this.integralNsgSchaltanlage.clear();
+          this.integralNsgSchaltanlagenabschnitt.clear();
+          this.integralNsgSchaltfelder.clear();
+          this.integralNsgKnotenSo.clear();
+          console.log(`Offset ${offset} done`);
+        }
+
+        /** Leitungen werden aufgrund besonderer Struktur separat implementiert. */
+        const restCountLeitung = this.leitungsAnzahl < this.limit ? this.leitungsAnzahl : (this.leitungsAnzahl % this.limit);
+        const intervalCountLeitung = (this.leitungsAnzahl - restCountLeitung) / this.limit;
+        const numberOfIntervalsLeitung = restCountLeitung > 0 ? intervalCountLeitung + 1 : intervalCountLeitung;
+        console.log('Convert ACLineSegments ' + this.leitungsAnzahl + ' restCountLeitung ' +restCountLeitung );
+
+        for (let i = 0; i < numberOfIntervalsLeitung; i++) {
+          const offset = i * this.limit;
+          const currentLimit = (i + 1 === numberOfIntervalsLeitung && restCountLeitung > 0) ? restCountLeitung : this.limit;
+
+          /** Stromkreisabschnitte */
+
+          await this.convertLeitungen(currentLimit, offset);
+          this.leitungsIDs = [...this.integralLeitungen.keys()];
+
+          if (this.leitungsIDs.length > 0)
+            await this.determineLeitungsTypen(this.leitungsIDs);
+
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.acLineSegments, RDF_XML.PROFILE_EQ);
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.terminals, RDF_XML.PROFILE_EQ);
+
+          this.objectToCIMXML(xmlWriterSV, this.cimModel.terminals, RDF_XML.PROFILE_SSH);
+
+          /** Collections leeren */
+          this.cimModel.acLineSegments.clear();
+          this.cimModel.connectivityNodes.clear();
+          this.cimModel.terminals.clear();
+          this.cimModel.diagramObjects.clear();
+
+
+          this.cimModel.objects.clear();
+          this.integralLeitungen.clear();
+          this.leitungsIDs.length = 0;
+        }
+
+        /** Transformatoren 2W */
+        const restCountTrafo2W = this.trafo2WAnzahl < this.limit ? this.trafo2WAnzahl : (this.trafo2WAnzahl % this.limit);
+        const intervalCountTrafo2W = (this.trafo2WAnzahl - restCountTrafo2W) / this.limit;
+        const numberOfIntervalsTrafo2W = restCountTrafo2W > 0 ? intervalCountTrafo2W + 1 : intervalCountTrafo2W;
+        console.log('Convert Transformers');
+        for (let i = 0; i < numberOfIntervalsTrafo2W; i++) {
+          const offset = i * this.limit;
+          const currentLimit = (i + 1 === numberOfIntervalsTrafo2W && restCountTrafo2W > 0) ? restCountTrafo2W : this.limit;
+
+          await this.convertTrafo2W(currentLimit, offset);
+
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.powerTransformer, RDF_XML.PROFILE_EQ);
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.terminals, RDF_XML.PROFILE_EQ);
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.tapChangerControls, RDF_XML.PROFILE_EQ);
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.ratioTapChangers, RDF_XML.PROFILE_EQ);
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.ratioTapChangerTables, RDF_XML.PROFILE_EQ);
+
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.operationalLimitSets, RDF_XML.PROFILE_EQ);
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.currentLimits, RDF_XML.PROFILE_EQ);
+
+          this.objectToCIMXML(xmlWriterSV, this.cimModel.terminals, RDF_XML.PROFILE_SSH);
+
+          /** Collections leeren */
+          this.cimModel.powerTransformer.clear();
+
+          this.cimModel.currentLimits.clear();
+          this.cimModel.operationalLimitSets.clear();
+          // this.cimModel.operationalLimitTypes.clear()
+
+          this.cimModel.tapChangerControls.clear();
+          this.cimModel.ratioTapChangers.clear();
+
+          for (const table of this.cimModel.ratioTapChangerTables.values()) {
+            table.ratioTapChangerTablePoints = [];
+          }
+          this.cimModel.ratioTapChangerTables.clear();
+          this.cimModel.svTapSteps.length = 0;
+          this.cimModel.terminals.clear();
+
+          this.cimModel.objects.clear();
+
+          //
+
+        }
+
+
+        const restCountTrafo3W = this.trafo2WAnzahl < this.limit ? this.trafo3WAnzahl : (this.trafo3WAnzahl % this.limit);
+        const intervalCountTrafo3W = (this.trafo3WAnzahl - restCountTrafo3W) / this.limit;
+        const numberOfIntervalsTrafo3W = restCountTrafo3W > 0 ? intervalCountTrafo3W + 1 : intervalCountTrafo3W;
+        console.log('Convert Transformers3W');
+        for (let i = 0; i < numberOfIntervalsTrafo3W; i++) {
+          const offset = i * this.limit;
+          const currentLimit = (i + 1 === numberOfIntervalsTrafo3W && restCountTrafo3W > 0) ? restCountTrafo3W : this.limit;
+
+          await this.convertTrafo3W(currentLimit, offset);
+
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.powerTransformer, RDF_XML.PROFILE_EQ);
+          this.cimModel.powerTransformer.clear();
+
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.currentLimits, RDF_XML.PROFILE_EQ);
+          this.cimModel.currentLimits.clear();
+
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.terminals, RDF_XML.PROFILE_EQ);
+          this.cimModel.terminals.clear();
+
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.tapChangerControls, RDF_XML.PROFILE_EQ);
+          this.cimModel.tapChangerControls.clear();
+
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.ratioTapChangers, RDF_XML.PROFILE_EQ);
+          this.cimModel.ratioTapChangers.clear();
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.ratioTapChangerTables, RDF_XML.PROFILE_EQ);
+
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.operationalLimitSets, RDF_XML.PROFILE_EQ);
+
+
+          this.objectToCIMXML(xmlWriterSV, this.cimModel.terminals, RDF_XML.PROFILE_SSH);
+
+          /** Collections leeren */
+
+          this.cimModel.operationalLimitSets.clear();
+          // this.cimModel.operationalLimitTypes.clear()
+
+
+          for (const table of this.cimModel.ratioTapChangerTables.values()) {
+            table.ratioTapChangerTablePoints = [];
+          }
+          this.cimModel.ratioTapChangerTables.clear();
+          this.cimModel.svTapSteps.length = 0;
+
+
+          this.cimModel.objects.clear();
+        }
+
+        const memoryTerminals = new Map();
+        for (const value of this.memoryObjects.values()) {
+          if (value instanceof Terminal) {
+            const terminal = value as Terminal;
+            if(terminal.conductingEquipment || terminal.conductingEquipmentUUID) {
+              memoryTerminals.set(value.mrid, value);
+            }
+          }
+        }
+        /** EQ */
+        // this.objectToCIMXML(xmlWriterEQ, this.cimModel.connectivityNodes, RDF_XML.PROFILE_EQ);
+        this.objectToCIMXML(xmlWriterEQ, this.cimModel.operationalLimitTypes, RDF_XML.PROFILE_EQ);
+        this.objectToCIMXML(xmlWriterEQ, this.cimModel.baseVoltages, RDF_XML.PROFILE_EQ);
+        this.objectToCIMXML(xmlWriterEQ, memoryTerminals, RDF_XML.PROFILE_EQ);
+        this.objectToCIMXML(xmlWriterSSH, memoryTerminals, RDF_XML.PROFILE_SSH);
+
+        this.objectToCIMXML(xmlWriterAmpI7, this.cimModel.psrTypes, RDF_XML.PROFILE_AMPI7);
+
+        /*        this.objectToCIMXML(xmlWriterEQ, memoryTerminals, RDF_XML.PROFILE_EQ);
+                /!** SV *!/
+                this.objectToCIMXML(xmlWriterSSH, memoryTerminals, RDF_XML.PROFILE_SSH); // Schaltzustände*/
+
+        this.cimModel.operationalLimitTypes.clear();
+        this.cimModel.baseVoltages.clear();
+        memoryTerminals.clear();
+
+        this.writeHeaderEnd(xmlWriterEQ);
+        writeStreamEQ.end();
+        writeStreamEQ.close();
+
+        /** DL */
+        this.writeHeaderEnd(xmlWriterDL);
+        writeStreamDL.end();
+        writeStreamDL.close();
+
+        /** SSH */
+        this.writeHeaderEnd(xmlWriterSSH);
+        writeStreamSSH.end();
+        writeStreamSSH.close();
+
+        /** SV */
+        this.writeHeaderEnd(xmlWriterSV);
+        writeStreamSV.end();
+        writeStreamSV.close();
+
+        /** Amprion I7 */
+        this.writeHeaderEnd(xmlWriterAmpI7);
+        writeStreamAmpI7.end();
+        writeStreamAmpI7.close();
+
+        await Promise.all([
+          createWriteStreamPromise(writeStreamEQ),
+          createWriteStreamPromise(writeStreamDL),
+          createWriteStreamPromise(writeStreamSSH),
+          createWriteStreamPromise(writeStreamSV),
+          createWriteStreamPromise(writeStreamAmpI7),
+        ]);
+
+        const zip = new JSZip();
+        const filePathZip = path.join(tempDirPath, 'cgmes.zip');
+        const readStreamEq = fs.createReadStream(filePathEQ);
+        zip.file('EQ.xml', readStreamEq);
+
+        const readStreamDl = fs.createReadStream(filePathDL);
+        zip.file('DL.xml', readStreamDl);
+
+        const readStreamSSH = fs.createReadStream(filePathSSH);
+        zip.file('SSH.xml', readStreamSSH);
+
+        const readStreamSV = fs.createReadStream(filePathSV);
+        zip.file('SV.xml', readStreamSV);
+
+        const readStreamAmpI7 = fs.createReadStream(filePathAmpI7);
+        zip.file('AMP_I7.xml', readStreamAmpI7);
+
+        await writeZipFile(zip, filePathZip);
+
+        resolve({status: 'successful', message: 'ok'});
+
+        console.log('path ' + tempDirPath);
+      } catch (e) {
+        console.log(e);
+        reject({status: 'error', message: e.toString()});
+      }
+    });
+  }
+
+  async end(): Promise<Status> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        this.closeConnection();
+        this.cimModel.purgeData();
+        resolve({status: 'successful', message: 'ok'});
+      } catch (e) {
+        reject({status: 'error', message: e.toString()});
+      }
+    });
+  }
+
+  /** Fragt die verfügbaren Tabellennamen. */
+  private async getAvailableTableNames(database: string) {
+    try {
+      const results = await this.queryFunctionWrapper(`SHOW TABLES FROM  ${database}`);
+      for (const table of results) {
+        this.availableTableNames.push(table[`Tables_in_${database}`]);
+      }
+    } catch (e) {
+      console.error("ERROR:" + e);
+    }
+  }
+
+  private async queryObjectCount(tableName: string): Promise<number> {
+    return new Promise((resolve, reject) => {
+
+      this.queryFunctionWrapper(`SELECT COUNT(id) FROM ${tableName}`).then(results => {
+        try {
+          for (const result of results) {
+            return resolve(Number(result[`COUNT(id)`]));
+          }
+        } catch (e) {
+          return reject(0);
+        }
+      });
+    });
+  }
+
+  /** Topologie von Leitungen und Trafos */
+  private async queryAnschlussIDs() {
+    try {
+      let results = await this.queryFunctionWrapper(`SELECT DISTINCT aknoten, eknoten FROM ${Integral7TableNames[I7Objects.LEITUNG]}`);
+      for (const result of results) {
+        this.leitungAnschlussKnotenIDs.add(result[`aknoten`]);
+        this.leitungAnschlussKnotenIDs.add(result[`eknoten`]);
+      }
+      results = await this.queryFunctionWrapper(`SELECT DISTINCT aknoten, eknoten FROM ${Integral7TableNames[I7Objects.TRAFO2W]}`);
+      for (const result of results) {
+        this.leitungAnschlussKnotenIDs.add(result[`aknoten`]);
+        this.leitungAnschlussKnotenIDs.add(result[`eknoten`]);
+      }
+      results = await this.queryFunctionWrapper(`SELECT DISTINCT aknoten, eknoten FROM ${Integral7TableNames[I7Objects.TRAFO3_WICKLUNG]}`);
+      for (const result of results) {
+        this.leitungAnschlussKnotenIDs.add(result[`aknoten`]);
+        this.leitungAnschlussKnotenIDs.add(result[`eknoten`]);
+      }
+    } catch (e) {
+      console.error("ERROR:" + e);
+    }
+  }
+
+  async convertGeoRegionen() {
+    if (this.isTableAvailable(Integral7TableNames.REGION)) {
+      const result: Georegion[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.REGION, 0, 0, []));
+
+      for (const i7Data of result) {
+        const region = new GeographicalRegion(getUUID(i7Data.guid), i7Data.bezeichner, i7Data.kurzname);
+        this.cimModel.addGeographicalRegion(region);
+        this.integralID2UUID.set(i7Data.id, region.mrid);
+      }
+    } else {
+      console.log(`Tabelle ${Integral7TableNames.REGION} ist nicht vorhanden.`);
+      console.log(`Erstelle Standard Region ENTSO-E.`);
+      createGeoregion(generateUUID(), 'ENTSO-E', 'default', 'Default GeographicalRegion', this.cimModel);
+    }
+  }
+
+  async convertSubGeoRegionen() {
+    if (this.isTableAvailable(Integral7TableNames.SUBREGION)) {
+
+      const result: Subgeoregion[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.SUBREGION, 0, 0, []));
+
+      for (const i7Data of result) {
+        const subregion = new SubGeographicalRegion(getUUID(i7Data.guid), i7Data.bezeichner, i7Data.kurzname);
+
+        let region = this.cimModel.getGeographicalRegion(this.integralID2UUID.get(i7Data.georegion));
+        if (!region) {
+          region = createIfNotExitsGeoregionByName(this.cimModel, 'ENTSO-E');
+        }
+        subregion.region = region;
+        region.addSubGeographicalRegion(subregion);
+
+        this.cimModel.addSubGeographicalRegion(subregion);
+        this.integralID2UUID.set(i7Data.id, subregion.mrid);
+      }
+    } else {
+      console.log(`Tabelle ${Integral7TableNames.SUBREGION} ist nicht vorhanden.`);
+      console.log(`Erstelle Standard Subregion Deutschland.`);
+      const region = createIfNotExitsGeoregionByName(this.cimModel, 'ENTSO-E');
+      createIfNotExitsSubGeoregionByName(this.cimModel, 'Detschland', region);
+    }
+  }
+
+  async convertStandorte(limit: number, offset: number) {
+    if (this.isTableAvailable(Integral7TableNames.STANDORT)) {
+      const result: Standort[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.STANDORT, limit, offset, []));
+
+      for (const i7Data of result) {
+
+        const i7Schluessel = STANDORT_PRAEFIX +
+          ueberpruefeZeichenkette(i7Data.ukz) +
+          MITTIGER_PUNKT +
+          ueberpruefeZeichenkette(i7Data.bezeichner);
+        const substation = new Substation(getUUID(i7Data.guid), getName(i7Data), i7Data.id + '', i7Schluessel);
+
+        let subregion = this.cimModel.getSubGeographicalRegion(this.integralID2UUID.get(i7Data.subgeoregion));
+        if (!subregion) {
+          const region = createIfNotExitsGeoregionByName(this.cimModel, 'ENTSO-E');
+          subregion = createIfNotExitsSubGeoregionByName(this.cimModel, 'Deutschland', region);
+        }
+
+        substation.subGeographicalRegion = subregion;
+        // subregion.addSubstation(substation);
+
+        this.cimModel.addSubstation(substation);
+        this.integralID2UUID.set(i7Data.id, substation.mrid);
+        putUUIDtoI7Ids(substation.mrid, i7Data.id, this.UUID2IntegralID);
+
+        /** Integral 7 Modell erstellen zur Berechnung der Netzschema */
+        const standort = new StandortImpl(i7Data);
+        this.integralStandorte.set(i7Data.id, standort);
+      }
+    } else {
+      console.log(`Tabelle ${Integral7TableNames.STANDORT} ist nicht vorhanden.`);
+    }
+  }
+
+  async convertKnotenSo(standortIDs: number[]) {
+    if (this.isTableAvailable(Integral7TableNames.KNOTEN_SO)) {
+      const result: Abzweig[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.KNOTEN_SO, 0, 0, standortIDs));
+      for (const i7Data of result) {
+
+        const object = new KnotenSoImpl(i7Data);
+        this.integralKnotenSo.set(i7Data.id, object);
+        object.standort = this.integralStandorte.get(object.standortid);
+
+        const vl = new VoltageLevel(getUUID(i7Data.guid), getName(i7Data), i7Data.kurzname);
+        const connectivityNode = new AMPRIONConnectivityNode(generateUUID(), 'Abzweig', 'knotenso');
+
+        connectivityNode.connectivityNodeContainer = vl;
+        connectivityNode.nodeNumber = i7Data.id_psse_cape;
+
+        vl.addConnectivityNode(connectivityNode);
+
+        const baseVoltage = createBaseVoltageIfNotExists(this.cimModel, i7Data.un);
+        vl.baseVoltage = baseVoltage;
+
+        const substation = this.cimModel.getSubstation(this.integralID2UUID.get(i7Data.standort));
+        if (substation) {
+          vl.substation = substation;
+          substation.addVoltageLevel(vl);
+
+          const i7Schluessel = substation.description +
+            KNOTEN_STANDORT_PRAEFIX +
+            i7Data.un +
+            MITTIGER_PUNKT +
+            ueberpruefeZeichenkette(i7Data.bezeichner);
+          vl.description = i7Schluessel;
+          connectivityNode.description = i7Schluessel;
+        } else {
+          console.log(`KnotenSo ${i7Data.id} ${vl.mrid} besitzt keine Substation.`);
+        }
+
+        //PSRType
+        const psrType = getPSRType(this.cimModel, 'Abzweigmast');
+        vl.psrTypeUUID = psrType?.mrid;
+        // psrType.addPowerSystemResource(vl);
+
+        this.integralID2UUID.set(i7Data.id, connectivityNode.mrid);
+        this.knotenSoIDs.push(i7Data.id);
+        this.cimModel.addVoltageLevel(vl);
+        this.cimModel.addConnectivityNode(connectivityNode);
+        //Spannung speichern
+        this.knotenSpannung.set(connectivityNode.mrid, baseVoltage);
+        this.checkMemoryObject(i7Data.id, connectivityNode);
+      }
+    } else {
+      console.log(`Tabelle ${Integral7TableNames.KNOTEN_SO} ist nicht vorhanden.`);
+    }
+  }
+
+  async covertSchaltanlagen(standortIDs: number[]) {
+    if (this.isTableAvailable(Integral7TableNames.SCHALTANLAGE)) {
+      const result: Anlage[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.SCHALTANLAGE, 0, 0, standortIDs));
+      // this.tableName2tableData.set(Integral7TableNames.SCHALTANLAGE, result);
+      for (const i7Data of result) {
+        const vl = new VoltageLevel(getUUID(i7Data.guid), getName(i7Data), i7Data.kurzname);
+        const baseVoltage = createBaseVoltageIfNotExists(this.cimModel, i7Data.un);
+        vl.baseVoltageUUID = baseVoltage.mrid;
+
+        this.cimModel.addVoltageLevel(vl);
+        this.integralID2UUID.set(i7Data.id, vl.mrid);
+        putUUIDtoI7Ids(vl.mrid, i7Data.id, this.UUID2IntegralID);
+
+        const substation = this.cimModel.getSubstation(this.integralID2UUID.get(i7Data.standort));
+        if (substation) {
+          vl.substationUUID = substation.mrid;
+          // substation.addVoltageLevel(vl);
+
+          const i7Schluessel = substation.description +
+            KNOTEN_STANDORT_PRAEFIX +
+            i7Data.un +
+            MITTIGER_PUNKT +
+            ueberpruefeZeichenkette(i7Data.bezeichner);
+          vl.description = i7Schluessel;
+
+          /** Integral 7 Modell erstellen zur Berechnung der Netzschema */
+          const schaltanlage = new SchaltanlageImpl(i7Data);
+          schaltanlage.addStandort(this.integralStandorte.get(schaltanlage.standortid));
+          this.integralSchaltanlagen.set(i7Data.id, schaltanlage);
+
+        } else {
+          console.log(`VoltageLevel ${i7Data.id} ${vl.mrid} besitzt keine Umspannanlage.`);
+        }
+      }
+    } else {
+      console.log(`Tabelle ${Integral7TableNames.SCHALTANLAGE} ist nicht vorhanden.`);
+    }
+  }
+
+  async convertSchaltanlagenAbschnitte(schaltanlagenIDs: number[]) {
+    if (this.isTableAvailable(Integral7TableNames.SCHALTANLAGENABSCHNITT)) {
+      const result: AnlagenAbschnitt[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.SCHALTANLAGENABSCHNITT, 0, 0, schaltanlagenIDs));
+      for (const i7Data of result) {
+        const voltageLevel = this.cimModel.getVoltageLevel(this.integralID2UUID.get(i7Data.schaltanlage));
+        this.integralID2UUID.set(i7Data.id, voltageLevel.mrid);
+        putUUIDtoI7Ids(voltageLevel.mrid, i7Data.id, this.UUID2IntegralID);
+
+        // this.schaltanlagenAbschnitteIDs.push(i7Data.id);
+
+        /** Integral 7 Modell erstellen zur Berechnung der Netzschema */
+        const schaltanlagenabschnitt = new SchaltanlagenabschnittImpl(i7Data);
+        schaltanlagenabschnitt.addSchaltanlage(this.integralSchaltanlagen.get(schaltanlagenabschnitt.schaltanlageid));
+        this.integralSchaltanlagenAbschnitte.set(i7Data.id, schaltanlagenabschnitt);
+      }
+    } else {
+      console.log(`Tabelle ${Integral7TableNames.SCHALTANLAGENABSCHNITT} ist nicht vorhanden.`);
+    }
+  }
+
+  async convertSammelschienenAbschnitte(schaltanlagenAbschnittIDs: number[]) {
+    if (this.isTableAvailable(Integral7TableNames.SAMMELSCHIENE)) {
+      const result: Ssab[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.SAMMELSCHIENE, 0, 0, schaltanlagenAbschnittIDs));
+      for (const i7Data of result) {
+
+        const busbarSection = new BusbarSection(getUUID(i7Data.guid), getName(i7Data), i7Data.kurzname);
+        const connectivityNode = new AMPRIONConnectivityNode(generateUUID(), 'ssab cn',);
+        createConnection(this.cimModel, busbarSection, connectivityNode, PhaseCode.ABC, 1);
+        const voltageLevel = this.cimModel.getVoltageLevel(this.integralID2UUID.get(i7Data.saabschnitt));
+
+        connectivityNode.nodeNumber = i7Data.id_psse_cape;
+        if (voltageLevel) {
+          busbarSection.equipmentContainerUUID = voltageLevel.mrid;
+          // voltageLevel.addEquipment(busbarSection);
+          connectivityNode.connectivityNodeContainerUUID = voltageLevel.mrid;
+          // voltageLevel.addConnectivityNode(connectivityNode);
+          // umin
+          voltageLevel.highVoltageLimit = i7Data.umax;
+          voltageLevel.lowVoltageLimit = i7Data.umin;
+
+          const i7Schluessel = voltageLevel.description +
+            SAMMELSCHIENENABSCHNITT_PRAEFIX +
+            ueberpruefeZeichenkette(i7Data.bezeichner);
+          busbarSection.description = i7Schluessel;
+          connectivityNode.description = i7Schluessel;
+        } else {
+          console.log('Sammelschiene ' + i7Data.id + ' besitzt keine Schaltanlage.');
+        }
+
+        this.integralID2UUID.set(i7Data.id, connectivityNode.mrid);
+        putUUIDtoI7Ids(busbarSection.mrid, i7Data.id, this.UUID2IntegralID);
+
+        this.cimModel.addConnectivityNode(connectivityNode);
+        this.cimModel.addBusbarSection(busbarSection);
+
+        /** Integral 7 Modell erstellen zur Berechnung der Netzschema */
+        if (this.integralSchaltanlagenAbschnitte.has(i7Data.saabschnitt)) {
+          this.integralSchaltanlagenAbschnitte.get(i7Data.saabschnitt).ssab.push(i7Data);
+        }
+      }
+    } else {
+      console.log(`Tabelle ${Integral7TableNames.SAMMELSCHIENE} ist nicht vorhanden.`);
+    }
+  }
+
+  async convertSchaltfelder(schaltanlagenAbschnittIDs: number[]) {
+    if (this.isTableAvailable(Integral7TableNames.SCHALTFELD)) {
+      const result: Schaltfeld[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.SCHALTFELD, 0, 0, schaltanlagenAbschnittIDs));
+      // this.tableName2tableData.set(Integral7TableNames.SCHALTFELD, result);
+      for (const i7Data of result) {
+        const bay = new AMPRIONBay(getUUID(i7Data.guid), getName(i7Data));
+
+        bay.number = i7Data.feldnummer;
+        bay.locationID = i7Data.ips_folder_id;
+
+        const sfImpl = new SchaltfeldImpl(i7Data);
+        this.integralSchaltfelder.set(i7Data.id, sfImpl);
+
+        if (this.integralSchaltanlagenAbschnitte.has(sfImpl.saabschnittid)) {
+          sfImpl.saabschnitt = this.integralSchaltanlagenAbschnitte.get(sfImpl.saabschnittid);
+          sfImpl.saabschnitt.schaltfelder.push(sfImpl);
+        } else {
+          console.log(`Schaltfeld ${i7Data.id} besitzt keine Anlage.`);
+        }
+
+        const voltageLevel = this.cimModel.getVoltageLevel(this.integralID2UUID.get(i7Data.saabschnitt));
+        if (voltageLevel) {
+          bay.voltageLevelUUID = voltageLevel.mrid;
+          // voltageLevel.addBay(bay);
+
+          const i7Schluessel = voltageLevel.description +
+            SCHALTFELD_PRAEFIX +
+            ueberpruefeZeichenkette(i7Data.bezeichner);
+          bay.description = i7Schluessel;
+        } else {
+          console.log(`Schaltfeld ${i7Data.id} besitzt keine Anlage.`);
+        }
+        this.cimModel.addBay(bay);
+        this.integralID2UUID.set(i7Data.id, bay.mrid);
+      }
+    } else {
+      console.log(`Tabelle ${Integral7TableNames.SCHALTFELD} ist nicht vorhanden.`);
+    }
+  }
+
+  async convertQuerkupplungen(schaltanlagenAbschnittIDs: number[]) {
+    if (this.isTableAvailable(Integral7TableNames.QUERKUPPLUNG)) {
+      const result: Querkupplung[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.QUERKUPPLUNG, 0, 0, schaltanlagenAbschnittIDs));
+      // this.tableName2tableData.set(Integral7TableNames.QUERKUPPLUNG, result);
+      for (const i7Data of result) {
+        const bay = new AMPRIONBay(getUUID(i7Data.guid), getName(i7Data), 'Querkupplung');
+
+        bay.number = i7Data.feldnummer;
+        bay.locationID = i7Data.ips_folder_id;
+
+        const voltageLevel = this.cimModel.getVoltageLevel(this.integralID2UUID.get(i7Data.saabschnitt));
+        if (voltageLevel) {
+          bay.voltageLevelUUID = voltageLevel.mrid;
+          // voltageLevel.addBay(bay);
+
+          const i7Schluessel = voltageLevel.description +
+            '/QK-' +
+            ueberpruefeZeichenkette(i7Data.bezeichner);
+          bay.description = i7Schluessel;
+        } else {
+          console.log(`Querkupplung ${i7Data.id} besitzt keine Anlage.`);
+        }
+        this.querkupplungIDs.push(i7Data.id);
+        this.cimModel.addBay(bay);
+        this.integralID2UUID.set(i7Data.id, bay.mrid);
+      }
+    } else {
+      console.log(`Tabelle ${Integral7TableNames.QUERKUPPLUNG} ist nicht vorhanden.`);
+    }
+  }
+
+  async convertLaegskupplungen(schaltanlagenIDs: number[]) {
+    if (this.isTableAvailable(Integral7TableNames.LAENGSKUPPLUNG)) {
+      const result: Laengskupplung[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.LAENGSKUPPLUNG, 0, 0, schaltanlagenIDs));
+
+      for (const i7Data of result) {
+
+        const bay = new AMPRIONBay(getUUID(i7Data.guid), getName(i7Data), i7Data.kurzname, 'Laengskupplung');
+        const voltageLevel = this.cimModel.getVoltageLevel(this.integralID2UUID.get(i7Data.schaltanlage));
+
+        bay.number = i7Data.feldnummer;
+        bay.locationID = i7Data.ips_folder_id;
+
+        if (voltageLevel) {
+          bay.voltageLevelUUID = voltageLevel.mrid;
+          // voltageLevel.addBay(bay);
+
+          const i7Schluessel = voltageLevel.description +
+            '/LK-' +
+            ueberpruefeZeichenkette(i7Data.bezeichner);
+          bay.description = i7Schluessel;
+        } else {
+          console.log(`Laengskupplung ${i7Data.id} besitzt keine Anlage.`);
+        }
+        this.laengskupplungIDs.push(i7Data.id);
+        this.integralID2UUID.set(i7Data.id, bay.mrid);
+        this.cimModel.addBay(bay);
+      }
+    } else {
+      console.log(`Tabelle ${Integral7TableNames.LAENGSKUPPLUNG} ist nicht vorhanden.`);
+    }
+  }
+
+  async convertBelastungen(knotenSfIDs: number[]) {
+    if (this.isTableAvailable(Integral7TableNames.BELASTUNG)) {
+      const result: Belastung[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.BELASTUNG, 0, 0, knotenSfIDs));
+      for (const i7Data of result) {
+        const energyConsumer = new EnergyConsumer(getUUID(i7Data.guid), getName(i7Data));
+        const inBetrieb = convertToBooleanI7(i7Data.betrieb);
+        const powerData = getActiveReactivePower(i7Data);
+
+        createSvStatus(this.cimModel, inBetrieb, energyConsumer);
+
+        energyConsumer.p = powerData[0] ? powerData[0] : 0;
+        energyConsumer.q = powerData[1] ? powerData[1] : 0;
+        energyConsumer.pFixed = energyConsumer.p;
+        energyConsumer.qFixed = energyConsumer.q;
+
+        const connectivityNode = this.cimModel.objects.get(this.integralID2UUID.get(i7Data.anschluss)) as IConnectivityNode;
+
+        if (connectivityNode) {
+          createConnection(this.cimModel, energyConsumer, connectivityNode, PhaseCode.ABC);
+
+          const equipmentContainer = determineEquipmentContainer('VoltageLevel', this.cimModel, this.cimModel.getObject(connectivityNode.getConnectivityNodeContainerUUID()) as EquipmentContainer);
+          if (equipmentContainer) {
+            // equipmentContainer.addEquipment(energyConsumer);
+            energyConsumer.equipmentContainerUUID = equipmentContainer.mrid;
+
+            const i7Schluesel = getDescription(equipmentContainer.getSubstation()) +
+              BELASTUNG_PRAEFIX + i7Data.bezeichner;
+            energyConsumer.description = i7Schluesel;
+          } else {
+            console.log(`EnergyConsumer ${i7Data.id} besitzt keinen EquipmentContainer.`);
+          }
+
+        } else {
+          console.log(`EnergyConsumer ${i7Data.id} besitzt keinen ConnectivityNode.`);
+        }
+
+        this.cimModel.addEnergyConsumer(energyConsumer);
+        this.integralID2UUID.set(i7Data.id, energyConsumer.mrid);
+      }
+    } else {
+      console.log(`Tabelle ${Integral7TableNames.BELASTUNG} ist nicht vorhanden.`);
+    }
+  }
+
+  async convertEinspeisungen(knotenSfIDs: number[]) {
+    if (this.isTableAvailable(Integral7TableNames.EINSPEISUNG)) {
+      const result: Einspeisung[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.EINSPEISUNG, 0, 0, knotenSfIDs));
+      for (const i7Data of result) {
+        const energySource = new EnergySource(getUUID(i7Data.guid), getName(i7Data), i7Data.kurzname);
+        const inBetrieb = convertToBooleanI7(i7Data.betrieb);
+
+        const prio = i7Data.einspprio;
+        const usoll = i7Data.usoll;
+
+        createSvStatus(this.cimModel, inBetrieb, energySource);
+        // TODO Eispeisungen mit Spannungsregelung  als ExternalNetworkInjection?
+        const spannungsgeregelt = convertToBooleanI7(i7Data.spannungsgeregelt);
+
+        const powerData = getActiveReactivePower(i7Data);
+        energySource.activePower = powerData[0];
+        energySource.reactivePower = powerData[1];
+
+        const connectivityNode = this.cimModel.objects.get(this.integralID2UUID.get(i7Data.anschluss)) as IConnectivityNode;
+
+        if (connectivityNode) {
+          createConnection(this.cimModel, energySource, connectivityNode, PhaseCode.ABC);
+
+          const equipmentContainer = determineEquipmentContainer('VoltageLevel', this.cimModel, this.cimModel.getObject(connectivityNode.getConnectivityNodeContainerUUID()) as EquipmentContainer);
+          if (equipmentContainer) {
+            // equipmentContainer.addEquipment(energySource);
+            energySource.equipmentContainerUUID = equipmentContainer.mrid;
+
+            const i7Schluesel = /*getDescription(this.cimModel.getObject(equipmentContainerUUID)?.getSubstation()) +*/
+              EINSPEISUNG_PRAEFIX + i7Data.bezeichner;
+            energySource.description = i7Schluesel;
+
+          } else {
+            console.log(`EnergySource ${i7Data.id} besitzt keinen EquipmentContainer.`);
+          }
+        } else {
+          console.log(`EnergySource ${i7Data.id} besitzt keinen ConnectivityNode.`);
+        }
+
+        // ToDo PSRType
+
+        this.cimModel.addEnergySource(energySource);
+        this.integralID2UUID.set(i7Data.id, energySource.mrid);
+      }
+    } else {
+      console.log(`Tabelle ${Integral7TableNames.EINSPEISUNG} ist nicht vorhanden.`);
+    }
+  }
+
+  async convertGeneratoren(knotenSfIDs: number[]) {
+    // Generatoren werden als GeneratingUnit und SynchronousMachine abgebildet
+    if (this.isTableAvailable(Integral7TableNames.GENERATOR)) {
+      const result: Generator[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.GENERATOR, 0, 0, knotenSfIDs))
+      for (const i7Data of result) {
+        const synchronousMachine = new SynchronousMachine(getUUID(i7Data.guid), i7Data.bezeichner, i7Data.kurzname);
+
+        const s = getActiveReactivePower(i7Data);
+        const s0 = getNumber(i7Data.sr);
+        synchronousMachine.ratedS = s0 === 0 ? s[0] : s0;
+        synchronousMachine.ratedU = i7Data.ur;
+
+        synchronousMachine.type = SynchronousMachineKind.generator;
+        synchronousMachine.referencePriority = i7Data.einspprio;
+
+        const maxQ = getNumber(i7Data.q_max);
+        synchronousMachine.maxQ = maxQ !== 0 ? maxQ : getNumber(i7Data.qmax_von_pmax);
+        const minQ = getNumber(i7Data.q_min);
+        synchronousMachine.minQ = minQ !== 0 ? minQ : getNumber(i7Data.qmin_von_pmin);
+
+        const reactiveCapabilityCurve = new ReactiveCapabilityCurve(generateUUID(), 'CurveData');
+        reactiveCapabilityCurve.curveStyle = CurveStyle.straightLineYValues;
+        reactiveCapabilityCurve.xUnit = UnitSymbol.W;
+        reactiveCapabilityCurve.y1Unit = UnitSymbol.VAr;
+        reactiveCapabilityCurve.y2Unit = UnitSymbol.VAr;
+
+        const curveData1 = new CurveData(generateUUID());
+        curveData1.curve = reactiveCapabilityCurve;
+        curveData1.xvalue = i7Data.p_min; //pMin
+        curveData1.y1value = i7Data.qmin_von_pmin;//qMin pMin
+        curveData1.y2value = i7Data.qmax_von_pmin;//qMay pMin
+        this.cimModel.addCurveData(curveData1);
+
+        const curveData2 = new CurveData(generateUUID());
+        curveData2.curve = reactiveCapabilityCurve;
+        curveData2.xvalue = i7Data.p_max; //pMin
+        curveData2.y1value = i7Data.qmin_von_pmax//qMin pMin
+        curveData2.y2value = i7Data.qmax_von_pmax;//qMay pMin
+        this.cimModel.addCurveData(curveData2);
+
+        this.cimModel.addReactiveCapabilityCurve(reactiveCapabilityCurve);
+        synchronousMachine.initialReactiveCapabilityCurveUUID = reactiveCapabilityCurve.mrid;
+
+
+        const inBetrieb = convertToBooleanI7(i7Data.betrieb);
+        createSvStatus(this.cimModel, inBetrieb, synchronousMachine);
+
+
+        synchronousMachine.ratedPowerFactor = i7Data.cosphir ? i7Data.cosphir : 0;
+        synchronousMachine.qPercent = i7Data.cos_phi ? (1 - i7Data.cosphir) : 0;
+
+        synchronousMachine.earthing = false;
+        synchronousMachine.r = 0;
+        synchronousMachine.r0 = 0;
+        synchronousMachine.r2 = 0;
+        synchronousMachine.x0 = 0;
+        synchronousMachine.x2 = 0;
+        synchronousMachine.satDirectSubtransX = i7Data.xd2s ? i7Data.xd2s : 0;
+
+        // synchronousMachine.earthingStarPointR
+        // synchronousMachine.earthingStarPointX
+        // ynchronousMachine.ikk: number;
+        // synchronousMachine.mu: number;
+
+        // synchronousMachine.satDirectSyncX: number;
+        // synchronousMachine.satDirectTransX: number;
+        // synchronousMachine.shortCircuitRotorType: ShortCircuitRotorKind;
+        // synchronousMachine.voltageRegulationRange: number;
+
+        // RegulatingControl
+        const regulatingControl = new RegulatingControl(generateUUID(), `RegulatingControl_${synchronousMachine.name}`);
+        switch (i7Data.spannungsgeregelt) {
+          case 1: {
+            regulatingControl.mode = RegulatingControlModeKind.voltage;
+          }
+          default: {
+            regulatingControl.mode = RegulatingControlModeKind.voltage;
+          }
+        }
+        synchronousMachine.regulatingControlUUID = regulatingControl.mrid;
+        // regulatingControl.addRegulatingCondEq(synchronousMachine);
+
+
+        // GeneratingUnit
+        const generatingUnitConfig = FUEL_TYPE_CONFIG[i7Data.nameprimaertyp];
+
+        /** Wenn ein Config für den Primärenergietyp vorhanden*/
+        let generatingUnit;
+
+        if (generatingUnitConfig) {
+          switch (generatingUnitConfig.class) {
+            case 'ThermalGeneratingUnit': {
+              generatingUnit = new ThermalGeneratingUnit(getUUID(''), 'Generator_' + i7Data.bezeichner, i7Data.kurzname, i7Data.nameprimaertyp);
+              if (generatingUnitConfig.fuelType) {
+                generateFuelType(i7Data.nameprimaertyp, generatingUnitConfig.fuelType, generatingUnit, this.cimModel);
+              }
+              break;
+            }
+            case 'SolarGeneratingUnit': {
+              generatingUnit = new SolarGeneratingUnit(getUUID(''), 'Generator_' + i7Data.bezeichner, i7Data.kurzname, i7Data.nameprimaertyp);
+              break;
+            }
+            case 'WindGeneratingUnit': {
+              generatingUnit = new WindGeneratingUnit(getUUID(''), 'Generator_' + i7Data.bezeichner, i7Data.kurzname, i7Data.nameprimaertyp);
+              switch (generatingUnitConfig.fuelType) {
+                case 'onshore':
+                  generatingUnit.windGenUnitType = WindGenUnitKind.onshore;
+                  break;
+                case 'offshore':
+                  generatingUnit.windGenUnitType = WindGenUnitKind.offshore;
+                  break;
+              }
+              break;
+            }
+            case 'NuclearGeneratingUnit': {
+              generatingUnit = new NuclearGeneratingUnit(getUUID(''), 'Generator_' + i7Data.bezeichner, i7Data.kurzname);
+              break;
+            }
+          }
+        }
+        if (!generatingUnit) {
+          generatingUnit = new GeneratingUnit(getUUID(''), 'Generator_' + i7Data.bezeichner, i7Data.kurzname);
+        }
+
+        generatingUnit.maxOperatingP = getNumber(i7Data.p_max);
+        generatingUnit.minOperatingP = getNumber(i7Data.p_min);
+
+        generatingUnit.maxOperatingQ = getNumber(i7Data.q_max);
+        generatingUnit.minOperatingQ = getNumber(i7Data.q_min);
+
+        generatingUnit.initialP = getNumber(i7Data.p0);
+        generatingUnit.nominalP = getNumber(generatingUnit.maxOperatingP);
+
+        generatingUnit.genControlSource = GeneratorControlSource.unavailable;
+
+
+        generatingUnit.addRotatingMachine(synchronousMachine);
+        synchronousMachine.generatingUnitUUID = generatingUnit.mrid;
+
+        const connectivityNode = this.cimModel.objects.get(this.integralID2UUID.get(i7Data.anschluss)) as IConnectivityNode;
+
+        if (connectivityNode) {
+          const terminal = createConnection(this.cimModel, synchronousMachine, connectivityNode, PhaseCode.ABC);
+          regulatingControl.terminalUUID = terminal.mrid;
+          const equipmentContainerEquip = determineEquipmentContainer('VoltageLevel', this.cimModel, this.cimModel.getObject(connectivityNode.getConnectivityNodeContainerUUID()) as EquipmentContainer);
+          if (equipmentContainerEquip) {
+            // equipmentContainer.addEquipment(synchronousMachine);
+            synchronousMachine.equipmentContainerUUID = equipmentContainerEquip.mrid;
+
+            // equipmentContainer.addEquipment(generatingUnit);
+            const i7Schluesel = /*getDescription(equipmentContainer.getSubstation()) +*/
+              GENERATOR_PRAEFIX + i7Data.bezeichner;
+            synchronousMachine.description = i7Schluesel;
+
+            // GeneratingUnits EquipContainer is Substation
+
+
+            const vlEqipContainer = (equipmentContainerEquip as VoltageLevel);
+            const equipmentContainergenUnitUUID = vlEqipContainer?.getSubstationUUID();
+            if (equipmentContainergenUnitUUID) {
+              generatingUnit.equipmentContainerUUID = equipmentContainergenUnitUUID;
+            } else {
+              console.log(`GeneratingUnit ${i7Data.id} besitzt keinen EquipmentContainer/Substation.`);
+            }
+          } else {
+            console.log(`SynchronousMachine ${i7Data.id} besitzt keinen EquipmentContainer.`);
+            console.log(`SynchronousMachine ${i7Data.id} besitzt keinen EquipmentContainer.`);
+          }
+        } else {
+          console.log(`SynchronousMachine ${i7Data.id} besitzt keinen ConnectivityNode.`);
+        }
+
+        this.cimModel.addRegulatingControl(regulatingControl);
+        this.cimModel.addGeneratingUnit(generatingUnit);
+        this.cimModel.addSynchronousMachine(synchronousMachine);
+        this.integralID2UUID.set(i7Data.id, synchronousMachine.mrid);
+
+      }
+    }
+  }
+
+  async convertKnotenSf(schaltfeldIDs: number[]) {
+    if (this.isTableAvailable(Integral7TableNames.KNOTEN_SF)) {
+      const result: SchaltfeldKnoten[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.KNOTEN_SF, 0, 0, schaltfeldIDs));
+
+      for (const i7Data of result) {
+        const connectivityNode = new ConnectivityNode(getUUID(i7Data.guid), 'knotensf cn', 'knotensf');
+        const bay = this.cimModel.getBay(this.integralID2UUID.get(i7Data.schaltfeld))
+        if (bay) {
+          connectivityNode.connectivityNodeContainerUUID = bay.mrid;
+          // bay.addConnectivityNode(connectivityNode);
+        } else {
+          console.log(`KnotenSf ${i7Data.id} besitzt kein Schaltfeld.`);
+        }
+        this.knotenSfIDs.push(i7Data.id);
+        this.cimModel.addConnectivityNode(connectivityNode);
+        this.integralID2UUID.set(i7Data.id, connectivityNode.mrid);
+        this.knotenSpannung.set(connectivityNode.mrid, connectivityNode.getBaseVoltage());
+        this.checkMemoryObject(i7Data.id, connectivityNode);
+      }
+    } else {
+      console.log(`Tabelle ${Integral7TableNames.KNOTEN_SF} ist nicht vorhanden.`);
+    }
+  }
+
+  async convertKnotenKf(querkupplungIDs: number[]) {
+    if (this.isTableAvailable(Integral7TableNames.KNOTEN_KF)) {
+      const result: KnotenKf[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.KNOTEN_KF, 0, 0, querkupplungIDs));
+      for (const i7Data of result) {
+        const connectivityNode = new ConnectivityNode(getUUID(i7Data.guid), 'knotenkf cn', 'knotenkf');
+
+        const bay = this.cimModel.getBay(this.integralID2UUID.get(i7Data.kpfeld))
+        if (bay) {
+          connectivityNode.connectivityNodeContainerUUID = bay.mrid;
+          // bay.addConnectivityNode(connectivityNode);
+        } else {
+          console.log(`KnotenKf ${i7Data.id} besitzt kein Schaltfeld.`);
+        }
+        this.integralID2UUID.set(i7Data.id, connectivityNode.mrid);
+        this.cimModel.addConnectivityNode(connectivityNode);
+      }
+    } else {
+      console.log(`Tabelle ${Integral7TableNames.KNOTEN_KF} ist nicht vorhanden.`);
+    }
+  }
+
+  async convertKnotenLk(laengskupplungIDs: number[]) {
+    if (this.isTableAvailable(Integral7TableNames.KNOTEN_LK)) {
+      const result: KnotenLk[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.KNOTEN_LK, 0, 0, laengskupplungIDs));
+      for (const i7Data of result) {
+        const connectivityNode = new ConnectivityNode(generateUUID(), getName(i7Data), 'KnotenLk',);
+
+        const bay = this.cimModel.getBay(this.integralID2UUID.get(i7Data.lkupplung));
+        if (bay) {
+          connectivityNode.connectivityNodeContainerUUID = bay.mrid;
+          // bay.addConnectivityNode(connectivityNode);
+        } else {
+          console.log(`KnotenLk ${i7Data.id} besitzt kein Schaltfeld.`);
+        }
+        this.integralID2UUID.set(i7Data.id, connectivityNode.mrid);
+        this.cimModel.addConnectivityNode(connectivityNode);
+      }
+    } else {
+      console.log(`Tabelle ${Integral7TableNames.KNOTEN_LK} ist nicht vorhanden.`);
+    }
+  }
+
+  /** Netzschlaufen werden als ein Terminal abgebildet
+   * Schaltzustand wird über Property 'connected' abgebildet. */
+  async convertSchlaufen(knotenSoIDs: number[]) {
+    //Schlaufen
+    if (this.isTableAvailable(Integral7TableNames.SCHLAUFE)) {
+      const result: Schlaufe[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.SCHLAUFE, 0, 0, knotenSoIDs));
+      for (const i7Data of result) {
+
+        const terminal = new Terminal(generateUUID(), 'T_Schlaufe', String(i7Data.id));
+        terminal.connected = convertToBooleanI7(i7Data.schaltzustand);
+        terminal.phases = PhaseCode.ABC;
+        /* Schlaufenterminals werden nicht im Modell,
+           sondern in der Map memoryObjects gespeichert.
+           Serialisierung erfolgt erst nach Konvertierung aller leitenden Elementen!
+           Der Grund: Die 'ConductingEquipment'-Assoziation muss bei jedem Terminal gesetzt sein!
+           this.cimModel.addTerminal(terminal);*/
+
+        this.integralID2UUID.set(i7Data.id, terminal.mrid);
+        this.integralID2UUID.set(i7Data.knotenzw, terminal.mrid);
+
+        this.memoryObjects.set(i7Data.id, terminal);
+        this.memoryObjects.set(i7Data.knotenzw, terminal);
+        const eknotenUUID = this.integralID2UUID.get(i7Data.eknoten);
+        // const connectivityNode = this.cimModel.getConnectivityNode(eknotenUUID) as IConnectivityNode;
+        if (eknotenUUID) {
+          // connectivityNode.addTerminal(terminal);
+          terminal.connectivityNodeUUID = eknotenUUID;
+          const connectivityNode = this.cimModel.getConnectivityNode(eknotenUUID);
+          this.knotenSpannung.set(connectivityNode?.mrid, connectivityNode?.getBaseVoltage());
+        } else {
+          console.log(`Schlaufe ${i7Data.id} besitzt kein KnotenSO).`);
+        }
+      }
+    } else {
+      console.log(`Tabelle ${Integral7TableNames.SCHLAUFE} ist nicht vorhanden.`)
+    }
+  }
+
+  async convertSchemaStandorte(standortIDs: number[]) {
+    if (this.isTableAvailable(Integral7TableNames.NSG_STANDORT)) {
+      const result: NsgStandort[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.NSG_STANDORT, 0, 0, standortIDs));
+      for (const i7Data of result) {
+        const standortNsgImpl = new StandortNsgImpl(i7Data);
+        this.integralNsgStandort.set(i7Data.id, standortNsgImpl);
+
+        if (this.integralStandorte.has(standortNsgImpl.standortid)) {
+          standortNsgImpl.standort = this.integralStandorte.get(standortNsgImpl.standortid);
+          standortNsgImpl.standort.standortNsg = standortNsgImpl;
+        } else {
+          console.log(`standortNsg/DiagramObject ${standortNsgImpl.id} hat keine Standort-Instanz.`);
+        }
+      }
+    } else {
+      console.log(`Tabelle ${Integral7TableNames.NSG_STANDORT} ist nicht vorhanden.`);
+    }
+  }
+
+  async convertSchemaKnotenSo(knotenSoIDs: number[]) {
+    if (this.isTableAvailable(Integral7TableNames.NSG_KNOTEN_SO)) {
+      const result: NsgKnotenSo[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.NSG_KNOTEN_SO, 0, 0, knotenSoIDs));
+      //const result: NsgStandort[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.NSG_STANDORT, 0, 0, standortIDs));
+      for (const i7Data of result) {
+
+        const knotenSoNsgImpl = new KnotenSoNsg(i7Data);
+        this.integralNsgKnotenSo.set(i7Data.id, knotenSoNsgImpl);
+
+        if (this.integralKnotenSo.has(knotenSoNsgImpl.knotensoid)) {
+          knotenSoNsgImpl.knotenso = this.integralKnotenSo.get(knotenSoNsgImpl.knotensoid);
+          knotenSoNsgImpl.knotenso.knotenSoNsg = knotenSoNsgImpl;
+        }
+
+        const diagramObject = new DiagramObject(getUUID(i7Data.guid), 'Abzweig', String(i7Data.variantennr));
+        this.cimModel.addDiagramObject(diagramObject);
+
+        const nsgStandortData = this.integralNsgStandort.get(i7Data.nsgso);
+
+        if (nsgStandortData) {
+
+          const diagramObjectPoint = new DiagramObjectPoint(nsgStandortData.xrel + i7Data.xrel, nsgStandortData.yrel + i7Data.yrel);
+
+          diagramObjectPoint.mrid = generateUUID();
+          diagramObjectPoint.diagramObject = diagramObject;
+          diagramObject.addDiagramObjectPoint(diagramObjectPoint);
+
+          const cnUUID = this.integralID2UUID.get(i7Data.knotenso);
+
+          const cn = this.cimModel.getObject(cnUUID);
+          if (cn) {
+            // cn.addDiagramObject(diagramObject);
+            diagramObject.identifiedObjectUUID = cn.mrid;
+          } else {
+            console.log(`KnotenSo/DiagramObject ${diagramObject.mrid} hat kein PSR-Objekt.`);
+          }
+          const diagramUUID = this.integralID2UUID.get(i7Data.variantennr);
+          const diagram = this.cimModel.getDiagram(diagramUUID);
+          if (diagram) {
+            // diagram.addDiagramObject(diagramObject);
+            diagramObject.diagramUUID = diagram.mrid;
+          } else {
+            //console.log(`Abzweig/DiagramObject ${diagramObject.mrid} mit der VariantenNr ${i7Data.variantennr} hat kein Diagram-Objekt.`);
+          }
+          //this.integralID2UUID.set(+(i7Data.id + '' +  i7Data.variantennr), diagramObject.mrid);
+        } else {
+          //console.log(`NSG KnotenSo hat keinen NsgStandort.`);
+        }
+      }
+    } else {
+      console.log(`Tabelle ${Integral7TableNames.NSG_KNOTEN_SO} ist nicht vorhanden.`);
+    }
+  }
+
+  async convertSchemaSchaltanlage(saIDs: number[]) {
+    if (this.isTableAvailable(Integral7TableNames.NSG_SCHALTANLAGE)) {
+      const result: NsgSA[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.NSG_SCHALTANLAGE, 0, 0, saIDs));
+      // const result: NsgSA[] = await getConnectionTypeOrm(this.dbConnectionName).query(NSG_SCHALTANLAGE_SQL_QUERY);
+      for (const i7Data of result) {
+
+        const saNsgImpl = new SchaltanlageNsgImpl(i7Data);
+        this.integralNsgSchaltanlage.set(i7Data.id, saNsgImpl);
+
+        //Netzschaltanlage
+        if (this.integralSchaltanlagen.has(saNsgImpl.schaltanlageid)) {
+          saNsgImpl.schaltanlage = this.integralSchaltanlagen.get(saNsgImpl.schaltanlageid);
+          saNsgImpl.schaltanlage.schaltanlageNsg = saNsgImpl;
+        } else {
+          console.log(`SchaltanlageNSG  ${i7Data.id} hat keine PSR Instanz.`);
+        }
+        //Standort
+        if (this.integralNsgStandort.has(saNsgImpl.nsgsoid)) {
+          saNsgImpl.nsgso = this.integralNsgStandort.get(saNsgImpl.nsgsoid);
+          saNsgImpl.nsgso.schaltanlagenNsg.push(saNsgImpl);
+        } else {
+          console.log(`SchaltanlageNSG  ${i7Data.id} hat keine standortNsg Instanz.`);
+        }
+      }
+    } else {
+      console.log(`Tabelle ${Integral7TableNames.NSG_KNOTEN_SO} ist nicht vorhanden.`);
+    }
+  }
+
+  async convertSchemaSchaltanlagenAbschnitte(schaltanlagenabschnittIDs: number[]) {
+    if (this.isTableAvailable(Integral7TableNames.NSG_SCHALTANLAGENABSCHNITT)) {
+      const result: NsgSAAB[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.NSG_SCHALTANLAGENABSCHNITT, 0, 0, schaltanlagenabschnittIDs));
+      for (const i7Data of result) {
+        const saabNsgImpl = new SchaltanlagenabschnittNsg(i7Data);
+        this.integralNsgSchaltanlagenabschnitt.set(i7Data.id, saabNsgImpl);
+
+        if (this.integralSchaltanlagenAbschnitte.has(saabNsgImpl.saabschnittid)) {
+          saabNsgImpl.saabschnitt = this.integralSchaltanlagenAbschnitte.get(saabNsgImpl.saabschnittid);
+          saabNsgImpl.saabschnitt.schaltanlagenabschnittNsg = saabNsgImpl;
+        } else {
+          console.log(`NSG Schaltanlagenabschnitt hat keinen PSR-Abschnitt`);
+        }
+        // Scaltanlage
+        if (saabNsgImpl.saabschnitt && saabNsgImpl.saabschnitt.schaltanlage) {
+          if (saabNsgImpl.saabschnitt.schaltanlage.schaltanlageNsg) {
+            saabNsgImpl.saabschnitt.schaltanlage.schaltanlageNsg.saabNsg.push(saabNsgImpl);
+            saabNsgImpl.nsgsa = saabNsgImpl.saabschnitt.schaltanlage.schaltanlageNsg;
+          }
+        }
+      }
+    } else {
+      console.log(`Tabelle ${Integral7TableNames.NSG_KNOTEN_SO} ist nicht vorhanden.`);
+    }
+  }
+
+  async convertSchemaSammelschienenAbschnitte() {
+    for (const sa of this.integralSchaltanlagen.values()) {
+      const totalSlots = sa.getTotalSlots();
+      // const delta = sa.getDelta();
+      if (sa.schaltanlageNsg) {
+        const saAusrichtung = sa.schaltanlageNsg.ausrichtung;
+        for (const saab of sa.saab) {
+          for (const ssab of saab.ssab) {
+            const cnUUID = this.integralID2UUID.get(ssab.id);
+            const connectivityNode = this.cimModel.getConnectivityNode(cnUUID) as IConnectivityNode;
+
+            const standortPoint = sa.standort.getPoint();
+            const saPoint = sa.getPoint();
+            const ssabPoint = standortPoint.translate(saPoint.x, saPoint.y);
+
+            const offset = saab.schaltanlagenabschnittNsg.nslots;
+            const laenge = saab.schaltanlagenabschnittNsg.laenge;
+            const delta = sa.getDelta(saab);
+            const hoehe = saab.ssab.length * 8;
+
+            const diagramObject = new DiagramObject(getUUID(''), 'SSAB Diagram', String(sa.schaltanlageNsg.variantennr));
+            const points: Point[] = [];
+
+            if (saAusrichtung === 0) { // oben/waagerecht
+              // points.push(new Pi);
+              points.push(new Point(ssabPoint.x - 8 + (offset * 16), ssabPoint.y + 4 - hoehe + ssab.pos * 8 + delta));
+              points.push(new Point(ssabPoint.x - 8 + (offset * 16) + (laenge * 16), ssabPoint.y + 4 - hoehe + ssab.pos * 8 + delta));
+
+            } else if (saAusrichtung === 1) { // rechts/senkrecht
+              points.push(new Point(ssabPoint.x + 4 - hoehe + ssab.pos * 8 + delta, ssabPoint.y - 8 + (offset * 16)));
+              points.push(new Point(ssabPoint.x + 4 - hoehe + ssab.pos * 8 + delta, ssabPoint.y - 8 + (offset * 16) + (laenge * 16)));
+
+            } else if (saAusrichtung === 2) { // unten/waagerecht
+              points.push(new Point(ssabPoint.x - 8 + (offset * 16), ssabPoint.y + 4 - hoehe + ssab.pos * 8 + delta));
+              points.push(new Point(ssabPoint.x - 8 + (offset * 16) + (laenge * 16), ssabPoint.y + 4 - hoehe + ssab.pos * 8 + delta));
+            } else if (saAusrichtung === 3) { // links/senkrecht
+              points.push(new Point(ssabPoint.x + 4 - hoehe + ssab.pos * 8 + delta, ssabPoint.y - 8 + (totalSlots * 16) - (offset * 16)));
+              points.push(new Point(ssabPoint.x + 4 - hoehe + ssab.pos * 8 + delta, ssabPoint.y - 8 + (totalSlots * 16) - (offset * 16 + laenge * 16)));
+            }
+
+            createDiagramObjectPoints(diagramObject, points);
+
+            // connectivityNode.addDiagramObject(diagramObject);
+            diagramObject.identifiedObjectUUID = connectivityNode.mrid;
+            this.cimModel.addDiagramObject(diagramObject);
+
+            const diagramUUID = this.integralID2UUID.get(sa.schaltanlageNsg.variantennr);
+            const diagram = this.cimModel.getDiagram(diagramUUID);
+            if (diagram) {
+              // diagram.addDiagramObject(diagramObject);
+              diagramObject.diagramUUID = diagram.mrid;
+            } else {
+              //console.log(`SSAB/DiagramObject ${diagramObject.mrid} mit der VariantenNr ${sa.schaltanlageNsg.variantennr} hat kein Diagram-Objekt.`);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  async convertSchemaSchaltfelder(schaltfeldIDs: number[]) {
+    if (this.isTableAvailable(Integral7TableNames.NSG_SCHALTFELD)) {
+      const result: NsgSchaltfeld[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.NSG_SCHALTFELD, 0, 0, schaltfeldIDs));
+      //const result: NsgSAAB[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.NSG_SCHALTANLAGENABSCHNITT, 0, 0, schaltanlagenabschnittIDs));
+      for (const i7Data of result) {
+
+        const sfNSG = new SchaltfeldNsgImpl(i7Data);
+        sfNSG.schaltfeld = this.integralSchaltfelder.get(sfNSG.schaltfeldid);
+        if (sfNSG.schaltfeld) {
+          sfNSG.schaltfeld.schaltfeldNsg = sfNSG;
+        }
+
+        sfNSG.nsgsaa = this.integralNsgSchaltanlagenabschnitt.get(sfNSG.nsgsaaid);
+
+        this.integralNsgSchaltfelder.set(i7Data.id, sfNSG);
+
+        const sf = sfNSG.schaltfeld;
+        if (sf) {
+          const standort = sf.getStandort();
+          const sa = sf.getSA();
+          const saab = sf.getSAAB();
+
+          if (standort && sa && saab) {
+            const pointSt = standort.getPoint();
+            const pointSaRel = sa.getPoint();
+            const pointSa = pointSt.translate(pointSaRel.x, pointSaRel.y);
+
+            const slotOffset = saab.getSlotOffset();
+
+            const saAusrichtung = sa.schaltanlageNsg.ausrichtung;
+            const deltaAusrichtung = sfNSG.deltaausrichtung;
+            const slotnummer = sfNSG.slotnummer;
+
+            const d = 4; //versatz in Pixeln auf Sammelschiene d=0 -> 4 Pixel länger d=1 ->3 / d=2 -> 2
+
+            const deltaSSAB = sa.getDelta(saab); // ssab.length * 8 - 16
+            const posSSAB = sfNSG.schaltfeld.getPosSSAB(saAusrichtung, deltaAusrichtung);
+
+
+            let pointLinksOben, pointRechtsUnten;
+            if (saAusrichtung === 0) { // oben/waagerecht
+              const pointSf = pointSa.translate(16 * (slotnummer + slotOffset) - 16, 0);
+              if (deltaAusrichtung === 1) {
+                pointSf.y = pointSf.y + 65 + deltaSSAB; // punkt links unten
+                pointRechtsUnten = pointSf.translate(32, 0);
+                pointLinksOben = pointSf.translate(0, -sfNSG.hoehe /*+ 8 * posSSAB + d*/);
+              } else {
+                pointSf.y = pointSf.y - sfNSG.hoehe + deltaSSAB; // punkt rechts oben
+                pointLinksOben = pointSf.translate(0, 0);
+                pointRechtsUnten = pointSf.translate(32, sfNSG.hoehe /*- 8 * posSSAB - d*/);
+              }
+            } else if (saAusrichtung === 1) { // rechts/senkrecht
+
+            } else if (saAusrichtung === 2) { // unten/waagerecht
+
+            } else if (saAusrichtung === 3) { // links/senkrecht
+
+            }
+
+            //
+            if (pointLinksOben && pointRechtsUnten) {
+
+              const points: Point[] = [];
+
+              points.push(new Point(pointLinksOben.x, pointLinksOben.y)); // links oben
+              points.push(new Point(pointRechtsUnten.x, pointLinksOben.y)); // rechts oben
+              points.push(new Point(pointRechtsUnten.x, pointRechtsUnten.y)); // rechts unten
+              points.push(new Point(pointLinksOben.x, pointRechtsUnten.y)); // links unten
+              points.push(new Point(pointLinksOben.x, pointLinksOben.y));
+
+              points.push(new Point(pointLinksOben.x + 16, pointLinksOben.y));
+              points.push(new Point(pointLinksOben.x + 16, pointRechtsUnten.y));
+
+              const diagramObject = new DiagramObject(getUUID(''), 'Schaltfeld',
+                String(sa.schaltanlageNsg.variantennr));
+
+              const bayUUID = this.integralID2UUID.get(sf.id);
+              const bay = this.cimModel.getBay(bayUUID);
+              if (bay) {
+                createDiagramObjectPoints(diagramObject, points);
+                // bay.addDiagramObject(diagramObject);
+                diagramObject.identifiedObjectUUID = bay.mrid;
+
+                const diagramUUID = this.integralID2UUID.get(sa.schaltanlageNsg.variantennr);
+                const diagram = this.cimModel.getDiagram(diagramUUID);
+                if (diagram) {
+                  // diagram.addDiagramObject(diagramObject);
+                  diagramObject.diagramUUID = diagram.mrid;
+
+                  // this.convertSchemaBayElements(bay, diagram, saAusrichtung, deltaAusrichtung);
+                } else {
+                  // console.log(`Schaltfeld/DiagramObject ${diagramObject.mrid} mit der VariantenNr ${sa.schaltanlageNsg.variantennr} hat kein Diagram-Objekt.`);
+                }
+              } else {
+                console.log(`DiagramObject Schaltfeld ${diagramObject.mrid} mit der VariantenNr ${sa.schaltanlageNsg.variantennr} hat kein CIM Schaltfeld ${sf.id} ${bayUUID}.`);
+              }
+            }
+          }
+        }
+        /*  const diagramObject = new DiagramObject(getUUID(i7Data.guid), 'Schaltfeld', String(i7Data.variantennr));
+          this.cimModel.addDiagramObject(diagramObject);*/
+
+
+      }
+    } else {
+      console.log(`Tabelle ${Integral7TableNames.NSG_KNOTEN_SO} ist nicht vorhanden.`);
+    }
+  }
+
+
+  async convertStarreVerbindungen(containerIDs: number[]) {
+
+    if (this.isTableAvailable(Integral7TableNames.KNOTEN_STARR)) {
+      const result: StarrerKnoten[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.KNOTEN_STARR, 0, 0, containerIDs));
+      for (const i7Data of result) {
+        const junction = new Junction(getUUID(i7Data.guid), i7Data.bezeichner, 'JNCT', 'starre Verbindung');
+        const schaltzustand = convertToBooleanI7(i7Data.schaltzustand);
+
+        const equipmentContainer = determineEquipmentContainer( 'VoltageLevel', this.cimModel, this.cimModel.getObject(this.integralID2UUID.get(i7Data.seliste)) as EquipmentContainer);
+
+        const cnStart = this.cimModel.getConnectivityNode(this.integralID2UUID.get(i7Data.aknoten));
+        const cnZiel = this.cimModel.getConnectivityNode(this.integralID2UUID.get(i7Data.eknoten));
+        if (equipmentContainer) {
+          // equipmentContainer.addEquipment(junction);
+          junction.equipmentContainerUUID = equipmentContainer.mrid;
+        } else {
+          console.log(`Starre verbindung ${i7Data.id} besitzt keinen EquipmentContainer.`);
+        }
+        if (cnStart) {
+          const terminal = createConnection(this.cimModel, junction, cnStart, PhaseCode.ABC, 1);
+          if (schaltzustand === false) {
+            terminal.connected = schaltzustand;
+          }
+        } else {
+          console.log(`Starre verbindung ${i7Data.id} besitzt keinen Anfangsknoten.`);
+        }
+        if (cnZiel) {
+          const terminal = createConnection(this.cimModel, junction, cnZiel, PhaseCode.ABC, 2);
+          if (schaltzustand === false) {
+            terminal.connected = schaltzustand;
+          }
+        } else {
+          console.log(`Starre verbindung ${i7Data.id} besitzt keinen Zielknoten.`);
+        }
+
+        const baseVoltage = getTerminalUn(this.cimModel, junction);
+        if (baseVoltage) {
+          junction.baseVoltageUUID = baseVoltage.mrid;
+        }
+
+        this.integralID2UUID.set(i7Data.id, junction.mrid);
+        this.cimModel.addJunction(junction);
+      }
+
+    } else {
+      console.log(`Tabelle ${Integral7TableNames.KNOTEN_STARR} ist nicht vorhanden.`)
+    }
+
+  }
+
+
+  /**
+   * @param lineAttribute Attribut zur Bestimmung der Stromkreise */
+
+  /*  async convertErsatzLaengszweige() {
+      if (this.isTableAvailable(Integral7TableNames.ERSATZLAENGSZWEIG)) {
+
+        const result: LeitungErsatzLaengszweig[] = await this.queryFunctionWrapper(ERSATZLAENGSZWEIG_SQL_QUERY);
+        for (const i7Data of result) {
+
+          // Topologie
+          /!* Anfang
+           * 3 moegliche Anschluesse
+           *  KontenSo -> Anschluesspunkt
+           *  KnotenSf -> Schaltfeldpunkt
+           *  KnotenZw -> Netzschlaufe -> KnotenSo -> Anschlusspunkt *!/
+
+          const i7Schluessel = ERSATZLAENGSZWEIG_PRAEFIX +
+            ueberpruefeZeichenkette(i7Data.ukz) +
+            MITTIGER_PUNKT +
+            ueberpruefeZeichenkette(i7Data.kurzname) +
+            MITTIGER_PUNKT +
+            ueberpruefeZeichenkette(i7Data.bezeichner) +
+            MITTIGER_PUNKT +
+            ueberpruefeZeichenkette(i7Data.stkabname);
+
+          const equivalentBranch = new EquivalentBranch(generateUUID(), getName(i7Data), i7Data.stkabname, i7Schluessel);
+
+          // TODO alles überprüfen
+          equivalentBranch.negativeR12 = i7Data.r12_lfl;
+          equivalentBranch.negativeR21 = i7Data.r21_lfl;
+          equivalentBranch.negativeX12 = i7Data.x12_lfl;
+          equivalentBranch.negativeX21 = i7Data.x21_lfl;
+
+          equivalentBranch.positiveR12 = i7Data.r12_lfl;
+          equivalentBranch.positiveR21 = i7Data.r21_lfl;
+          equivalentBranch.positiveX12 = i7Data.x12_lfl;
+          equivalentBranch.positiveX21 = i7Data.x21_lfl;
+
+          // equivalentBranch.r = i7Data.r;
+          equivalentBranch.r21 = i7Data.r12_lfl;
+          // equivalentBranch.x = ;
+          equivalentBranch.x21 = i7Data.x21_lfl;
+          equivalentBranch.zeroR12 = i7Data.r12_ks;
+          equivalentBranch.zeroR21 = i7Data.r12_ks;
+          equivalentBranch.zeroX12 = i7Data.x12_ks;
+          equivalentBranch.zeroX21 = i7Data.x12_ks;
+
+          const baseVoltageUr1 = createBaseVoltageIfNotExists(this.cimModel, i7Data.ur1);
+          const baseVoltageUr2 = createBaseVoltageIfNotExists(this.cimModel, i7Data.ur2);
+          if (baseVoltageUr1) {
+            equivalentBranch.baseVoltage = baseVoltageUr1;
+          } else if (baseVoltageUr2) {
+            equivalentBranch.baseVoltage = baseVoltageUr2;
+          } else {
+            console.log(`Ersatzlaengszweig ${i7Data.id} ${equivalentBranch.mrid} besitzt keine Spannungsebenenangabe.`);
+          }
+          this.cimModel.addEquivalentBranch(equivalentBranch);
+          this.integralID2UUID.set(i7Data.id, equivalentBranch.mrid);
+
+          // Topologie
+          /!* Anfang
+           * 3 moegliche Anschluesse
+           *  KontenSo -> Anschluesspunkt
+           *  KnotenSf -> Schaltfeldpunkt
+           *  KnotenZw -> Netzschlaufe -> KnotenSo -> Anschlusspunkt *!/
+          const startUUID =  this.integralID2UUID.get(i7Data.aknoten);
+          const targetUUID = this.integralID2UUID.get(i7Data.eknoten);
+
+          const start = this.cimModel.getObject(startUUID);
+          if(start) {
+            createConnection(this.cimModel, equivalentBranch, start, PhaseCode.ABC, 1);
+          } else {
+            console.log(`Ersatzlaengszweig ${i7Data.id} ${equivalentBranch.mrid} besitzt keinen Anfangsknoten.`);
+          }
+          const target = this.cimModel.getObject(targetUUID);
+          if(target) {
+            createConnection(this.cimModel, equivalentBranch, target, PhaseCode.ABC, 2);
+          } else {
+            console.log(`Ersatzlaengszweig ${i7Data.id} ${equivalentBranch.mrid} besitzt keinen Zielknoten.`);
+          }
+        }
+
+      } else {
+        console.log(`Tabelle ${Integral7TableNames.ERSATZLAENGSZWEIG} ist nicht vorhanden.`);
+      }
+    }*/
+
+  /**
+   * @param lineAttribute Attributsname zum Bestimmen der Stronkreise*/
+  async convertStromkreise() {
+    if (this.isTableAvailable(Integral7TableNames.LEITUNG)) {
+      const result: LeitungStk[] = await this.queryFunctionWrapper(`SELECT DISTINCT kurzname, bezeichner FROM ${Integral7TableNames[I7Objects.LEITUNG]}`);
+      for (const i7Data of result) {
+
+        let line = getLineByAttribute(this.cimModel, 'name', i7Data.bezeichner);
+        if (!line) {
+          line = new Line(generateUUID());
+          line.name = i7Data.bezeichner ? i7Data.bezeichner : 'Stromkreis_' + i7Data.kurzname;
+          line.shortName = i7Data.kurzname;
+          const region = createIfNotExitsGeoregionByName(this.cimModel, 'ENTSO-E');
+          const subregion = createIfNotExitsSubGeoregionByName(this.cimModel, 'Deutschland', region);
+          line.regionUUID = subregion.mrid;
+
+          const i7Schluessel = LEITUNG_PRAEFIX +
+            ueberpruefeZeichenkette(i7Data.ukz) +
+            MITTIGER_PUNKT +
+            ueberpruefeZeichenkette(i7Data.kurzname) +
+            MITTIGER_PUNKT +
+            ueberpruefeZeichenkette(i7Data.bezeichner);
+          line.description = i7Schluessel;
+
+          this.cimModel.addLine(line);
+        }
+      }
+    } else {
+      console.log(`Tabelle ${Integral7TableNames.LEITUNG} ist nicht vorhanden.`);
+    }
+  }
+
+  async convertBetriebsmitteltypenLeitung() {
+    // Freileitungstypen
+    if (this.isTableAvailable(Integral7TableNames.TYP_FREILEITUNG)) {
+      const result: StkTyp[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.TYP_FREILEITUNG, 0, 0, []));
+      for (const i7Data of result) {
+        const typ = new OverheadWireInfo(generateUUID(), i7Data.name);
+        this.setWireInfoProperties(typ, i7Data);
+        this.cimModel.addOverheadWireInfo(typ);
+      }
+    } else {
+      console.log(`Tabelle ${Integral7TableNames.TYP_FREILEITUNG} ist nicht vorhanden.`);
+    }
+
+    // Kabelstypen
+    if (this.isTableAvailable(Integral7TableNames.TYP_KABEL)) {
+      const result: StkTyp[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.TYP_KABEL, 0, 0, []));
+      for (const i7Data of result) {
+        const typ = new CableInfo(generateUUID(), i7Data.name);
+        this.setWireInfoProperties(typ, i7Data);
+        this.cimModel.addCableInfo(typ);
+      }
+    } else {
+      console.log(`Tabelle ${Integral7TableNames.TYP_KABEL} ist nicht vorhanden.`);
+    }
+  }
+
+  async convertLeitungen(limit: number, offset: number) {
+    if (this.isTableAvailable(Integral7TableNames.LEITUNG)) {
+      const result: LeitungStk[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.LEITUNG, limit, offset, []));
+      for (const i7Data of result) {
+        const leitung = new LeitungImpl(i7Data);
+        this.integralLeitungen.set(i7Data.id, leitung);
+
+        const i7Schluessel = LEITUNG_PRAEFIX +
+          ueberpruefeZeichenkette(i7Data.ukz) +
+          MITTIGER_PUNKT +
+          ueberpruefeZeichenkette(i7Data.kurzname) +
+          MITTIGER_PUNKT +
+          ueberpruefeZeichenkette(i7Data.bezeichner) +
+          MITTIGER_PUNKT +
+          ueberpruefeZeichenkette(i7Data.stkabname);
+
+        const acLineSegment = new ACLineSegment(getUUID(i7Data.guid), i7Data.bezeichner, i7Data.stkabname, i7Schluessel);
+
+        this.cimModel.addACLineSegment(acLineSegment);
+        this.integralID2UUID.set(i7Data.id, acLineSegment.mrid);
+
+        const line = getLine(this.cimModel, i7Data.bezeichner, i7Data.kurzname);
+        if (line) {
+          acLineSegment.equipmentContainerUUID = line.mrid;
+          // line.addEquipment(acLineSegment);
+        } else {
+          console.log(`Leitung  ${i7Data.id} besitzt keinen Stromkreis.`);
+        }
+
+        // Topologie
+        /* Anfang
+         * 3 moegliche Anschluesse
+         *  KontenSo -> Anschluesspunkt
+         *  KnotenSf -> Schaltfeldpunkt
+         *  KnotenZw -> Netzschlaufe -> KnotenSo -> Anschlusspunkt */
+        /*
+                const startUUID = this.integralID2UUID.get(i7Data.aknoten);
+                const targetUUID = this.integralID2UUID.get(i7Data.eknoten);
+        */
+
+        const start = this.memoryObjects.get(i7Data.aknoten);
+        // console.log(`${i7Schluessel} start ${start?.constructor.name}`);
+        if (start) {
+          const terminal = createConnection(this.cimModel, acLineSegment, start, PhaseCode.ABC, 1);
+          const baseVoltage = this.knotenSpannung.get(terminal.connectivityNodeUUID);
+          acLineSegment.baseVoltage = baseVoltage;
+
+        } else {
+          console.log(`Leitung ${i7Data.id} ${acLineSegment.mrid} besitzt keinen Anfangsknoten. ${i7Data.aknoten} ${this.integralID2UUID.get(i7Data.aknoten)}`);
+        }
+        const target = this.memoryObjects.get(i7Data.eknoten);
+        //console.log(`${i7Schluessel} target ${target?.constructor.name}`);
+        if (target) {
+          const terminal = createConnection(this.cimModel, acLineSegment, target, PhaseCode.ABC, 2);
+          const baseVoltage = this.knotenSpannung.get(terminal.connectivityNodeUUID);
+          acLineSegment.baseVoltage = baseVoltage;
+        } else {
+          console.log(`Leitung ${i7Data.id} ${acLineSegment.mrid} besitzt keinen Zielknoten.`);
+        }
+      }
+
+    } else {
+      console.log(`Tabelle ${Integral7TableNames.LEITUNG} ist nicht vorhanden.`);
+    }
+  }
+
+  async determineLeitungsTypen(leitungsIDs: number[]) {
+    // Freileitungen
+    if (this.isTableAvailable(Integral7TableNames.FREILEITUNG)) {
+      const result: Stk[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.FREILEITUNG, 0, 0, leitungsIDs));
+      for (const i7Data of result) {
+        const acLineSegment = this.cimModel.getACLineSegment(this.integralID2UUID.get(i7Data.leitung));
+        if (acLineSegment) {
+          this.setACLineSegmentProperties(acLineSegment, i7Data, 'OverheadLine');
+        } else {
+          console.log(`Freileitung ${i7Data.id} besitzt kein Leitungsobjekt.`);
+        }
+      }
+    } else {
+      console.log(`Tabelle ${Integral7TableNames.TYP_FREILEITUNG} ist nicht vorhanden.`);
+    }
+
+    // Kabel
+    if (this.isTableAvailable(Integral7TableNames.KABEL)) {
+      const result: Stk[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.KABEL, 0, 0, leitungsIDs));
+      for (const i7Data of result) {
+        const acLineSegment = this.cimModel.getACLineSegment(this.integralID2UUID.get(i7Data.leitung));
+        if (acLineSegment) {
+          this.setACLineSegmentProperties(acLineSegment, i7Data, 'Cable');
+        } else {
+          console.log(`Kabel ${i7Data.id} besitzt kein Leitungsobjekt.`);
+        }
+      }
+    } else {
+      console.log(`Tabelle ${Integral7TableNames.TYP_FREILEITUNG} ist nicht vorhanden.`);
+    }
+  }
+
+  async convertBetriebsmitteltypenTrafo() {
+    // Trafo2WTypen
+    if (this.isTableAvailable(Integral7TableNames.TYP_TRAFO2W)) {
+      const result: Trafo2w[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.TYP_TRAFO2W, 0, 0, []));
+      for (const i7Data of result) {
+        const typTrafo = new PowerTransformer2WInfo(generateUUID(), i7Data.name);
+
+        typTrafo.ukr = i7Data.ukr;
+        typTrafo.pkr = i7Data.pkr;
+        typTrafo.pLeer = i7Data.p_leer;
+        typTrafo.iLeer = i7Data.i_leer;
+
+        const typWicklung1 = new TransformerEndInfo(generateUUID());
+        typWicklung1.ratedS = new ApparentPower(i7Data.sr, UnitMultiplier.m, UnitSymbol.VA);
+        this.setTransformerEndInfoProperties(typWicklung1, i7Data, 1);
+        typWicklung1.powerTransformerInfo = typTrafo;
+        typTrafo.transformerEndInfo.push(typWicklung1);
+
+        const typWicklung2 = new TransformerEndInfo(generateUUID());
+        typWicklung2.ratedS = new ApparentPower(i7Data.sr, UnitMultiplier.m, UnitSymbol.VA);
+        // ratedS not needed
+        this.setTransformerEndInfoProperties(typWicklung2, i7Data, 2);
+        typWicklung2.powerTransformerInfo = typTrafo;
+        typTrafo.transformerEndInfo.push(typWicklung2);
+        // const aktstufe = `aktstufe_s${endNumber}`;
+        // const regelung = `regelung_s${endNumber}`;
+        // wicklung.connectionKind
+        this.cimModel.addPowerTransformer2WInfo(typTrafo);
+      }
+    } else {
+      console.log(`Tabelle ${Integral7TableNames.TYP_TRAFO2W} ist nicht vorhanden.`);
+    }
+
+    // Trafo3WTypen
+    if (this.isTableAvailable(Integral7TableNames.TYP_TRAFO3W)) {
+      const result: Trafo3w[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.TYP_TRAFO3W, 0, 0, []));
+      for (const i7Data of result) {
+        const typTrafo = new PowerTransformer3WInfo(generateUUID(), i7Data.name);
+
+        typTrafo.pLeer = i7Data.p_leer;
+        typTrafo.iLeer = i7Data.i_leer;
+
+        typTrafo.ukr12 = i7Data.ukr12;
+        typTrafo.ukr13 = i7Data.ukr13;
+        typTrafo.ukr23 = i7Data.ukr23;
+
+        typTrafo.pkr12 = i7Data.pkr12;
+        typTrafo.pkr13 = i7Data.pkr13;
+        typTrafo.pkr23 = i7Data.pkr23;
+
+        const typWicklung1 = new TransformerEndInfo(generateUUID());
+        typWicklung1.ratedS = new ApparentPower(i7Data.sr1, UnitMultiplier.m, UnitSymbol.VA);
+        this.setTransformerEndInfoProperties(typWicklung1, i7Data, 1);
+        typWicklung1.powerTransformerInfo = typTrafo;
+        typTrafo.transformerEndInfo.push(typWicklung1);
+
+        const typWicklung2 = new TransformerEndInfo(generateUUID());
+        typWicklung2.ratedS = new ApparentPower(i7Data.sr2, UnitMultiplier.m, UnitSymbol.VA);
+        this.setTransformerEndInfoProperties(typWicklung2, i7Data, 2);
+        typWicklung2.powerTransformerInfo = typTrafo;
+        typTrafo.transformerEndInfo.push(typWicklung2);
+
+        const typWicklung3 = new TransformerEndInfo(generateUUID());
+        typWicklung3.ratedS = new ApparentPower(i7Data.sr3, UnitMultiplier.m, UnitSymbol.VA);
+        this.setTransformerEndInfoProperties(typWicklung3, i7Data, 3);
+        typWicklung3.powerTransformerInfo = typTrafo;
+        typTrafo.transformerEndInfo.push(typWicklung3);
+
+        // const aktstufe = `aktstufe_s${endNumber}`;
+        // const regelung = `regelung_s${endNumber}`;
+        // wicklung.connectionKind
+
+        this.cimModel.addPowerTransformer3WInfo(typTrafo);
+      }
+    } else {
+      console.log(`Tabelle ${Integral7TableNames.TYP_TRAFO3W} ist nicht vorhanden.`);
+    }
+  }
+
+  /*  async convertTrafo2W(standortIDs: number[]) {
+      if (this.isTableAvailable(Integral7TableNames.TRAFO2W)) {
+        const result: Trafo2w[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.TRAFO2W, 0, 0, standortIDs));*/
+  async convertTrafo2W(limit: number, offset: number) {
+    if (this.isTableAvailable(Integral7TableNames.TRAFO2W)) {
+      const result: Trafo2w[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.TRAFO2W, limit, offset, []));
+      for (const i7Data of result) {
+        const powerTransformer = new PowerTransformer(getUUID(i7Data.guid), getName(i7Data), i7Data.id + '', i7Data.bezeichner);
+        const powerTransformerInfo = this.cimModel.getPowerTransformer2WInfoByName(i7Data.nametyp);
+
+        // Topologie
+        /* Anfang
+         * 3 moegliche Anschluesse
+         *  KontenSo -> Anschluesspunkt
+         *  KnotenSf -> Schaltfeldpunkt
+         *  KnotenZw -> Netzschlaufe -> KnotenSo -> Anschlusspunkt */
+        /*    const startUUID =  this.integralID2UUID.get(i7Data.aknoten);
+            const targetUUID = this.integralID2UUID.get(i7Data.eknoten);*/
+
+        // const start = this.cimModel.getObject(startUUID);
+        const start = this.memoryObjects.get(i7Data.aknoten);
+        let startTerminal;
+        if (start) {
+          startTerminal = createConnection(this.cimModel, powerTransformer, start, PhaseCode.ABC, 1);
+        } else {
+          console.log(`PowerTransformer2W ${i7Data.id} ${powerTransformer.mrid} besitzt keinen Anfangsknoten.`);
+        }
+        // const target = this.cimModel.getObject(targetUUID);
+        const target = this.memoryObjects.get(i7Data.eknoten);
+        let targetTerminal;
+        if (target) {
+          targetTerminal = createConnection(this.cimModel, powerTransformer, target, PhaseCode.ABC, 2);
+        } else {
+          console.log(`PowerTransformer2W ${i7Data.id} ${powerTransformer.mrid} besitzt keinen Zielknoten.`);
+        }
+        const schaltgruppe = i7Data.schaltgr;
+
+        // Wicklungen
+        const powerTransformerEnd1 = new PowerTransformerEnd(getUUID(i7Data.guid_w1), `W1_${powerTransformer.name}`);
+        powerTransformerEnd1.endNumber = 1;
+        powerTransformerEnd1.connectionKind = getSchaltgruppe(schaltgruppe, powerTransformerEnd1.endNumber);
+        powerTransformerEnd1.phaseAngleClock = getSchaltgruppeAngleClock(schaltgruppe, powerTransformerEnd1.endNumber);
+        const pkr = getPkrTrafo(i7Data, powerTransformerInfo, '');
+        const ukr = getUkrTrafo(i7Data, powerTransformerInfo, '') / 100; // prozente umrechnen
+
+        const sr = getSrTrafo(i7Data, powerTransformerInfo, powerTransformerEnd1.endNumber, false);
+        const ur = getUrTrafo(i7Data, powerTransformerInfo, powerTransformerEnd1.endNumber);
+        // I rated
+        const ir1 = (sr * Math.pow(10, 6) / ur * 1000) / Math.sqrt(3);
+
+        // Berechnung
+        powerTransformerEnd1.r = calculateR(ur, pkr, sr);
+        powerTransformerEnd1.x = calculateX(ur, ukr, sr, powerTransformerEnd1.r);
+        powerTransformerEnd1.g = calculateG(ur, 0);
+        powerTransformerEnd1.b = calculateB(ur, sr, 0, 0);
+        powerTransformerEnd1.ratedU = ur;
+        powerTransformerEnd1.ratedS = sr;
+
+        // Spannungsebene
+        if (powerTransformerEnd1.ratedU) {
+          let baseVoltage = this.cimModel.getBaseVoltage(powerTransformerEnd1.ratedU);
+          if (!baseVoltage) {
+            baseVoltage = createBaseVoltageIfNotExists(this.cimModel, powerTransformerEnd1.ratedU);
+          }
+          powerTransformerEnd1.baseVoltageUUID = baseVoltage.mrid;
+        } else {
+          console.log(`Wicklung2W ${i7Data.id} ${powerTransformerEnd1.endNumber} ${powerTransformerEnd1.mrid} besitzt keine Spannungsangabe.`);
+        }
+
+        // Terminal
+        const terminal = startTerminal
+        if (terminal) {
+          powerTransformerEnd1.terminalUUID = terminal.mrid;
+          this.setConductingEquipmentCurrentLimit('W1 ' + powerTransformer.name, terminal.mrid, ir1);
+        } else {
+          console.log(`Wicklung2W ${i7Data.id} ${powerTransformerEnd1.endNumber} ${powerTransformerEnd1.mrid} besitzt keine Terminalinstanz.`);
+          // console.log(`StartTerminal created ` + (startTerminal !== undefined));
+        }
+
+        powerTransformerEnd1.powerTransformerUUID = powerTransformer.mrid;
+        powerTransformer.addPowerTransformerEnd(powerTransformerEnd1);
+
+        // Stufenschalter 1
+        createTapChanger(i7Data, powerTransformerEnd1, this.cimModel, powerTransformerEnd1.ratedU);
+
+        // Wicklung 2
+        const powerTransformerEnd2 = new PowerTransformerEnd(getUUID(i7Data.guid_w2), `W2_${powerTransformer.name}`);
+        powerTransformerEnd2.endNumber = 2;
+        powerTransformerEnd2.connectionKind = getSchaltgruppe(schaltgruppe, powerTransformerEnd2.endNumber);
+        powerTransformerEnd2.phaseAngleClock = getSchaltgruppeAngleClock(schaltgruppe, powerTransformerEnd2.endNumber);
+
+        const sr2 = getSrTrafo(i7Data, powerTransformerInfo, powerTransformerEnd2.endNumber, false);
+        const ur2 = getUrTrafo(i7Data, powerTransformerInfo, powerTransformerEnd2.endNumber);
+        // Berechnung
+        powerTransformerEnd2.r = 0;
+        powerTransformerEnd2.x = 0;
+        powerTransformerEnd2.ratedS = sr2;
+        powerTransformerEnd2.ratedU = ur2;
+
+        // I rated
+        const ir2 = (sr * Math.pow(10, 6) / ur * 1000) / Math.sqrt(3);
+
+        // Spannungsebene
+        if (powerTransformerEnd2.ratedU) {
+          let baseVoltage = this.cimModel.getBaseVoltage(powerTransformerEnd2.ratedU);
+          if (!baseVoltage) {
+            baseVoltage = createBaseVoltageIfNotExists(this.cimModel, powerTransformerEnd2.ratedU);
+          }
+          powerTransformerEnd2.baseVoltageUUID = baseVoltage.mrid;
+          // powerTransformerEnd2.baseVoltage = baseVoltage;
+        } else {
+          console.log(`Wicklung ${i7Data.id} ${powerTransformerEnd2.endNumber} ${powerTransformerEnd2.mrid} besitzt keine Spannungsangabe.`);
+        }
+
+        // Terminal2
+        const terminal2 = targetTerminal;
+        if (terminal2) {
+          powerTransformerEnd2.terminalUUID = terminal2.mrid;
+          this.setConductingEquipmentCurrentLimit('W2 ' + powerTransformer.name, terminal.mrid, ir2);
+        } else {
+          console.log(`Wicklung2W ${i7Data.id} ${powerTransformerEnd2.endNumber} ${powerTransformerEnd2.mrid} besitzt keine Terminalinstanz.`);
+          console.log(`TargetTerminal created ` + (targetTerminal === undefined));
+        }
+
+        powerTransformerEnd2.powerTransformerUUID = powerTransformer.mrid;
+        powerTransformer.addPowerTransformerEnd(powerTransformerEnd2);
+
+        // Stufenschalter 2
+        createTapChanger(i7Data, powerTransformerEnd2, this.cimModel, powerTransformerEnd2.ratedU);
+
+        // Umspannanlage
+        const substationUUID = this.integralID2UUID.get(i7Data.standort);
+        if (substationUUID) {
+          powerTransformer.equipmentContainerUUID = substationUUID;
+
+          const i7Schluessel = /*substation.description*/ +
+              TRAFO2WPRAEFIX_PRAEFIX +
+            i7Data.bezeichner;
+          powerTransformer.description = i7Schluessel;
+
+        } else {
+          console.log(`Trafo2W ${i7Data.id} besitzt keine Umspannanlage.`);
+        }
+        this.cimModel.addPowerTransformer(powerTransformer);
+        this.integralID2UUID.set(i7Data.id, powerTransformer.mrid);
+      }
+    } else {
+      console.log(`Tabelle ${Integral7TableNames.TRAFO2W} ist nicht vorhanden.`);
+    }
+  }
+
+  async convertTrafo3W(limit: number, offset: number) {
+    if (this.isTableAvailable(Integral7TableNames.TRAFO3W)) {
+      const result: Trafo3w[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.TRAFO3W, limit, offset, []));
+
+      const trafoIDs = result.map(obj => obj['id']);
+
+      const trafoWicklungen = new Map<number, Trafo3wWicklung>();
+      if (this.isTableAvailable(Integral7TableNames.TRAFO3_WICKLUNG) && trafoIDs.length) {
+        const wicklungenResult: Trafo3wWicklung[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.TRAFO3_WICKLUNG, 0, 0, trafoIDs));
+        for (const wicklung of wicklungenResult) {
+          trafoWicklungen.set(wicklung.id, wicklung);
+        }
+      } else {
+        console.log(`Tabelle ${Integral7TableNames.TRAFO3_WICKLUNG} ist nicht vorhanden.`);
+      }
+
+      for (const i7Data of result) {
+        const powerTransformer = new PowerTransformer(getUUID(i7Data.guid), getName(i7Data), i7Data.id + '', i7Data.bezeichner);
+
+        const powerTransformerInfo = this.cimModel.getPowerTransformer3WInfoByName(i7Data.nametyp);
+
+        const schaltgruppe = i7Data.schaltgr;
+        // Impedanzen
+        // Topologie
+        /* Anfang
+         * 3 moegliche Anschluesse
+         *  KontenSo -> Anschluesspunkt
+         *  KnotenSf -> Schaltfeldpunkt
+         *  KnotenZw -> Netzschlaufe -> KnotenSo -> Anschlusspunkt */
+
+        const pkr12 = getPkrTrafo(i7Data, powerTransformerInfo, '12');
+        const pkr13 = getPkrTrafo(i7Data, powerTransformerInfo, '13');
+        const pkr23 = getPkrTrafo(i7Data, powerTransformerInfo, '23');
+
+        const ukr12 = getUkrTrafo(i7Data, powerTransformerInfo, '12');
+        const ukr13 = getUkrTrafo(i7Data, powerTransformerInfo, '13');
+        const ukr23 = getUkrTrafo(i7Data, powerTransformerInfo, '23');
+
+        const sr1 = getSrTrafo(i7Data, powerTransformerInfo, 1, true);
+        const sr2 = getSrTrafo(i7Data, powerTransformerInfo, 2, true);
+        const sr3 = getSrTrafo(i7Data, powerTransformerInfo, 3, true);
+
+        const ur1 = getUrTrafo(i7Data, powerTransformerInfo, 1);
+        const ur2 = getUrTrafo(i7Data, powerTransformerInfo, 2);
+        const ur3 = getUrTrafo(i7Data, powerTransformerInfo, 3);
+
+        // I rated
+        const ir1 = (sr1 * Math.pow(10, 6) / ur1 * 1000) / Math.sqrt(3);
+        const ir2 = (sr2 * Math.pow(10, 6) / ur2 * 1000) / Math.sqrt(3);
+        const ir3 = (sr3 * Math.pow(10, 6) / ur3 * 1000) / Math.sqrt(3);
+
+        //Leerlaufverluste in kW
+        const pLeer = getTrafoPleer(i7Data, powerTransformerInfo)
+        // Leerlaufstrom bezogen auf Wicklung mit dem grössten Sr in %
+        const iLeer = getTrafoIleer(i7Data, powerTransformerInfo);
+
+        // Impedanzen
+        const impedanzW1 = calculateImpedanzenTrafo3W(1, ur1, ur2, ur3,
+          sr1, sr2, sr3,
+          pkr12, pkr13, pkr23,
+          ukr12, ukr13, ukr23,
+          pLeer, iLeer);
+        const impedanzW2 = calculateImpedanzenTrafo3W(2, ur1, ur2, ur3,
+          sr1, sr2, sr3,
+          pkr12, pkr13, pkr23,
+          ukr12, ukr13, ukr23,
+          pLeer, iLeer);
+        const impedanzW3 = calculateImpedanzenTrafo3W(3, ur1, ur2, ur3,
+          sr1, sr2, sr3,
+          pkr12, pkr13, pkr23,
+          ukr12, ukr13, ukr23,
+          pLeer, iLeer);
+
+        const wicklung1 = trafoWicklungen.get(i7Data.trafowicklung3w1);
+        let terminal1, terminal2, terminal3;
+        if (wicklung1) {
+          const start = this.memoryObjects.get(wicklung1.aknoten);
+          /*          const startUUID = this.integralID2UUID.get(wicklung1.aknoten)
+                    const start = this.cimModel.getObject(startUUID);*/
+          if (start) {
+            terminal1 = createConnection(this.cimModel, powerTransformer, start, PhaseCode.ABC, 1);
+          } else {
+            console.log(`PowerTransformer ${i7Data.id} ${powerTransformer.mrid} besitzt keinen Anfangsknoten.`);
+          }
+        } else {
+          console.log(`Trafo ${i7Data.id} Wicklung 1 ${i7Data.trafowicklung3w1} ist nicht vorhanden.`);
+        }
+
+        const powerTransformerEnd1 = new PowerTransformerEnd(getUUID(i7Data.guid_w1), `W1 ${powerTransformer.name}`);
+        powerTransformerEnd1.endNumber = 1;
+
+        powerTransformerEnd1.connectionKind = getSchaltgruppe(schaltgruppe, powerTransformerEnd1.endNumber);
+        powerTransformerEnd1.phaseAngleClock = getSchaltgruppeAngleClock(schaltgruppe, powerTransformerEnd1.endNumber);
+
+
+        // Berechnung
+        powerTransformerEnd1.r = impedanzW1.r;
+        powerTransformerEnd1.x = impedanzW1.x;
+        powerTransformerEnd1.g = impedanzW1.g;
+        powerTransformerEnd1.b = impedanzW1.b;
+        powerTransformerEnd1.ratedU = ur1;
+        powerTransformerEnd1.ratedS = sr1;
+
+        // Spannungsebene
+        if (powerTransformerEnd1.ratedU) {
+          let baseVoltage = this.cimModel.getBaseVoltage(powerTransformerEnd1.ratedU);
+          if (!baseVoltage) {
+            baseVoltage = createBaseVoltageIfNotExists(this.cimModel, powerTransformerEnd1.ratedU);
+          }
+          powerTransformerEnd1.baseVoltageUUID = baseVoltage.mrid;
+        } else {
+          console.log(`Wicklung ${i7Data.id} ${powerTransformerEnd1.endNumber} ${powerTransformerEnd1.mrid} besitzt keine Spannungsangabe.`);
+        }
+
+        powerTransformerEnd1.powerTransformerUUID = powerTransformer.mrid;
+        powerTransformer.addPowerTransformerEnd(powerTransformerEnd1);
+
+        // Terminal
+        // const terminal1 = getConductingEquipmentTerminalBySecNumber(powerTransformer, powerTransformerEnd1.endNumber);
+        if (terminal1) {
+          powerTransformerEnd1.terminalUUID = terminal1.mrid;
+          this.setConductingEquipmentCurrentLimit('W1 ' + powerTransformer.name, terminal1.mrid, ir1);
+        } else {
+          console.log(`Wicklung3W ${i7Data.id} ${powerTransformerEnd1.endNumber} ${powerTransformerEnd1.mrid} besitzt keine Terminalinstanz.`);
+        }
+
+        // Wicklung 2
+        const wicklung2 = trafoWicklungen.get(i7Data.trafowicklung3w2);
+        if (wicklung2) {
+          /*    const startUUID = this.integralID2UUID.get(wicklung2.aknoten)
+              const start = this.cimModel.getObject(startUUID);*/
+          const start = this.memoryObjects.get(wicklung2.aknoten);
+          if (start) {
+            terminal2 = createConnection(this.cimModel, powerTransformer, start, PhaseCode.ABC, 2);
+          } else {
+            console.log(`PowerTransformer ${i7Data.id} ${powerTransformer.mrid} besitzt keinen Anfangsknoten.`);
+          }
+        } else {
+          console.log(`Trafo ${i7Data.id} Wicklung 2 ${i7Data.trafowicklung3w2} ist nicht vorhanden.`);
+        }
+        const powerTransformerEnd2 = new PowerTransformerEnd(getUUID(i7Data.guid_w2), `Wicklung 2 ${powerTransformer.name}`);
+        powerTransformerEnd2.endNumber = 2;
+        powerTransformerEnd2.connectionKind = getSchaltgruppe(schaltgruppe, powerTransformerEnd2.endNumber);
+        powerTransformerEnd2.phaseAngleClock = getSchaltgruppeAngleClock(schaltgruppe, powerTransformerEnd2.endNumber);
+
+        // Berechnung
+        powerTransformerEnd2.r = impedanzW2.r;
+        powerTransformerEnd2.x = impedanzW2.x;
+        powerTransformerEnd2.g = impedanzW2.g;
+        powerTransformerEnd2.b = impedanzW2.b;
+        powerTransformerEnd2.ratedS = sr2;
+        powerTransformerEnd2.ratedU = ur2;
+
+        // Spannungsebene
+        if (powerTransformerEnd2.ratedU) {
+          let baseVoltage = this.cimModel.getBaseVoltage(powerTransformerEnd2.ratedU);
+          if (!baseVoltage) {
+            baseVoltage = createBaseVoltageIfNotExists(this.cimModel, powerTransformerEnd2.ratedU);
+          }
+          powerTransformerEnd2.baseVoltageUUID = baseVoltage.mrid;
+        } else {
+          console.log(`Wicklung ${i7Data.id} ${powerTransformerEnd2.endNumber} ${powerTransformerEnd2.mrid} besitzt keine Spannungsangabe.`);
+        }
+        powerTransformerEnd2.powerTransformerUUID = powerTransformer.mrid;
+        powerTransformer.addPowerTransformerEnd(powerTransformerEnd2);
+        // Terminal2
+        /*      const terminal2 = getConductingEquipmentTerminalBySecNumber(powerTransformer, powerTransformerEnd2.endNumber);*/
+        if (terminal2) {
+          powerTransformerEnd2.terminalUUID = terminal2.mrid;
+          this.setConductingEquipmentCurrentLimit('W2 ' + powerTransformer.name, terminal2.mrid, ir2);
+        } else {
+          console.log(`Wicklung3W ${i7Data.id} ${powerTransformerEnd2.endNumber} ${powerTransformerEnd2.mrid} besitzt keine Terminalinstanz.`);
+        }
+
+        // Wicklung 3
+        const wicklung3 = trafoWicklungen.get(i7Data.trafowicklung3w3);
+        if (wicklung3) {
+          /*       const startUUID = this.integralID2UUID.get(wicklung3.aknoten)
+                 const start = this.cimModel.getObject(startUUID);*/
+          const start = this.memoryObjects.get(wicklung3.aknoten);
+          if (start) {
+            terminal3 = createConnection(this.cimModel, powerTransformer, start, PhaseCode.ABC, 3);
+          } else {
+            console.log(`PowerTransformer ${i7Data.id} ${powerTransformer.mrid} besitzt keinen Anfangsknoten.`);
+          }
+        } else {
+          console.log(`Trafo ${i7Data.id} Wicklung 3 ${i7Data.trafowicklung3w2} ist nicht vorhanden.`);
+        }
+        const powerTransformerEnd3 = new PowerTransformerEnd(getUUID(i7Data.guid_w3), `Wicklung 3 ${powerTransformer.name}`);
+        powerTransformerEnd3.endNumber = 3;
+        powerTransformerEnd3.connectionKind = getSchaltgruppe(schaltgruppe, powerTransformerEnd3.endNumber);
+        powerTransformerEnd3.phaseAngleClock = getSchaltgruppeAngleClock(schaltgruppe, powerTransformerEnd3.endNumber);
+
+        // Berechnung
+        powerTransformerEnd3.r = impedanzW3.r;
+        powerTransformerEnd3.x = impedanzW3.x;
+        powerTransformerEnd2.g = impedanzW3.g;
+        powerTransformerEnd2.b = impedanzW3.b;
+        powerTransformerEnd3.ratedS = sr3;
+        powerTransformerEnd3.ratedU = ur3;
+
+        // Spannungsebene
+        if (powerTransformerEnd3.ratedU) {
+          let baseVoltage = this.cimModel.getBaseVoltage(powerTransformerEnd3.ratedU);
+          if (!baseVoltage) {
+            baseVoltage = createBaseVoltageIfNotExists(this.cimModel, powerTransformerEnd3.ratedU);
+          }
+          powerTransformerEnd3.baseVoltageUUID = baseVoltage.mrid;
+        } else {
+          console.log(`Wicklung3W ${i7Data.id} ${powerTransformerEnd3.endNumber} ${powerTransformerEnd3.mrid} besitzt keine Spannungsangabe.`);
+        }
+
+        powerTransformerEnd3.powerTransformerUUID = powerTransformer.mrid;
+        powerTransformer.addPowerTransformerEnd(powerTransformerEnd3);
+
+        // Terminal3
+        /*const terminal3 = getConductingEquipmentTerminalBySecNumber(powerTransformer, powerTransformerEnd3.endNumber);*/
+        if (terminal3) {
+          powerTransformerEnd3.terminalUUID = terminal3.mrid;
+          this.setConductingEquipmentCurrentLimit('W3 ' + powerTransformer.name, terminal3.mrid, ir3);
+        } else {
+          console.log(`Wicklung ${i7Data.id} ${powerTransformerEnd3.endNumber} ${powerTransformerEnd3.mrid} besitzt keine Terminalinstanz.`);
+        }
+
+
+        // Umspannanlage
+        const substationUUID = this.integralID2UUID.get(i7Data.standort);
+        if (substationUUID) {
+          powerTransformer.equipmentContainerUUID = substationUUID;
+
+          const i7Schluessel = /*substation.description +*/
+            TRAFO3WPRAEFIX_PRAEFIX +
+            i7Data.bezeichner;
+          powerTransformer.description = i7Schluessel;
+
+        } else {
+          console.log(`Trafo2W ${i7Data.id} besitzt keine Umspannanlage.`);
+        }
+        this.cimModel.addPowerTransformer(powerTransformer);
+        this.integralID2UUID.set(i7Data.id, powerTransformer.mrid);
+      }
+    } else {
+      console.log(`Tabelle ${Integral7TableNames.TRAFO3W} ist nicht vorhanden.`);
+    }
+  }
+
+  async convertTrenner3f(containerIDs: number[]) {
+    if (this.isTableAvailable(Integral7TableNames.TRENNER_3P)) {
+      const result: Trenner3p[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.TRENNER_3P, 0, 0, containerIDs));
+      for (const i7Data of result) {
+        const disconnector = new Disconnector(getUUID(i7Data.guid), i7Data.bezeichner);
+        disconnector.normalOpen = convertToBooleanI7(!i7Data.schaltzustand);
+        disconnector.open = convertToBooleanI7(!i7Data.schaltzustand);
+
+        const equipmentContainer = this.cimModel.objects.get(this.integralID2UUID.get(i7Data.seliste)) as EquipmentContainer;
+
+        const cnStart = this.cimModel.getConnectivityNode(this.integralID2UUID.get(i7Data.aknoten));
+        const cnZiel = this.cimModel.getConnectivityNode(this.integralID2UUID.get(i7Data.eknoten));
+
+        if (equipmentContainer) {
+          // equipmentContainer.addEquipment(disconnector);
+          disconnector.equipmentContainerUUID = equipmentContainer.mrid;
+        } else {
+          console.log(`Disconnector ${i7Data.id} besitzt keinen EquipmentContainer.`);
+        }
+
+        if (cnStart) {
+          createConnection(this.cimModel, disconnector, cnStart, PhaseCode.ABC, 1);
+        } else {
+          console.log(`Disconnector ${i7Data.id} besitzt keinen Anfangsknoten.`);
+        }
+        if (cnZiel) {
+          createConnection(this.cimModel, disconnector, cnZiel, PhaseCode.ABC, 2);
+        } else {
+          console.log(`Disconnector ${i7Data.id} besitzt keinen Zielknoten.`);
+        }
+
+        const vl = this.cimModel.objects.get((equipmentContainer as Bay)?.voltageLevelUUID) as VoltageLevel;
+        const baseVoltage = this.cimModel.getBaseVoltageByUUID(vl?.baseVoltageUUID);
+        if (baseVoltage) {
+          disconnector.baseVoltageUUID = baseVoltage.mrid;
+        }
+
+        this.cimModel.addDisconnector(disconnector);
+        this.integralID2UUID.set(i7Data.id, disconnector.mrid);
+      }
+    } else {
+      console.log(`Tabelle ${Integral7TableNames.TRENNER_3P} ist nicht vorhanden.`);
+    }
+  }
+
+  async convertTrennerFi3f(containerIDs: number[]) {
+    if (this.isTableAvailable(Integral7TableNames.TRENNERFI_3P)) {
+      const result: Trenner3p[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.TRENNERFI_3P, 0, 0, containerIDs));
+      for (const i7Data of result) {
+        const disconnector = new Disconnector(generateUUID(), i7Data.bezeichner);
+        disconnector.normalOpen = convertToBooleanI7(i7Data.schaltzustand);
+        disconnector.open = convertToBooleanI7(i7Data.schaltzustand);
+
+        const equipmentContainer = this.cimModel.objects.get(this.integralID2UUID.get(i7Data.seliste)) as EquipmentContainer;
+
+        const cnStart = this.cimModel.getConnectivityNode(this.integralID2UUID.get(i7Data.aknoten));
+        const cnZiel = this.cimModel.getConnectivityNode(this.integralID2UUID.get(i7Data.eknoten));
+
+        if (equipmentContainer) {
+          // equipmentContainer.addEquipment(disconnector);
+          disconnector.equipmentContainerUUID = equipmentContainer.mrid;
+        } else {
+          console.log(`Disconnector Fi3 ${i7Data.id} besitzt keinen EquipmentContainer.`);
+        }
+
+        if (cnStart) {
+          createConnection(this.cimModel, disconnector, cnStart, PhaseCode.ABC, 1);
+        } else {
+          console.log(`Disconnector Fi3 ${i7Data.id} besitzt keinen Anfangsknoten.`);
+        }
+        if (cnZiel) {
+          createConnection(this.cimModel, disconnector, cnZiel, PhaseCode.ABC, 2);
+        } else {
+          console.log(`Disconnector Fi3 ${i7Data.id} besitzt keinen Zielknoten.`);
+        }
+
+        const vl = this.cimModel.objects.get((equipmentContainer as Bay)?.voltageLevelUUID) as VoltageLevel;
+        const baseVoltage = this.cimModel.getBaseVoltageByUUID(vl?.baseVoltageUUID);
+        if (baseVoltage) {
+          disconnector.baseVoltageUUID = baseVoltage.mrid;
+        }
+        this.cimModel.addDisconnector(disconnector);
+        this.integralID2UUID.set(i7Data.id, disconnector.mrid);
+      }
+    } else {
+      console.log(`Tabelle ${Integral7TableNames.TRENNERFI_3P} ist nicht vorhanden.`);
+    }
+  }
+
+  async convertLeistungsschalter(containerIDs: number[]) {
+    if (this.isTableAvailable(Integral7TableNames.LEISTUNGSSCHALTER)) {
+      const result: Leistungsschalter[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.LEISTUNGSSCHALTER, 0, 0, containerIDs));
+      for (const i7Data of result) {
+        const breaker = new Breaker(generateUUID(), i7Data.bezeichner);
+        breaker.normalOpen = convertToBooleanI7(i7Data.schaltzustand);
+        breaker.open = convertToBooleanI7(i7Data.schaltzustand);
+
+        const equipmentContainer = this.cimModel.objects.get(this.integralID2UUID.get(i7Data.seliste)) as EquipmentContainer;
+        const cnStart = this.cimModel.getConnectivityNode(this.integralID2UUID.get(i7Data.aknoten));
+        const cnZiel = this.cimModel.getConnectivityNode(this.integralID2UUID.get(i7Data.eknoten));
+        if (equipmentContainer) {
+          // equipmentContainer.addEquipment(breaker);
+          breaker.equipmentContainerUUID = equipmentContainer.mrid;
+        } else {
+          console.log(`LS ${i7Data.id} besitzt keinen EquipmentContainer.`);
+        }
+        if (cnStart) {
+          createConnection(this.cimModel, breaker, cnStart, PhaseCode.ABC, 1);
+        } else {
+          console.log(`LS ${i7Data.id} besitzt keinen Anfangsknoten.`);
+        }
+        if (cnZiel) {
+          createConnection(this.cimModel, breaker, cnZiel, PhaseCode.ABC, 2);
+        } else {
+          console.log(`LS ${i7Data.id} besitzt keinen Zielknoten.`);
+        }
+
+        const vl = this.cimModel.objects.get((equipmentContainer as Bay)?.voltageLevelUUID) as VoltageLevel;
+        const baseVoltage = this.cimModel.getBaseVoltageByUUID(vl?.baseVoltageUUID);
+        if (baseVoltage) {
+          breaker.baseVoltageUUID = baseVoltage.mrid;
+        }
+
+
+        this.cimModel.addBreaker(breaker);
+        this.integralID2UUID.set(i7Data.id, breaker.mrid);
+      }
+    } else {
+      console.log(`Tabelle ${Integral7TableNames.LEISTUNGSSCHALTER} ist nicht vorhanden.`);
+    }
+  }
+
+  /*  async convertBelastungen() {
+      if (this.isTableAvailable(Integral7TableNames.BELASTUNG)) {
+        const result: Belastung[] = await this.queryFunctionWrapper(BELASTUNG_SQL_QUERY);
+        for (const i7Data of result) {
+          const energyConsumer = new EnergyConsumer(getUUID(i7Data.guid), i7Data.bezeichner, i7Data.kurzname);
+          const inBetrieb = convertToBooleanI7(i7Data.betrieb);
+          const powerData = getActiveReactivePower(i7Data);
+
+          createSvStatus(this.cimModel, inBetrieb, energyConsumer);
+
+          energyConsumer.p = powerData[0];
+          energyConsumer.q = powerData[1];
+
+          const connectivityNode = this.cimModel.objects.get(this.integralID2UUID.get(i7Data.anschluss)) as IConnectivityNode;
+
+          if (connectivityNode) {
+            createConnection(this.cimModel, energyConsumer, connectivityNode, PhaseCode.ABC);
+
+            const equipmentContainerCn = connectivityNode.connectivityNodeContainer as EquipmentContainer;
+            if (equipmentContainerCn) {
+              const equipmentContainer = determineEquipmentContainer(equipmentContainerCn);
+              equipmentContainer.addEquipment(energyConsumer);
+              energyConsumer.equipmentContainer = equipmentContainer;
+
+              const i7Schluesel = getDescription(equipmentContainer.getSubstation()) +
+                BELASTUNG_PRAEFIX + i7Data.bezeichner;
+              energyConsumer.description = i7Schluesel;
+            } else {
+              console.log(`EnergyConsumer ${i7Data.id} besitzt keinen EquipmentContainer.`);
+            }
+
+          } else {
+            console.log(`EnergyConsumer ${i7Data.id} besitzt keinen ConnectivityNode.`);
+          }
+
+          this.cimModel.addEnergyConsumer(energyConsumer);
+          this.integralID2UUID.set(i7Data.id, energyConsumer.mrid);
+        }
+      } else {
+        console.log(`Tabelle ${Integral7TableNames.BELASTUNG} ist nicht vorhanden.`);
+      }
+    }*/
+  /*  async convertEinspeisungen() {
+      if (this.isTableAvailable(Integral7TableNames.EINSPEISUNG)) {
+        const result: Einspeisung[] = await this.queryFunctionWrapper(EINSPEISUNG_SQL_QUERY);
+        for (const i7Data of result) {
+          const energySource = new EnergySource(getUUID(i7Data.guid), getName(i7Data), i7Data.kurzname);
+          const inBetrieb = convertToBooleanI7(i7Data.betrieb);
+
+          const prio = i7Data.einspprio;
+          const usoll = i7Data.usoll;
+
+          createSvStatus(this.cimModel, inBetrieb, energySource);
+          // TODO Eispeisungen mit Spannungsregelung  als ExternalNetworkInjection?
+          const spannungsgeregelt = convertToBooleanI7(i7Data.spannungsgeregelt);
+
+          const powerData = getActiveReactivePower(i7Data);
+          energySource.activePower = powerData[0];
+          energySource.reactivePower = powerData[1];
+
+          const connectivityNode = this.cimModel.objects.get(this.integralID2UUID.get(i7Data.anschluss)) as IConnectivityNode;
+
+          if (connectivityNode) {
+            createConnection(this.cimModel, energySource, connectivityNode, PhaseCode.ABC);
+
+            const equipmentContainerCn = connectivityNode.connectivityNodeContainer as EquipmentContainer;
+            if (equipmentContainerCn) {
+              const equipmentContainer = determineEquipmentContainer(equipmentContainerCn);
+              equipmentContainer.addEquipment(energySource);
+              energySource.equipmentContainer = equipmentContainer;
+
+              const i7Schluesel = getDescription(equipmentContainer.getSubstation()) +
+                EINSPEISUNG_PRAEFIX + i7Data.bezeichner;
+              energySource.description = i7Schluesel;
+
+            } else {
+              console.log(`EnergySource ${i7Data.id} besitzt keinen EquipmentContainer.`);
+            }
+          } else {
+            console.log(`EnergySource ${i7Data.id} besitzt keinen ConnectivityNode.`);
+          }
+
+          // ToDo PSRType
+
+          this.cimModel.addEnergySource(energySource);
+          this.integralID2UUID.set(i7Data.id, energySource.mrid);
+        }
+      } else {
+        console.log(`Tabelle ${Integral7TableNames.EINSPEISUNG} ist nicht vorhanden.`);
+      }
+    }*/
+  /*  async convertBoundaryInjections() {
+      if (this.isTableAvailable(Integral7TableNames.BOUNDARYINJECTION)) {
+        const result: RandnetzEinspeisung[] = await this.queryFunctionWrapper(BOUNDARYINJECTION_SQL_QUERY);
+        for (const i7Data of result) {
+          const externalNetworkInjection = new ExternalNetworkInjection(getUUID(i7Data.guid), getName(i7Data), i7Data.kurzname);
+
+          const inBetrieb = convertToBooleanI7(i7Data.betrieb);
+          createSvStatus(this.cimModel, inBetrieb, externalNetworkInjection);
+
+          const prio = i7Data.einspprio;
+          const usoll = i7Data.usoll;
+
+
+          const spannungsgeregelt = convertToBooleanI7(i7Data.spannungsgeregelt);
+
+          externalNetworkInjection.p = getNumber(i7Data.p_ersatznetz ) + getNumber(i7Data.p_restnetz);
+          externalNetworkInjection.q = getNumber(i7Data.q_ersatznetz) + getNumber(i7Data.q_restnetz);
+
+          externalNetworkInjection.governorSCD = getNumber(i7Data.kr);
+          externalNetworkInjection.referencePriority = getNumber(i7Data.einspprio);
+          /!*        externalNetworkInjection.maxR0ToX0Ratio = 1/(/x0/r0)
+                  externalNetworkInjection.maxR1ToX1Ratio = (1/x1/r1)*!/
+          externalNetworkInjection.maxZ0ToZ1Ratio = getNumber(i7Data.z0_z1);
+          const connectivityNode = this.cimModel.objects.get(this.integralID2UUID.get(i7Data.anschluss)) as IConnectivityNode;
+
+          if (connectivityNode) {
+            createConnection(this.cimModel, externalNetworkInjection, connectivityNode, PhaseCode.ABC);
+
+            const equipmentContainerCn = connectivityNode.connectivityNodeContainer as EquipmentContainer;
+            if (equipmentContainerCn) {
+              const equipmentContainer = determineEquipmentContainer(equipmentContainerCn);
+              equipmentContainer.addEquipment(externalNetworkInjection);
+              externalNetworkInjection.equipmentContainer = equipmentContainer;
+
+              const i7Schluesel = getDescription(equipmentContainer.getSubstation()) +
+                EINSPEISUNG_PRAEFIX + i7Data.bezeichner;
+              externalNetworkInjection.description = i7Schluesel;
+
+            } else {
+              console.log(`BoundaryInjection ${i7Data.id} besitzt keinen EquipmentContainer.`);
+            }
+          } else {
+            console.log(`BoundaryInjection ${i7Data.id} besitzt keinen ConnectivityNode.`);
+          }
+
+          // ToDo PSRType
+
+          this.cimModel.addExternalNetworkInjection(externalNetworkInjection);
+          this.integralID2UUID.set(i7Data.id, externalNetworkInjection.mrid);
+        }
+      } else {
+        console.log(`Tabelle ${Integral7TableNames.EINSPEISUNG} ist nicht vorhanden.`);
+      }
+    }*/
+
+  /*  async convertGeneratoren() {
+      // Generatoren werden als GeneratingUnit und SynchronousMachine abgebildet
+      if (this.isTableAvailable(Integral7TableNames.GENERATOR)) {
+        const result: Generator[] = await this.queryFunctionWrapper(GENERATOR_SQL_QUERY);
+        for (const i7Data of result) {
+          const synchronousMachine = new SynchronousMachine(getUUID(i7Data.guid), i7Data.bezeichner, i7Data.kurzname);
+
+          const s = getActiveReactivePower(i7Data);
+          const s0 = getNumber(i7Data.sr);
+          synchronousMachine.ratedS = s0 === 0 ? s[0] : s0;
+          synchronousMachine.ratedU = i7Data.ur;
+
+          synchronousMachine.type = SynchronousMachineKind.generator;
+          synchronousMachine.referencePriority = i7Data.einspprio;
+
+          const maxQ = getNumber(i7Data.q_max);
+          synchronousMachine.maxQ = maxQ !== 0 ? maxQ : getNumber(i7Data.qmax_von_pmax);
+          const minQ = getNumber(i7Data.q_min);
+          synchronousMachine.minQ = minQ !== 0 ? minQ : getNumber(i7Data.qmin_von_pmin);
+
+          const reactiveCapabilityCurve = new ReactiveCapabilityCurve(generateUUID(), 'CurveData');
+          reactiveCapabilityCurve.curveStyle = CurveStyle.straightLineYValues;
+          reactiveCapabilityCurve.xUnit = UnitSymbol.W;
+          reactiveCapabilityCurve.y1Unit = UnitSymbol.VAr;
+          reactiveCapabilityCurve.y2Unit = UnitSymbol.VAr;
+
+          const curveData1 = new CurveData(generateUUID());
+          curveData1.curve = reactiveCapabilityCurve;
+          curveData1.xvalue = i7Data.p_min; //pMin
+          curveData1.y1value = i7Data.qmin_von_pmin;//qMin pMin
+          curveData1.y2value = i7Data.qmax_von_pmin;//qMay pMin
+          this.cimModel.addCurveData(curveData1);
+
+          const curveData2 = new CurveData(generateUUID());
+          curveData2.curve = reactiveCapabilityCurve;
+          curveData2.xvalue = i7Data.p_max; //pMin
+          curveData2.y1value = i7Data.qmin_von_pmax//qMin pMin
+          curveData2.y2value = i7Data.qmax_von_pmax;//qMay pMin
+          this.cimModel.addCurveData(curveData2);
+
+          this.cimModel.addReactiveCapabilityCurve(reactiveCapabilityCurve);
+          synchronousMachine.initialReactiveCapabilityCurve = reactiveCapabilityCurve;
+
+
+          const inBetrieb = convertToBooleanI7(i7Data.betrieb);
+          createSvStatus(this.cimModel, inBetrieb, synchronousMachine);
+
+
+          synchronousMachine.ratedPowerFactor =  i7Data.cosphir ?  i7Data.cosphir : 0;
+          synchronousMachine.qPercent = i7Data.cos_phi ? (1 -  i7Data.cosphir) : 0;
+
+          synchronousMachine.earthing = false;
+          // synchronousMachine.r: number;
+          // synchronousMachine.r0: number;
+          // synchronousMachine.r2: number;
+          // synchronousMachine.x0: number;
+          // synchronousMachine.x2: number;
+          synchronousMachine.satDirectSubtransX = i7Data.xd2s ?  i7Data.xd2s : 0;
+
+          // synchronousMachine.earthingStarPointR
+          // synchronousMachine.earthingStarPointX
+          // ynchronousMachine.ikk: number;
+          // synchronousMachine.mu: number;
+
+          // synchronousMachine.satDirectSyncX: number;
+          // synchronousMachine.satDirectTransX: number;
+          // synchronousMachine.shortCircuitRotorType: ShortCircuitRotorKind;
+          // synchronousMachine.voltageRegulationRange: number;
+
+          // RegulatingControl
+          const regulatingControl = new RegulatingControl(generateUUID(), `RegulatingControl_${synchronousMachine.name}`);
+          switch (i7Data.spannungsgeregelt) {
+            case 1: {
+              regulatingControl.mode = RegulatingControlModeKind.voltage;
+            }
+          }
+          synchronousMachine.regulatingControl = regulatingControl;
+          regulatingControl.addRegulatingCondEq(synchronousMachine);
+
+
+          // GeneratingUnit
+          const generatingUnitConfig = FUEL_TYPE_CONFIG[i7Data.nameprimaertyp];
+
+          /!** Wenn ein Config für den Primärenergietyp vorhanden*!/
+          let generatingUnit;
+
+          if (generatingUnitConfig) {
+            switch (generatingUnitConfig.class) {
+              case 'ThermalGeneratingUnit': {
+                generatingUnit = new ThermalGeneratingUnit(getUUID(''), 'Generator_' + i7Data.bezeichner, i7Data.kurzname, i7Data.nameprimaertyp);
+                if (generatingUnitConfig.fuelType) {
+                  generateFuelType(i7Data.nameprimaertyp, generatingUnitConfig.fuelType, generatingUnit, this.cimModel);
+                }
+                break;
+              }
+              case 'SolarGeneratingUnit': {
+                generatingUnit = new SolarGeneratingUnit(getUUID(''), 'Generator_' + i7Data.bezeichner, i7Data.kurzname, i7Data.nameprimaertyp);
+                break;
+              }
+              case 'WindGeneratingUnit': {
+                generatingUnit = new WindGeneratingUnit(getUUID(''), 'Generator_' + i7Data.bezeichner, i7Data.kurzname, i7Data.nameprimaertyp);
+                switch (generatingUnitConfig.fuelType) {
+                  case 'onshore':
+                    generatingUnit.windGenUnitType = WindGenUnitKind.onshore;
+                    break;
+                  case 'offshore':
+                    generatingUnit.windGenUnitType = WindGenUnitKind.offshore;
+                    break;
+                }
+                break;
+              }
+              case 'NuclearGeneratingUnit': {
+                generatingUnit = new NuclearGeneratingUnit(getUUID(''), 'Generator_' + i7Data.bezeichner, i7Data.kurzname);
+                break;
+              }
+            }
+          }
+
+          if(!generatingUnit) {
+            generatingUnit = new GeneratingUnit(getUUID(''), 'Generator_' + i7Data.bezeichner, i7Data.kurzname);
+          }
+
+          generatingUnit.maxOperatingP = getNumber(i7Data.p_max);
+          generatingUnit.minOperatingP = getNumber(i7Data.p_min);
+
+          generatingUnit.initialP = i7Data.p0;
+          generatingUnit.nominalP = generatingUnit.maxOperatingP;
+
+          generatingUnit.genControlSource = GeneratorControlSource.unavailable;
+
+
+
+          generatingUnit.addRotatingMachine(synchronousMachine);
+          synchronousMachine.generatingUnit = generatingUnit;
+
+          const connectivityNode = this.cimModel.objects.get(this.integralID2UUID.get(i7Data.anschluss)) as IConnectivityNode;
+
+          if (connectivityNode) {
+            const terminal =  createConnection(this.cimModel, synchronousMachine, connectivityNode, PhaseCode.ABC);
+            regulatingControl.terminal = terminal;
+            const equipmentContainerCn = connectivityNode.connectivityNodeContainer as EquipmentContainer;
+            if (equipmentContainerCn) {
+              const equipmentContainer = determineEquipmentContainer(equipmentContainerCn);
+              equipmentContainer.addEquipment(synchronousMachine);
+              synchronousMachine.equipmentContainer = equipmentContainer;
+
+              equipmentContainer.addEquipment(generatingUnit);
+              generatingUnit.equipmentContainer = equipmentContainer;
+
+              const i7Schluesel = getDescription(equipmentContainer.getSubstation()) +
+                GENERATOR_PRAEFIX + i7Data.bezeichner;
+              synchronousMachine.description = i7Schluesel;
+
+            } else {
+              console.log(`SynchronousMachine ${i7Data.id} besitzt keinen EquipmentContainer.`);
+            }
+          } else {
+            console.log(`SynchronousMachine ${i7Data.id} besitzt keinen ConnectivityNode.`);
+          }
+
+          this.cimModel.addRegulatingControl(regulatingControl);
+          this.cimModel.addGeneratingUnit(generatingUnit);
+          this.cimModel.addSynchronousMachine(synchronousMachine);
+          this.integralID2UUID.set(i7Data.id, synchronousMachine.mrid);
+
+        }
+      }
+    }*/
+
+  /*  async convertAsynchronmotor() {
+      // Generatoren werden als GeneratingUnit und SynchronousMachine abgebildet
+      if (this.isTableAvailable(Integral7TableNames.ASYNCHRONMOTOR)) {
+        const result: Asynchronmotor[] = await this.queryFunctionWrapper(ASYNCHRONMOTOR_SQL_QUERY);
+        for (const i7Data of result) {
+          const asynchronousMachine = new AsynchronousMachine(getUUID(i7Data.guid), getName(i7Data), i7Data.bezeichner, i7Data.kurzname);
+          asynchronousMachine.efficiency = i7Data.wirkungsgrad * 100;
+          asynchronousMachine.iaIrRatio = i7Data.ilr_ir;
+          asynchronousMachine.rxLockedRotorRatio = 0;
+          asynchronousMachine.polePairNumber = i7Data.polpaarz;
+          asynchronousMachine.ratedMechanicalPower = i7Data.p_mech;
+          asynchronousMachine.ratedPowerFactor = i7Data.cos_phir;
+
+          asynchronousMachine.ratedS = i7Data.sr;
+          asynchronousMachine.ratedU = i7Data.ur;
+
+          asynchronousMachine.p = i7Data.p0;
+          asynchronousMachine.q = i7Data.flag_ind === 1 ? i7Data.q0_ind : i7Data.q0_kap;
+          asynchronousMachine.asynchronousMachineType = AsynchronousMachineKind.motor;
+          asynchronousMachine.controlEnabled = false;
+
+          const inBetrieb = convertToBooleanI7(i7Data.betrieb);
+          createSvStatus(this.cimModel, inBetrieb, asynchronousMachine);
+
+          const connectivityNode = this.cimModel.objects.get(this.integralID2UUID.get(i7Data.anschluss)) as IConnectivityNode;
+
+          if (connectivityNode) {
+            createConnection(this.cimModel, asynchronousMachine, connectivityNode, PhaseCode.ABC);
+
+            const equipmentContainerCN = connectivityNode.connectivityNodeContainer as EquipmentContainer;
+            if (equipmentContainerCN) {
+              const equipmentContainer = determineEquipmentContainer(equipmentContainerCN);
+
+              equipmentContainer.addEquipment(asynchronousMachine);
+              asynchronousMachine.equipmentContainer = equipmentContainer;
+
+              const i7Schluesel = getDescription(equipmentContainer.getSubstation()) +
+                EINSPEISUNG_PRAEFIX + i7Data.bezeichner;
+              asynchronousMachine.description = i7Schluesel;
+
+              this.cimModel.addAsynchronousMachine(asynchronousMachine);
+              this.integralID2UUID.set(i7Data.id, asynchronousMachine.mrid);
+
+            } else {
+              console.log(`AsynchronousMachine ${i7Data.id} besitzt keinen EquipmentContainer.`);
+            }
+          } else {
+            console.log(`AsynchronousMachine ${i7Data.id} besitzt keinen ConnectivityNode.`);
+          }
+
+        }
+      } else {
+        console.log(`Tabelle ${Integral7TableNames.ASYNCHRONMOTOR} ist nicht vorhanden.`);
+      }
+    }*/
+
+  /**------------------Schema----------------------------*/
+  async convertNetzvarianten() {
+    if (this.isTableAvailable(Integral7TableNames.NETZVARIANTEN)) {
+      const result: Netzvarianten[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.NETZVARIANTEN, 0, 0, []));
+      for (const i7Data of result) {
+        // this.allg_netzvarianten.set(i7Data.id, i7Data);
+        /** Netzschemas art mit der id 2 */
+        if (i7Data.art === 2) {
+          const diagram = new Diagram(getUUID(i7Data.guid), i7Data.name, String(i7Data.id));
+          diagram.orientation = OrientationKind.negative;
+          diagram.diagramStyle = this.cimModel.getDiagramStyle(DIAGRAM_LAYOUT_TYPES.NODE_BREAKER);
+          this.cimModel.addDiagram(diagram);
+          this.integralID2UUID.set(i7Data.id, diagram.mrid);
+        }
+      }
+    } else {
+      console.log(`Tabelle ${Integral7TableNames.NETZVARIANTEN} ist nicht vorhanden.`);
+    }
+  }
+
+  private setWireInfoProperties(object: WireInfo, data: StkTyp) {
+    /*    object.r1 = new ResistancePerLength(data.r1, UnitMultiplier.none, UnitSymbol.ohm);
+        object.x1 = new ReactancePerLength(data.x1, UnitMultiplier.none, UnitSymbol.ohm);
+        object.c1 = new CapacitancePerLength(data.c1, UnitMultiplier.micro, UnitSymbol.F);
+
+        object.r0 = new ResistancePerLength(data.r1, UnitMultiplier.none, UnitSymbol.ohm);
+        object.x0 = new ReactancePerLength(data.x1, UnitMultiplier.none, UnitSymbol.ohm);
+        object.c0 = new CapacitancePerLength(data.c1, UnitMultiplier.micro, UnitSymbol.F);
+
+        object.ratedCurrent = new CurrentFlow(data.ir, UnitMultiplier.none, UnitSymbol.A);*/
+    object.r1 = +data.r1;
+    object.x1 = +data.x1;
+    object.c1 = new CapacitancePerLength(data.c1, UnitMultiplier.micro, UnitSymbol.F)
+
+    object.r0 = new ResistancePerLength(data.r1, UnitMultiplier.none, UnitSymbol.ohm);
+    object.x0 = new ReactancePerLength(data.x1, UnitMultiplier.none, UnitSymbol.ohm);
+    object.c0 = new CapacitancePerLength(data.c1, UnitMultiplier.micro, UnitSymbol.F);
+
+    object.ratedCurrent = +data.ir;
+  }
+
+
+  private setACLineSegmentProperties(acLineSegment: ACLineSegment, data: Stk, psrTypeName: string) {
+    // acLineSegment.description = data.nametyp;
+
+    // Spannungsebene
+    if (!acLineSegment.baseVoltage) {
+      let baseVoltage;
+      if (data.un && data.un > 0) {
+        baseVoltage = createBaseVoltageIfNotExists(this.cimModel, data.un);
+      } else {
+        baseVoltage = createBaseVoltageIfNotExists(this.cimModel, 110);
+      }
+      acLineSegment.baseVoltage = baseVoltage;
+    }
+
+    // Laenge
+    if (data.laenge) {
+      acLineSegment.length = data.laenge;
+    } else {
+      //console.log(`Stromkreissbschnitt ${data.id} besitzt keine Längenangabe. Annahme der Länge: 0.1 km. `);
+    }
+
+    const assetType = this.cimModel.getWireInfoByName(data.nametyp);
+    // r0
+    if (data.r0 && data.r0 !== 0) {
+      acLineSegment.r0 = data.laenge <= 0 ? data.r0 : data.r0 /*/ data.laenge*/;
+    } else {
+      // console.log(`Stromkreissbschnitt ${data.id} ${acLineSegment.mrid} r0 ist 0. Btyp. `);
+      if (assetType) {
+        // acLineSegment.r0 = assetType.r0.value * acLineSegment.length;
+        acLineSegment.r0 = assetType.r0.value * acLineSegment.length;
+        // console.log(`\tBtyp r0 ist ${acLineSegment.r0}`);
+      }
+    }
+
+    // x0
+    if (data.x0 && data.x0 !== 0) {
+      acLineSegment.x0 = data.laenge <= 0 ? data.x0 : data.x0 /*/ data.laenge*/;
+    } else {
+      // console.log(`Stromkreissbschnitt ${data.id} ${acLineSegment.mrid} x0 ist 0. Btyp. `);
+      if (assetType) {
+        // acLineSegment.x0 = assetType.x0.value * acLineSegment.length;
+        acLineSegment.x0 = assetType.x0.value * acLineSegment.length;
+        // console.log(`\tBtyp x0 ist ${acLineSegment.x0}`);
+      }
+    }
+
+    // r1
+    if (data.r1 && data.r1 !== 0) {
+      acLineSegment.r = data.laenge <= 0 ? data.r1 : data.r1 /*/ data.laenge*/;
+    } else {
+      // console.log(`Stromkreissbschnitt ${data.id} ${acLineSegment.mrid} r1 ist 0. Btyp. `);
+      if (assetType) {
+        // acLineSegment.r = assetType.r1.value * acLineSegment.length;
+        acLineSegment.r = assetType.r1 * data.laenge;
+        // console.log(`\tBtyp r1 ist ${acLineSegment.r}`);
+      }
+    }
+
+    // x1
+    if (data.x1 && data.x1 !== 0) {
+      acLineSegment.x = data.laenge <= 0 ? data.x1 : data.x1 /*/ data.laenge*/;
+    } else {
+      // console.log(`Stromkreissbschnitt ${data.id} ${acLineSegment.mrid} x1 ist 0. Btyp. `);
+      if (assetType) {
+        // acLineSegment.x = assetType.x1.value * acLineSegment.length;
+        acLineSegment.x = assetType.x1 * data.laenge;
+        // console.log(`\tBtyp x1 ist ${acLineSegment.x}`);
+      }
+    }
+
+    // ir
+    for (const terminalUUID of acLineSegment.terminalsUUIDs) {
+      if (data.ir && data.ir !== 0) {
+        this.setConductingEquipmentCurrentLimit(acLineSegment.name, terminalUUID, data.ir);
+      } /*else {
+        console.log(`Stromkreissbschnitt ${data.id} ${acLineSegment.mrid} ir ist 0. `);
+      }*/
+      else if (assetType && assetType.ratedCurrent && assetType.ratedCurrent !== 0) {
+        this.setConductingEquipmentCurrentLimit(acLineSegment.name, terminalUUID, assetType.ratedCurrent);
+      } else {
+        // console.log(`Stromkreissbschnitt ${data.id} ${acLineSegment.mrid} ir ist 0 und hat keinen Assettyp`);
+      }
+
+    }
+    //PSRType
+    const psrType = createIfNotExitsPSRType(this.cimModel, psrTypeName);
+    acLineSegment.psrTypeUUID = psrType.mrid;
+    // psrType.addPowerSystemResource(acLineSegment);
+  }
+
+  private setConductingEquipmentCurrentLimit(name: string, terminalUUID: string, ir: number) {
+    const currentLimit = new CurrentLimit(generateUUID(), `${name}`);
+    this.cimModel.addCurrentLimit(currentLimit);
+    currentLimit.value = new CurrentFlow(ir, UnitMultiplier.none, UnitSymbol.A);
+
+
+    const operationalLimitSet = new OperationalLimitSet(generateUUID(), `${name}`);
+    this.cimModel.addOperationalLimitSet(operationalLimitSet);
+    // operationalLimitSet.addOperationalLimit(currentLimit);
+    currentLimit.operationalLimitSetUUID = operationalLimitSet.mrid;
+
+    const operationalLimitType = this.getOperationalLimitType('patl');
+    // operationalLimitType.addOperationalLimit(currentLimit);  speicher
+    currentLimit.operationalLimitTypeUUID = operationalLimitType.mrid;
+
+    // terminal.addOperationalLimitSet(operationalLimitSet); speicher
+    operationalLimitSet.terminalUUID = terminalUUID;
+  }
+
+  private getOperationalLimitType(name: string) {
+    let operationalLimitType = this.cimModel.getOperationalLimitTypeByName(name);
+    if (!operationalLimitType) {
+      operationalLimitType = new OperationalLimitType(generateUUID(), name);
+      operationalLimitType.direction = OperationalLimitDirectionKind.absoluteValue;
+      operationalLimitType.limitType = LimitTypeKind.patl;
+      this.cimModel.addOperationalLimitType(operationalLimitType);
+    }
+    return operationalLimitType;
+  }
+
+  private setTransformerEndInfoProperties(wicklung: TransformerEndInfo, data: any, endNumber: number) {
+
+    const minstufe = `minstufe_s${endNumber}`;
+    const mittelstufe = `mittelstufe_s${endNumber}`;
+    const maxstufe = `maxstufe_s${endNumber}`;
+    const umax = `umax_s${endNumber}`;
+    const umin = `umin_s${endNumber}`;
+    const gestufte_seite = `gestufte_seite_s${endNumber}`;
+
+    const ur = `ur${endNumber}`;
+
+    wicklung.endNumber = endNumber;
+    wicklung.ratedU = new Voltage(data[ur], UnitMultiplier.k, UnitSymbol.V);
+    wicklung.tapActiv = convertToBooleanI7(data[gestufte_seite]);
+
+    const tapChangerInfo = new TapChangerInfo(generateUUID(), `TapChangerInfo_${data['id']}`);
+    tapChangerInfo.highStep = data[maxstufe];
+    tapChangerInfo.lowStep = data[minstufe];
+    tapChangerInfo.neutralStep = data[mittelstufe];
+
+    wicklung.uMax = data[umax];
+    wicklung.uMin = data[umin];
+
+  }
+
+
+  async convertSchemaBayElements(bay: Bay, diagram: Diagram, saAusrichtung: number, deltaAusrichtung: number) {
+    for (const eqiup of bay.equipments) {
+      if (eqiup instanceof Disconnector) {
+        const disconnector = eqiup as Disconnector;
+
+        for (const terminal of disconnector.terminals.values()) {
+          const connectedCE = isConnectedTo(terminal.connectivityNode as ConnectivityNode, 'BusbarSection');
+          if (connectedCE && terminal.connectivityNode.diagramObjects.length > 0) {
+            const diagramObjectSSAB = getDiagramObjectBelonginToDiagram(terminal.connectivityNode.diagramObjects, diagram.mrid);
+            const diagramObjectBay = getDiagramObjectBelonginToDiagram(bay.diagramObjects, diagram.mrid);
+            if (diagramObjectSSAB && diagramObjectBay) {
+              const diagramObject = new DiagramObject(getUUID(''), 'SSAB Trenner');
+              if (saAusrichtung === 0) { // oben/waagerecht
+                const x = diagramObjectBay.diagramObjectPoints[0].xPosition + 16;
+                const y = diagramObjectSSAB.diagramObjectPoints[0].yPosition + 0.5;
+                const points = [new Point(x, y)];
+                createDiagramObjectPoints(diagramObject, points);
+                eqiup.addDiagramObject(diagramObject);
+                diagramObject.identifiedObject = eqiup;
+                diagram.addDiagramObject(diagramObject);
+                diagramObject.diagram = diagram;
+              }
+            }
+          } else {
+
+          }
+        }
+      }
+    }
+  }
+
+  private writeHeaderStart(xmlWriter: XMLWriter, profileURI?: string) {
+    xmlWriter.startDocument('1.0', 'UTF-8');
+    /** <rdf:RDF xmlns:...>*/
+    xmlWriter.startElementNS(RDF_XML.RDF_NS_PREFIX, 'RDF', RDF_XML.RDF_NS);
+
+    writeElementAttribute(xmlWriter, `xmlns:${RDF_XML.RDF_NS_PREFIX}`, RDF_XML.RDF_NS);
+    writeElementAttribute(xmlWriter, `xmlns:${RDF_XML.CIM_NS_PREFIX}`, RDF_XML.CIM_NS_16);
+    writeElementAttribute(xmlWriter, `xmlns:${RDF_XML.ENTSOE_NS_PREFIX}`, RDF_XML.ENTSOE_NS);
+    writeElementAttribute(xmlWriter, `xmlns:${RDF_XML.MD_NS_PREFIX}`, RDF_XML.MD_NS);
+
+    if (profileURI === RDF_XML.AMP_I7_PROFILE_URI) {
+      writeElementAttribute(xmlWriter, `xmlns:${RDF_XML.AMPRION_NS_PREFIX}`, RDF_XML.AMPRION_NS);
+      writeElementAttribute(xmlWriter, `xmlns:${RDF_XML.IPS_NS_PREFIX}`, RDF_XML.IPS_NS);
+      writeElementAttribute(xmlWriter, `xmlns:${RDF_XML.CAPE_NS_PREFIX}`, RDF_XML.CAPE_NS);
+    }
+  }
+
+  private writeHeaderEnd(xmlWriter: XMLWriter) {
+    /** </rdf:RDF>*/
+    xmlWriter.endElement();
+    xmlWriter.endDocument();
+  }
+
+  private objectToCIMXML(xmlWriter: XMLWriter, values: Map<string, IIdentifiedObject>, profileName: string) {
+    for (const object of values.values()) {
+      object.toCIMXML(xmlWriter, profileName);
+    }
+  }
+
+  private objectArrayToCIMXML(xmlWriter: XMLWriter, values: any[], profileName: string) {
+    for (const object of values) {
+      object.toCIMXML(xmlWriter, profileName);
+    }
+  }
+
+  private checkMemoryObject(i7ID: number, cimObject: IdentifiedObject) {
+    /** Wenn an diesem Knoten eine Leitung/Trafo angeschlossen ist, dann belasse dieses Objekt im Speicher. */
+    if (this.leitungAnschlussKnotenIDs.has(i7ID)) {
+      this.memoryObjects.set(i7ID, cimObject);
+    }
+  }
+
+  queryFunctionWrapper(query): Promise<any> {
+    return new Promise((resolve, reject) => {
+      this.queryFunction(query, (successResponse) => {
+        resolve(successResponse);
+      }, (errorResponse) => {
+        reject(errorResponse)
+      });
+    });
+  }
+
+  queryFunction(query, successCallback, errorCallback) {
+    this.mysqlConnection.query(query, (error, results, fields) => {
+      if (error) errorCallback(error);
+      successCallback(results);
+    });
+  }
+
+  private isTableAvailable(tableName: string): boolean {
+    return this.availableTableNames.indexOf(tableName) > -1 ? true : false;
+  }
+
+  private initDbConnection(mySqlConfig: MySQL) {
+    this.mysqlConnection = mysql.createConnection({
+      host: mySqlConfig.host,
+      port: mySqlConfig.port,
+      database: mySqlConfig.database,
+      user: mySqlConfig.user,
+      password: mySqlConfig.password,
+    });
+  }
+
+  openConnection() {
+    this.mysqlConnection.connect();
+  }
+
+  closeConnection() {
+    this.mysqlConnection.end();
+  }
+
+}