@enervance/insight-cim-model 0.0.1

package/src/model/core/ConnectivityNode.ts

@@ -0,0 +1,417 @@
+import { IdentifiedObject } from '../core/IdentifiedObject';
+import { ConnectivityNodeContainer } from '../core/ConnectivityNodeContainer';
+import { BaseVoltage } from './BaseVoltage';
+import { VoltageLevel } from './VoltageLevel';
+import { Terminal } from './Terminal';
+import { Model } from '../model/Model';
+import { DiagramObject } from '../diagram/DiagramObject';
+import { Switch } from '../wires/Switch';
+import { Bay } from './Bay';
+import { isInArray, isTerminalsAssociatedWith, writeElementAttribute } from '../../util/utils';
+import { getValue } from '../../util/utils';
+import { IRectangleShapeInfo, ISchemaSettings } from '../../interfaces/schema-settings/ShapeInfos';
+import { RDF_XML } from '../../constants/rdf-xml';
+import XMLWriter from 'xml-writer';
+import { IIdentifiedObject } from '../..';
+import { IConnectivityNode } from '../../interfaces/model/core/IConnectivityNode';
+
+
+export class ConnectivityNode extends IdentifiedObject implements IConnectivityNode {
+
+  public static sparqlQuery: string = `
+        PREFIX cim:	 		            <http://iec.ch/TC57/2013/CIM-schema-cim16#> 
+        PREFIX enervance:           <http://enervance.com/CIM/Extensions#> 
+        PREFIX westnetzneplan:	    <http://westnetzneplan.de/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/Extensions#> 
+        PREFIX apf:	 		            <http://jena.hpl.hp.com/ARQ/property#>
+        PREFIX afn:	 		            <http://jena.apache.org/ARQ/function#>
+        
+        SELECT  (STRAFTER(str(?MRID), '#_') AS ?uuid)  
+                (CONCAT(STRBEFORE(str(?MRID), '#_'), '#_') AS ?baseIRI) 
+                ?name ?shortName ?description 
+                (STRAFTER(str(?cncUUID), '#_') AS ?connectivityNodeContainerUUID)
+        
+        WHERE { 
+            GRAPH <http://default/>{
+                ?MRID rdf:type cim:ConnectivityNode .
+                OPTIONAL {?MRID cim:IdentifiedObject.name ?name .}
+                OPTIONAL {?MRID entsoe:IdentifiedObject.shortName ?shortName .}
+                OPTIONAL {?MRID cim:IdentifiedObject.description ?description .}
+                OPTIONAL {?MRID cim:ConnectivityNode.ConnectivityNodeContainer ?cncUUID .}
+            }
+        }
+    `
+
+  /* Bay, VoltageLevel, Substation, Line ...*/
+  connectivityNodeContainer: ConnectivityNodeContainer | undefined;
+  connectivityNodeContainerUUID: string | undefined;
+
+  terminals: Map<string, Terminal>;
+
+  constructor(uuid?: string, name?: string, shortName?: string, description?: string) {
+    super(uuid, name, shortName, description);
+    this.terminals = new Map();
+  }
+
+
+  public getBaseVoltage(): BaseVoltage | undefined {
+    if (this.connectivityNodeContainer instanceof VoltageLevel) {
+      return (this.connectivityNodeContainer as VoltageLevel).baseVoltage;
+    } else if (this.connectivityNodeContainer instanceof Bay) {
+      return (this.connectivityNodeContainer as Bay).getBaseVoltage();
+    }
+    return;
+  }
+
+  public getVoltageLevel(): VoltageLevel | undefined {
+    if (this.connectivityNodeContainer instanceof VoltageLevel) {
+      return this.connectivityNodeContainer;
+    } else if (this.connectivityNodeContainer instanceof Bay) {
+      return (this.connectivityNodeContainer as Bay).getVoltageLevel();
+    }
+    return;
+  }
+
+  public getBaseVoltageAsNumber(): number {
+    try {
+      if (this.connectivityNodeContainer instanceof VoltageLevel) {
+        return (this.connectivityNodeContainer as VoltageLevel).baseVoltage.nominalVoltage.value;
+      } else if (this.connectivityNodeContainer instanceof Bay) {
+        return (this.connectivityNodeContainer as Bay).getBaseVoltage().nominalVoltage.value;
+      }
+    } catch (e) {
+      console.log(this.connectivityNodeContainer.mrid + ' has no Voltage.');
+    }
+
+    return 0;
+  }
+
+
+  public getTerminal(uuid: string): Terminal | undefined {
+    return this.terminals.get(uuid);
+  }
+
+  public addTerminal(terminal: Terminal) {
+    this.terminals.set(terminal.getUUID(), terminal);
+  }
+
+  public static getQuerySPARQL(graphURI: string): string {
+    if (graphURI.length > 0) {
+      return ConnectivityNode.sparqlQuery.replace('<http://default/>', graphURI);
+    }
+    return ConnectivityNode.sparqlQuery;
+  }
+
+  public static resolveClassFusekiJSON(data: any, cimModel: Model) {
+    data.results.bindings.forEach((value: any) => {
+      const newClass = new ConnectivityNode();
+      newClass.resolveAttributesFusekiJSON(value);
+      cimModel.addConnectivityNode(newClass);
+    });
+  }
+
+  public resolveAttributesFusekiJSON(value: any) {
+    super.resolveAttributesFusekiJSON(value);
+    this.connectivityNodeContainerUUID = getValue(value, 'connectivityNodeContainerUUID');
+  }
+
+  public resolveParsedAssociations(cimModel: Model) {
+    super.resolveParsedAssociations(cimModel);
+    this.connectivityNodeContainer = cimModel.getConnectivityNodeContainer(this.connectivityNodeContainerUUID);
+
+    if (this.connectivityNodeContainer) this.connectivityNodeContainer.addConnectivityNode(this);
+    else console.log(this.constructor.name + ' ' + this.mrid + ' hat keine connectivityNodeContainerInstanz ' + this.connectivityNodeContainerUUID);
+  }
+
+
+  public toJSON() {
+    super.toJSON();
+    this.toJSONAttributes();
+    this.toJSONAssociations();
+    return this.json;
+  }
+
+  public toJSONAttributes() {
+    super.toJSONAttributes();
+  }
+
+  public toJSONAssociations() {
+    super.toJSONAssociations();
+    this.json['connectivityNodeContainerUUID'] = this.connectivityNodeContainerUUID;
+  }
+
+  /* Graphalgorithmen  */
+  public determineGridIslands(networkElements: any []) {
+    if (!this.visited) {
+      this.addNetworkElement(networkElements);
+      // 0 = key, 1 = value
+      for (const entry of this.terminals.entries()) {
+        const value = entry[1];
+        value.determineGridIslands(networkElements);
+      }
+    }
+  }
+
+  public breadthFirstSearch(networkElements: any[]) {
+    if (!this.visited) {
+      //console.log(this.constructor.name + ' ' + this.mrid)
+      this.addNetworkElement(networkElements);
+      // 0 = key, 1 = value
+      for (const entry of this.terminals.entries()) {
+        const value = entry[1];
+        value.breadthFirstSearch(networkElements);
+      }
+    }
+  }
+
+  /* Bestimmt alle zum Slack gehörende Netzelemente (CN, Terminals Sammelschienen, Trafos)*/
+  public determineSlackNodes(slackElemenets: IdentifiedObject[]) {
+    if (!this.visited) {
+      /* Sonderfall: den Knoten nur berücksichtigen, wenn keine Stromkreisabschnitte
+                     an den assozierten Terminals hängen.
+      */
+      this.addNetworkElement(slackElemenets);
+      const isAssociatedWith = isTerminalsAssociatedWith(this.terminals, 'ACLineSegment');
+      if (!isAssociatedWith) {
+        // 0 = key, 1 = value
+        for (const entry of this.terminals.entries()) {
+          const value = entry[1];
+          value.determineSlackNodes(slackElemenets);
+        }
+      }
+    }
+  }
+
+
+  public determineMidVoltageLineElements(feederLineElemenets: IIdentifiedObject[], slackSubstationElements: IIdentifiedObject[][]) {
+    if (!this.visited && !isInArray(this, slackSubstationElements)) {
+      this.addNetworkElement(feederLineElemenets);
+      // 0 = key, 1 = value
+      for (const entry of this.terminals.entries()) {
+        const value = entry[1];
+        value.determineMidVoltageLineElements(feederLineElemenets, slackSubstationElements);
+      }
+    }
+  }
+
+
+  public determineTopologicalNodes(connNodes: IConnectivityNode[]) {
+    if (!this.visited) {
+      this.visited = true;
+      connNodes.push(this);
+      // 0 = key, 1 = value
+      for (const entry of this.terminals.entries()) {
+        const value = entry[1];
+        value.determineTopologicalNodes(connNodes);
+      }
+    }
+  }
+
+  /** */
+  public determineLoadNFeeder(loadsNfeeders: Map<string, IIdentifiedObject[]>) {
+    for (const value of this.terminals.values()) {
+      value.determineLoadNFeeder(loadsNfeeders);
+    }
+  }
+
+
+  // TODO temp. Lösung
+  hasSwitchAssociation(): boolean {
+    if (isTerminalsAssociatedWith(this.terminals, 'Switch')) {
+      return true;
+    }
+    if (isTerminalsAssociatedWith(this.terminals, 'ProtectedSwitch')) {
+      return true;
+    }
+    if (isTerminalsAssociatedWith(this.terminals, 'Breaker')) {
+      return true;
+    }
+    if (isTerminalsAssociatedWith(this.terminals, 'Recloser')) {
+      return true;
+    }
+    if (isTerminalsAssociatedWith(this.terminals, 'LoadBreakSwitch')) {
+      return true;
+    }
+    if (isTerminalsAssociatedWith(this.terminals, 'Sectionaliser')) {
+      return true;
+    }
+    if (isTerminalsAssociatedWith(this.terminals, 'Jumper')) {
+      return true;
+    }
+    if (isTerminalsAssociatedWith(this.terminals, 'Fuse')) {
+      return true;
+    }
+    if (isTerminalsAssociatedWith(this.terminals, 'GroundDisconnector')) {
+      return true;
+    }
+    if (isTerminalsAssociatedWith(this.terminals, 'Disconnector')) {
+      return true;
+    }
+    return false
+  }
+
+
+  /* public static sparqlQueryDelete : string = `
+       ${NS_PREFIX_CIM}
+       ${NS_PREFIX_ENERVANCE}
+       ${NS_PREFIX_AMPRION}
+       ${NS_PREFIX_ENTSOE}
+       ${NS_PREFIX_RDF}
+
+       DELETE DATA
+       ${IDENTIFIED_OBJECT_PROP_SELECT}
+       ${CONNECTIVITY_NODE_SELECT}
+
+       WHERE {
+           GRAPH <http://default/>{
+
+               ${PROP_MRID} rdf:type cim:ConnectivityNode .
+               ${IDENTIFIED_OBJECT_PROP_WHERE}
+               #Anlage
+               ${CONNECTIVITY_NODE_WHERE}
+           }
+       }
+   `;*/
+
+
+  /*    public setAsset(value: Asset): string {
+          this.asset = value;
+          return this.createSPARQLStatement('enervance', 'ConnectivityNode', 'Asset', this.asset.mrid, false);
+      }*/
+
+  /** 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, 'ConnectivityNode', RDF_XML.CIM_NS_16);
+      writeElementAttribute(xmlWriter, suffixID, `${prefixUUID}${this.mrid}`);
+      this.toCIMXMLAttributes(xmlWriter, profile);
+      this.toCIMXMLAssociations(xmlWriter, profile);
+      xmlWriter.endElement();
+    }
+  }
+
+  public toCIMXMLAttributes(xmlWriter: XMLWriter, profile: string) {
+    super.toCIMXMLAttributes(xmlWriter, profile);
+  }
+
+  public toCIMXMLAssociations(xmlWriter: XMLWriter, profile: string) {
+    super.toCIMXMLAssociations(xmlWriter, profile);
+    if (profile === RDF_XML.PROFILE_EQ) {
+      if (this.connectivityNodeContainer) {
+        xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'ConnectivityNode.ConnectivityNodeContainer', RDF_XML.CIM_NS_16);
+        writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.HASH_UNDERSCORE}${this.connectivityNodeContainer.mrid}`);
+        xmlWriter.endElement();
+      } else if (this.connectivityNodeContainerUUID) {
+        xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'ConnectivityNode.ConnectivityNodeContainer', RDF_XML.CIM_NS_16);
+        writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.HASH_UNDERSCORE}${this.connectivityNodeContainerUUID}`);
+        xmlWriter.endElement();
+      }
+      else {
+        xmlWriter.writeComment('ConnectivityNodeContainer is not defined');
+      }
+    }
+  }
+
+  public toGeoJSON(geoJSON: any, profile: string, schemaSettings: ISchemaSettings, diagramObject: DiagramObject): any {
+
+    const coordinates: number[] = diagramObject.computeRectBounds(diagramObject);
+    const shapeInfos: IRectangleShapeInfo = schemaSettings.getRectangleShapeInfo(profile);
+
+    let x = coordinates[0];
+    let y = coordinates[1];
+    let offsetX = 0;
+    let offsetY = 0;
+
+    let width: number = coordinates[2];
+    let height: number = coordinates[3];
+
+    /* Shape besteht nur aus einer Koordinate */
+    if (shapeInfos && width === 1 && height === 1) {
+
+      width = +shapeInfos.width ?? 0;
+      height = +shapeInfos.height;
+      offsetX = +width / 2;
+      offsetY = +height / 2;
+    }
+
+    if (x != 0 && y != 0 && width != 0 && height != 0) {
+      super.toGeoJSON(geoJSON, profile, schemaSettings, diagramObject);
+
+      if (profile === 'Integral 7') {
+        let xx = coordinates[0];
+        let yy = coordinates[1] * -1;
+
+        let offsetXX = width / 2;
+        let offsetYY = height / 2;
+
+        //Als Raute
+        const pointsPolygon: number[][][] = /*stationsTyp === 'Muffe' ? [[[x , -y]]] :*/ [
+          [
+            [xx, yy + offsetYY], // oben
+            [xx + offsetXX, yy], // rechts
+            [xx, yy - offsetYY], // unten
+            [xx - offsetXX, yy],
+            [xx, yy + offsetYY]
+          ]
+        ];
+
+        geoJSON['geometry'] = {
+          type: 'Polygon',
+          coordinates: pointsPolygon
+        };
+
+        geoJSON['properties'] = {
+          diagramObjectUUID: diagramObject.mrid,
+          objectType: this.constructor.name,
+          width: width,
+          height: height,
+          offsetX: offsetXX,
+          offsetY: offsetYY,
+          fill: undefined,
+        }
+      } else {
+        const xOff = x - offsetX;
+        const yOff = y - offsetY;
+        let fill = undefined;
+
+
+        let pointsPolygon: number[][][] = /*stationsTyp === 'Muffe' ? [[[x , -y]]] :*/ [
+          [
+            [xOff, yOff * -1],
+            [xOff + width, yOff * -1],
+            [xOff + width, (yOff + height) * -1],
+            [xOff, (yOff + height) * -1],
+            [xOff, yOff * -1]
+          ]
+        ];
+        // Typ der Station (Westnetz)
+        geoJSON['geometry'] = {
+          type: 'Polygon',
+          coordinates: pointsPolygon
+        }
+
+
+        geoJSON['properties'] = {
+          diagramObjectUUID: diagramObject.mrid,
+          objectType: this.constructor.name,
+          width: width,
+          height: height,
+          offsetX: offsetX,
+          offsetY: offsetY,
+          fill: fill,
+          radius: 1.5
+        }
+      }
+    }
+    return geoJSON;
+  }
+
+
+  getConnectivityNodeContainerUUID(): string {
+    return this.connectivityNodeContainer ? this.connectivityNodeContainer.mrid : this.connectivityNodeContainerUUID;
+  }
+}

