@enervance/insight-cim-model 0.0.1 → 0.0.3

package/src/graph/graph-util.ts

@@ -0,0 +1,158 @@
+import { WNConnectivityNode } from '../model/extensions/neplan-westnetz/core/WNConnectivityNode';
+import { Graph } from './graph';
+import { OutageResult, SwitchEvalResult } from './graph-interfaces';
+import { Node } from './nodes/node';
+import { generateUUID } from '../util/utils';
+import { Terminal } from '../model/core/Terminal';
+import { Switch } from '../model/wires/Switch';
+import { IdentifiedObject } from '../model/core/IdentifiedObject';
+import { Connection } from './connections/connection';
+import { Edge } from './edges/edge';
+import { WNFeeder } from '../model/extensions/neplan-westnetz/core/WNFeeder';
+import { IFeeder } from '../interfaces/model/core/IFeeder';
+import { ConnectivityNode } from '../model/core/ConnectivityNode';
+
+export function determineOutageAffectedSubstations(graph: Graph,
+                                                   outageNodeUUIDs: string[],
+                                                   stations: Map<string, WNConnectivityNode>,
+                                                   slackUUIDs: string[]): OutageResult  {
+
+  const outageStations = new Map<string, Node[]>();
+  const feededStations = new Map<string, Node[]>();
+  for (const object of stations.values()) {
+    if (outageNodeUUIDs.indexOf(object.mrid) === -1 &&
+      !isInMap(object.mrid, outageStations) && // betrachtetes Objekt ist noch nicht zugeordnet
+      !isInMap(object.mrid, feededStations)) { // betrachtetes Objekt ist noch nicht zugeordnet
+      const node = graph.nodes.get(object.mrid);
+      const resultBFS = graph.isObjectReachableBFS(node, slackUUIDs);
+
+      if (!resultBFS.found) {
+        outageStations.set(generateUUID(), resultBFS.nodesVisited);
+      } else {
+        feededStations.set(generateUUID(), resultBFS.nodesVisited);
+      }
+    }
+  }
+
+  return {
+    outageObjects: outageNodeUUIDs,
+    outageStations,
+    feededStations
+  }
+}
+
+export function isInMap(nodeUUID: string, stations: Map<string, Node[]>): boolean {
+  for (const nodes of stations.values()) {
+    if (nodes.find(node => node.uuid === nodeUUID)) return true;
+  }
+  return false;
+}
+
+export function isSwitchObjectInArray(switchObject: IdentifiedObject, switchActions: IdentifiedObject[][]): boolean {
+  for (const switchAction of switchActions) {
+    if (switchAction.indexOf(switchObject) !== -1) return true;
+  }
+  return false;
+}
+
+
+export function evaluateSwitchActions(outageNodeUUID: string, initOutageStations: Map<string, Node[]>,
+                                             normalEnergizedConnectivityNodes: Map<string, WNConnectivityNode>,
+                                             graph: Graph, switchActions: IdentifiedObject[][], slackUUIDs: string[]): SwitchEvalResult[] {
+
+
+  const switchEvalResults: SwitchEvalResult[] = []
+
+  for (const switchObject of switchActions) {
+    applySwitchState(graph, switchObject, false);
+    const switchedStationsResult = determineOutageAffectedSubstations(graph, [outageNodeUUID], normalEnergizedConnectivityNodes, slackUUIDs);
+    applySwitchState(graph, switchObject, true);
+    const evalResult = rateSwichAction(initOutageStations, switchedStationsResult.outageStations);
+    switchEvalResults.push({
+      switchObjects: arrayStringPropArray(switchObject, 'mrid'),
+      type: evalResult,
+      outageResult: switchedStationsResult
+    });
+
+  }
+  return switchEvalResults;
+}
+
+function applySwitchState(graph: Graph, switchObjects: IdentifiedObject[], open: boolean) {
+  for (const switchObject of switchObjects) {
+    if (switchObject instanceof Terminal) {
+      changeSwitchState(graph.terminals.get(switchObject.mrid), open ? false : true);
+    }
+    if (switchObject instanceof Switch) {
+      changeEdgeState(graph.edges.get(switchObject.mrid), open ? true : false);
+    }
+  }
+
+}
+
+function changeSwitchState(conn: Connection | undefined, state: boolean) {
+  if (!conn) return;
+  conn.connected = state;
+}
+
+function changeEdgeState(conn: Edge | undefined, state: boolean) {
+  if (!conn) return;
+  conn.open = state;
+}
+
+/*export function evaluateSwichActionSwitch(outageNodeUUID: string, initOutageStations: Map<string, Node[]>,
+                                             normalEnergizedConnectivityNodes: Map<string, WNConnectivityNode>,
+                                             graph: Graph, switches: Switch[], slackUUIDs: string[]): SwitchEvalResult[]{
+  const switchEvalResults: SwitchEvalResult[] = []
+  for (const swtch of switches) {
+    const connection = graph.edges.get(swtch.mrid);
+    if (!connection) continue;
+    connection.open = false;
+    const switchedStationsResult = determineOutageAffectedSubstations(graph, [outageNodeUUID], normalEnergizedConnectivityNodes, slackUUIDs);
+    connection.open = true;
+    const evalResult = evaluateSwichAction(initOutageStations, switchedStationsResult.outageStations);
+
+    switchEvalResults.push({
+      switchObjects: [swtch.mrid],
+      type: evalResult,
+      outageResult: switchedStationsResult
+    });
+
+  }
+  return switchEvalResults;
+}*/
+
+/** prüft, ob eine Schaltmaßnahme zu keiner, partieller oder vollständiger Wiederversorgung führt.
+ * 0 -> keine Wiederversorgung
+ * 1 -> partielle Wiederversorgung
+ * 2 -> vollständige Wiederversorgung */
+export function rateSwichAction(outageStations: Map<string, Node[]>, switchActionOutageStations: Map<string, Node[]>): number {
+  if (switchActionOutageStations.size === 0) {
+    return 2;
+  } else if (switchActionOutageStations.size < outageStations.size) {
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
+export function arrayStringPropArray (data: any[], propName): string[] {
+  return data.map(elemt => {
+    return elemt[propName];
+  });
+}
+
+export function isBelongingToFeeder(elementUUID: string, feeders: Map<string, IFeeder>, node: boolean): boolean {
+  for (const feeder of feeders.values()) {
+    const wnFeeder = feeder as WNFeeder;
+    // Konten
+    if (node && wnFeeder.normalEnergizedConnectivityNodes.has(elementUUID)) {
+      return true;
+    }
+    //Equipment
+    if (!node && wnFeeder.additionalGroupedEquipment.has(elementUUID)) {
+      return true;
+    }
+  }
+  return false;
+}

package/src/graph/graph.ts

@@ -0,0 +1,84 @@
+import { Edge } from './edges/edge';
+import { GraphObject, Node } from './nodes/node';
+import { Connection } from './connections/connection';
+import { ResultBFS } from './graph-interfaces';
+
+export class Graph {
+
+  nodes: Map<string, Node> = new Map();
+  edges: Map<string, Edge> = new Map();
+  terminals: Map<string, Connection> = new Map();
+
+  constructor() { }
+
+  addNode(node: Node) {
+    this.nodes.set(node.uuid, node);
+  }
+
+  addEdge(edge: Edge) {
+    this.edges.set(edge.uuid, edge);
+  }
+  addTerminal(terminal: Connection) {
+    this.terminals.set(terminal.uuid, terminal);
+  }
+
+  /** Breitensuche zur Bestimmung der Slackerreichbarkeit */
+  isObjectReachableBFS(startNode: Node, toObjectUUID: string []): ResultBFS {
+    let pathNodeList: GraphObject [] = [];
+    let nodesOnCurrentLevel: GraphObject [];
+    let nodesOnNextLevel: GraphObject [] = [startNode];
+    let nodesVisited: string [] = [];
+    let foundNode = false;
+    const visitedStations = [];
+    while (!foundNode) {
+
+      nodesOnCurrentLevel = [];
+      nodesOnCurrentLevel = [...nodesOnNextLevel];
+      nodesOnNextLevel = [];
+
+      // gibt nichts mehr zu entdecken
+      if (nodesOnCurrentLevel.length === 0) break;
+      for (const currentNode of nodesOnCurrentLevel) {
+        nodesVisited.push(currentNode.uuid);
+        /** Wenn gefunden, dann abbruch*/
+        if (foundNode) break;
+        /** Wenn ausgefallen, dann abbruch*/
+        if (!currentNode.canPassThrough()) break;
+        for (const terminal of currentNode.terminals.values()) {
+          if (terminal.canPassThrough() && nodesVisited.indexOf(terminal.uuid) === -1) {
+            nodesVisited.push(terminal.uuid);
+            if (toObjectUUID.indexOf(terminal.edge.uuid) !== -1 || toObjectUUID.indexOf(terminal.node.uuid) !== -1) {
+              foundNode = true;
+              break;
+            } else {
+              /** suche weiter*/
+              if (nodesVisited.indexOf(terminal.node.uuid) === -1 && terminal.node.canPassThrough()) nodesOnNextLevel.push(terminal.node);
+              if (nodesVisited.indexOf(terminal.edge.uuid) === -1) nodesOnNextLevel.push(terminal.edge);
+            }
+          }
+        }
+        if(currentNode.constructor.name === 'Node') visitedStations.push(currentNode);
+
+      }
+    }
+
+    return {
+      found: foundNode,
+      nodesVisited: visitedStations
+    };
+  }
+
+  getObject(uuid: string): any {
+    if (this.terminals.has(uuid)) {
+      return this.terminals.get(uuid);
+    }
+    if (this.nodes.has(uuid)) {
+      return this.nodes.get(uuid);
+    }
+    if (this.edges.has(uuid)) {
+      return this.edges.get(uuid);
+    }
+  }
+
+}
+

package/src/graph/nodes/node.ts

@@ -0,0 +1,43 @@
+import { Connection } from '../connections/connection';
+
+export class GraphObject {
+  uuid: string;
+  visited: boolean = false;
+  terminals: Map<string, Connection> = new Map();
+
+  constructor(uuid: string) {
+    this.uuid = uuid;
+  }
+
+  canPassThrough(): boolean {
+    return false
+  }
+
+  addTerminal(termnal: Connection) {
+    this.terminals.set(termnal.uuid, termnal);
+  }
+}
+
+
+export class Node extends GraphObject {
+  inService: boolean;
+  constructor(uuid: string) {
+    super(uuid);
+    this.inService = true;
+  }
+
+  canPassThrough(): boolean {
+    return this.inService;
+  }
+
+/*  isSlackReachable(): boolean {
+    if (this.inService && !this.visited) {
+      this.visited = true;
+      for (const term of this.terminals.values()) {
+        term.isSlackReachable();
+      }
+    }
+    return false;
+  }*/
+
+}

package/src/index.ts

@@ -196,6 +196,14 @@ export { UnitSymbol } from './model/domain/UnitSymbol';
 export { Status } from './model/common/Status';
 
 
+// Amprion
+export { AMPRIONConstructionProject } from './model/extensions/amprion/project/AMPRIONConstructionProject';
+export { AMPRIONErpProjectPhase } from './model/extensions/amprion/project/AMPRIONErpProjectPhase';
+export { AMPRIONConstructionProjectBundle } from './model/extensions/amprion/project/AMPRIONConstructionProjectBundle';
+export { AMPRIONConstructionProjectPlan } from './model/extensions/amprion/project/AMPRIONConstructionProjectPlan';
+export { AMPRIONErpProject } from './model/extensions/amprion/project/AMPRIONErpProject';
+export { AMPRIONErpProjectStructure } from './model/extensions/amprion/project/AMPRIONErpProjectStructure';
+
 export {
   NS_PREFIX_CIM,
   NS_PREFIX_ENERVANCE,

package/src/model/core/ACDCTerminal.ts

@@ -38,8 +38,8 @@ export abstract class ACDCTerminal extends IdentifiedObject implements IACDCTerm
 
   protected resolveAttributesFusekiJSON(value: any) {
     super.resolveAttributesFusekiJSON(value);
-    this.sequenceNumber = +getValue(value, 'sequenceNumber'),
-      this.connected = toBoolean(getValue(value, 'connected'))
+    this.sequenceNumber = +getValue(value, 'sequenceNumber');
+    this.connected = toBoolean(getValue(value, 'connected'));
 
   }
 

package/src/model/core/ConnectivityNode.ts

@@ -186,8 +186,8 @@ export class ConnectivityNode extends IdentifiedObject implements IConnectivityN
 
 
   public determineMidVoltageLineElements(feederLineElemenets: IIdentifiedObject[], slackSubstationElements: IIdentifiedObject[][]) {
-    if (!this.visited && !isInArray(this, slackSubstationElements)) {
-      this.addNetworkElement(feederLineElemenets);
+    if (!this.visited /*&& !isInArray(this, slackSubstationElements)*/) {
+      if (!isInArray(this, slackSubstationElements)) this.addNetworkElement(feederLineElemenets);
       // 0 = key, 1 = value
       for (const entry of this.terminals.entries()) {
         const value = entry[1];

package/src/model/core/PSRType.ts

@@ -144,11 +144,11 @@ export class PSRType extends IdentifiedObject{
 
     /** CIM RDF/XML Serialisierung */
     public toCIMXML(xmlWriter: XMLWriter, profile: string) {
-        if(!profile || profile === '') {
+        if(!profile || profile === RDF_XML.PROFILE_AMPI7) {
             xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'PSRType', RDF_XML.CIM_NS_16);
             writeElementAttribute(xmlWriter, RDF_XML.RDF_ID, `${RDF_XML.UNDERSCORE}${this.mrid}`);
-            this.toCIMXMLAttributes(xmlWriter, profile);
-            this.toCIMXMLAssociations(xmlWriter, profile);
+            this.toCIMXMLAttributes(xmlWriter, undefined);
+            this.toCIMXMLAssociations(xmlWriter, undefined);
             xmlWriter.endElement();
         }
     }
@@ -161,7 +161,4 @@ export class PSRType extends IdentifiedObject{
         super.toCIMXMLAssociations(xmlWriter, profile);
     }
 
-    protected getSuffixID(profile: string): string {
-        return RDF_XML.RDF_ID
-    }
 }

package/src/model/core/PowerSystemResource.ts

@@ -68,13 +68,9 @@ export class PowerSystemResource extends IdentifiedObject implements IPowerSyste
     protected toCIMXMLAssociations(xmlWriter: XMLWriter, profile: string) {
         super.toCIMXMLAssociations(xmlWriter, profile);
         /*<cim:VoltageLevel.Substation rdf:resource="#_1be806f9-0316-4bb8-b350-f54a292353f1"/>*/
-        if(profile !== RDF_XML.PROFILE_EQ && profile !== RDF_XML.PROFILE_DL && profile !== RDF_XML.PROFILE_GL &&
-          profile !== RDF_XML.PROFILE_SSH && profile !== RDF_XML.PROFILE_SV && profile !== RDF_XML.PROFILE_TP) {
-            if(this.psrType) {
-                xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'PowerSystemResource.PSRType', RDF_XML.CIM_NS_16);
-                writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.HASH_UNDERSCORE}${this.psrType.mrid}`);
-                xmlWriter.endElement();
-            } else if(this.psrTypeUUID) {
+        if(!profile || profile === RDF_XML.PROFILE_AMPI7) {
+            this.psrTypeUUID = this.psrType ? this.psrType.mrid: this.psrTypeUUID;
+            if(this.psrTypeUUID) {
                 xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'PowerSystemResource.PSRType', RDF_XML.CIM_NS_16);
                 writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.HASH_UNDERSCORE}${this.psrTypeUUID}`);
                 xmlWriter.endElement();

package/src/model/core/Substation.ts

@@ -8,6 +8,7 @@ import { RDF_XML } from '../../constants/rdf-xml';
 import { SubGeographicalRegion } from './SubGeographicalRegion';
 import { Feeder } from './Feeder';
 import { DiagramObject, IRectangleShapeInfo, ISchemaSettings } from '../..';
+import { DCConverterUnit } from '../dc/DCConverterUnit';
 
 export class Substation extends EquipmentContainer {
 
@@ -16,6 +17,7 @@ export class Substation extends EquipmentContainer {
   voltageLevels: VoltageLevel[];
   bays: Bay[];
 
+  dcConverterUnit: Map<string, DCConverterUnit>
   /** The feeders that potentially energize the downstream substation. */
   normalEnergizingFeeder: Map<string, Feeder>;
 
@@ -28,6 +30,7 @@ export class Substation extends EquipmentContainer {
     this.bays = [];
     this.normalEnergizingFeeder = new Map();
     this.normalEnergizedFeeder = new Map();
+    this.dcConverterUnit = new Map();
   }
 
 
@@ -39,6 +42,9 @@ export class Substation extends EquipmentContainer {
     this.bays.push(bay);
   }
 
+  public addDCConverterUnit(dcConverterUnit: DCConverterUnit) {
+    this.dcConverterUnit.set(dcConverterUnit.mrid, dcConverterUnit);
+  }
   public static sparqlQuery: string = `
         PREFIX cim:	 		<http://iec.ch/TC57/2013/CIM-schema-cim16#> 
         PREFIX enervance:	<http://enervance.com/CIM/Extensions#> 

package/src/model/core/Terminal.ts

@@ -18,6 +18,7 @@ import { IdentifiedObject } from './IdentifiedObject';
 import { ITerminal } from '../../interfaces/model/core/ITerminal';
 import { ISvPowerFlow } from '../../interfaces/model/statevariables/ISvPowerFlow';
 import { IFeeder } from '../../interfaces/model/core/IFeeder';
+import { ACDCConverter } from '../dc/ACDCConverter';
 
 export class Terminal extends ACDCTerminal implements ITerminal {
 
@@ -39,6 +40,13 @@ export class Terminal extends ACDCTerminal implements ITerminal {
 
   regulatingControl: Map<string, RegulatingControl>;
 
+  /** DC Model */
+
+  /** Point of common coupling terminal for this converter DC side.
+   * It is typically the terminal on the power transformer (or switch) closest to the AC network.
+   * The power flow measurement must be the sum of all flows into the transformer.*/
+  converterDCSides: ACDCConverter;
+
   /** The feeder that this terminal normally feeds.  Only specified for the terminals at head of feeders.*/
   normalHeadFeeder: IFeeder;
   normalHeadFeederUUID: string;
@@ -248,13 +256,14 @@ export class Terminal extends ACDCTerminal implements ITerminal {
       if (this.connectivityNode) {
         this.connectivityNode.breadthFirstSearch(networkElements);
       }
-      // if(this.topologicalNode){
-      //     this.topologicalNode.breadthFirstSearch(networkElements);
-      // }
       if (this.conductingEquipment) {
         this.conductingEquipment.breadthFirstSearch(networkElements);
       }
     }
+    //TESTEN!
+/*    if (!this.visited && !this.isClosed()) {
+      this.addNetworkElement(networkElements);
+    }*/
   }
 
   public determineTopologicalNodes(connNodes: IConnectivityNode[]) {
@@ -301,7 +310,7 @@ export class Terminal extends ACDCTerminal implements ITerminal {
   }
 
 
-  /* Bestimmt alle zum Slack gehörende Netzelemente (CN, Terminals Sammelschienen, Trafos)*/
+  /** Bestimmt alle zum Slack gehörende Netzelemente (CN, Terminals Sammelschienen, Trafos)*/
   public determineSlackNodes(slackElemenets: IIdentifiedObject[]) {
     if (!this.visited) {
       this.addNetworkElement(slackElemenets);
@@ -317,10 +326,10 @@ export class Terminal extends ACDCTerminal implements ITerminal {
   }
 
   public determineMidVoltageLineElements(feederLineElemenets: IIdentifiedObject[], slackSubstationElements: IIdentifiedObject[][]) {
-    if (!this.visited && this.isClosed() && !isInArray(this, slackSubstationElements)) {
+    if (!this.visited && this.isClosed() /*&& !isInArray(this, slackSubstationElements)*/) {
       this.addNetworkElement(feederLineElemenets);
 
-      if (this.conductingEquipment) {
+      if (this.conductingEquipment && !isInArray(this.conductingEquipment, slackSubstationElements)) {
         this.conductingEquipment.determineMidVoltageLineElements(feederLineElemenets, slackSubstationElements);
       }
 

package/src/model/core/VoltageLevel.ts

@@ -61,7 +61,6 @@ export class VoltageLevel extends EquipmentContainer {
         PREFIX enervance:	<http://enervance.com/CIM/Extensions#> 
         PREFIX entsoe:	 	<http://entsoe.eu/CIM/SchemaExtension/3/1#> 
         PREFIX rdf:	 		<http://www.w3.org/1999/02/22-rdf-syntax-ns#> 
-        PREFIX amp:	 		<http://amprion.net/2018/cim_extensions#> 
         PREFIX apf:	 		<http://jena.hpl.hp.com/ARQ/property#>
         PREFIX afn:	 		<http://jena.apache.org/ARQ/function#>
         

package/src/model/dc/ACDCConverter.ts

@@ -0,0 +1,66 @@
+import { ConductingEquipment } from '../core/ConductingEquipment';
+import { Terminal } from '../core/Terminal';
+import { ACDCConverterDCTerminal } from './ACDCConverterDCTerminal';
+import { RDF_XML } from '../../constants/rdf-xml';
+import { writeElement, writeElementAttribute } from '../../util/utils';
+import { DCConverterOperatingModeKind } from './DCConverterOperatingModeKind';
+import XMLWriter from 'xml-writer';
+
+export class ACDCConverter extends ConductingEquipment {
+
+  /** Base apparent power of the converter pole */
+  baseS: number;
+  /** Active power loss in pole at no power transfer. Converter configuration data used in power flow. */
+  idleLoss: number;
+
+  /** The maximum voltage on the DC side at which the converter should operate. Converter configuration data used in power flow.*/
+  maxUdc: number;
+
+  /** Min allowed converter DC voltage. Converter configuration data used in power flow. */
+  minUdc: number;
+
+  /** Number of valves in the converter. Used in loss calculations. */
+  numberOfValves: number;
+
+  /** Rated converter DC voltage, also called UdN. Converter configuration data used in power flow. */
+  ratedUdc: number;
+
+  /** Converter configuration data used in power flow. Refer to poleLossP. */
+  resistiveLoss: number;
+
+  /** Switching losses, relative to the base apparent power 'baseS'.
+   Refer to poleLossP.*/
+  switchingLoss: number;
+
+  /** Valve threshold voltage. Forward voltage drop when the valve is conducting. Used in loss calculations, i.e. the switchLoss depend on numberOfValves * valveU0. */
+  valveU0: number;
+
+
+  /** All converters' DC sides linked to this point of common coupling terminal.*/
+  pccTerminal: Terminal;
+  pccTerminalUUID: string;
+
+  dCTerminals: Map<string,ACDCConverterDCTerminal> = new Map();
+
+
+  //SSH Profil
+  p: number; //ActivePower mandatory
+  q: number; //ReactivePower mandatory
+  targetPpcc: number; //ActivePower mandatory
+  targetUdc:number; //Voltage mandatory
+
+  protected toCIMXMLAttributes(xmlWriter: XMLWriter, profile: string) {
+    super.toCIMXMLAttributes(xmlWriter, profile);
+    if (profile === RDF_XML.PROFILE_EQ) {
+      if (this.baseS > 0) writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:ACDCConverter.baseS`, this.baseS);
+      if (this.idleLoss) writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:ACDCConverter.idleLoss`, this.idleLoss);
+      if (this.maxUdc) writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:ACDCConverter.maxUdc`, this.maxUdc);
+      if (this.minUdc) writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:ACDCConverter.minUdc`, this.minUdc);
+
+      if (this.ratedUdc) writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:ACDCConverter.ratedUdc`, this.ratedUdc);
+      if (this.resistiveLoss) writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:ACDCConverter.resistiveLoss`, this.resistiveLoss);
+      if (this.switchingLoss) writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:ACDCConverter.switchingLoss`, this.switchingLoss);
+    }
+  }
+
+}

package/src/model/dc/ACDCConverterDCTerminal.ts

@@ -0,0 +1,64 @@
+import { DCBaseTerminal } from './DCBaseTerminal';
+import { DCPolarityKind } from './DCPolarityKind';
+import { ACDCConverter } from './ACDCConverter';
+import { RDF_XML } from '../../constants/rdf-xml';
+import { writeElement, writeElementAttribute } from '../../util/utils';
+import XMLWriter from 'xml-writer';
+
+export class ACDCConverterDCTerminal extends DCBaseTerminal {
+
+  polarity: DCPolarityKind;
+
+  dCConductingEquipment: ACDCConverter; // mandatory
+  dCConductingEquipmentUUID: string;
+
+  constructor(uuid?: string, name?: string, shortName?: string, description?: string) {
+    super(uuid, name, shortName, description);
+  }
+
+  /** CIM RDF/XML Serialisierung */
+  public toCIMXML(xmlWriter: XMLWriter, profile: string) {
+    if (profile === RDF_XML.PROFILE_EQ) {
+      const suffixID = this.getSuffixID(profile);
+      const prefixUUID = this.getPrefixUUID(suffixID);
+      xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, this.constructor.name, RDF_XML.CIM_NS_16);
+      writeElementAttribute(xmlWriter, suffixID, `${prefixUUID}${this.mrid}`);
+      this.toCIMXMLAttributes(xmlWriter, profile);
+      this.toCIMXMLAssociations(xmlWriter, profile);
+      xmlWriter.endElement();
+    }
+  }
+
+
+  protected toCIMXMLAttributes(xmlWriter: XMLWriter, profile: string) {
+    super.toCIMXMLAttributes(xmlWriter, profile);
+    if (profile === RDF_XML.PROFILE_EQ) {
+      if (this.polarity) {
+        xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, `${this.constructor.name}.polarity`, RDF_XML.CIM_NS_16);
+        writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.CIM_NS_16}DCPolarityKind.${this.polarity}`);
+        xmlWriter.endElement();
+      }
+    }
+  }
+
+
+  protected toCIMXMLAssociations(xmlWriter: XMLWriter, profile: string) {
+    super.toCIMXMLAssociations(xmlWriter, profile);
+    if (profile === RDF_XML.PROFILE_EQ) {
+      if (this.dCConductingEquipment) {
+        xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'ACDCConverterDCTerminal.DCConductingEquipment', RDF_XML.CIM_NS_16);
+        writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.HASH_UNDERSCORE}${this.dCConductingEquipment.mrid}`);
+        xmlWriter.endElement();
+      } else if (this.dCConductingEquipmentUUID) {
+        xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'ACDCConverterDCTerminal.DCConductingEquipment', RDF_XML.CIM_NS_16);
+        writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.HASH_UNDERSCORE}${this.dCConductingEquipmentUUID}`);
+        xmlWriter.endElement();
+      } else {
+        if (this.constructor.name === 'DCLineSegment') {
+          xmlWriter.writeComment('DCConductingEquipment is not defined');
+        }
+      }
+    }
+  }
+
+}

package/src/model/dc/CsConverter.ts

@@ -0,0 +1,68 @@
+import { ACDCConverter } from './ACDCConverter';
+import { RDF_XML } from '../../constants/rdf-xml';
+import { writeElement, writeElementAttribute } from '../../util/utils';
+
+import XMLWriter from 'xml-writer';
+import { CsOperatingModeKind } from './CsOperatingModeKind';
+import { CsPpccControlKind } from './CsPpccControlKind';
+
+export class CsConverter extends ACDCConverter {
+
+  /** Maximum firing angle. CSC configuration data used in power flow. */
+  maxAlpha: number;
+  /** Maximum extinction angle. CSC configuration data used in power flow. */
+  maxGamma: number;
+
+  /** The maximum direct current (Id) on the DC side at which the converter should operate. Converter configuration data use in power flow. */
+  maxIdc: number;
+
+  /** Minimum firing angle. CSC configuration data used in power flow. */
+  minAlpha: number;
+
+  /** Minimum extinction angle. CSC configuration data used in power flow.*/
+  minGamma: number;
+
+  /** The minimum direct current (Id) on the DC side at which the converter should operate. CSC configuration data used in power flow. */
+  minIdc: number;
+
+  /** Rated converter DC current, also called IdN. Converter configuration data used in power flow. */
+  ratedIdc: number;
+
+  //SSH Profil
+  operatingMode: CsOperatingModeKind; //mandatory
+  pPccControl: CsPpccControlKind; //mandatory
+  targetAlpha: number; //ActivePower mandatory
+  targetGamma: number; //ActivePower mandatory
+  targetIdc: number; //ActivePower mandatory
+
+  constructor(uuid?: string, name?: string, shortName?: string, description?: string) {
+    super(uuid, name, shortName, description);
+  }
+
+  /** CIM RDF/XML Serialisierung */
+  public toCIMXML(xmlWriter: XMLWriter, profile: string) {
+    if (profile === RDF_XML.PROFILE_EQ) {
+      const suffixID = this.getSuffixID(profile);
+      const prefixUUID = this.getPrefixUUID(suffixID);
+      xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, this.constructor.name, RDF_XML.CIM_NS_16);
+      writeElementAttribute(xmlWriter, suffixID, `${prefixUUID}${this.mrid}`);
+      this.toCIMXMLAttributes(xmlWriter, profile);
+      this.toCIMXMLAssociations(xmlWriter, profile);
+      xmlWriter.endElement();
+    }
+  }
+
+  protected toCIMXMLAttributes(xmlWriter: XMLWriter, profile: string) {
+    super.toCIMXMLAttributes(xmlWriter, profile);
+    if (profile === RDF_XML.PROFILE_EQ) {
+      if (this.maxAlpha > 0) writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:CsConverter.maxAlpha`, this.maxAlpha);
+      if (this.minAlpha > 0) writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:CsConverter.minAlpha`, this.minAlpha);
+      if (this.maxGamma > 0) writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:CsConverter.maxGamma`, this.maxGamma);
+      if (this.minGamma > 0) writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:CsConverter.minGamma`, this.minGamma);
+      if (this.maxIdc > 0) writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:CsConverter.maxIdc`, this.maxIdc);
+      if (this.minIdc > 0) writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:CsConverter.minIdc`, this.minIdc);
+      if (this.ratedIdc > 0) writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:CsConverter.ratedIdc`, this.ratedIdc);
+    }
+  }
+
+}