@enervance/insight-cim-model 0.0.1 → 0.0.2

package/src/model/dc/CsOperatingModeKind.ts

@@ -0,0 +1,4 @@
+export enum CsOperatingModeKind {
+  inverter = 'inverter', // Wechselrichter Spannungs-, Winkelregelung
+  rectifier = 'rectifier' // Gleichrichter => P-Leistungsregelung
+}

package/src/model/dc/CsPpccControlKind.ts

@@ -0,0 +1,5 @@
+export enum CsPpccControlKind {
+  activePower = 'activePower',
+  dcVoltage = 'dcVoltage',
+  dcCurrent = 'dcCurrent'
+}

package/src/model/dc/DCBaseTerminal.ts

@@ -0,0 +1,30 @@
+import { ACDCTerminal } from '../core/ACDCTerminal';
+import { DCNode } from './DCNode';
+import { RDF_XML } from '../../constants/rdf-xml';
+import { writeElementAttribute } from '../../util/utils';
+import XMLWriter from 'xml-writer';
+
+export class DCBaseTerminal extends ACDCTerminal {
+
+  dcNode: DCNode;
+  dcNodeUUID: string;
+
+  protected toCIMXMLAssociations(xmlWriter: XMLWriter, profile: string) {
+    super.toCIMXMLAssociations(xmlWriter, profile);
+    if (profile === RDF_XML.PROFILE_EQ) {
+      if (this.dcNode) {
+        xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'DCBaseTerminal.DCNode', RDF_XML.CIM_NS_16);
+        writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.HASH_UNDERSCORE}${this.dcNode.mrid}`);
+        xmlWriter.endElement();
+      } else if (this.dcNodeUUID) {
+        xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'DCBaseTerminal.DCNode', RDF_XML.CIM_NS_16);
+        writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.HASH_UNDERSCORE}${this.dcNodeUUID}`);
+        xmlWriter.endElement();
+      } else {
+        if (this.constructor.name === 'DCBaseTerminal') {
+          xmlWriter.writeComment('DCNode is not defined');
+        }
+      }
+    }
+  }
+}

package/src/model/dc/DCConductingEquipment.ts

@@ -0,0 +1,8 @@
+import { ConductingEquipment } from '../core/ConductingEquipment';
+import { DCTerminal } from './DCTerminal';
+
+export class DCConductingEquipment extends ConductingEquipment {
+
+  dCTerminals: Map<string, DCTerminal> = new Map();
+
+}

package/src/model/dc/DCConverterOperatingModeKind.ts

@@ -0,0 +1,6 @@
+
+export enum DCConverterOperatingModeKind {
+  bipolar = 'bipolar',
+  monopolarMetallicReturn = 'monopolarMetallicReturn',
+  monopolarGroundReturn = 'monopolarGroundReturn'
+}

package/src/model/dc/DCConverterUnit.ts

