@enervance/insight-cim-model 0.0.1 → 0.0.3

package/src/converter/integral7/config/db-config.ts

@@ -8,5 +8,6 @@
   }
   export interface Status {
     status: 'successful' | 'error';
-    message: any;
-  }
+    message: string;
+    data?: NodeJS.ReadableStream;
+  }

package/src/converter/integral7/model/integral/Hgueleitung.ts

@@ -0,0 +1,12 @@
+import { BaseClass } from '../interfaces';
+
+
+export interface Hgueleitung extends BaseClass {
+  anetzobjekt: number;
+  enetzobjekt: number;
+  bipol: number;
+  rdc: number;
+  pr: number;
+  ur: number;
+
+}

package/src/converter/integral7/model/integral/Kopfstation.ts

@@ -0,0 +1,46 @@
+import { BaseClass } from '../interfaces';
+
+export interface Kopfstation extends BaseClass {
+  anschluss: number;
+  betrieb: number;
+
+  u_geregelt: number;
+  p_geregelt: number;
+  grad_geregelt: number;
+
+  alpha: number;
+  gamma: number;
+  rix: number;
+
+  kr: number;
+  kr_dc: number;
+
+  ranking_dc: number;
+  ranking_nr: number;
+
+
+  winkel_1: number;
+  winkel_2: number;
+
+  nachbar_ng: number;
+
+  pr: number;
+  ur: number;
+
+  pges: number;
+  uges: number;
+
+  udc: number;
+
+  p_min: number;
+  p_max: number;
+  q_min: number;
+  q_max: number;
+  p_leer: number;
+  pkr: number;
+
+  pgrad: number;
+  usoll: number;
+
+
+}

package/src/converter/integral7/model/interfaces.ts

@@ -37,32 +37,32 @@ export interface Standort extends BaseClass {
 
 }
 
