@enervance/insight-cim-model 0.0.1 → 0.0.3

package/src/converter/integral7/ConverterIntegral7.ts

@@ -1,6 +1,6 @@
 import {
   ACLineSegment,
-  ApparentPower, BaseVoltage,
+  ApparentPower, AsynchronousMachine, AsynchronousMachineKind, BaseVoltage,
   Bay,
   Breaker,
   BusbarSection,
@@ -22,7 +22,7 @@ import {
   Disconnector,
   EnergyConsumer,
   EnergySource,
-  EquipmentContainer,
+  EquipmentContainer, EquivalentBranch,
   generateUUID,
   GeneratingUnit,
   GeneratorControlSource,
@@ -51,7 +51,7 @@ import {
   ReactiveCapabilityCurve,
   RegulatingControl,
   RegulatingControlModeKind,
-  ResistancePerLength,
+  ResistancePerLength, SeriesCompensator,
   SolarGeneratingUnit,
   SubGeographicalRegion,
   Substation,
@@ -72,15 +72,15 @@ import * as mysql from 'mysql';
 import {
   Abzweig,
   Anlage,
-  AnlagenAbschnitt,
+  AnlagenAbschnitt, Asynchronmotor,
   Belastung,
   Einspeisung,
   Generator,
   Georegion,
   KnotenKf,
   KnotenLk,
-  Laengskupplung,
-  Leistungsschalter,
+  Laengskupplung, Ldrossel,
+  Leistungsschalter, LeitungErsatzLaengszweig,
   LeitungStk,
   Netzvarianten,
   NsgKnotenSo,
@@ -111,7 +111,7 @@ import {
 } from '../../util/utils';
 import {
   BELASTUNG_PRAEFIX,
-  EINSPEISUNG_PRAEFIX,
+  EINSPEISUNG_PRAEFIX, ERSATZLAENGSZWEIG_PRAEFIX,
   GENERATOR_PRAEFIX,
   KNOTEN_STANDORT_PRAEFIX,
   LEITUNG_PRAEFIX,
@@ -129,10 +129,9 @@ import {
   calculateX,
   convertToBooleanI7,
   createTapChanger,
-  createTempDirPath,
   createWriteStreamPromise,
   determineEquipmentContainer,
-  generateFuelType,
+  generateFuelType, generateNodeStream,
   getActiveReactivePower,
   getDescription,
   getLine,
@@ -146,7 +145,7 @@ import {
   getSrTrafo,
   getTerminalUn,
   getTrafoIleer,
-  getTrafoPleer,
+  getTrafoPleer, getU,
   getUkrTrafo,
   getUrTrafo,
   putUUIDtoI7Ids,
@@ -154,7 +153,7 @@ import {
   writeZipFile
 } from './utils';
 import { calculateImpedanzenTrafo3W } from './utils-trafo3w';
-import { FUEL_TYPE_CONFIG } from './config/generation-unit-fuel-types';
+// 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";
@@ -178,11 +177,29 @@ 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';
+import { AMPRIONSeriesCompensator } from '../../model/extensions/amprion/wires/AMPRIONSeriesCompensator';
+import { Kopfstation } from './model/integral/Kopfstation';
+import { Hgueleitung } from './model/integral/Hgueleitung';
+import { CsConverter } from '../../model/dc/CsConverter';
+import { DCConverterUnit } from '../../model/dc/DCConverterUnit';
+import { DCNode } from '../../model/dc/DCNode';
+import { DCLine } from '../../model/dc/DCLine';
+import { ACDCConverterDCTerminal } from '../../model/dc/ACDCConverterDCTerminal';
+import { DCTerminal } from '../../model/dc/DCTerminal';
+import { DCLineSegment } from '../../model/dc/DCLineSegment';
+import { ACDCConverter } from '../../model/dc/ACDCConverter';
+import { DCConverterOperatingModeKind } from '../../model/dc/DCConverterOperatingModeKind';
+import { VsConverter } from '../../model/dc/VsConverter';
+import { CsOperatingModeKind } from '../../model/dc/CsOperatingModeKind';
+import { VsPpccControlKind } from '../../model/dc/VsPpccControlKind';
+import { VsQpccControlKind } from '../../model/dc/VsQpccControlKind';
 
 export class ConverterIntegral7 {
   mysqlConnection: mysql.Connection;
   cimModel: Model;
 
+  /** Standardspannungsebene: falls im I7-Modell keine Spannung angegeben ist */
+  deafultUn = 110;
   /** 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*/
@@ -196,6 +213,9 @@ export class ConverterIntegral7 {
 
   standortAnzahl: number;
   leitungsAnzahl: number;
+  hgueLeitungsAnzahl: number;
+  ersatzlaengszweigAnzahl: number;
+  laengsdrosselAnzahl: number;
   trafo2WAnzahl: number;
   trafo3WAnzahl: number;
   /** Begrenzt die Anzahl der abgefragten Daten aus der DB
@@ -221,20 +241,19 @@ export class ConverterIntegral7 {
 
   integralLeitungen: Map<number, LeitungImpl> = new Map();
 
-  /** Integral 7 IDs for blockweise Verarbeitung SQLs */
+  /** Integral 7 IDs für 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
+  /** IDs von Leitungsanlussknoten
    * Die IDs werden zur Bestimmung der im Speicher zu haltenden Objekte (ConnectivityNodes, Terminals) herangezogen. */
   leitungAnschlussKnotenIDs = new Set();
 
@@ -243,6 +262,14 @@ export class ConverterIntegral7 {
    * Key -> CN UUID -> Basevoltage */
   knotenSpannung = new Map<string, BaseVoltage>();
 
+  /** Längsdrossel sind im I7 Modell einer Station zugeordnet.
+   * Im CIM Modell sind sie einer Anlage zugeornet.
+   * Da Längsdrossel erst nach Stationen konvertiert werden,
+   * müssen die konvertierten Sbustation- und VoltageLevelObjekte im Speicher gehalten werden,
+   * um LDs eine EquipmentContainer-Instanz zuordnen zuu können.
+   * key I7 SubstationID -> {spannungsebene, uuid des VL-Instanz} */
+  substationVoltagelevels: Map<number, { un: number; vlUUID: string }[]> = new Map();
+
   constructor() {
     this.cimModel = new Model();
     this.availableTableNames = [];
@@ -257,6 +284,9 @@ export class ConverterIntegral7 {
         await this.getAvailableTableNames(mySqlConfig.database);
         this.standortAnzahl = await this.queryObjectCount(Integral7TableNames.STANDORT);
         this.leitungsAnzahl = await this.queryObjectCount(Integral7TableNames.LEITUNG);
+        this.hgueLeitungsAnzahl = await this.queryObjectCount(Integral7TableNames.HGUE_LEITUNG);
+        this.ersatzlaengszweigAnzahl = await this.queryObjectCount(Integral7TableNames.ERSATZLAENGSZWEIG);
+        this.laengsdrosselAnzahl = await this.queryObjectCount(Integral7TableNames.LAENGSDROSSEL);
         this.trafo2WAnzahl = await this.queryObjectCount(Integral7TableNames.TRAFO2W);
         this.trafo3WAnzahl = await this.queryObjectCount(Integral7TableNames.TRAFO3W);
         await this.queryAnschlussIDs();
@@ -267,12 +297,12 @@ export class ConverterIntegral7 {
     });
   }
 
-  async start(): Promise<Status> {
+  async convert(energyTypesConfig: any, tempDirPath: string): Promise<Status> {
 
     return new Promise(async (resolve, reject) => {
       try {
 
-        const tempDirPath = await createTempDirPath() as string;
+        /*const tempDirPath = exportPath ? exportPath : await createTempDirPath() as string;*/
 
         /** EQ Profile */
         const filePathEQ = path.join(tempDirPath, 'eq.xml');
@@ -320,7 +350,7 @@ export class ConverterIntegral7 {
 
 
         /** Amprion I7 Profile */
-        const filePathAmpI7 = path.join(tempDirPath, 'AMP_I7.xml');
+        const filePathAmpI7 = path.join(tempDirPath, 'amp_i7.xml');
         const writeStreamAmpI7 = fs.createWriteStream(filePathAmpI7);
         const xmlWriterAmpI7 = new XMLWriter(true, (string, encoding) => {
           writeStreamAmpI7.write(string, encoding);
@@ -466,7 +496,10 @@ export class ConverterIntegral7 {
           /** Generatoren -> SynchronousMachine */
           //console.log(`Gen currentLimit = ${currentLimit} offset = ${offset}`);
           if (knotenSoIDs.length > 0 || this.knotenSfIDs.length > 0) {
-            await this.convertGeneratoren([...knotenSoIDs, ...this.knotenSfIDs]);
+            await this.convertGeneratoren([...knotenSoIDs, ...this.knotenSfIDs], energyTypesConfig);
+          }
+          if (knotenSoIDs.length > 0 || this.knotenSfIDs.length > 0) {
+            await this.convertAsynchronmotor([...knotenSoIDs, ...this.knotenSfIDs]);
           }
           // if (offset === 4800 || offset === 4900) console.log(`9082->${this.integralID2UUID.get(9082)} Generatoren offset = ${offset}`);
 
@@ -494,11 +527,21 @@ export class ConverterIntegral7 {
           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  */
+          /** hguekopfklassisch */
+          //console.log(`Last currentLimit = ${currentLimit} offset = ${offset}`);
+          if (knotenSoIDs.length > 0 || this.knotenSfIDs.length > 0) {
+            await this.convertCsConverterDC([...knotenSoIDs, ...this.knotenSfIDs]);
+          }
+
+          /** netz_hguekopfvsc */
+          //console.log(`Last currentLimit = ${currentLimit} offset = ${offset}`);
+          if (knotenSoIDs.length > 0 || this.knotenSfIDs.length > 0) {
+            await this.convertVsConverterDC([...knotenSoIDs, ...this.knotenSfIDs]);
+          }
+
 
+          /** Ende CONDUCTING EQUIPMENT  */
           /** Schema konvertieren */
           //console.log(`Schema currentLimit = ${currentLimit} offset = ${offset}`);
           await this.convertSchemaStandorte(standortIDs);
@@ -527,6 +570,7 @@ export class ConverterIntegral7 {
           // if (offset > 0) console.log(`32716->${this.integralID2UUID.get(32716)} convertSchemaSchaltfelder offset = ${offset}`);
 
           /** Export EQ */
+          /** DC Modell wird nach den HGÜ-Leitungen exportiert */
           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);
@@ -542,6 +586,7 @@ export class ConverterIntegral7 {
           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.asynchronousMachine, 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);
@@ -595,6 +640,7 @@ export class ConverterIntegral7 {
           this.cimModel.energySources.clear();
 
           this.cimModel.synchronousMachine.clear();
+          this.cimModel.asynchronousMachine.clear();
           this.cimModel.generatingUnit.clear();
           this.cimModel.thermalGeneratingUnit.clear();
           this.cimModel.nuclearGeneratingUnit.clear();
@@ -642,17 +688,41 @@ export class ConverterIntegral7 {
           console.log(`Offset ${offset} done`);
         }
 
+        /** Ersatzlaengszweige */
+        const restCountELZ = this.ersatzlaengszweigAnzahl < this.limit ? this.ersatzlaengszweigAnzahl : (this.ersatzlaengszweigAnzahl % this.limit);
+        const intervalCountELZ = (this.ersatzlaengszweigAnzahl - restCountELZ) / this.limit;
+        const numberOfIntervalsELZ = restCountELZ > 0 ? intervalCountELZ + 1 : intervalCountELZ;
+        console.log('Convert Ersatzlaengszweige ' + this.ersatzlaengszweigAnzahl);
+        for (let i = 0; i < numberOfIntervalsELZ; i++) {
+          const offset = i * this.limit;
+          const currentLimit = (i + 1 === numberOfIntervalsELZ && restCountELZ > 0) ? restCountELZ : this.limit;
+
+          await this.convertErsatzLaengszweige(currentLimit, offset);
+
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.equivalentBranches, 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.equivalentBranches.clear();
+          this.cimModel.connectivityNodes.clear();
+          this.cimModel.terminals.clear();
+
+          this.cimModel.objects.clear();
+        }
+
+
         /** 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 );
-
+        console.log('Convert ACLineSegments ' + this.leitungsAnzahl);
+        /** Stromkreisabschnitte */
         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()];
@@ -665,6 +735,9 @@ export class ConverterIntegral7 {
 
           this.objectToCIMXML(xmlWriterSV, this.cimModel.terminals, RDF_XML.PROFILE_SSH);
 
+          // AMP
+          this.objectToCIMXML(xmlWriterAmpI7, this.cimModel.acLineSegments, RDF_XML.PROFILE_AMPI7);
+
           /** Collections leeren */
           this.cimModel.acLineSegments.clear();
           this.cimModel.connectivityNodes.clear();
@@ -677,6 +750,60 @@ export class ConverterIntegral7 {
           this.leitungsIDs.length = 0;
         }
 
+        /** HGÜ-Leitungen . */
+        const restCountHgueLeitung = this.hgueLeitungsAnzahl < this.limit ? this.hgueLeitungsAnzahl : (this.hgueLeitungsAnzahl % this.limit);
+        const intervalCountHgueLeitung = (this.hgueLeitungsAnzahl - restCountHgueLeitung) / this.limit;
+        const numberOfIntervalsHgueLeitung = restCountHgueLeitung > 0 ? intervalCountHgueLeitung + 1 : intervalCountHgueLeitung;
+        console.log('Convert ACLineSegments ' + this.hgueLeitungsAnzahl);
+        /** HGÜ Stromkreisabschnitte */
+        for (let i = 0; i < numberOfIntervalsHgueLeitung; i++) {
+          const offset = i * this.limit;
+          const currentLimit = (i + 1 === numberOfIntervalsHgueLeitung && restCountHgueLeitung > 0) ? restCountHgueLeitung : this.limit;
+          await this.convertDCLines(currentLimit, offset);
+
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.dcLines, RDF_XML.PROFILE_EQ);
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.dcLineSegment, RDF_XML.PROFILE_EQ);
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.dcTerminals, RDF_XML.PROFILE_EQ);
+
+          /** Collections leeren */
+          this.cimModel.dcLines.clear();
+          this.cimModel.dcLineSegment.clear();
+          this.cimModel.dcTerminals.clear();
+        }
+
+        /** Längsdrossel */
+        const restCountLD = this.laengsdrosselAnzahl < this.limit ? this.laengsdrosselAnzahl : (this.laengsdrosselAnzahl % this.limit);
+        const intervalCountLD = (this.laengsdrosselAnzahl - restCountLD) / this.limit;
+        const numberOfIntervalsLD = restCountLD > 0 ? intervalCountLD + 1 : intervalCountLD;
+        console.log('Convert Längsdrossel ' + this.laengsdrosselAnzahl);
+        for (let i = 0; i < numberOfIntervalsLD; i++) {
+          const offset = i * this.limit;
+          const currentLimit = (i + 1 === numberOfIntervalsLD && restCountLD > 0) ? restCountLD : this.limit;
+          await this.convertLaengsdrosseln(currentLimit, offset);
+
+          // EQ
+          console.log('Export Längsdrossel ' + this.cimModel.seriesCompensators.size);
+          this.objectToCIMXML(xmlWriterEQ, this.cimModel.seriesCompensators, 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.terminals, RDF_XML.PROFILE_EQ);
+
+          // SSH
+          this.objectToCIMXML(xmlWriterSV, this.cimModel.terminals, RDF_XML.PROFILE_SSH);
+
+          // AMP
+          this.objectToCIMXML(xmlWriterAmpI7, this.cimModel.seriesCompensators, RDF_XML.PROFILE_AMPI7);
+
+          /** Collections leeren */
+          this.cimModel.seriesCompensators.clear();
+          this.cimModel.operationalLimitSets.clear();
+          this.cimModel.currentLimits.clear();
+
+          this.cimModel.terminals.clear();
+
+          this.cimModel.objects.clear();
+
+        }
         /** Transformatoren 2W */
         const restCountTrafo2W = this.trafo2WAnzahl < this.limit ? this.trafo2WAnzahl : (this.trafo2WAnzahl % this.limit);
         const intervalCountTrafo2W = (this.trafo2WAnzahl - restCountTrafo2W) / this.limit;
@@ -722,7 +849,7 @@ export class ConverterIntegral7 {
 
         }
 
-
+        /** Transformatoren 3W */
         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;
@@ -771,11 +898,14 @@ export class ConverterIntegral7 {
         }
 
         const memoryTerminals = new Map();
-        for (const value of this.memoryObjects.values()) {
+        for (const entry of this.memoryObjects.entries()) {
+          const value = entry[1];
           if (value instanceof Terminal) {
             const terminal = value as Terminal;
-            if(terminal.conductingEquipment || terminal.conductingEquipmentUUID) {
+            if (terminal.conductingEquipment || terminal.conductingEquipmentUUID) {
               memoryTerminals.set(value.mrid, value);
+            } else {
+              console.log(`Terminal ohne conductingEquipment UUID ${terminal.mrid} shortName ${terminal.shortName} ID | ${entry[0]}`);
             }
           }
         }
@@ -786,6 +916,20 @@ export class ConverterIntegral7 {
         this.objectToCIMXML(xmlWriterEQ, memoryTerminals, RDF_XML.PROFILE_EQ);
         this.objectToCIMXML(xmlWriterSSH, memoryTerminals, RDF_XML.PROFILE_SSH);
 
+
+        /** HGÜ Kopfstationen */
+        this.objectToCIMXML(xmlWriterEQ, this.cimModel.dcConverterUnit, RDF_XML.PROFILE_EQ);
+        this.objectToCIMXML(xmlWriterEQ, this.cimModel.vsConverter, RDF_XML.PROFILE_EQ);
+        this.objectToCIMXML(xmlWriterEQ, this.cimModel.csConverter, RDF_XML.PROFILE_EQ);
+        this.objectToCIMXML(xmlWriterEQ, this.cimModel.acDCConverterDCTerminals, RDF_XML.PROFILE_EQ);
+        this.objectToCIMXML(xmlWriterEQ, this.cimModel.dcNodes, RDF_XML.PROFILE_EQ);
+
+        this.cimModel.dcConverterUnit.clear();
+        this.cimModel.vsConverter.clear();
+        this.cimModel.csConverter.clear();
+        this.cimModel.acDCConverterDCTerminals.clear();
+        this.cimModel.dcNodes.clear();
+
         this.objectToCIMXML(xmlWriterAmpI7, this.cimModel.psrTypes, RDF_XML.PROFILE_AMPI7);
 
         /*        this.objectToCIMXML(xmlWriterEQ, memoryTerminals, RDF_XML.PROFILE_EQ);
@@ -829,7 +973,7 @@ export class ConverterIntegral7 {
         ]);
 
         const zip = new JSZip();
-        const filePathZip = path.join(tempDirPath, 'cgmes.zip');
+        // const filePathZip = path.join(tempDirPath, 'cgmes.zip');
         const readStreamEq = fs.createReadStream(filePathEQ);
         zip.file('EQ.xml', readStreamEq);
 
@@ -845,26 +989,39 @@ export class ConverterIntegral7 {
         const readStreamAmpI7 = fs.createReadStream(filePathAmpI7);
         zip.file('AMP_I7.xml', readStreamAmpI7);
 
-        await writeZipFile(zip, filePathZip);
 
-        resolve({status: 'successful', message: 'ok'});
+        resolve(await generateNodeStream(zip));
 
-        console.log('path ' + tempDirPath);
+/*        if (exportPath) {
+          console.log('Path ' + filePathZip);
+          resolve(await writeZipFile(zip, filePathZip));
+        } else {
+          resolve({status: 'successful', message: 'ok', data: zip.generateAsync({type:'nodebuffer', streamFiles: true})});
+        }*/
+        reject({status: 'error', message: 'GenerateNodeStream failed.'});
       } catch (e) {
-        console.log(e);
         reject({status: 'error', message: e.toString()});
       }
     });
   }
 
-  async end(): Promise<Status> {
+  async release(tempDirPath?: string): Promise<Status> {
     return new Promise(async (resolve, reject) => {
       try {
         this.closeConnection();
         this.cimModel.purgeData();
+
+        if (tempDirPath) {
+          try {
+            fs.rmdirSync(tempDirPath, { recursive: true });
+            console.log(`${path} is deleted!`);
+          } catch (err) {
+            console.error(`Error while deleting ${path}.`);
+          }
+        }
         resolve({status: 'successful', message: 'ok'});
       } catch (e) {
-        reject({status: 'error', message: e.toString()});
+        reject({status: 'error', message: JSON.stringify(e)});
       }
     });
   }
@@ -883,16 +1040,19 @@ export class ConverterIntegral7 {
 
   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)`]));
+      if (this.isTableAvailable(tableName)) {
+        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);
           }
-        } catch (e) {
-          return reject(0);
-        }
-      });
+        });
+      } else {
+        return resolve(0);
+      }
     });
   }
 
@@ -904,6 +1064,11 @@ export class ConverterIntegral7 {
         this.leitungAnschlussKnotenIDs.add(result[`aknoten`]);
         this.leitungAnschlussKnotenIDs.add(result[`eknoten`]);
       }
+      results = await this.queryFunctionWrapper(`SELECT DISTINCT anetzobjekt, enetzobjekt FROM ${Integral7TableNames[I7Objects.HGUE_LEITUNG]}`);
+      for (const result of results) {
+        this.leitungAnschlussKnotenIDs.add(result[`anetzobjekt`]);
+        this.leitungAnschlussKnotenIDs.add(result[`enetzobjekt`]);
+      }
       results = await this.queryFunctionWrapper(`SELECT DISTINCT aknoten, eknoten FROM ${Integral7TableNames[I7Objects.TRAFO2W]}`);
       for (const result of results) {
         this.leitungAnschlussKnotenIDs.add(result[`aknoten`]);
@@ -914,6 +1079,16 @@ export class ConverterIntegral7 {
         this.leitungAnschlussKnotenIDs.add(result[`aknoten`]);
         this.leitungAnschlussKnotenIDs.add(result[`eknoten`]);
       }
+      results = await this.queryFunctionWrapper(`SELECT DISTINCT aknoten, eknoten FROM ${Integral7TableNames[I7Objects.LAENGSDROSSEL]}`);
+      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.ERSATZLAENGSZWEIG]}`);
+      for (const result of results) {
+        this.leitungAnschlussKnotenIDs.add(result[`aknoten`]);
+        this.leitungAnschlussKnotenIDs.add(result[`eknoten`]);
+      }
     } catch (e) {
       console.error("ERROR:" + e);
     }
@@ -982,10 +1157,13 @@ export class ConverterIntegral7 {
         substation.subGeographicalRegion = subregion;
         // subregion.addSubstation(substation);
 
+        /** Speichern, um später Längsdrossel die VoltageLevelInstanz bestimmen zu können. */
+        this.substationVoltagelevels.set(i7Data.id, []);
         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);
@@ -1012,7 +1190,8 @@ export class ConverterIntegral7 {
 
         vl.addConnectivityNode(connectivityNode);
 
-        const baseVoltage = createBaseVoltageIfNotExists(this.cimModel, i7Data.un);
+        const un = getU(i7Data.un, this.deafultUn);
+        const baseVoltage = createBaseVoltageIfNotExists(this.cimModel, un);
         vl.baseVoltage = baseVoltage;
 
         const substation = this.cimModel.getSubstation(this.integralID2UUID.get(i7Data.standort));
@@ -1055,7 +1234,9 @@ export class ConverterIntegral7 {
       // 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);
+
+        const un = getU(i7Data.un, this.deafultUn);
+        const baseVoltage = createBaseVoltageIfNotExists(this.cimModel, un);
         vl.baseVoltageUUID = baseVoltage.mrid;
 
         this.cimModel.addVoltageLevel(vl);
@@ -1079,6 +1260,12 @@ export class ConverterIntegral7 {
           schaltanlage.addStandort(this.integralStandorte.get(schaltanlage.standortid));
           this.integralSchaltanlagen.set(i7Data.id, schaltanlage);
 
+          /** Speichern, um später Längsdrossel die VoltageLevelInstanz bestimmen zu können. */
+          const subVlData: { un: number; vlUUID: string }[] = this.substationVoltagelevels.get(i7Data.standort);
+          subVlData.push({
+            un: i7Data.un,
+            vlUUID: vl.mrid,
+          });
         } else {
           console.log(`VoltageLevel ${i7Data.id} ${vl.mrid} besitzt keine Umspannanlage.`);
         }
@@ -1349,7 +1536,7 @@ export class ConverterIntegral7 {
     }
   }
 
-  async convertGeneratoren(knotenSfIDs: number[]) {
+  async convertGeneratoren(knotenSfIDs: number[], energyTypesConfig: any) {
     // Generatoren werden als GeneratingUnit und SynchronousMachine abgebildet
     if (this.isTableAvailable(Integral7TableNames.GENERATOR)) {
       const result: Generator[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.GENERATOR, 0, 0, knotenSfIDs))
@@ -1433,7 +1620,7 @@ export class ConverterIntegral7 {
 
 
         // GeneratingUnit
-        const generatingUnitConfig = FUEL_TYPE_CONFIG[i7Data.nameprimaertyp];
+        const generatingUnitConfig = energyTypesConfig[i7Data.nameprimaertyp];
 
         /** Wenn ein Config für den Primärenergietyp vorhanden*/
         let generatingUnit;
@@ -1454,12 +1641,18 @@ export class ConverterIntegral7 {
             case 'WindGeneratingUnit': {
               generatingUnit = new WindGeneratingUnit(getUUID(''), 'Generator_' + i7Data.bezeichner, i7Data.kurzname, i7Data.nameprimaertyp);
               switch (generatingUnitConfig.fuelType) {
-                case 'onshore':
+                case 'onshore': {
                   generatingUnit.windGenUnitType = WindGenUnitKind.onshore;
                   break;
-                case 'offshore':
+                }
+                case 'offshore': {
                   generatingUnit.windGenUnitType = WindGenUnitKind.offshore;
                   break;
+                }
+                default : {
+                  generatingUnit.windGenUnitType = WindGenUnitKind.onshore;
+                  break;
+                }
               }
               break;
             }
@@ -1940,7 +2133,7 @@ export class ConverterIntegral7 {
         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 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));
@@ -1986,89 +2179,95 @@ export class ConverterIntegral7 {
   /**
    * @param lineAttribute Attribut zur Bestimmung der Stromkreise */
 
-  /*  async convertErsatzLaengszweige() {
-      if (this.isTableAvailable(Integral7TableNames.ERSATZLAENGSZWEIG)) {
+  async convertErsatzLaengszweige(limit: number, offset: number) {
+    if (this.isTableAvailable(Integral7TableNames.ERSATZLAENGSZWEIG)) {
+      const result: LeitungErsatzLaengszweig[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.ERSATZLAENGSZWEIG, limit, offset, []));
+      for (const i7Data of result) {
 
-        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 */
 
-          // 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 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.`);
-          }
+        const equivalentBranch = new EquivalentBranch(getUUID(i7Data.guid), i7Data.bezeichner, i7Data.kurzname, i7Schluessel);
+
+        // TODO alles überprüfen
+        equivalentBranch.negativeR12 = isNaN(i7Data.r12_lfl) ? 0.1 : i7Data.r12_lfl;
+        equivalentBranch.negativeR21 = isNaN(i7Data.r21_lfl) ? 0.1 : i7Data.r21_lfl;
+        equivalentBranch.negativeX12 = isNaN(i7Data.x12_lfl) ? 0.1 : i7Data.x12_lfl;
+        equivalentBranch.negativeX21 = isNaN(i7Data.x21_lfl) ? 0.1 : i7Data.x21_lfl;
+
+        equivalentBranch.positiveR12 = isNaN(i7Data.r12_lfl) ? 0.1 : i7Data.r12_lfl;
+        equivalentBranch.positiveR21 = isNaN(i7Data.r21_lfl) ? 0.1 : i7Data.r21_lfl;
+        equivalentBranch.positiveX12 = isNaN(i7Data.x12_lfl) ? 0.1 : i7Data.x12_lfl;
+        equivalentBranch.positiveX21 = isNaN(i7Data.x21_lfl) ? 0.1 : i7Data.x21_lfl;
+
+        equivalentBranch.r = equivalentBranch.negativeR12;
+        equivalentBranch.x = equivalentBranch.negativeX21;
+        equivalentBranch.r21 = equivalentBranch.positiveR12;
+
+        equivalentBranch.x21 = equivalentBranch.negativeX21
+        equivalentBranch.zeroR12 = isNaN(i7Data.r12_ks) ? 0.1 : i7Data.r12_ks;
+        equivalentBranch.zeroR21 = isNaN(i7Data.r12_ks) ? 0.1 : i7Data.r12_ks;
+        equivalentBranch.zeroX12 = isNaN(i7Data.x12_ks) ? 0.1 : i7Data.x12_ks;
+        equivalentBranch.zeroX21 = isNaN(i7Data.x12_ks) ? 0.1 : i7Data.x12_ks;
+
+        const ur1 = getU(i7Data.ur1, this.deafultUn);
+        const ur2 = getU(i7Data.ur2, this.deafultUn);
+        const baseVoltageUr1 = createBaseVoltageIfNotExists(this.cimModel, ur1);
+        const baseVoltageUr2 = createBaseVoltageIfNotExists(this.cimModel, ur2);
+        if (baseVoltageUr1) {
+          equivalentBranch.baseVoltage = baseVoltageUr1;
+        } else if (baseVoltageUr2) {
+          equivalentBranch.baseVoltage = baseVoltageUr2;
         }
 
-      } else {
-        console.log(`Tabelle ${Integral7TableNames.ERSATZLAENGSZWEIG} ist nicht vorhanden.`);
+
+        // 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) {
+          createConnection(this.cimModel, equivalentBranch, start, PhaseCode.ABC, 1);
+        } else {
+          console.log(`Leitung ${i7Data.id} ${equivalentBranch.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) {
+          createConnection(this.cimModel, equivalentBranch, target, PhaseCode.ABC, 2);
+        } else {
+          console.log(`Leitung ${i7Data.id} ${equivalentBranch.mrid} besitzt keinen Zielknoten.`);
+        }
+
+        this.cimModel.addEquivalentBranch(equivalentBranch);
+        this.integralID2UUID.set(i7Data.id, equivalentBranch.mrid);
       }
-    }*/
+
+    } else {
+      console.log(`Tabelle ${Integral7TableNames.ERSATZLAENGSZWEIG} ist nicht vorhanden.`);
+    }
+  }
 
   /**
    * @param lineAttribute Attributsname zum Bestimmen der Stronkreise*/
@@ -2201,7 +2400,7 @@ export class ConverterIntegral7 {
       for (const i7Data of result) {
         const acLineSegment = this.cimModel.getACLineSegment(this.integralID2UUID.get(i7Data.leitung));
         if (acLineSegment) {
-          this.setACLineSegmentProperties(acLineSegment, i7Data, 'OverheadLine');
+          this.setACLineSegmentProperties(acLineSegment, i7Data, 'Freileitung');
         } else {
           console.log(`Freileitung ${i7Data.id} besitzt kein Leitungsobjekt.`);
         }
@@ -2216,7 +2415,7 @@ export class ConverterIntegral7 {
       for (const i7Data of result) {
         const acLineSegment = this.cimModel.getACLineSegment(this.integralID2UUID.get(i7Data.leitung));
         if (acLineSegment) {
-          this.setACLineSegmentProperties(acLineSegment, i7Data, 'Cable');
+          this.setACLineSegmentProperties(acLineSegment, i7Data, 'Kabel');
         } else {
           console.log(`Kabel ${i7Data.id} besitzt kein Leitungsobjekt.`);
         }
@@ -2702,6 +2901,100 @@ export class ConverterIntegral7 {
     }
   }
 
+  async convertLaengsdrosseln(limit: number, offset: number) {
+    console.log('isTableAvailable ' + this.isTableAvailable(Integral7TableNames.LAENGSDROSSEL));
+    if (this.isTableAvailable(Integral7TableNames.LAENGSDROSSEL)) {
+      const result: Ldrossel[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.LAENGSDROSSEL, limit, offset, []));
+
+      for (const i7Data of result) {
+        const seriesCompensator = new AMPRIONSeriesCompensator(getUUID(i7Data.guid), getName(i7Data), i7Data.id + '', i7Data.bezeichner);
+
+        // 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, seriesCompensator, start, PhaseCode.ABC, 1);
+        } else {
+          console.log(`Längsdrossel ${i7Data.id} ${seriesCompensator.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, seriesCompensator, target, PhaseCode.ABC, 2);
+        } else {
+          console.log(`Längsdrossel ${i7Data.id} ${seriesCompensator.mrid} besitzt keinen Zielknoten.`);
+        }
+        /** Spannungsebene */
+        const ur = getU(i7Data.ur, this.deafultUn);
+        const baseVoltage = createBaseVoltageIfNotExists(this.cimModel, ur);
+        seriesCompensator.baseVoltage = baseVoltage;
+        /**
+         * Längsdrossel ist beschrieben durch:
+         Un = 10 kV = 10000 V
+         IrA = 2500
+         Ukr = 7% = 0,07
+         Pkr = 0
+
+         S = Un(V) * IrA * Wurzel(3) => 43301270,2
+         Z = Ukr * un^2/IrA (umgerechnet) = 0,161
+         R = 0, da Pkr = 0
+         X = Z = 0,161
+         * */
+        /** elektrische Parameter */
+        let ira = 100;
+        if (i7Data.ir && i7Data.ir > 0) {
+          ira = i7Data.ir;
+        }
+        const voltage = baseVoltage.nominalVoltage.value * 1000
+        const z = (i7Data.ukr / 100) * Math.pow(voltage, 2) / (voltage * ira * Math.sqrt(3));
+        seriesCompensator.x = z;
+
+        seriesCompensator.varistorRatedCurrent = ira;
+
+
+        /** CurrentLimit */
+        const terminal = startTerminal
+        if (terminal) {
+          this.setConductingEquipmentCurrentLimit('Rating ' + seriesCompensator.name, terminal.mrid, ira);
+        } else {
+          console.log(`Längsdrossel ${i7Data.id} ${seriesCompensator.mrid} besitzt keine Terminalinstanz.`);
+        }
+
+        // Umspannanlage
+        const substationUUID = this.integralID2UUID.get(i7Data.standort);
+
+        /** VoltageLevel */
+        /** Speichern, um später Längsdrossel die VoltageLevelInstanz bestimmen zu können. */
+        const subVlData: { un: number; vlUUID: string }[] = this.substationVoltagelevels.get(i7Data.standort);
+        const vlUUID = subVlData.find(elem => elem.un === i7Data.ur);
+
+        if (vlUUID) {
+          seriesCompensator.equipmentContainerUUID = vlUUID.vlUUID;
+        } else {
+          console.log(`Längsdrossel ${i7Data.id} besitzt kein VoltageLevel Ur ${i7Data.ur}.`);
+        }
+
+        /** PSR Types */
+        const psrType = createIfNotExitsPSRType(this.cimModel, 'Längsdrossel');
+        seriesCompensator.psrTypeUUID = psrType.mrid;
+        this.cimModel.addSeriesCompensator(seriesCompensator);
+        this.integralID2UUID.set(i7Data.id, seriesCompensator.mrid);
+      }
+    } else {
+      console.log(`Tabelle ${Integral7TableNames.LAENGSDROSSEL} 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));
@@ -2834,6 +3127,293 @@ export class ConverterIntegral7 {
     }
   }
 
+
+  async convertCsConverterDC(knotenSfIDs: number[]) {
+    if (this.isTableAvailable(Integral7TableNames.HGUE_KOPFSTATION_KLASSISCH)) {
+      const result: Kopfstation[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.HGUE_KOPFSTATION_KLASSISCH, 0, 0, knotenSfIDs));
+      for (const i7Data of result) {
+        /** Containment DC DCConverterUnit */
+        const dcConverterUnit = new DCConverterUnit(generateUUID(), 'DCConverterUnit');
+        // 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 connectivityNode = this.cimModel.objects.get(this.integralID2UUID.get(i7Data.anschluss)) as IConnectivityNode;
+        const acConnectivityNode = this.cimModel.connectivityNodes.get(this.integralID2UUID.get(i7Data.anschluss));
+        if (acConnectivityNode) {
+          const equipmentContainer = determineEquipmentContainer('Substation', this.cimModel, this.cimModel.getObject(acConnectivityNode.getConnectivityNodeContainerUUID()) as EquipmentContainer);
+          if (equipmentContainer) {
+            dcConverterUnit.name = `DCConverterUnit ${equipmentContainer.name}`;
+            dcConverterUnit.setSubstation(equipmentContainer as Substation);
+          } else {
+            console.log(`DCConverterUnit ${i7Data.id} besitzt keinen EquipmentContainer.`);
+          }
+        } else {
+          console.log(`DCConverterUnit ${i7Data.id} besitzt keinen ConnectivityNode.`);
+        }
+
+        const csConverter = new CsConverter(getUUID(i7Data.guid), getName(i7Data), i7Data.kurzname);
+
+        /** Wenn Leitungen konvertiert werden, wird das Attribut operationMode gesetzt. */
+        csConverter.equipmentContainer = dcConverterUnit;
+
+        /** Bemessungsleistung (Gleichstromseite) in MW
+         * im CS-Fall S = P?
+         * Abhängig vom  */
+        csConverter.baseS = i7Data.pr;
+
+        /** Bemessungsspannung (Gleichstromseite) in kV*/
+        csConverter.ratedUdc = i7Data.ur;
+        /** spannungsabhängige Wirk-Verluste bei Leerlauf mit Bemessungsspannung in kV*/
+        csConverter.idleLoss = i7Data.p_leer;
+
+        csConverter.maxUdc = i7Data.ur; // +5% * ratedUdc
+        csConverter.minUdc = 0;         // -5% * ratedUdc
+
+        csConverter.resistiveLoss = 0;
+        csConverter.switchingLoss = 0;
+        /*        csConverter.numberOfValves
+                csConverter.valveU0*/
+        /** Stromrichter */
+        /** Zündwinkel bei Gleichrichterbetrieb (ins Drehstromnetz eingespeiste Wirkleistung < 0) - etwa 15 Grad */
+        /*    csConverter.maxAlpha = i7Data.alpha;
+            csConverter.minAlpha = i7Data.alpha;*/
+
+        /** Löschwinkel bei Wechselrichterbetrieb (ins Drehstromnetz Wirkleistung > 0) - etwa 21,5 Grad */
+        /*      csConverter.maxGamma = i7Data.gamma;
+              csConverter.minGamma = i7Data.gamma;*/
+
+        const regelungU = convertToBooleanI7(i7Data.u_geregelt);
+        const regelungP = convertToBooleanI7(i7Data.p_geregelt);
+        const regelungW = convertToBooleanI7(i7Data.grad_geregelt);
+        if (regelungU) {
+          csConverter.operatingMode = CsOperatingModeKind.inverter
+        } else if (regelungP) {
+          csConverter.operatingMode = CsOperatingModeKind.rectifier
+        } else {
+          csConverter.operatingMode = CsOperatingModeKind.rectifier
+        }
+        /** Status */
+        const inBetrieb = convertToBooleanI7(i7Data.betrieb);
+        createSvStatus(this.cimModel, inBetrieb, csConverter);
+
+        /** Topologie AC Seite*/
+        if (acConnectivityNode) {
+          createConnection(this.cimModel, csConverter, acConnectivityNode, PhaseCode.ABC, 1);
+        } else {
+          console.log(`CsConverter ${i7Data.id} ${csConverter.mrid} besitzt keinen AC Anschluss.`);
+        }
+
+        /** Topologie DC Seite*/
+        const dcNode = new DCNode(generateUUID(), 'DCNode');
+        dcNode.dcEquipmentContainerUUID = dcConverterUnit.mrid;
+
+        const acDCConverterDCTerminal = new ACDCConverterDCTerminal(generateUUID(), 'ACDCConvTerminal');
+        acDCConverterDCTerminal.sequenceNumber = 1;
+        acDCConverterDCTerminal.dCConductingEquipmentUUID = csConverter.mrid;
+        acDCConverterDCTerminal.dcNodeUUID = dcNode.mrid;
+
+        /** Topologie DC Leitung Seite*/
+        /** s. DCLineSegment Teil */
+
+        /** DCNode speichern, um später DCLines anschließen zu können*/
+        this.checkMemoryObject(i7Data.id, dcNode);
+
+        this.cimModel.addDCConverterUnit(dcConverterUnit);
+        this.cimModel.addCSConverter(csConverter);
+        this.cimModel.addDCNode(dcNode);
+        this.cimModel.addACDCConverterDCTerminal(acDCConverterDCTerminal);
+
+        this.integralID2UUID.set(i7Data.id, csConverter.mrid);
+      }
+    }
+  }
+
+  async convertVsConverterDC(knotenSfIDs: number[]) {
+    if (this.isTableAvailable(Integral7TableNames.HGUE_KOPFSTATION_VSC)) {
+      const result: Kopfstation[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.HGUE_KOPFSTATION_VSC, 0, 0, knotenSfIDs));
+      for (const i7Data of result) {
+        /** Containment DC DCConverterUnit */
+        const dcConverterUnit = new DCConverterUnit(generateUUID(), 'DCConverterUnit');
+        // Topologie
+        /* Anfang
+         * 3 moegliche Anschluesse
+         *  KontenSo -> Anschluesspunkt
+         *  KnotenSf -> Schaltfeldpunkt
+         *  KnotenZw -> Netzschlaufe -> KnotenSo -> Anschlusspunkt */
+
+        //const connectivityNode = this.cimModel.objects.get(this.integralID2UUID.get(i7Data.anschluss)) as IConnectivityNode;
+        //const acConnectivityNode = this.memoryObjects.get(i7Data.anschluss) as unknown as IConnectivityNode;
+        const acConnectivityNode = this.cimModel.connectivityNodes.get(this.integralID2UUID.get(i7Data.anschluss));
+        if (acConnectivityNode) {
+          const equipmentContainer = determineEquipmentContainer('Substation', this.cimModel, this.cimModel.getObject(acConnectivityNode.getConnectivityNodeContainerUUID()) as EquipmentContainer);
+          if (equipmentContainer) {
+            dcConverterUnit.name = `DCConverterUnit ${equipmentContainer.name}`;
+            dcConverterUnit.setSubstation(equipmentContainer as Substation);
+          } else {
+            console.log(`DCConverterUnit ${i7Data.id} besitzt keinen EquipmentContainer.`);
+          }
+        } else {
+          console.log(`DCConverterUnit ${i7Data.id} besitzt keinen ConnectivityNode.`);
+        }
+
+        const vsConverter = new VsConverter(getUUID(i7Data.guid), getName(i7Data), i7Data.kurzname);
+
+        /** Wenn Leitungen konvertiert werden, wird das Attribut operationMode gesetzt. */
+        vsConverter.equipmentContainer = dcConverterUnit;
+
+        /** Bemessungsleistung (Gleichstromseite) in MW
+         * im CS-Fall S = P?
+         * Abhängig vom  */
+        vsConverter.baseS = i7Data.pr;
+
+        /** Bemessungsspannung (Gleichstromseite) in kV*/
+        vsConverter.ratedUdc = i7Data.ur;
+        /** spannungsabhängige Wirk-Verluste bei Leerlauf mit Bemessungsspannung in kV*/
+        vsConverter.idleLoss = i7Data.p_leer;
+
+        vsConverter.maxUdc = i7Data.ur; // +5% * ratedUdc
+        vsConverter.minUdc = 0;         // -5% * ratedUdc
+
+        vsConverter.resistiveLoss = 0;
+        vsConverter.switchingLoss = 0;
+        /*  csConverter.maxModulationIndex = ;
+            csConverter.maxValveCurrent =  */
+
+        const regelungU = convertToBooleanI7(i7Data.u_geregelt);
+        const regelungP = convertToBooleanI7(i7Data.p_geregelt);
+        const regelungW = convertToBooleanI7(i7Data.grad_geregelt);
+        if (regelungU) {
+          vsConverter.pPccControl = VsPpccControlKind.pPcc;
+          vsConverter.qPccControl = VsQpccControlKind.powerFactorPcc;
+        } else if (regelungP) {
+          vsConverter.pPccControl = VsPpccControlKind.pPcc;
+          vsConverter.qPccControl = VsQpccControlKind.powerFactorPcc;
+        } else {
+          vsConverter.pPccControl = VsPpccControlKind.pPcc;
+          vsConverter.qPccControl = VsQpccControlKind.powerFactorPcc;
+        }
+
+        /** Status */
+        const inBetrieb = convertToBooleanI7(i7Data.betrieb);
+        createSvStatus(this.cimModel, inBetrieb, vsConverter);
+
+        /** Topologie AC Seite*/
+        if (acConnectivityNode) {
+          createConnection(this.cimModel, vsConverter, acConnectivityNode, PhaseCode.ABC, 1);
+        } else {
+          console.log(`VsConverter ${i7Data.id} ${vsConverter.mrid} besitzt keinen AC Anschluss.`);
+        }
+
+        /** Topologie DC Seite*/
+        const dcNode = new DCNode(generateUUID(), 'DCNode');
+        dcNode.dcEquipmentContainerUUID = dcConverterUnit.mrid;
+
+        const acDCConverterDCTerminal = new ACDCConverterDCTerminal(generateUUID(), 'ACDCConvTerminal');
+        acDCConverterDCTerminal.sequenceNumber = 1;
+        acDCConverterDCTerminal.dCConductingEquipmentUUID = vsConverter.mrid;
+        acDCConverterDCTerminal.dcNodeUUID = dcNode.mrid;
+
+        /** Topologie DC Leitung Seite*/
+        /** s. DCLineSegment Teil */
+
+        /** DCNode speichern, um später DCLines anschließen zu können*/
+        this.checkMemoryObject(i7Data.id, dcNode);
+
+        this.cimModel.addDCConverterUnit(dcConverterUnit);
+        this.cimModel.addVSConverter(vsConverter);
+        this.cimModel.addDCNode(dcNode);
+        this.cimModel.addACDCConverterDCTerminal(acDCConverterDCTerminal);
+
+        this.integralID2UUID.set(i7Data.id, vsConverter.mrid);
+      }
+    }
+  }
+
+  async convertDCLines(limit: number, offset: number) {
+    if (this.isTableAvailable(Integral7TableNames.HGUE_LEITUNG)) {
+      const result: Hgueleitung[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.HGUE_LEITUNG, limit, offset, []));
+      for (const i7Data of result) {
+        const dcLine = new DCLine(getUUID(i7Data['guid_dcline']), 'DCLine');
+
+        const i7Schluessel = LEITUNG_PRAEFIX +
+          ueberpruefeZeichenkette(i7Data.ukz) +
+          MITTIGER_PUNKT +
+          ueberpruefeZeichenkette(i7Data.kurzname) +
+          MITTIGER_PUNKT +
+          ueberpruefeZeichenkette(i7Data.bezeichner);
+
+        const dcLineSegment = new DCLineSegment(getUUID(i7Data.guid), i7Data.bezeichner, i7Data.kurzname, i7Schluessel);
+        /*
+        dcLineSegment.length = keine Informationen vorhanden
+        dcLineSegment.capacitance = keine Informationen vorhanden
+        dcLineSegment.inductance = keine Informationen vorhanden
+        */
+        dcLineSegment.resistance = i7Data.rdc;
+
+        dcLineSegment.equipmentContainerUUID = dcLine.mrid;
+
+        /** operationMode der Anfangs- und Zielkopfstation setzen */
+        const bipol = convertToBooleanI7(i7Data.bipol);
+        const acDCConverterStart = this.cimModel.getObject(this.integralID2UUID.get(i7Data.anetzobjekt));
+        const acDCConverterTarget = this.cimModel.getObject(this.integralID2UUID.get(i7Data.enetzobjekt));
+
+        const converterUnitStart = (acDCConverterStart as ACDCConverter)?.equipmentContainer as DCConverterUnit;
+        const converterUnitTarget = (acDCConverterTarget as ACDCConverter)?.equipmentContainer as DCConverterUnit;
+        switch (bipol) {
+          case (true) : {
+            converterUnitStart.operationMode = DCConverterOperatingModeKind.bipolar;
+            converterUnitTarget.operationMode = DCConverterOperatingModeKind.bipolar;
+          }
+          default: {
+            converterUnitStart.operationMode = DCConverterOperatingModeKind.monopolarGroundReturn;
+            converterUnitTarget.operationMode = DCConverterOperatingModeKind.monopolarGroundReturn;
+          }
+        }
+        // Topologie DC
+        /* Anfang / Ende DCNodes*/
+        const startDCNode = this.memoryObjects.get(i7Data.anetzobjekt);
+        if (startDCNode) {
+          const dcTerminal = new DCTerminal(generateUUID(), 'DCTerminal_HGÜ_Leitung');
+          dcTerminal.sequenceNumber = 2;
+          dcTerminal.dCConductingEquipmentUUID = dcLineSegment.mrid;
+          dcTerminal.dcNodeUUID = startDCNode.mrid;
+          this.cimModel.addDCTerminal(dcTerminal);
+
+        } else {
+          console.log(`HGÜ-Leitung ${i7Data.id} ${dcLineSegment.mrid} besitzt keinen Anfangsknoten. ${i7Data.anetzobjekt} ${this.integralID2UUID.get(i7Data.anetzobjekt)}`);
+        }
+
+        const tartgetDCNode = this.memoryObjects.get(i7Data.enetzobjekt);
+        if (tartgetDCNode) {
+          const dcTerminal = new DCTerminal(generateUUID(), 'DCTerminal_HGÜ_Leitung');
+          dcTerminal.sequenceNumber = 2;
+          dcTerminal.dCConductingEquipmentUUID = dcLineSegment.mrid;
+          dcTerminal.dcNodeUUID = tartgetDCNode.mrid;
+          this.cimModel.addDCTerminal(dcTerminal);
+
+        } else {
+          console.log(`HGÜ-Leitung ${i7Data.id} ${dcLineSegment.mrid} besitzt keinen Zielknoten. ${i7Data.enetzobjekt} ${this.integralID2UUID.get(i7Data.enetzobjekt)}`);
+        }
+
+        this.cimModel.addDCLine(dcLine);
+        this.cimModel.addDCLineSegment(dcLineSegment);
+
+        this.integralID2UUID.set(i7Data.id, dcLineSegment.mrid);
+      }
+
+    } else {
+      console.log(`Tabelle ${Integral7TableNames.HGUE_LEITUNG} ist nicht vorhanden.`);
+    }
+  }
+
   /*  async convertBelastungen() {
       if (this.isTableAvailable(Integral7TableNames.BELASTUNG)) {
         const result: Belastung[] = await this.queryFunctionWrapper(BELASTUNG_SQL_QUERY);
@@ -2925,6 +3505,7 @@ export class ConverterIntegral7 {
         console.log(`Tabelle ${Integral7TableNames.EINSPEISUNG} ist nicht vorhanden.`);
       }
     }*/
+
   /*  async convertBoundaryInjections() {
       if (this.isTableAvailable(Integral7TableNames.BOUNDARYINJECTION)) {
         const result: RandnetzEinspeisung[] = await this.queryFunctionWrapper(BOUNDARYINJECTION_SQL_QUERY);
@@ -2980,230 +3561,61 @@ export class ConverterIntegral7 {
       }
     }*/
 
-  /*  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;
+  async convertAsynchronmotor(knotenSfIDs: number[]) {
+    // Generatoren werden als GeneratingUnit und SynchronousMachine abgebildet
+    if (this.isTableAvailable(Integral7TableNames.ASYNCHRONMOTOR)) {
+      const result: Asynchronmotor[] = await this.queryFunctionWrapper(getNetzQuery(I7Objects.ASYNCHRONMOTOR, 0, 0, knotenSfIDs))
+      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;
 
-          generatingUnit.addRotatingMachine(synchronousMachine);
-          synchronousMachine.generatingUnit = generatingUnit;
+        if (connectivityNode) {
+          createConnection(this.cimModel, asynchronousMachine, connectivityNode, PhaseCode.ABC);
 
-          const connectivityNode = this.cimModel.objects.get(this.integralID2UUID.get(i7Data.anschluss)) as IConnectivityNode;
+          const equipmentContainer = determineEquipmentContainer('VoltageLevel', this.cimModel, this.cimModel.getObject(connectivityNode.getConnectivityNodeContainerUUID()) as EquipmentContainer);
+          if (equipmentContainer) {
 
-          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(asynchronousMachine);
+            asynchronousMachine.equipmentContainerUUID = equipmentContainer?.mrid;
 
-              equipmentContainer.addEquipment(generatingUnit);
-              generatingUnit.equipmentContainer = equipmentContainer;
+            /*           const i7Schluesel = getDescription(equipmentContainer.getSubstation()) +
+                         EINSPEISUNG_PRAEFIX + i7Data.bezeichner;
+                       asynchronousMachine.description = i7Schluesel;*/
 
-              const i7Schluesel = getDescription(equipmentContainer.getSubstation()) +
-                GENERATOR_PRAEFIX + i7Data.bezeichner;
-              synchronousMachine.description = i7Schluesel;
+            this.cimModel.addAsynchronousMachine(asynchronousMachine);
+            this.integralID2UUID.set(i7Data.id, asynchronousMachine.mrid);
 
-            } else {
-              console.log(`SynchronousMachine ${i7Data.id} besitzt keinen EquipmentContainer.`);
-            }
           } else {
-            console.log(`SynchronousMachine ${i7Data.id} besitzt keinen ConnectivityNode.`);
+            console.log(`AsynchronousMachine ${i7Data.id} besitzt keinen EquipmentContainer.`);
           }
-
-          this.cimModel.addRegulatingControl(regulatingControl);
-          this.cimModel.addGeneratingUnit(generatingUnit);
-          this.cimModel.addSynchronousMachine(synchronousMachine);
-          this.integralID2UUID.set(i7Data.id, synchronousMachine.mrid);
-
+        } else {
+          console.log(`AsynchronousMachine ${i7Data.id} besitzt keinen ConnectivityNode.`);
         }
-      }
-    }*/
-
-  /*  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.`);
       }
-    }*/
+    } else {
+      console.log(`Tabelle ${Integral7TableNames.ASYNCHRONMOTOR} ist nicht vorhanden.`);
+    }
+  }
 
   /**------------------Schema----------------------------*/
   async convertNetzvarianten() {
@@ -3252,12 +3664,8 @@ export class ConverterIntegral7 {
 
     // Spannungsebene
     if (!acLineSegment.baseVoltage) {
-      let baseVoltage;
-      if (data.un && data.un > 0) {
-        baseVoltage = createBaseVoltageIfNotExists(this.cimModel, data.un);
-      } else {
-        baseVoltage = createBaseVoltageIfNotExists(this.cimModel, 110);
-      }
+      const un = getU(data.un, this.deafultUn);
+      const baseVoltage = createBaseVoltageIfNotExists(this.cimModel, un);
       acLineSegment.baseVoltage = baseVoltage;
     }