@@ -0,0 +1,60 @@
+import { DCEquipmentContainer } from './DCEquipmentContainer';
+import { DCConverterOperatingModeKind } from './DCConverterOperatingModeKind';
+import { Substation } from '../core/Substation';
+import { RDF_XML } from '../../constants/rdf-xml';
+import { writeElementAttribute } from '../../util/utils';
+import XMLWriter from 'xml-writer';
+
+export class DCConverterUnit extends DCEquipmentContainer {
+
+  operationMode: DCConverterOperatingModeKind; // cgmes mandatory
+  substation: Substation;
+  substationUUID: string;
+
+  constructor(uuid?: string, name?: string, shortName?: string, description?: string) {
+    super(uuid, name, shortName, description);
+  }
+
+  setSubstation(substation: Substation) {
+    this.substation = substation;
+  }
+
+  /** 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) {
+      xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, `${this.constructor.name}.operationMode`, RDF_XML.CIM_NS_16);
+      writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.CIM_NS_16}DCConverterOperatingModeKind.${this.operationMode ? this.operationMode : DCConverterOperatingModeKind.monopolarGroundReturn}`);
+      xmlWriter.endElement();
+    }
+  }
+
+  protected toCIMXMLAssociations(xmlWriter: XMLWriter, profile: string) {
+    super.toCIMXMLAssociations(xmlWriter, profile);
+    if (profile === RDF_XML.PROFILE_EQ) {
+      if (this.substation) {
+        xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, `${this.constructor.name}.Substation`, RDF_XML.CIM_NS_16);
+        writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.HASH_UNDERSCORE}${this.substation.mrid}`);
+        xmlWriter.endElement();
+      } else if (this.substationUUID) {
+        xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, `${this.constructor.name}.Substation`, RDF_XML.CIM_NS_16);
+        writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.HASH_UNDERSCORE}${this.substationUUID}`);
+        xmlWriter.endElement();
+      } else {
+        xmlWriter.writeComment(`${this.constructor.name}.Substation is not defined`);
+      }
+    }
+  }
+}

package/src/model/dc/DCEquipmentContainer.ts

@@ -0,0 +1,8 @@
+import { EquipmentContainer } from '../core/EquipmentContainer';
+import { DCNode } from './DCNode';
+
+export class DCEquipmentContainer extends EquipmentContainer {
+
+  dCNodes: Map<string,DCNode> = new Map();
+
+}

package/src/model/dc/DCLine.ts

@@ -0,0 +1,56 @@
+import { DCEquipmentContainer } from './DCEquipmentContainer';
+import { SubGeographicalRegion } from '../core/SubGeographicalRegion';
+import { RDF_XML } from '../../constants/rdf-xml';
+import { writeElementAttribute } from '../../util/utils';
+import XMLWriter from 'xml-writer';
+import { DCConverterOperatingModeKind } from './DCConverterOperatingModeKind';
+
+export class DCLine extends DCEquipmentContainer {
+
+  region: SubGeographicalRegion;
+  regionUUID: string;
+
+  constructor(mrid?: string, name?: string, shortName?: string, description?: string) {
+    super(mrid, name, shortName, description);
+  }
+
+  public static sparqlQuery: string = `
+        PREFIX cim:         <http://iec.ch/TC57/2013/CIM-schema-cim16#> 
+        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 apf:         <http://jena.hpl.hp.com/ARQ/property#>
+        PREFIX afn:         <http://jena.apache.org/ARQ/function#>
+        
+        SELECT  (STRAFTER(str(?hsUUID), '#_') AS ?uuid)  
+        (CONCAT(STRBEFORE(str(?hsUUID), '#_'), '#_') AS ?baseIRI) 
+        ?name 
+        WHERE { 
+            GRAPH <http://default/>{
+                ?MRID rdf:type cim:DCLine .
+                OPTIONAL { ?MRID cim:IdentifiedObject.name ?name .}
+            }
+        }
+    `;
+
+  public static getQuerySPARQL(graphURI: string) : string{
+    if(graphURI.length > 0){
+      return DCLine.sparqlQuery.replace('<http://default/>', graphURI);
+    }
+    return DCLine.sparqlQuery;
+  }
+
+  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();
+    }
+  }
+
+
+}

package/src/model/dc/DCLineSegment.ts

@@ -0,0 +1,81 @@
+import { DCConductingEquipment } from './DCConductingEquipment';
+import XMLWriter from 'xml-writer';
+import { RDF_XML } from '../../constants/rdf-xml';
+import { writeElement, writeElementAttribute } from '../../util/utils';
+export class DCLineSegment extends DCConductingEquipment {
+
+  /** Capacitance of the DC line segment. Significant for cables only. */
+  capacitance: number;
+
+  /** Inductance of the DC line segment. Neglectable compared with DCSeriesDevice used for smoothing.*/
+  inductance: number;
+
+  /** Resistance of the DC line segment. */
+  resistance: number;
+
+  /** Segment length for calculating line section capabilities. */
+  length: number;
+
+  constructor(mrid?: string, name?: string, shortName?: string, description?: string) {
+    super(mrid, name, shortName, description);
+  }
+
+  public static sparqlQuery: string = `
+        PREFIX cim:         <http://iec.ch/TC57/2013/CIM-schema-cim16#> 
+        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 apf:         <http://jena.hpl.hp.com/ARQ/property#>
+        PREFIX afn:         <http://jena.apache.org/ARQ/function#>
+        
+        SELECT  (STRAFTER(str(?hsUUID), '#_') AS ?uuid)  
+        (CONCAT(STRBEFORE(str(?hsUUID), '#_'), '#_') AS ?baseIRI) 
+        ?name ?capacitance ?inductance ?length ?resistance
+        
+         (strafter(strafter(str(?ecUUID), '#'), '_') AS ?equipmentContainerUUID) 
+        WHERE { 
+            GRAPH <http://default/>{
+                ?MRID rdf:type cim:DCLine .
+                OPTIONAL { ?MRID cim:IdentifiedObject.name ?name .}
+                OPTIONAL { ?MRID cim:DCLineSegment.capacitance ?capacitance .}
+                OPTIONAL { ?MRID cim:DCLineSegment.inductance ?inductance .}
+                OPTIONAL { ?MRID cim:DCLineSegment.length ?length .}
+                OPTIONAL { ?MRID cim:DCLineSegment.resistance ?resistance .}
+                
+                OPTIONAL {?acLineSegmentUUID cim:Equipment.EquipmentContainer ?ecUUID .}
+            }
+        }
+    `;
+
+  public static getQuerySPARQL(graphURI: string) : string{
+    if(graphURI.length > 0){
+      return DCLineSegment.sparqlQuery.replace('<http://default/>', graphURI);
+    }
+    return DCLineSegment.sparqlQuery;
+  }
+
+  /** 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.length > 0) writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:DCLineSegment.length`, this.length);
+      if (this.capacitance > 0) writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:DCLineSegment.capacitance`, this.capacitance);
+      if (this.inductance > 0) writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:DCLineSegment.inductance`, this.inductance);
+      if (this.resistance > 0) writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:DCLineSegment.resistance`, this.resistance);
+    }
+  }
+
+
+}

package/src/model/dc/DCNode.ts

@@ -0,0 +1,49 @@
+import { IdentifiedObject } from '../core/IdentifiedObject';
+import { DCEquipmentContainer } from './DCEquipmentContainer';
+import { DCBaseTerminal } from './DCBaseTerminal';
+import { RDF_XML } from '../../constants/rdf-xml';
+import { writeElementAttribute } from '../../util/utils';
+import XMLWriter from 'xml-writer';
+
+export class DCNode extends IdentifiedObject {
+
+  dcEquipmentContainer: DCEquipmentContainer; // mandatory
+  dcEquipmentContainerUUID: string;
+
+  /** ACDCConverterDCTerminal / DCTerminal*/
+  dcTerminals: Map<string, DCBaseTerminal> = new Map();
+
+  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 toCIMXMLAssociations(xmlWriter: XMLWriter, profile: string) {
+    super.toCIMXMLAssociations(xmlWriter, profile);
+    if (profile === RDF_XML.PROFILE_EQ) {
+      this.dcEquipmentContainerUUID = this.dcEquipmentContainer ?this.dcEquipmentContainer.mrid : this.dcEquipmentContainerUUID;
+      if (this.dcEquipmentContainerUUID) {
+        xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'DCNode.DCEquipmentContainer', RDF_XML.CIM_NS_16);
+        writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.HASH_UNDERSCORE}${this.dcEquipmentContainerUUID}`);
+        xmlWriter.endElement();
+      } else {
+        if (this.constructor.name === 'DCNode') {
+          xmlWriter.writeComment('DCEquipmentContainer is not defined');
+        }
+      }
+    }
+  }
+
+}

package/src/model/dc/DCPolarityKind.ts

@@ -0,0 +1,5 @@
+export enum DCPolarityKind {
+  positive = 'positive',
+  middle = 'middle',
+  negative = 'negative'
+}

package/src/model/dc/DCTerminal.ts

@@ -0,0 +1,45 @@
+import { DCBaseTerminal } from './DCBaseTerminal';
+import { DCConductingEquipment } from './DCConductingEquipment';
+import { RDF_XML } from '../../constants/rdf-xml';
+import { writeElementAttribute } from '../../util/utils';
+import XMLWriter from 'xml-writer';
+
+export class DCTerminal extends DCBaseTerminal {
+
+  /** */
+  dCConductingEquipment: DCConductingEquipment; // mandatory
+  dCConductingEquipmentUUID: string;
+
+  constructor(mrid?: string, name?: string, shortName?: string, description?: string) {
+    super(mrid, 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 toCIMXMLAssociations(xmlWriter: XMLWriter, profile: string) {
+    super.toCIMXMLAssociations(xmlWriter, profile);
+    if (profile === RDF_XML.PROFILE_EQ) {
+      this.dCConductingEquipmentUUID = this.dCConductingEquipment ?this.dCConductingEquipment.mrid : this.dCConductingEquipmentUUID;
+      if (this.dCConductingEquipmentUUID) {
+        xmlWriter.startElementNS(RDF_XML.CIM_NS_PREFIX, 'DCTerminal.DCConductingEquipment', RDF_XML.CIM_NS_16);
+        writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `${RDF_XML.HASH_UNDERSCORE}${this.dCConductingEquipmentUUID}`);
+        xmlWriter.endElement();
+      } else {
+        xmlWriter.writeComment('DCConductingEquipment is not defined');
+      }
+    }
+  }
+
+}

package/src/model/dc/VsConverter.ts

@@ -0,0 +1,48 @@
+import { ACDCConverter } from './ACDCConverter';
+import { VsPpccControlKind } from './VsPpccControlKind';
+import { VsQpccControlKind } from './VsQpccControlKind';
+import { RDF_XML } from '../../constants/rdf-xml';
+import { writeElement, writeElementAttribute } from '../../util/utils';
+import XMLWriter from 'xml-writer';
+
+export class VsConverter extends ACDCConverter {
+
+  /** The max quotient between the AC converter voltage (Uc) and DC voltage (Ud). A factor typically less than 1. VSC configuration data used in power flow. */
+  maxModulationIndex: number;
+  /** The maximum current through a valve. This current limit is the basis for calculating the capability diagram. VSC  configuration data. */
+  maxValveCurrent: number;
+
+  droop: number; // PU mandatory
+  droopCompensation: number; // resistance mandatory
+  pPccControl: VsPpccControlKind; // mandatory Kind of control of real power and/or DC voltage.
+  qPccControl: VsQpccControlKind; // mandatory
+  qShare: number; // Percent mandatory Reactive power sharing factor among parallel converters on Uac control.
+  targetQpcc: number; // ReactivePower mandatory
+  targetUpcc: number; // Voltage 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.maxModulationIndex > 0) writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:VsConverter.maxModulationIndex`, this.maxModulationIndex);
+      if (this.maxValveCurrent > 0) writeElement(xmlWriter, `${RDF_XML.CIM_NS_PREFIX}:VsConverter.maxValveCurrent`, this.maxValveCurrent);
+    }
+  }
+
+}