-export interface Anlage extends BaseClass{
+export interface Anlage extends BaseClass {
   standort: number,
   un: number;
 }
 
 
-export interface AnlagenAbschnitt extends BaseClass{
+export interface AnlagenAbschnitt extends BaseClass {
   schaltanlage: number,
   pos: number;
 }
 
-export interface Abzweig extends BaseClass{
+export interface Abzweig extends BaseClass {
   standort: number,
   un: number;
   netzgruppe: number;
   id_psse_cape: number;
 }
 
-export interface Schaltfeld extends BaseClass{
+export interface Schaltfeld extends BaseClass {
   seltyp: number,
   saabschnitt: number;
   feldnummer: number;
   ips_folder_id: string;
 }
 
-export interface NsgSchaltfeld extends SchemaObject{
+export interface NsgSchaltfeld extends SchemaObject {
   deltaausrichtung: number,
   hoehe: number;
   nsgsaa: number,
@@ -71,9 +71,7 @@ export interface NsgSchaltfeld extends SchemaObject{
 }
 
 
-
-
-export interface SchaltfeldKnoten extends BaseClass{
+export interface SchaltfeldKnoten extends BaseClass {
   schaltfeld: number,
 
 }
@@ -121,7 +119,7 @@ export interface NsgLeitungsPunkt extends SchemaObject {
   abstand_rel_anchor_m: number;
 }
 
-export interface Stk extends BaseClass{
+export interface Stk extends BaseClass {
   leitung: number;
   laenge: number;
   un: number;
@@ -136,6 +134,15 @@ export interface Stk extends BaseClass{
   tend: number;
 }
 
+export interface Ldrossel extends BaseClass, Connection {
+  standort: number,
+  ur: number;
+  ir: number;
+  ukr: number;
+  pkr: number;
+  id_psse_cape: number;
+}
+
 export interface StkTyp {
   id: number;
   name: string
@@ -234,8 +241,8 @@ export interface Wicklung {
   guid_w3: string,
 
 
-
 }
+
 export interface Trafo2w extends BaseClass, Connection, Wicklung {
   standort: number;
   name: string;
@@ -245,8 +252,6 @@ export interface Trafo2w extends BaseClass, Connection, Wicklung {
 }
 
 
-
-
 export interface Trafo3w extends BaseClass, Connection, Wicklung {
   standort: number;
   name: string;
@@ -311,6 +316,7 @@ export interface Belastung extends BaseClass {
   flag_ind: number;
   multfaktor: number;
 }
+
 export interface Einspeisung extends Belastung {
   einspprio: number;
   kr: number;
@@ -412,6 +418,7 @@ export interface NsgSAAB extends SchemaObject {
   saabschnitt: number;
   nsgsa: number;
 }
+
 export interface NsgLeitung extends SchemaObject {
   leitung: number;
   anschlussanf: number;
@@ -435,9 +442,9 @@ export interface NsgLeitungsPunkt extends SchemaObject {
 }
 
 export interface Impedanz {
-    r: number;
-    x: number;
-    g: number;
-    b: number;
+  r: number;
+  x: number;
+  g: number;
+  b: number;
 }
 

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

@@ -21,6 +21,7 @@ export class Integral7TableNames {
   public static ERSATZLAENGSZWEIG = "netz_ersatzlaengszweig";
   public static TRAFO2W = "netz_trafo2w";
   public static TRAFO3W = "netz_trafo3w";
+  public static LAENGSDROSSEL = "netz_ldrossel";
   public static TRAFO3_WICKLUNG = "netz_trafowicklung3w";
   public static TRAFO3W_KNOTEN = "netz_knotent3w";
 
@@ -37,6 +38,9 @@ export class Integral7TableNames {
   public static ASYNCHRONMOTOR = "netz_asynchronmotor";
   public static BOUNDARYINJECTION = "netz_boundaryinjection";
 
+  public static HGUE_LEITUNG = "netz_hgueleitung";
+  public static HGUE_KOPFSTATION_KLASSISCH = "netz_hguekopfklassisch";
+  public static HGUE_KOPFSTATION_VSC = "netz_hguekopfvsc";
   public static TYP_FREILEITUNG = "typen_freileitungabschnitt";
   public static TYP_KABEL = "typen_kabelabschnitt";
   public static TYP_DROSSEL = "typen_kdrossel";
@@ -86,6 +90,7 @@ export class I7Objects {
   public static ERSATZLAENGSZWEIG = "ERSATZLAENGSZWEIG";
   public static TRAFO2W = "TRAFO2W";
   public static TRAFO3W = "TRAFO3W";
+  public static LAENGSDROSSEL = "LAENGSDROSSEL";
   public static TRAFO3_WICKLUNG = "TRAFO3_WICKLUNG";
   public static TRAFO3W_KNOTEN = "TRAFO3W_KNOTEN";
 
@@ -102,6 +107,10 @@ export class I7Objects {
   public static ASYNCHRONMOTOR = "ASYNCHRONMOTOR";
   public static BOUNDARYINJECTION = "BOUNDARYINJECTION";
 
+  public static HGUE_LEITUNG = "HGUE_LEITUNG";
+  public static HGUE_KOPFSTATION_KLASSISCH = "HGUE_KOPFSTATION_KLASSISCH";
+  public static HGUE_KOPFSTATION_VSC = "HGUE_KOPFSTATION_VSC";
+
   public static TYP_FREILEITUNG = "TYP_FREILEITUNG";
   public static TYP_KABEL = "TYP_KABEL";
   public static TYP_DROSSEL = "TYP_DROSSEL";
@@ -201,9 +210,26 @@ export function getNetzQuery(objectName: I7Objects, limit: number, offset: numbe
     case I7Objects.KABEL: {
       return `SELECT * FROM ${Integral7TableNames[I7Objects.KABEL]} WHERE ${getWhereIDs('leitung', whereIDs).join(' OR ')};`;
     }
+    case I7Objects.LAENGSDROSSEL: {
+      console.log(`SELECT * FROM ${Integral7TableNames[I7Objects.LAENGSDROSSEL]} LIMIT ${limit} OFFSET ${offset};`);
+      return `SELECT * FROM ${Integral7TableNames[I7Objects.LAENGSDROSSEL]} LIMIT ${limit} OFFSET ${offset};`;
+    }
     case I7Objects.ERSATZLAENGSZWEIG: {
       return `SELECT * FROM ${Integral7TableNames[I7Objects.ERSATZLAENGSZWEIG]} LIMIT ${limit} OFFSET ${offset};`;
     }
+
+    case I7Objects.HGUE_LEITUNG: {
+      return `SELECT * FROM ${Integral7TableNames[I7Objects.HGUE_LEITUNG]} LIMIT ${limit} OFFSET ${offset};`;
+    }
+
+    case I7Objects.HGUE_KOPFSTATION_KLASSISCH: {
+      return `SELECT * FROM ${Integral7TableNames[I7Objects.HGUE_KOPFSTATION_KLASSISCH]} WHERE ${getWhereIDs('anschluss', whereIDs).join(' OR ')};`;
+    }
+
+    case I7Objects.HGUE_KOPFSTATION_VSC: {
+      return `SELECT * FROM ${Integral7TableNames[I7Objects.HGUE_KOPFSTATION_VSC]} WHERE ${getWhereIDs('anschluss', whereIDs).join(' OR ')};`;
+    }
+
     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};`;
@@ -262,7 +288,7 @@ export function getNetzQuery(objectName: I7Objects, limit: number, offset: numbe
       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};`;
+      return `SELECT * FROM ${Integral7TableNames[I7Objects.ASYNCHRONMOTOR]} WHERE ${getWhereIDs('anschluss', whereIDs).join(' OR ')};`;
     }
     case I7Objects.BOUNDARYINJECTION: {
       return `SELECT * FROM ${Integral7TableNames[I7Objects.BOUNDARYINJECTION]} LIMIT ${limit} OFFSET ${offset};`;

package/src/converter/integral7/utils.ts

@@ -2,7 +2,7 @@ import { BaseClass, Belastung, Wicklung } from './model/interfaces';
 import {
   BaseVoltage,
   Bay,
-  ConductingEquipment, ConnectivityNode,
+  ConductingEquipment, ConnectivityNode, createBaseVoltageIfNotExists,
   createRatioTapChangerTablePoint,
   EquipmentContainer,
   FossilFuel,
@@ -79,6 +79,10 @@ export function getLine(cimModel: Model, bezeichner: string, kurzname: string):
   return;
 }
 
+export function getU(un: any, deafultUn: number): number {
+  return (isNaN(un) || un === null) ? deafultUn : +un;
+}
+
 /** Wenn die Objektreferenzen nicht vorhanden sind, wird das BV-Objekt über die UUID bestimmt. */
 export function getTerminalUn(cimModel: Model, ce: ConductingEquipment): BaseVoltage | undefined {
   const terminals = ce.terminals.size > 0 ? [...ce.terminals.keys()] : ce.terminalsUUIDs;
@@ -545,20 +549,48 @@ export function writeFile(filePath: string, data: any) {
   });
 }
 
-
-export function writeZipFile(zip: JSZip, path: string): Promise<any> {
+export function generateNodeStream(zip: JSZip): Promise<Status> {
   return new Promise((resolve, reject) => {
+    try {
+      resolve({status: 'successful', message: 'ok', data: zip.generateNodeStream({type: 'nodebuffer', streamFiles: true})});
+    } catch (e) {
+      reject({status: 'error', message: e.toString()});
+    }
+  });
+}
 
-    zip
-      .generateNodeStream({type: 'nodebuffer', streamFiles: true})
-      .pipe(fs.createWriteStream(path))
-      .on('finish', function () {
-        // JSZip generates a readable stream with a "end" event,
-        // but is piped here in a writable stream which emits a "finish" event.
-        resolve();
-      });
+export function writeZipFile(data: NodeJS.ReadableStream, path: string): Promise<any> {
+  return new Promise((resolve, reject) => {
+    try {
+      data.pipe(fs.createWriteStream(path))
+        .on('finish', function () {
+          // JSZip generates a readable stream with a "end" event,
+          // but is piped here in a writable stream which emits a "finish" event.
+          resolve({status: 'successful', message: 'ok'});
+        });
+    } catch (e) {
+      reject({status: 'error', message: e.toString()});
+    }
   });
 }
+
+/*export function writeZipFile(zip: JSZip, path: string): Promise<any> {
+  return new Promise((resolve, reject) => {
+    try {
+      zip
+        .generateNodeStream({type: 'nodebuffer', streamFiles: true})
+        .pipe(fs.createWriteStream(path))
+        .on('finish', function () {
+          // JSZip generates a readable stream with a "end" event,
+          // but is piped here in a writable stream which emits a "finish" event.
+          resolve();
+        });
+    } catch (e) {
+
+    }
+
+  });
+}*/
 /** Integral 7 Exporter */
 export function determineEquipmentContainer(equipmentContainerType: string, cimModel: Model, equipmentContainer: EquipmentContainer): EquipmentContainer | undefined {
   switch (equipmentContainerType)  {

package/src/etl-neplan/etl-neplan-contingency-analysis.ts

@@ -1,6 +1,5 @@
 import { Model } from '../model/model/Model';
 import { WNFeeder } from '../model/extensions/neplan-westnetz/core/WNFeeder';
-import { Equipment } from '../model/core/Equipment';
 import { WNConnectivityNode } from '../model/extensions/neplan-westnetz/core/WNConnectivityNode';
 import { ConductingEquipment } from '../model/core/ConductingEquipment';
 import { Switch } from '../model/wires/Switch';
@@ -12,7 +11,7 @@ import { SwitchingPlan } from '../model/operations/SwitchingPlan';
 import { EVTerminalAction } from '../model/extensions/enervance/operations/EVTerminalAction';
 import { SwitchActionKind } from '../model/operations/SwitchActionKind';
 import { IOutage } from '../interfaces/model/operations/IOutage';
-import { ITerminal } from '../interfaces/model/core/ITerminal';
+import { Graph } from '../graph/graph';
 
 export function performContingencyAnalysis(cimModel: Model): string[] {
 
@@ -21,21 +20,32 @@ export function performContingencyAnalysis(cimModel: Model): string[] {
   /** 2 Erstelle für jedes nicht verbundenes Element, das zu einem anderen Abgang gehört, eine Schaltmaßname. */
 
   const insertSPARQL = [];
+  const graph = new Graph();
+
   for (const feeder of cimModel.feeders.values()) {
     const wnFeeder = feeder as WNFeeder;
-    const disconnectedTerminalCNs = []; // nicht verbundene Knoten
-    const disconnectedSwitches = []; // nicht verbundene Schaltelemente
+    const disconnectedTerminalCNs = []; // nicht verbundene Knoten zu anderen Abgängen
     const disconnectedTerminalCEs = []; // nicht verbundene leitende Equipments
 
+    const disconnectedSwitches = []; // nicht verbundene Schaltelemente
+    const disconnectedTerminal = []; // nicht verbundene Knoten zum gleichen Abgang
+
     /** 1.1 / 1.2) nicht verbundene Knoten und Switches bestimmen */
     for (const equip of wnFeeder.additionalGroupedEquipment.values()) {
       if (equip instanceof ConductingEquipment) {
         const ce = equip as ConductingEquipment;
         // Bestimme nicht verbundene CNs
         for (const terminal of ce.terminals.values()) {
-          if (!terminal.isClosed() && !wnFeeder.normalEnergizedConnectivityNodes.has(terminal.connectivityNode.mrid)) {
-            if (terminal.connectivityNode && (terminal.connectivityNode as WNConnectivityNode).additionalConnectivityNodeContainer) {
-              disconnectedTerminalCNs.push(terminal);
+
+          if (!terminal.isClosed()) {
+            /** verbindungen zu anderen Angängen */
+            if(!wnFeeder.normalEnergizedConnectivityNodes.has(terminal.connectivityNode.mrid)) {
+              if (terminal.connectivityNode && (terminal.connectivityNode as WNConnectivityNode).additionalConnectivityNodeContainer) {
+                disconnectedTerminalCNs.push(terminal);
+              }
+            } else if (wnFeeder.normalEnergizedConnectivityNodes.has(terminal.connectivityNode.mrid)) {
+              /** offene Verbindungen zu sich selbst */
+              if (!disconnectedTerminal.includes(terminal)) disconnectedTerminal.push(terminal);
             }
           }
         }
@@ -50,15 +60,20 @@ export function performContingencyAnalysis(cimModel: Model): string[] {
       }
     }
 
-
     /** 1.1 / 1.2) nicht verbundene leitende Elemente bestimmen */
     for (const cn of wnFeeder.normalEnergizedConnectivityNodes.values()) {
       // Bestimme nicht verbundene CNs
       for (const terminal of cn.terminals.values()) {
-        /** ist offen und gehört zu einem anderen Abgang */
-        if (!terminal.isClosed() && !wnFeeder.additionalGroupedEquipment.has(terminal.conductingEquipment.mrid)) {
-          if (terminal.conductingEquipment.additionalEquipmentContainer.size) {
-            disconnectedTerminalCEs.push(terminal);
+
+        if (!terminal.isClosed()) {
+          /** ist offen und gehört zu einem anderen Abgang */
+          if (!wnFeeder.additionalGroupedEquipment.has(terminal.conductingEquipment.mrid)) {
+            if (terminal.conductingEquipment.additionalEquipmentContainer.size) {
+              disconnectedTerminalCEs.push(terminal);
+            }
+          } else if (wnFeeder.additionalGroupedEquipment.has(terminal.conductingEquipment.mrid)) {
+            /** offene Verbindungen zu sich selbst */
+            if (!disconnectedTerminal.includes(terminal)) disconnectedTerminal.push(terminal);
           }
         }
       }
@@ -86,6 +101,9 @@ export function performContingencyAnalysis(cimModel: Model): string[] {
         console.log('\twnFeeder.additionalGroupedEquipment ' + wnFeeder.additionalGroupedEquipment.size);
         console.log('\twnFeeder.normalEnergizedConnectivityNodes + ' + wnFeeder.normalEnergizedConnectivityNodes.size);*/
 
+    // Stationen mit mehr als einem Anbgang ausfallen lassen.
+
+    // Head TerminalAusfälle
     for (const headTerminal of feeder.normalHeadTerminals.values()) {
       //Lege einen N-1 Fall an, wenn es Schaltmaßnahmen exisitieren
 

package/src/etl-neplan/etl-neplan-feederline.ts

@@ -9,12 +9,15 @@ import { Model } from '../model/model/Model';
 import { WNFeeder } from '../model/extensions/neplan-westnetz/core/WNFeeder';
 import { IConnectivityNode } from '../interfaces/model/core/IConnectivityNode';
 import { ACLineSegment } from '../model/wires/ACLineSegment';
-import { generateUUID } from '../util/utils';
+import { generateUUID, isInArray } from '../util/utils';
 import { Equipment } from '../model/core/Equipment';
 import { WNConnectivityNode } from '../model/extensions/neplan-westnetz/core/WNConnectivityNode';
 import { EVTerminal } from '../model/extensions/enervance/core/EVTerminal';
 import { ITerminal } from '../interfaces/model/core/ITerminal';
 import { ConductingEquipment } from '../model/core/ConductingEquipment';
+import { VoltageLevel } from '../model/core/VoltageLevel';
+import { Bay } from '../model/core/Bay';
+import { ExternalNetworkInjection } from '../model/wires/ExternalNetworkInjection';
 
 /**
  * Erzeugung von Abgängen
@@ -34,20 +37,34 @@ export function createFeederLines(cimModel: Model, basiIRI: string): string [] {
   const computableGridsSlackElements: IIdentifiedObject[][] = determineNetworksSlackElements(cimModel, computableGrids);
 
   /** KRUECKE Anlagen mit mehr als 10 Switchelementen und Slacks werden als Umspannanlagen markiert. */
-  const substationElements = determineSubstations(cimModel);
-  computableGridsSlackElements.push(substationElements);
+  const substationElements = determineSubstations(cimModel, computableGridsSlackElements);
+
+  const computableGridsSlackElementsForFeeder = [...computableGridsSlackElements, substationElements]
+
+  //_9fafa042-b9d1-4052-ace2-9bfbefeb0134
+  //_59f7d40a-36c9-4b39-95e4-657976e50b12
+  const cn1 =  cimModel.getConnectivityNode('9fafa042-b9d1-4052-ace2-9bfbefeb0134');
+  const cn2 =  cimModel.getConnectivityNode('59f7d40a-36c9-4b39-95e4-657976e50b12');
+  for (const s of computableGridsSlackElementsForFeeder) {
+    if (s.indexOf(cn1) !== -1) console.log('9fafa042-b9d1-4052-ace2-9bfbefeb0134')
+    if (s.indexOf(cn2) !== -1) console.log('59f7d40a-36c9-4b39-95e4-657976e50b12')
+  }
 
   const insertObjectSPARQL = [];
   /** bestimmt ALLE elektrisch zusammenhängende Abgänge (eine Art Stromkreis für Mittelspannungsnetze) */
   for (const grid of computableGrids) {
     /** Für das Netz die elektrisch zusammenhängenden Abgänge bestimmen (bestehend aus allen Elementen ) */
-    const networkFeederElements: IIdentifiedObject[][] = determineFeederLinesElements(cimModel, grid, computableGridsSlackElements);
-
+    const networkFeederElements: IIdentifiedObject[][] = determineFeederLinesElements(cimModel, grid, computableGridsSlackElementsForFeeder);
 
     /** Erstellen der FeederLine Objekte */
     for (const feederObjects of networkFeederElements) {
-      const headTerminal = determineHeadTerminal(feederObjects);
+
+      const headTerminals = determineHeadTerminals(feederObjects, computableGridsSlackElements, substationElements);
+
+      const headTerminal = determineStartHeadTerminals(headTerminals, substationElements);
+
       const startCN = headTerminal?.connectivityNode;
+      console.log(startCN.name);
       const substation = startCN?.getVoltageLevel()?.getSubstation();
 
       if (substation && startCN) {
@@ -80,6 +97,7 @@ export function createFeederLines(cimModel: Model, basiIRI: string): string [] {
         insertObjectSPARQL.push(headTerminal.setNormalHeadFeeder(feeder));
 
         cimModel.addFeeder(feeder);
+
       } else {
         console.log(`Der StartConnNode oder die Substion für Feeder konnte nicht bestimmt werden`);
         console.log(substation + ' ' + startCN);
@@ -96,7 +114,8 @@ export function createFeederLines(cimModel: Model, basiIRI: string): string [] {
  * ???Trafos gehören immer zu einer Umspannanlage und können nicht zu einem Angang gehören???.
  depricated Hinweis: der Algorythmus setzt varaus, dass Slackelemente vorher bestimmt wurden.
  D.h. sie sind als 'visited' markiert. */
-export function determineFeederLinesElements(cimModel: Model, grid: IIdentifiedObject[], slackSubstationElements: IIdentifiedObject[][]): IIdentifiedObject[][] {
+export function determineFeederLinesElements(cimModel: Model, grid: IIdentifiedObject[],
+                                             slackSubstationElements: IIdentifiedObject[][]): IIdentifiedObject[][] {
 
   const networkFeederLineElements: IIdentifiedObject[][] = [];
   for (let i = 0; i < grid.length; i++) {
@@ -120,19 +139,83 @@ export function determineFeederLinesElements(cimModel: Model, grid: IIdentifiedO
  * Gesucht ist ein ConnectivityNode der nicht Teil des Abgangs ist.
  * Die Bedingung ist erfüllt, wenn der ConnectivityNode nicht
  * im Array gridElements enthalten ist. */
-export function determineHeadTerminal(gridElements: IIdentifiedObject[]): ITerminal {
+export function determineHeadTerminals(gridElements: IIdentifiedObject[],
+                                       slackSubstationElements: IIdentifiedObject[][],
+                                       additionalslackSubstationElements: IIdentifiedObject[]): ITerminal[] {
+  const headTerminals = [];
   for (const object of gridElements) {
-    if (object.constructor.name.includes('ACLineSegment')) {
-      const acLineSegment = object as unknown as ACLineSegment;
+    /*if (object.constructor.name.includes('ACLineSegment')) {*/
+    if (object instanceof ConductingEquipment) {
+      const ce = object as unknown as ConductingEquipment;
+      if (ce.mrid === '6d21f61c-e0cc-44f7-9382-026b7663bf9f' ||
+        ce.mrid === '6ad74c2d-4194-4537-9d0a-96b27bea096c' ||
+        ce.mrid === '871c91f0-9abb-49e5-9d38-fcbc58633ddb' ||
+        ce.mrid === 'a9b2f23b-c799-4edf-9972-8f594d67446b') {
+        console.log();
+      }
+      //_9fafa042-b9d1-4052-ace2-9bfbefeb0134
+      //_59f7d40a-36c9-4b39-95e4-657976e50b12
+      for (const terminal of ce.terminals.values()) {
+        if (terminal.connectivityNode.mrid === '9fafa042-b9d1-4052-ace2-9bfbefeb0134' ||
+          terminal.connectivityNode.mrid === '59f7d40a-36c9-4b39-95e4-657976e50b12' ||
+          terminal.connectivityNode.mrid === '871c91f0-9abb-49e5-9d38-fcbc58633ddb' ||
+          terminal.connectivityNode.mrid === 'a9b2f23b-c799-4edf-9972-8f594d67446b') {
+          console.log();
+        }
 
-      for (const terminal of acLineSegment.terminals.values()) {
-        if (terminal.isClosed()) { /** ist elektrisch angeschlossen. */
-          if (gridElements.indexOf(terminal.connectivityNode) === -1) { /** ist CN Teil des Abgabgs und ist mit einem ConductEquip verbunden? */
-            return terminal;
-          }
+        if (isInArray(terminal.connectivityNode, slackSubstationElements)) { /** gehört der CN zur Substation mit Slack */
+           headTerminals.push(terminal);
+        } else if (additionalslackSubstationElements.indexOf(terminal.connectivityNode) != null) {  /** gehört der CN zur (Schwerpunkt-)Substation ohne Slack */
+          headTerminals.push(terminal);
         }
+/*        if (terminal.isClosed()) { /!** ist elektrisch angeschlossen. *!/
+          if (gridElements.indexOf(terminal.connectivityNode) === -1) { /!** ist CN Teil des Abgabgs und ist mit einem ConductEquip verbunden? *!/
+          headTerminals.push(terminal);
+          }
+        }*/
       }
     }
   }
-  return;
-}
+  return headTerminals;
+}
+
+/** HeadTerminal bestimmen
+ * HeadTerminal gehört zu der Station mit dem Slack
+ * falls der 2 Headterminals mit je einem Slack existieren, wird das erste Element als Head festgelegt*/
+export function determineStartHeadTerminals(terminals: ITerminal[], additionalslackSubstationElements: IIdentifiedObject[]): ITerminal {
+  for (const terminal of terminals) {
+    const cnc = terminal.connectivityNode.connectivityNodeContainer;
+    let voltageLevel;
+    if (cnc instanceof VoltageLevel) {
+      voltageLevel = cnc as VoltageLevel;
+    } else if (cnc instanceof Bay) {
+      voltageLevel = (cnc as Bay).voltageLevel;
+    }
+    for (const equip of voltageLevel?.equipments) {
+      if (equip instanceof ExternalNetworkInjection) {
+        return terminal;
+      }
+    }
+  }
+
+  /** Wenn keine Kriterien erfüllt werden,
+   * dann überprüfe additionalslackSubstationElements */
+  const trm = determineStartHeadTerminalsTemporary(terminals, additionalslackSubstationElements);
+  if(trm) return trm;
+  /** Wenn keine Kriterien erfüllt werden,
+   * dann nehme den ersten Terminal*/
+  return terminals[0];
+}
+
+/** Übergangslösung, Schwerpunktstationen ohne Slack */
+export function determineStartHeadTerminalsTemporary(terminals: ITerminal[], additionalslackSubstationElements: IIdentifiedObject[]): ITerminal {
+  for (const terminal of terminals) {
+    if (additionalslackSubstationElements.indexOf(terminal.connectivityNode) !==-1) {
+      return terminal;
+    }
+  }
+  /** Wenn keine Kriterien erfüllt werden,
+   * dann nehme den ersten Terminal*/
+  return terminals[0];
+}
+

package/src/etl-neplan/etl-neplan.ts

@@ -328,6 +328,7 @@ export async function loadFusekiData(fusekiURI: string, graphURI: string,
     return await Promise.all(loadConfig.map(async (className) => {
         const sparqlQuery = neplanClassDefinitions.get(className).getQuerySPARQL(graphURI);
         const dataResponse = await fetch(`${fusekiURI}?query=${encodeURIComponent(sparqlQuery)}&format=json`);
+
         return await dataResponse.json();
     }));
 }