package/src/model/core/ConnectivityNodeContainer.ts

@@ -0,0 +1,26 @@
+import { PowerSystemResource } from '../core/PowerSystemResource';
+import { ConnectivityNode } from '../core/ConnectivityNode';
+import { TopologicalNode } from '../topology/TopologicalNode';
+import { IConnectivityNodeContainer } from '../../interfaces/model/core/IConnectivityNodeContainer';
+import { IConnectivityNode } from '../../interfaces/model/core/IConnectivityNode';
+
+export class ConnectivityNodeContainer extends PowerSystemResource implements IConnectivityNodeContainer {
+
+  connectivityNodes: IConnectivityNode[];
+  topologicalNodes: TopologicalNode [];
+
+  constructor(mrid?: string, name?: string, shortName?: string, description?: string) {
+    super(mrid, name, shortName, description);
+    this.connectivityNodes = [];
+    this.topologicalNodes = [];
+  }
+
+  public addConnectivityNode(connectivityNode: IConnectivityNode) {
+    this.connectivityNodes.push(connectivityNode);
+  }
+
+  public addTopologicalNode(topologicalNode: TopologicalNode) {
+    this.topologicalNodes.push(topologicalNode);
+  }
+
+}

package/src/model/core/Curve.ts

@@ -0,0 +1,55 @@
+import {RDF_XML, CurveStyle, IdentifiedObject, UnitSymbol} from "../../index";
+import {writeElement, writeElementAttribute} from "../../util/utils";
+import XMLWriter from 'xml-writer';
+import {CurveData} from "./CurveData";
+
+export class Curve extends IdentifiedObject {
+
+    curveStyle: CurveStyle;// manadatory "http://iec.ch/TC57/2013/CIM-schema-cim16#CurveStyle.straightLineYValues"
+    xUnit: UnitSymbol; // manadatory  "http://iec.ch/TC57/2013/CIM-schema-cim16#UnitSymbol.W"
+    y1Unit: UnitSymbol; // manadatory  "http://iec.ch/TC57/2013/CIM-schema-cim16#UnitSymbol.VAr"
+    y2Unit: UnitSymbol; // manadatory  "http://iec.ch/TC57/2013/CIM-schema-cim16#UnitSymbol.VAr"
+
+    curveDatas: CurveData[] = [];
+
+    constructor(uuid?: string, name?: string, shortName?: string, description?: string) {
+        super(uuid, name, shortName, description);
+    }
+
+    protected toCIMXMLAttributes(xmlWriter: XMLWriter, profile: string) {
+        super.toCIMXMLAttributes(xmlWriter, profile);
+        /*<cim:Curve.curveStyle rdf:resource="http://iec.ch/TC57/2013/CIM-schema-cim16#CurveStyle.straightLineYValues"/>
+    <cim:Curve.xUnit rdf:resource="http://iec.ch/TC57/2013/CIM-schema-cim16#UnitSymbol.W"/>
+    <cim:Curve.y1Unit rdf:resource="http://iec.ch/TC57/2013/CIM-schema-cim16#UnitSymbol.VAr"/>
+    <cim:Curve.y2Unit rdf:resource="http://iec.ch/TC57/2013/CIM-schema-cim16#UnitSymbol.VAr"/>*/
+        if(profile === RDF_XML.PROFILE_EQ) {
+
+            if(profile === RDF_XML.PROFILE_EQ) {
+                // curveStyle
+                xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'Curve.curveStyle', RDF_XML.CIM_NS_16);
+                writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.CIM_NS_16}CurveStyle.${this.curveStyle}`);
+                xmlWriter.endElement();
+
+                // xUnit
+                xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'Curve.xUnit', RDF_XML.CIM_NS_16);
+                writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.CIM_NS_16}UnitSymbol.${this.xUnit}`);
+                xmlWriter.endElement();
+
+                // y1Unit
+                xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'Curve.y1Unit', RDF_XML.CIM_NS_16);
+                writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.CIM_NS_16}UnitSymbol.${this.y1Unit}`);
+                xmlWriter.endElement();
+
+                // y2Unit
+                if (this.y2Unit) {
+                    xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'Curve.y2Unit', RDF_XML.CIM_NS_16);
+                    writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.CIM_NS_16}UnitSymbol.${this.y2Unit}`);
+                    xmlWriter.endElement();
+                }
+            }
+        }
+    }
+
+}
+
+

