@enervance/insight-cim-model 0.0.1

package/src/converter/integral7/sql/integral.sql.ts

@@ -0,0 +1,319 @@
+export class Integral7TableNames {
+
+  public static REGION = "netz_georegion";
+  public static SUBREGION = "netz_subgeoregion";
+
+  public static STANDORT = "netz_standort";
+  public static SCHALTANLAGE = "netz_schaltanlage";
+  public static SCHALTANLAGENABSCHNITT = "netz_saabschnitt";
+  public static SAMMELSCHIENE = "netz_ssab"
+  public static KNOTEN_SO = "netz_knotenso";
+  public static SCHALTFELD = "netz_schaltfeld";
+  public static KNOTEN_SF = "netz_knotensf";
+  public static SCHLAUFE = "netz_schlaufe";
+  public static KNOTEN_ZW = "netz_knotenzw";
+  public static TRENNER_3P = "netz_trenner3p";
+  public static TRENNERFI_3P = "netz_trennerfi3p";
+  public static LEISTUNGSSCHALTER = "netz_leistungsschalter";
+  public static LEITUNG = "netz_leitung";
+  public static FREILEITUNG = "netz_freileitungabschnitt";
+  public static KABEL = "netz_kabelabschnitt";
+  public static ERSATZLAENGSZWEIG = "netz_ersatzlaengszweig";
+  public static TRAFO2W = "netz_trafo2w";
+  public static TRAFO3W = "netz_trafo3w";
+  public static TRAFO3_WICKLUNG = "netz_trafowicklung3w";
+  public static TRAFO3W_KNOTEN = "netz_knotent3w";
+
+  public static QUERKUPPLUNG = "netz_kpfeld";
+  public static KNOTEN_KF = "netz_knotenkf";
+  public static LAENGSKUPPLUNG = "netz_lkupplung";
+  public static KNOTEN_LK = "netz_knotenlk";
+
+  public static KNOTEN_STARR = "netz_sestarr3p";
+
+  public static BELASTUNG = "netz_belastung";
+  public static EINSPEISUNG = "netz_netzeinspeisung";
+  public static GENERATOR = "netz_generator";
+  public static ASYNCHRONMOTOR = "netz_asynchronmotor";
+  public static BOUNDARYINJECTION = "netz_boundaryinjection";
+
+  public static TYP_FREILEITUNG = "typen_freileitungabschnitt";
+  public static TYP_KABEL = "typen_kabelabschnitt";
+  public static TYP_DROSSEL = "typen_kdrossel";
+  public static TYP_TRAFO2W = "typen_trafo2w";
+  public static TYP_TRAFO3W = "typen_trafo3w";
+  public static FUEL_TYPES = "typen_primaerenergie";
+
+  // Netzschema/ Geo
+  public static NETZVARIANTEN = "allg_netzvarianten";
+  public static NSG_STANDORT = "nsg_nsgstandort";
+  public static NSG_KNOTEN_SO = "nsg_nsgknotenso";
+  public static NSG_SCHALTANLAGE = "nsg_nsgschaltanlage";
+  public static NSG_SCHALTANLAGENABSCHNITT = "nsg_nsgsaabschnitt";
+  public static NSG_SCHALTFELD = "nsg_nsgschaltfeld";
+  public static NSG_TRAFO2W = "nsg_nsgtrafo2w";
+  public static NSG_TRAFO3W = "nsg_nsgtrafo3w";
+  public static NSG_ABSTACTION = "nsg_nsgabstraction";
+  public static NSG_QUERZWEIG = "nsg_nsgquerzweig";
+  public static NSG_QUERKUPPLUNG = "nsg_nsgkpfeld";
+  public static NSG_DROSSEL = "nsg_nsgldrossel";
+
+  public static NSG_LEITUNG = "nsg_nsgleitung";
+  public static NSG_LEITUNGSPUNKT = "nsg_nsgltgpunkt";
+
+}
+
+export class I7Objects {
+
+  public static REGION = "REGION";
+  public static SUBREGION = "SUBREGION";
+
+  public static STANDORT = "STANDORT";
+  public static SCHALTANLAGE = "SCHALTANLAGE";
+  public static SCHALTANLAGENABSCHNITT = "SCHALTANLAGENABSCHNITT";
+  public static SAMMELSCHIENE = "SAMMELSCHIENE"
+  public static KNOTEN_SO = "KNOTEN_SO";
+  public static SCHALTFELD = "SCHALTFELD";
+  public static KNOTEN_SF = "KNOTEN_SF";
+  public static SCHLAUFE = "SCHLAUFE";
+  public static KNOTEN_ZW = "KNOTEN_ZW";
+  public static TRENNER_3P = "TRENNER_3P";
+  public static TRENNERFI_3P = "TRENNERFI_3P";
+  public static LEISTUNGSSCHALTER = "LEISTUNGSSCHALTER";
+  public static LEITUNG = "LEITUNG";
+  public static FREILEITUNG = "FREILEITUNG";
+  public static KABEL = "KABEL";
+  public static ERSATZLAENGSZWEIG = "ERSATZLAENGSZWEIG";
+  public static TRAFO2W = "TRAFO2W";
+  public static TRAFO3W = "TRAFO3W";
+  public static TRAFO3_WICKLUNG = "TRAFO3_WICKLUNG";
+  public static TRAFO3W_KNOTEN = "TRAFO3W_KNOTEN";
+
+  public static QUERKUPPLUNG = "QUERKUPPLUNG";
+  public static KNOTEN_KF = "KNOTEN_KF";
+  public static LAENGSKUPPLUNG = "LAENGSKUPPLUNG";
+  public static KNOTEN_LK = "KNOTEN_LK";
+
+  public static KNOTEN_STARR = "KNOTEN_STARR";
+
+  public static BELASTUNG = "BELASTUNG";
+  public static EINSPEISUNG = "EINSPEISUNG";
+  public static GENERATOR = "GENERATOR";
+  public static ASYNCHRONMOTOR = "ASYNCHRONMOTOR";
+  public static BOUNDARYINJECTION = "BOUNDARYINJECTION";
+
+  public static TYP_FREILEITUNG = "TYP_FREILEITUNG";
+  public static TYP_KABEL = "TYP_KABEL";
+  public static TYP_DROSSEL = "TYP_DROSSEL";
+  public static TYP_TRAFO2W = "TYP_TRAFO2W";
+  public static TYP_TRAFO3W = "TYP_TRAFO3W";
+  public static FUEL_TYPES = "FUEL_TYPES";
+
+  // Netzschema/ Geo
+  public static NETZVARIANTEN = "NETZVARIANTEN";
+  public static NSG_STANDORT = "NSG_STANDORT";
+  public static NSG_KNOTEN_SO = "NSG_KNOTEN_SO";
+  public static NSG_SCHALTANLAGE = "NSG_SCHALTANLAGE";
+  public static NSG_SCHALTANLAGENABSCHNITT = "NSG_SCHALTANLAGENABSCHNITT";
+  public static NSG_SCHALTFELD = "NSG_SCHALTFELD";
+  public static NSG_TRAFO2W = "NSG_TRAFO2W";
+  public static NSG_TRAFO3W = "NSG_TRAFO3W";
+  public static NSG_ABSTACTION = "NSG_ABSTACTION";
+  public static NSG_QUERZWEIG = "NSG_QUERZWEIG";
+  public static NSG_QUERKUPPLUNG = "NSG_QUERKUPPLUNG";
+  public static NSG_DROSSEL = "NSG_DROSSEL";
+
+  public static NSG_LEITUNG = "NSG_LEITUNG";
+  public static NSG_LEITUNGSPUNKT = "NSG_LEITUNGSPUNKT";
+
+}
+
+/**
+ * @param limit Begrenzung des Abfragergebnisses auf vorgebene Anzahl der Datensätze
+ * @param offset Berüchsichtigung der Daten ab vorgebenen Index */
+export function getNetzQuery(objectName: I7Objects, limit: number, offset: number, whereIDs: number[]) {
+  switch (objectName) {
+    case I7Objects.REGION: {
+      return `SELECT id, bezeichner, kurzname, guid FROM ${Integral7TableNames[I7Objects.REGION]};`
+    }
+    case I7Objects.SUBREGION: {
+      return `SELECT id, bezeichner, kurzname, guid, georegion FROM ${Integral7TableNames[I7Objects.SUBREGION]};`;
+    }
+    case I7Objects.STANDORT: {
+      return `SELECT * FROM ${Integral7TableNames[I7Objects.STANDORT]} LIMIT ${limit} OFFSET ${offset};`;
+    }
+    case I7Objects.NSG_STANDORT: {
+      return `SELECT variantennr, id, xrel, yrel, standort FROM ${Integral7TableNames[I7Objects.NSG_STANDORT]} WHERE ${getWhereIDs('standort', whereIDs).join(' OR ')};`;
+    }
+    case I7Objects.SCHALTANLAGE: {
+      const sql = [];
+      for (const saID of whereIDs) {
+        sql.push(`standort=${saID}`);
+      }
+      return `SELECT * FROM ${Integral7TableNames[I7Objects.SCHALTANLAGE]} WHERE ${sql.join(' OR ')};`;
+    }
+    case I7Objects.NSG_SCHALTANLAGE: {
+      return `SELECT variantennr, id, xrel, yrel, ausrichtung, schaltanlage, nsgso FROM ${Integral7TableNames[I7Objects.NSG_SCHALTANLAGE]} WHERE ${getWhereIDs('schaltanlage', whereIDs).join(' OR ')};`;
+    }
+    case I7Objects.SCHALTANLAGENABSCHNITT: {
+      const sql = [];
+      for (const saID of whereIDs) {
+        sql.push(`schaltanlage=${saID}`);
+      }
+      return `SELECT * FROM ${Integral7TableNames[I7Objects.SCHALTANLAGENABSCHNITT]} WHERE ${sql.join(' OR ')};`;
+    }
+    case I7Objects.NSG_SCHALTANLAGENABSCHNITT: {
+      return `SELECT variantennr, id, laenge, nslots, saabschnitt, nsgsa FROM ${Integral7TableNames[I7Objects.NSG_SCHALTANLAGENABSCHNITT]} WHERE ${getWhereIDs('saabschnitt', whereIDs).join(' OR ')};`;
+    }
+    case I7Objects.SAMMELSCHIENE: {
+      const sql = [];
+      for (const saabID of whereIDs) {
+        sql.push(`saabschnitt=${saabID}`);
+      }
+      return `SELECT * FROM ${Integral7TableNames[I7Objects.SAMMELSCHIENE]} WHERE ${sql.join(' OR ')};`;
+    }
+    case I7Objects.KNOTEN_SO: {
+      return `SELECT id ,bezeichner, kurzname, guid, standort, un  FROM ${Integral7TableNames[I7Objects.KNOTEN_SO]} WHERE ${getWhereIDs('standort', whereIDs).join(' OR ')};`;
+    }
+    case I7Objects.NSG_KNOTEN_SO: {
+      return `SELECT variantennr, id, xrel, yrel, knotenso, nsgso  FROM ${Integral7TableNames[I7Objects.NSG_KNOTEN_SO]} WHERE ${getWhereIDs('knotenso', whereIDs).join(' OR ')};`;
+    }
+    case I7Objects.SCHALTFELD: {
+      // console.log(`SELECT id, bezeichner, kurzname, namezuvtyp_sel, seltyp, feldnummer, slotnummer, baujahr, nametyp, saabschnitt, guid  FROM ${Integral7TableNames[I7Objects.SCHALTFELD]} WHERE ${getWhereIDs('saabschnitt', whereIDs).join(' OR ')};`);
+      return `SELECT id, bezeichner, kurzname, namezuvtyp_sel, seltyp, feldnummer, slotnummer, baujahr, nametyp, saabschnitt, guid, feldnummer, ips_folder_id  FROM ${Integral7TableNames[I7Objects.SCHALTFELD]} WHERE ${getWhereIDs('saabschnitt', whereIDs).join(' OR ')};`;
+    }
+    case I7Objects.NSG_SCHALTFELD: {
+      return `SELECT variantennr, id, deltaausrichtung, hoehe, slotnummer, nsgsaa, schaltfeld FROM ${Integral7TableNames[I7Objects.NSG_SCHALTFELD]} WHERE ${getWhereIDs('schaltfeld', whereIDs).join(' OR ')};`;
+    }
+    case I7Objects.KNOTEN_SF: {
+      // console.log(`SELECT id, bezeichner, kurzname, schaltfeld, geerdet FROM ${Integral7TableNames[I7Objects.KNOTEN_SF]} WHERE ${getWhereIDs('schaltfeld', whereIDs).join(' OR ')};`);
+      return `SELECT id, bezeichner, kurzname, schaltfeld, geerdet FROM ${Integral7TableNames[I7Objects.KNOTEN_SF]} WHERE ${getWhereIDs('schaltfeld', whereIDs).join(' OR ')};`;
+    }
+    case I7Objects.KNOTEN_STARR: {
+      return `SELECT * FROM ${Integral7TableNames[I7Objects.KNOTEN_STARR]}  WHERE ${getWhereIDs('seliste', whereIDs).join(' OR ')};`;
+    }
+    case I7Objects.LEITUNG: {
+      return `SELECT * FROM ${Integral7TableNames[I7Objects.LEITUNG]} LIMIT ${limit} OFFSET ${offset};`;
+    }
+    case I7Objects.FREILEITUNG: {
+      return `SELECT * FROM ${Integral7TableNames[I7Objects.FREILEITUNG]} WHERE ${getWhereIDs('leitung', whereIDs).join(' OR ')};`;
+    }
+    case I7Objects.KABEL: {
+      return `SELECT * FROM ${Integral7TableNames[I7Objects.KABEL]} WHERE ${getWhereIDs('leitung', whereIDs).join(' OR ')};`;
+    }
+    case I7Objects.ERSATZLAENGSZWEIG: {
+      return `SELECT * FROM ${Integral7TableNames[I7Objects.ERSATZLAENGSZWEIG]} LIMIT ${limit} OFFSET ${offset};`;
+    }
+    case I7Objects.TRAFO2W: {
+      // return `SELECT * FROM ${Integral7TableNames[I7Objects.TRAFO2W]} WHERE ${getWhereIDs('standort', whereIDs).join(' OR ')};`;
+      return `SELECT * FROM ${Integral7TableNames[I7Objects.TRAFO2W]} LIMIT ${limit} OFFSET ${offset};`;
+    }
+    case I7Objects.TRAFO3W: {
+      return `SELECT * FROM ${Integral7TableNames[I7Objects.TRAFO3W]} LIMIT ${limit} OFFSET ${offset};`;
+    }
+/*    case I7Objects.TRAFO3W: {
+      return `SELECT * FROM ${Integral7TableNames[I7Objects.TRAFO3W]} WHERE ${getWhereIDs('standort', whereIDs).join(' OR ')};`;
+    }*/
+    case I7Objects.TRAFO3_WICKLUNG: {
+      return `SELECT * FROM ${Integral7TableNames[I7Objects.TRAFO3_WICKLUNG]} WHERE ${getWhereIDs('trafo3w', whereIDs).join(' OR ')};`;
+    }
+    case I7Objects.TRAFO3W_KNOTEN: {
+      return `SELECT * FROM ${Integral7TableNames[I7Objects.TRAFO3W_KNOTEN]} WHERE ${getWhereIDs('trafo3w', whereIDs).join(' OR ')};`;
+    }
+    case I7Objects.QUERKUPPLUNG: {
+      return `SELECT id, bezeichner, kurzname, langname, seltyp, saabschnitt, guid, default_zust_anf,default_zust_end, slotnummer, feldnummer, ips_folder_id FROM ${Integral7TableNames[I7Objects.QUERKUPPLUNG]} WHERE ${getWhereIDs('saabschnitt', whereIDs).join(' OR ')};`;
+    }
+
+    case I7Objects.KNOTEN_KF: {
+      return `SELECT id, bezeichner, kurzname, kpfeld, geerdet FROM ${Integral7TableNames[I7Objects.KNOTEN_KF]} WHERE ${getWhereIDs('kpfeld', whereIDs).join(' OR ')};`;
+    }
+    case I7Objects.LAENGSKUPPLUNG: {
+      return `SELECT id, bezeichner, kurzname, langname, guid, seltyp, schaltanlage, saa_anf, saa_end, default_zust_anf,default_zust_end, slotnummer, feldnummer, ips_folder_id  FROM ${Integral7TableNames[I7Objects.LAENGSKUPPLUNG]} WHERE ${getWhereIDs('schaltanlage', whereIDs).join(' OR ')};`;
+    }
+    case I7Objects.KNOTEN_LK: {
+      return `SELECT id, bezeichner,geerdet,lkupplung,kurzname FROM ${Integral7TableNames[I7Objects.KNOTEN_LK]} WHERE ${getWhereIDs('lkupplung', whereIDs).join(' OR ')};`;
+    }
+
+    case I7Objects.SCHLAUFE: {
+      return `SELECT id, bezeichner,kurzname, aknoten,eknoten,schaltzustand,knotenzw FROM ${Integral7TableNames[I7Objects.SCHLAUFE]} WHERE ${getWhereIDs('eknoten', whereIDs).join(' OR ')};`;
+    }
+
+    case I7Objects.KNOTEN_ZW: {
+      return `SELECT id,bezeichner,kurzname,geerdet,schlaufe,bzweig3p  FROM ${Integral7TableNames[I7Objects.KNOTEN_ZW]} WHERE ${getWhereIDs('schlaufe', whereIDs).join(' OR ')};`;
+    }
+
+    case I7Objects.TRENNER_3P: {
+      return `SELECT id, bezeichner, kurzname, aknoten, eknoten, schaltzustand, seliste  FROM ${Integral7TableNames[I7Objects.TRENNER_3P]} WHERE ${getWhereIDs('seliste', whereIDs).join(' OR ')};`;
+    }
+    case I7Objects.TRENNERFI_3P: {
+      return `SELECT * FROM ${Integral7TableNames[I7Objects.TRENNERFI_3P]} WHERE ${getWhereIDs('seliste', whereIDs).join(' OR ')};`;
+    }
+    case I7Objects.LEISTUNGSSCHALTER: {
+      return `SELECT id, bezeichner, kurzname, aknoten, eknoten, schaltzustand, seliste FROM ${Integral7TableNames[I7Objects.LEISTUNGSSCHALTER]} WHERE ${getWhereIDs('seliste', whereIDs).join(' OR ')};`;
+    }
+    case I7Objects.BELASTUNG: {
+      // console.log(`SELECT * FROM ${Integral7TableNames[I7Objects.BELASTUNG]} WHERE ${getWhereIDs('anschluss', whereIDs).join(' OR ')};`);
+      return `SELECT * FROM ${Integral7TableNames[I7Objects.BELASTUNG]} WHERE ${getWhereIDs('anschluss', whereIDs).join(' OR ')};`;
+    }
+    case I7Objects.EINSPEISUNG: {
+      return `SELECT * FROM ${Integral7TableNames[I7Objects.EINSPEISUNG]} WHERE ${getWhereIDs('anschluss', whereIDs).join(' OR ')};`;
+    }
+    case I7Objects.GENERATOR: {
+      return `SELECT * FROM ${Integral7TableNames[I7Objects.GENERATOR]} WHERE ${getWhereIDs('anschluss', whereIDs).join(' OR ')};`;
+    }
+    case I7Objects.ASYNCHRONMOTOR: {
+      return `SELECT * FROM ${Integral7TableNames[I7Objects.ASYNCHRONMOTOR]} LIMIT ${limit} OFFSET ${offset};`;
+    }
+    case I7Objects.BOUNDARYINJECTION: {
+      return `SELECT * FROM ${Integral7TableNames[I7Objects.BOUNDARYINJECTION]} LIMIT ${limit} OFFSET ${offset};`;
+    }
+    case I7Objects.TYP_FREILEITUNG: {
+      return `SELECT * FROM ${Integral7TableNames[I7Objects.TYP_FREILEITUNG]};`;
+    }
+    case I7Objects.TYP_KABEL: {
+      return `SELECT * FROM ${Integral7TableNames[I7Objects.TYP_KABEL]};`;
+    }
+    case I7Objects.TYP_DROSSEL: {
+      return `SELECT * FROM ${Integral7TableNames[I7Objects.TYP_DROSSEL]} LIMIT ${limit} OFFSET ${offset};`;
+    }
+    case I7Objects.TYP_TRAFO2W: {
+      return `SELECT * FROM ${Integral7TableNames[I7Objects.TYP_TRAFO2W]};`;
+    }
+    case I7Objects.TYP_TRAFO3W: {
+      return `SELECT * FROM ${Integral7TableNames[I7Objects.TYP_TRAFO3W]};`;
+    }
+    case I7Objects.FUEL_TYPES: {
+      return `SELECT * FROM ${Integral7TableNames[I7Objects.FUEL_TYPES]};`;
+    }
+    case I7Objects.NETZVARIANTEN: {
+      return `SELECT * FROM ${Integral7TableNames[I7Objects.NETZVARIANTEN]};`;
+    }
+
+  }
+}
+
+export function getWhereIDs(attr: string, whereIDs: number[]): string[] {
+  const sql = [];
+  for (const saID of whereIDs) {
+    sql.push(`${attr}=${saID}`);
+  }
+  return sql;
+}
+
+// Netzschema
+export const NETZVARIANTEN_SQL_QUERY = `SELECT * FROM ${Integral7TableNames['NETZVARIANTEN']};`;
+export const NSG_STANDORT_SQL_QUERY = `SELECT * FROM ${Integral7TableNames['NSG_STANDORT']};`;
+export const NSG_KNOTEN_SO_SQL_QUERY = `SELECT * FROM ${Integral7TableNames['NSG_KNOTEN_SO']};`;
+export const NSG_SCHALTANLAGE_SQL_QUERY = `SELECT * FROM ${Integral7TableNames['NSG_SCHALTANLAGE']};`;
+export const NSG_SCHALTANLAGENABSCHNITT_SQL_QUERY = `SELECT * FROM ${Integral7TableNames['NSG_SCHALTANLAGENABSCHNITT']};`;
+export const NSG_SCHALTFELD_SQL_QUERY = `SELECT * FROM ${Integral7TableNames['NSG_SCHALTFELD']};`;
+export const NSG_TRAFO2W_SQL_QUERY = `SELECT * FROM ${Integral7TableNames['NSG_TRAFO2W']};`;
+export const NSG_TRAFO3W_SQL_QUERY = `SELECT * FROM ${Integral7TableNames['NSG_TRAFO3W']};`;
+export const NSG_ABSTACTION_SQL_QUERY = `SELECT * FROM ${Integral7TableNames['NSG_ABSTACTION']};`;
+export const NSG_QUERZWEIG_SQL_QUERY = `SELECT * FROM ${Integral7TableNames['NSG_QUERZWEIG']};`;
+export const NSG_QUERKUPPLUNG_SQL_QUERY = `SELECT * FROM ${Integral7TableNames['NSG_QUERKUPPLUNG']};`;
+export const NSG_DROSSEL_SQL_QUERY = `SELECT * FROM ${Integral7TableNames['NSG_DROSSEL']};`;
+
+
+export const NSG_LEITUNG_SQL_QUERY = `SELECT * FROM ${Integral7TableNames['NSG_LEITUNG']};`;
+export const NSG_LEITUNGSPUNKT_SQL_QUERY = `SELECT * FROM ${Integral7TableNames['NSG_LEITUNGSPUNKT']};`;