package/src/model/dc/VsPpccControlKind.ts

@@ -0,0 +1,7 @@
+export enum VsPpccControlKind {
+  pPcc = 'pPcc', // Control variable (target) is real power at PCC bus.
+  udc = 'udc', // Control variable (target) is DC voltage and real power at PCC bus is derived.
+  pPccAndUdcDroop = 'pPccAndUdcDroop', // Control variables (targets) are both active power at point of common coupling and local DC voltage, with the droop.
+  pPccAndUdcDroopWithCompensation = 'pPccAndUdcDroopWithCompensation', // Control variables (targets) are both active power at point of common coupling and compensated DC voltage, with the droop; compensation factor is the resistance, as an approximation of the DC voltage of a common (real or virtual) node in the DC network.
+  pPccAndUdcDroopPilot = 'pPccAndUdcDroopPilot', // Control variables (targets) are both active power at point of common coupling and the pilot DC voltage, with the droop.
+}

package/src/model/dc/VsQpccControlKind.ts

@@ -0,0 +1,5 @@
+export enum VsQpccControlKind {
+  reactivePcc = 'reactivePcc',
+  voltagePcc = 'voltagePcc',
+  powerFactorPcc = 'powerFactorPcc'
+}

package/src/model/domain/UnitMultiplier.ts