package/src/model/core/CurveData.ts

@@ -0,0 +1,74 @@
+import { RDF_XML } from "../..";
+import { writeElement, writeElementAttribute } from "../../util/utils";
+import XMLWriter from 'xml-writer';
+import { Curve } from "./Curve";
+
+
+export class CurveData {
+
+  mrid: string;
+  xvalue: number;
+  y1value: number;
+  y2value: number;
+  curve: Curve;
+  curveUUID: string;
+
+  constructor(mrid?: string) {
+    this.mrid = mrid;
+  }
+
+  /** CIM RDF/XML Serialisierung */
+  public toCIMXML(xmlWriter: XMLWriter, profile: string) {
+    this.checkMandatoryAttributes(profile);
+    if (profile === RDF_XML.PROFILE_EQ) {
+      xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, this.constructor.name, RDF_XML.CIM_NS_16);
+      writeElementAttribute(xmlWriter, RDF_XML.RDF_ID, `${RDF_XML.UNDERSCORE}${this.mrid}`);
+      this.toCIMXMLAttributes(xmlWriter, profile);
+      this.toCIMXMLAssociations(xmlWriter, profile);
+      xmlWriter.endElement();
+    }
+  }
+
+  protected toCIMXMLAttributes(xmlWriter: XMLWriter, profile: string) {
+    writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:CurveData.xvalue`, this.xvalue);
+    writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:CurveData.y1value`, this.y1value);
+    writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:CurveData.y2value`, this.y2value);
+  }
+
+  protected toCIMXMLAssociations(xmlWriter: XMLWriter, profile: string) {
+    /* <cim:CurveData.Curve rdf:resource="#_a2f5d184-1ebd-4231-8ad6-bbdcf2addf36"/>*/
+    if (profile === RDF_XML.PROFILE_EQ) {
+      if (this.curve) {
+        xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'CurveData.Curve', RDF_XML.CIM_NS_16);
+        writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.HASH_UNDERSCORE}${this.curve.mrid}`);
+        xmlWriter.endElement();
+      } else if (this.curveUUID) {
+        xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'CurveData.Curve', RDF_XML.CIM_NS_16);
+        writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.HASH_UNDERSCORE}${this.curveUUID}`);
+        xmlWriter.endElement();
+      } else {
+        xmlWriter.writeComment('CurveData.Curve is not defined');
+      }
+    }
+  }
+
+  /** Überprüft die Instanz auf verpflichtende CGMES-Attribute.
+   * Bei nicht Vorhandensein eines verpflichtenden Attributes,
+   * wird ein Defaultwert gesetzt
+   * @return Eine Zeichenkette mit den gesetzen Defaultwerten.
+   * */
+  checkMandatoryAttributes(profile: string): string {
+    let defaultValues = '';
+    if (profile === RDF_XML.PROFILE_EQ) {
+      if (!this.xvalue) {
+        this.xvalue = 0;
+        defaultValues += 'xvalue,'
+      }
+      if (!this.y1value) {
+        this.y1value = 0;
+        defaultValues += 'y1value,'
+      }
+    }
+    return defaultValues;
+  }
+}

package/src/model/core/CurveStyle.ts

@@ -0,0 +1,4 @@
+export enum CurveStyle {
+    constantYValue = 'constantYValue',
+    straightLineYValues = 'straightLineYValues',
+}