package/src/converter/integral7/utils-schema.ts

@@ -0,0 +1,50 @@
+import {
+  ConductingEquipment,
+  ConnectivityNode, ConverterIntegral7,
+  Diagram,
+  DiagramObject,
+  DiagramObjectPoint,
+  generateUUID,
+  IdentifiedObject,
+} from '../..';
+import { Point } from './model/integral/Point';
+
+export function createDiagramObjectPoints(diagramObject: DiagramObject, points: Point[]) {
+  for (let i = 0; i < points.length; i++) {
+    const p = points[i];
+    const diagramObjectPoint = new DiagramObjectPoint(p.x, p.y, (i + 1));
+    diagramObjectPoint.mrid = generateUUID();
+    diagramObjectPoint.diagramObject = diagramObject;
+    diagramObject.addDiagramObjectPoint(diagramObjectPoint);
+  }
+}
+
+
+export function getPsrDiagramObject(diagram: Diagram, psrObject: IdentifiedObject): DiagramObject | undefined {
+  for (const diagramObject of psrObject.diagramObjects) {
+    if(diagram.mrid === diagramObject.diagram.mrid) {
+      return diagramObject;
+    }
+  }
+  return;
+}
+
+export function isConnectedTo(connectivityNode: ConnectivityNode, equipmentName: string): ConductingEquipment | undefined {
+  for (const terminal of connectivityNode.terminals.values()) {
+    const ce = terminal.conductingEquipment;
+    if(ce && ce.constructor.name === equipmentName) {
+      return terminal.conductingEquipment;
+    }
+  }
+  return;
+}
+
+export function getDiagramObjectBelonginToDiagram(diagramObjects: DiagramObject[], diagramUUID: string): DiagramObject | undefined {
+  for (const diagramObject of diagramObjects) {
+    if(diagramObject.diagram && diagramObject.diagram.mrid === diagramUUID) {
+      return diagramObject;
+    }
+  }
+  return;
+}
+