@@ -1,13 +1,13 @@
-export enum UnitMultiplier{
-    p = 'p',
-    n = 'n',
-    micro = 'micro',
-    m = 'm',
-    c = 'c',
-    d = 'd',
-    k = 'k',
-    M = 'M',
-    G = 'G',
-    T = 'T',
-    none  = 'none'
+export enum UnitMultiplier {
+  p = 'p',
+  n = 'n',
+  micro = 'micro',
+  m = 'm',
+  c = 'c',
+  d = 'd',
+  k = 'k',
+  M = 'M',
+  G = 'G',
+  T = 'T',
+  none = 'none'
 }

package/src/model/equivalents/EquivalentBranch.ts

@@ -5,19 +5,19 @@ import XMLWriter from 'xml-writer';
 
 export class EquivalentBranch extends EquivalentEquipment {
 
-    negativeR12: number;
-    negativeR21: number;
-    negativeX12: number;
-    negativeX21: number;
+    negativeR12: number;  // Mandatory, if not r und x
+    negativeR21: number;  // Mandatory, if not r und x
+    negativeX12: number;  // Mandatory, if not r und x
+    negativeX21: number;  // Mandatory, if not r und x
 
-    positiveR12: number;
-    positiveR21: number;
-    positiveX12: number;
-    positiveX21: number;
+    positiveR12: number; // Mandatory, if not r und x
+    positiveR21: number; // Mandatory, if not r und x
+    positiveX12: number; // Mandatory, if not r und x
+    positiveX21: number; // Mandatory, if not r und x
 
-    r: number;
+    r: number; // Mandatory
     r21: number;
-    x: number;
+    x: number;  // Mandatory
     x21: number;
     zeroR12: number;
     zeroR21: number;

package/src/model/extensions/amprion/model/AmprionModell.ts

@@ -0,0 +1,92 @@
+import { Model } from '../../../model/Model';
+import { AMPRIONErpProjectPhase } from '../project/AMPRIONErpProjectPhase';
+import { Substation } from '../../../core/Substation';
+import { AMPRIONErpProjectStructure } from '../project/AMPRIONErpProjectStructure';
+import { AMPRIONConstructionProject } from '../project/AMPRIONConstructionProject';
+import { AMPRIONConstructionProjectBundle } from '../project/AMPRIONConstructionProjectBundle';
+import { AMPRIONConstructionProjectPlan } from '../project/AMPRIONConstructionProjectPlan';
+import { IdentifiedObject } from '../../../core/IdentifiedObject';
+import { IFault } from '../../../../interfaces/model/faults/IFault';
+import { IOutage } from '../../../../interfaces/model/operations/IOutage';
+import { SwitchingPlan } from '../../../operations/SwitchingPlan';
+import { ISwitchingAction } from '../../../../interfaces/model/operations/ISwitchingAction';
+
+export class AmprionModel extends Model {
+
+
+  constructionProjectPlan: Map<string, AMPRIONConstructionProjectPlan> = new Map();
+  constructionProjectBundle: Map<string, AMPRIONConstructionProjectBundle> = new Map();
+  constructionProject: Map<string, AMPRIONConstructionProject> = new Map();
+
+  projectStructures: Map<string, AMPRIONErpProjectStructure> = new Map();
+
+  erpProjectPhases: Map<string, AMPRIONErpProjectPhase> = new Map();
+
+
+
+  constructor() {
+    super();
+  }
+
+  resolveParsedAssociations() {
+    super.resolveParsedAssociations();
+
+    this.constructionProjectPlan.forEach((cimInstance: IdentifiedObject) => {
+      cimInstance.resolveParsedAssociations(this);
+    });
+    this.constructionProjectBundle.forEach((cimInstance: IdentifiedObject) => {
+      cimInstance.resolveParsedAssociations(this);
+    });
+    this.constructionProject.forEach((cimInstance: IdentifiedObject) => {
+      cimInstance.resolveParsedAssociations(this);
+    });
+
+    this.erpProjectPhases.forEach((cimInstance: IdentifiedObject) => {
+      cimInstance.resolveParsedAssociations(this);
+    });
+  }
+
+  public getConstructionProject(uuid: string): AMPRIONConstructionProject | undefined {
+    return this.constructionProject.get(uuid);
+  }
+
+  public addConstructionProject(project: AMPRIONConstructionProject) {
+    this.constructionProject.set(project.getUUID(), project);
+    this.addErpProjectStructure(project);
+  }
+
+  public getErpProjectPhase(uuid: string): AMPRIONErpProjectPhase | undefined {
+    return this.erpProjectPhases.get(uuid);
+  }
+
+  public addErpProjectPhase(phase: AMPRIONErpProjectPhase) {
+    this.erpProjectPhases.set(phase.getUUID(), phase);
+  }
+
+  addErpProjectStructure(structure: AMPRIONErpProjectStructure) {
+    this.projectStructures.set(structure.getUUID(), structure);
+  }
+
+  public getErpProjectStructure(uuid: string): AMPRIONErpProjectStructure | undefined {
+    return this.projectStructures.get(uuid);
+  }
+
+  public getConstructionProjectBundle(uuid: string): AMPRIONConstructionProjectBundle | undefined {
+    return this.constructionProjectBundle.get(uuid);
+  }
+
+  public addConstructionProjectBundle(projectBundle: AMPRIONConstructionProjectBundle) {
+    this.constructionProjectBundle.set(projectBundle.getUUID(), projectBundle);
+    this.addErpProjectStructure(projectBundle);
+  }
+
+  public getConstructionProjectPlan(uuid: string): AMPRIONConstructionProjectPlan | undefined {
+    return this.constructionProjectPlan.get(uuid);
+  }
+
+  public addConstructionProjectPlan(projectPlan: AMPRIONConstructionProjectPlan) {
+    this.constructionProjectPlan.set(projectPlan.getUUID(), projectPlan);
+    this.addErpProjectStructure(projectPlan);
+  }
+
+}