package/src/converter/integral7/utils-trafo3w.ts

@@ -0,0 +1,321 @@
+import { Impedanz } from './model/interfaces';
+
+
+export function calculateImpedanzenTrafo3W(wicklung: number,
+                                           ur1: number, ur2: number, ur3: number,
+                                           sr1: number, sr2: number, sr3: number,
+                                           pkr12: number, pkr13: number, pkr23: number,
+                                           ukr12: number, ukr13: number, ukr23: number,
+                                           pLeer: number, iLeer: number): Impedanz {
+
+
+  const z12 = calculateZ12(wicklung, ur1, ur2, ur3, sr2, ukr12);
+  const z23 = calculateZ23(wicklung, ur1, ur2, ur3, sr3, ukr23);
+  const z13 = calculateZ13(wicklung, ur1, ur2, ur3, sr3, ukr13);
+
+  const z1 = calculateZ(wicklung, z12, z13, z23);
+  const z2 = calculateZ(wicklung, z12, z13, z23);
+  const z3 = calculateZ(wicklung, z12, z13, z23);
+
+  const r12 = calculateR12(wicklung, ur1, ur2, ur3, sr2, pkr12);
+  const r23 = calculateR23(wicklung, ur1, ur2, ur3, sr3, pkr23);
+  const r13 = calculateR13(wicklung, ur1, ur2, ur3, sr3, pkr13);
+
+  const r1 = calculateRTrafo3W(wicklung, r12, r13, r23);
+  const r2 = calculateRTrafo3W(wicklung, r12, r13, r23);
+  const r3 = calculateRTrafo3W(wicklung, r12, r13, r23);
+
+  const x1 = calculateXTrafo3W(wicklung, z1, z2, z3, r1, r2, r3);
+  const x2 = calculateXTrafo3W(wicklung, z1, z2, z3, r1, r2, r3);
+  const x3 = calculateXTrafo3W(wicklung, z1, z2, z3, r1, r2, r3);
+
+  const g1 = calculateGTrafo3W(wicklung, ur1, ur2, ur3, pLeer);
+  const g2 = calculateGTrafo3W(wicklung, ur1, ur2, ur3, pLeer);
+  const g3 = calculateGTrafo3W(wicklung, ur1, ur2, ur3, pLeer);
+
+  const b1 = calculateBTrafo3W(wicklung, ur1, ur2, ur3, sr1, sr2, sr3, pLeer, iLeer);
+  const b2 = calculateBTrafo3W(wicklung, ur1, ur2, ur3, sr1, sr2, sr3, pLeer, iLeer);
+  const b3 = calculateBTrafo3W(wicklung, ur1, ur2, ur3, sr1, sr2, sr3, pLeer, iLeer);
+  const impedanz  =  {
+    r: 0,
+    x: 0,
+    b: 0,
+    g: 0
+  };
+
+  switch (wicklung) {
+    case 1 :
+      impedanz['r'] = r1;
+      impedanz['x'] = x1;
+      impedanz['b'] = b1;
+      impedanz['g'] = g1;
+      break;
+    case 2 :
+      impedanz['r'] = r2;
+      impedanz['x'] = x2;
+      impedanz['b'] = b2;
+      impedanz['g'] = g2;
+      break;
+    case 3 :
+      impedanz['r'] = r3;
+      impedanz['x'] = x3;
+      impedanz['b'] = b3;
+      impedanz['g'] = g3;
+      break;
+    default:
+      console.log(`Impedanz Kein Case für Seite ${wicklung}`);
+      break;
+  }
+
+  return impedanz;
+}
+
+/**
+ * @param seite Seite, auf die sich die Berechnungen beziehen (ungeregelteSeite).
+ * @param ur1 Bemessungsspannung Wicklung 1 in kV.
+ * @param ur2 Bemessungsspannung Wicklung 2 in kV.
+ * @param ur3 Bemessungsspannung Wicklung 3 in kV.
+ * @param sr2 Bemessungsscheinleistung Wicklung 2 in MVA
+ * @param ukr12 auf Wicklung 1 und Wicklung 2 bezogene Kurzschlussspannung in %.
+ * */
+export function calculateZ12(wicklung: number, ur1: number, ur2: number, ur3: number,
+                             sr2: number, ukr12: number): number {
+  if(sr2 === 0) {
+    console.log('Division by zero. Sr2 = 0');
+    return 0;
+  }
+  switch (wicklung) {
+    case 1 :
+      return (ukr12/100) * Math.pow(ur1, 2)/sr2;
+    case 2 :
+      return (ukr12/100) * Math.pow(ur2, 2)/sr2;
+    case 3 :
+      return (ukr12/100) * Math.pow(ur3, 2)/sr2;
+    default:
+      console.log(`Z12 Kein Case für Seite ${wicklung}`);
+      return 0;
+  }
+}
+
+/**
+ * @param seite Seite, auf die sich die Berechnungen beziehen (ungeregelteSeite).
+ * @param ur1 Bemessungsspannung Wicklung 1 in kV.
+ * @param ur2 Bemessungsspannung Wicklung 2 in kV.
+ * @param ur3 Bemessungsspannung Wicklung 3 in kV.
+ * @param sr3 Bemessungsscheinleistung Wicklung 3 in MVA
+ * @param ukr23 auf Wicklung 2 und Wicklung 3 bezogene Kurzschlussspannung in %.
+ * */
+export function calculateZ23(wicklung: number, ur1: number, ur2: number, ur3: number,
+                             sr3: number, ukr23: number): number {
+  if(sr3 === 0) {
+    console.log('Division by zero. sr3 = 0');
+    return 0;
+  }
+  switch (wicklung) {
+    case 1 :
+      return (ukr23/100) * Math.pow(ur1, 2)/sr3;
+    case 2 :
+      return (ukr23/100) * Math.pow(ur2, 2)/sr3;
+    case 3 :
+      return (ukr23/100) * Math.pow(ur3, 2)/sr3;
+    default:
+      console.log(`Z23 Kein Case für Seite ${wicklung}`);
+      return 0;
+  }
+}
+
+/**
+ * @param seite Seite, auf die sich die Berechnungen beziehen (ungeregelteSeite).
+ * @param ur1 Bemessungsspannung Wicklung 1 in kV.
+ * @param ur2 Bemessungsspannung Wicklung 2 in kV.
+ * @param ur3 Bemessungsspannung Wicklung 3 in kV.
+ * @param sr3 Bemessungsscheinleistung Wicklung 3 in MVA
+ * @param ukr13 auf Wicklung 1 und Wicklung 3 bezogene Kurzschlussspannung in %.
+ * */
+export function calculateZ13(wicklung: number, ur1: number, ur2: number, ur3: number,
+                             sr3: number, ukr13: number): number {
+  if(sr3 === 0) {
+    console.log('Division by zero. sr3 = 0');
+    return 0;
+  }
+  switch (wicklung) {
+    case 1 :
+      return (ukr13/100) * Math.pow(ur1, 2)/sr3;
+    case 2 :
+      return (ukr13/100) * Math.pow(ur2, 2)/sr3;
+    case 3 :
+      return (ukr13/100) * Math.pow(ur3, 2)/sr3;
+    default:
+      console.log(`Z23 Kein Case für Seite ${wicklung}`);
+      return 0;
+  }
+}
+
+
+/**
+ * @param wicklung Berechnung des Scheinwiderstandes für Wicklung .
+ * @param z12 Scheinwiderstand Wicklung 1 in Relation zu Wicklung 2.
+ * @param z13 Scheinwiderstand Wicklung 1 in Relation zu Wicklung 3.
+ * @param z23 Scheinwiderstand Wicklung 2 in Relation zu Wicklung 3.
+ * */
+export function calculateZ(wicklung: number, z12: number, z13: number, z23: number): number {
+  switch (wicklung) {
+    case 1 :
+      return (z12 - z23 + z13)/2;
+    case 2 :
+      return (z12 + z23 - z13)/2;
+    case 3 :
+      return (-z12 + z23 + z13)/2;
+    default:
+      console.log(`Z kein Case für Wicklung ${wicklung}`);
+      return 0;
+  }
+}
+
+/**
+ * @param wicklung Seite, auf die sich die Berechnungen beziehen (ungeregelteSeite).
+ * @param ur1 Bemessungsspannung Wicklung 1 in kV.
+ * @param ur2 Bemessungsspannung Wicklung 2 in kV.
+ * @param ur3 Bemessungsspannung Wicklung 3 in kV.
+ * @param sr2 Bemessungsscheinleistung Wicklung 2 in MVA
+ * @param pkr12 auf Wicklung 1 und Wicklung 2 bezogene Kurzschlussverluste in kW.
+ * */
+export function calculateR12(wicklung: number, ur1: number, ur2: number, ur3: number,
+                             sr2: number, pkr12: number): number {
+  if(sr2 === 0) {
+    console.log('Division by zero. Sr2 = 0');
+    return 0;
+  }
+  switch (wicklung) {
+    case 1 :
+      return pkr12 * Math.pow(ur1, 2)/Math.pow(sr2, 2)/1000;
+    case 2 :
+      return pkr12 * Math.pow(ur2, 2)/Math.pow(sr2, 2)/1000; // durch 1000 -> mega in kilo umrechnen
+    case 3 :
+      return pkr12 * Math.pow(ur3, 2)/Math.pow(sr2, 2)/1000;
+    default:
+      console.log(`R12 kein Case für Seite ${wicklung}`);
+      return 0;
+  }
+}
+
+/**
+ * @param wicklung Seite, auf die sich die Berechnungen beziehen (ungeregelteSeite).
+ * @param ur1 Bemessungsspannung Wicklung 1 in kV.
+ * @param ur2 Bemessungsspannung Wicklung 2 in kV.
+ * @param ur3 Bemessungsspannung Wicklung 3 in kV.
+ * @param sr3 Bemessungsscheinleistung Wicklung 3 in MVA
+ * @param pkr23 auf Wicklung 2 und Wicklung 3 bezogene Kurzschlussverluste in kW.
+ * */
+export function calculateR23(wicklung: number, ur1: number, ur2: number, ur3: number,
+                             sr3: number, pkr23: number): number {
+  if(sr3 === 0) {
+    console.log('Division by zero. sr3 = 0');
+    return 0;
+  }
+  switch (wicklung) {
+    case 1 :
+      return pkr23 * Math.pow(ur1, 2)/Math.pow(sr3, 2)/1000;
+    case 2 :
+      return pkr23 * Math.pow(ur2, 2)/Math.pow(sr3, 2)/1000; // durch 1000 -> mega in kilo umrechnen
+    case 3 :
+      return pkr23 * Math.pow(ur3, 2)/Math.pow(sr3, 2)/1000;
+    default:
+      console.log(`R12 kein Case für Seite ${wicklung}`);
+      return 0;
+  }
+}
+
+/**
+ * @param wicklung Seite, auf die sich die Berechnungen beziehen (ungeregelteSeite).
+ * @param ur1 Bemessungsspannung Wicklung 1 in kV.
+ * @param ur2 Bemessungsspannung Wicklung 2 in kV.
+ * @param ur3 Bemessungsspannung Wicklung 3 in kV.
+ * @param sr3 Bemessungsscheinleistung Wicklung 3 in MVA
+ * @param pkr23 auf Wicklung 2 und Wicklung 3 bezogene Kurzschlussverluste in kW.
+ * */
+export function calculateR13(wicklung: number, ur1: number, ur2: number, ur3: number,
+                             sr3: number, pkr13: number): number {
+  if(sr3 === 0) {
+    console.log('Division by zero. sr3 = 0');
+    return 0;
+  }
+  switch (wicklung) {
+    case 1 :
+      return pkr13 * Math.pow(ur1, 2)/Math.pow(sr3, 2)/1000;
+    case 2 :
+      return pkr13 * Math.pow(ur2, 2)/Math.pow(sr3, 2)/1000; // durch 1000 -> mega in kilo umrechnen
+    case 3 :
+      return pkr13 * Math.pow(ur3, 2)/Math.pow(sr3, 2)/1000;
+    default:
+      console.log(`R12 kein Case für Seite ${wicklung}`);
+      return 0;
+  }
+}
+
+/**
+ * @param wicklung Berechnung des Scheinwiderstandes für Wicklung .
+ * @param z12 Scheinwiderstand Wicklung 1 in Relation zu Wicklung 2.
+ * @param z13 Scheinwiderstand Wicklung 1 in Relation zu Wicklung 3.
+ * @param z23 Scheinwiderstand Wicklung 2 in Relation zu Wicklung 3.
+ * */
+export function calculateRTrafo3W(wicklung: number, r12: number, r13: number, r23: number): number {
+  switch (wicklung) {
+    case 1 :
+      return (r12 - r23 + r13)/2;
+    case 2 :
+      return (r12 + r23 - r13)/2;
+    case 3 :
+      return (-r12 + r23 + r13)/2;
+    default:
+      console.log(`Z kein Case für Wicklung ${wicklung}`);
+      return 0;
+  }
+}
+
+
+export function calculateXTrafo3W(wicklung: number, z1: number, z2: number, z3: number, r1: number, r2: number, r3: number) {
+  switch (wicklung) {
+    case 1 :
+      return Math.sqrt(Math.pow(z1,2) - Math.pow(r1,2)) * z1 / Math.abs(z1);
+    case 2 :
+      return Math.sqrt(Math.pow(z2,2) - Math.pow(r2,2)) * z2 / Math.abs(z2);
+    case 3 :
+      return Math.sqrt(Math.pow(z3,2) - Math.pow(r3,2)) * z3 / Math.abs(z3);
+    default:
+      console.log(`X kein Case für Wicklung ${wicklung}`);
+      return 0;
+  }
+}
+
+
+export function calculateGTrafo3W(wicklung: number,  ur1: number, ur2: number, ur3: number,
+                                  pLeer: number) {
+  switch (wicklung) {
+    case 1 :
+      return pLeer / Math.pow(ur1,2) * 1000;
+    case 2 :
+      return pLeer / Math.pow(ur2,2) * 1000;
+    case 3 :
+      return pLeer / Math.pow(ur3,2) * 1000;
+    default:
+      console.log(`G kein Case für Wicklung ${wicklung}`);
+      return 0;
+  }
+}
+
+export function calculateBTrafo3W(wicklung: number, ur1: number, ur2: number, ur3: number,
+                                  sr1: number, sr2: number, sr3: number,
+                                  pLeer: number, iLeer: number) {
+  switch (wicklung) {
+    case 1 :
+      return Math.sqrt(Math.pow(sr1,2) * Math.pow(iLeer,2) - Math.pow(pLeer,2))/ Math.pow(ur1,2) * -1000;
+    case 2 :
+      return Math.sqrt(Math.pow(sr2,2) * Math.pow(iLeer,2) - Math.pow(pLeer,2))/ Math.pow(ur2,2) * -1000;
+    case 3 :
+      return Math.sqrt(Math.pow(sr3,2) * Math.pow(iLeer,2) - Math.pow(pLeer,2))/ Math.pow(ur3,2) * -1000;
+    default:
+      console.log(`G kein Case für Wicklung ${wicklung}`);
+      return 0;
+  }
+}