@enervance/insight-cim-model 0.0.1

package/src/model/model/Model.ts

@@ -0,0 +1,1129 @@
+import { Substation } from '../core/Substation';
+import { BaseVoltage } from '../core/BaseVoltage';
+import { BusbarSection } from '../wires/BusbarSection';
+import { Diagram } from '../diagram/Diagram';
+import { Voltage } from '../domain/Voltage';
+import { VoltageLevel } from '../core/VoltageLevel';
+import { ConnectivityNodeContainer } from '../core/ConnectivityNodeContainer';
+import { DiagramObject } from '../diagram/DiagramObject';
+import { IdentifiedObject } from '../core/IdentifiedObject';
+import { EquipmentContainer } from '../core/EquipmentContainer';
+
+import { Location } from '../common/Location';
+import { CoordinateSystem } from '../common/CoordinateSystem';
+
+import { ACLineSegment } from '../wires/ACLineSegment';
+import { Line } from '../wires/Line';
+
+import { Switch } from '../wires/Switch';
+import { Disconnector } from '../wires/Disconnector';
+import { LoadBreakSwitch } from '../wires/LoadBreakSwitch';
+
+import { EnergySource } from '../wires/EnergySource';
+import { ExternalNetworkInjection } from '../wires/ExternalNetworkInjection';
+
+import { TopologicalIsland } from '../topology/TopologicalIsland';
+import { TopologicalNode } from '../topology/TopologicalNode';
+import { UnitSymbol } from '../domain/UnitSymbol';
+import { UnitMultiplier } from '../domain/UnitMultiplier';
+
+import { PowerTransformer } from '../wires/PowerTransformer';
+import { PowerTransformerEnd } from '../wires/PowerTransformerEnd';
+
+import { SvPowerFlow } from '../statevariables/SvPowerFlow';
+import { ConductingEquipment } from '../core/ConductingEquipment';
+import { DiagramObjectPoint } from '../diagram/DiagramObjectPoint';
+import { Breaker } from '../wires/Breaker';
+import { SvVoltage } from '../statevariables/SvVoltage';
+import { OperationalLimitSet } from '../operationallimits/OperationalLimitSet';
+import { OperationalLimitType } from '../operationallimits/OperationalLimitType';
+import { CurrentLimit } from '../operationallimits/CurrentLimit';
+import { Equipment } from '../core/Equipment';
+import { PSRType } from '../core/PSRType';
+import { RegulatingControl } from '../wires/RegulatingControl';
+import { SynchronousMachine } from '../wires/SynchronousMachine';
+
+import { EquivalentBranch } from '../equivalents/EquivalentBranch';
+
+
+import {
+  AssetDeployment,
+  AsynchronousMachine,
+  Bay, CurveData,
+  Cut, FossilFuel, HealthScore,
+  HydroGeneratingUnit, IIdentifiedObject,
+  Jumper,
+  Junction, NuclearGeneratingUnit, PositionPoint, SolarGeneratingUnit, SvTapStep,
+  ThermalGeneratingUnit, WindGeneratingUnit,
+  WireInfo
+} from '../..';
+import { RDF_XML } from '../../constants/rdf-xml';
+import { generateUUID, writeElement, writeElementAttribute } from '../../util/utils';
+import { Facility } from '../assets/Facility';
+import { OverheadWireInfo } from '../assetinfo/OverheadWireInfo';
+import { CableInfo } from '../assetinfo/CableInfo';
+import { PowerTransformer2WInfo } from '../assetinfo/PowerTransformer2WInfo';
+import { PowerTransformer3WInfo } from '../assetinfo/PowerTransformer3WInfo';
+import { GeographicalRegion } from '../core/GeographicalRegion';
+import { SubGeographicalRegion } from '../core/SubGeographicalRegion';
+import { RdfXmlSerializer } from '../../util/xml/xml.serializer';
+import XMLWriter from 'xml-writer';
+import { SvStatus } from '../statevariables/SvStatus';
+import { DiagramStyle } from '../diagram/DiagramStyle';
+import { DIAGRAM_LAYOUT_TYPES } from '../../constants/cim-constants';
+import { GeneratingUnit } from '../generation/GeneratingUnit';
+import { AssetOwner } from '../assets/AssetOwner';
+import { AssetHealthEvent } from '../assets/AssetHealthEvent';
+import { TapChangerControl } from '../wires/TapChangerControl';
+import { RatioTapChanger } from '../wires/RatioTapChanger';
+import { RatioTapChangerTable } from "../wires/RatioTapChangerTable";
+import { ReactiveCapabilityCurve } from "../wires/ReactiveCapabilityCurve";
+import { PetersenCoil } from "../wires/PetersenCoil";
+import { Feeder } from '../core/Feeder';
+import { IConnectivityNode } from '../../interfaces/model/core/IConnectivityNode';
+import { IEnergyConsumer } from '../../interfaces/model/wires/IEnergyConsumer';
+import { IFacility } from '../../interfaces/model/assets/IFacility';
+import { AnalyticScore } from '../assets/AnalyticScore';
+import { EVImportanceScore } from '../extensions/enervance/assets/EVImportanceScore';
+import { Outage } from '../operations/Outage';
+import { IOutage } from '../../interfaces/model/operations/IOutage';
+import { ITerminal } from '../../interfaces/model/core/ITerminal';
+import { IFault } from '../../interfaces/model/faults/IFault';
+import { ISwitchingAction } from '../../interfaces/model/operations/ISwitchingAction';
+import { ISwitchingPlan } from '../../interfaces/model/operations/ISwitchingPlan';
+import { SwitchingPlan } from '../operations/SwitchingPlan';
+import { IFeeder } from '../../interfaces/model/core/IFeeder';
+
+export class Model {
+
+  nodeBreaker: boolean = true;
+
+  /** die Version gibt die Serialisierungsform an. */
+  cimVersion: string = 'v16';
+
+  voltages: Map<string, Voltage> = new Map();
+  baseVoltages: Map<string, BaseVoltage> = new Map();
+
+  substations: Map<string, Substation> = new Map();
+  voltageLevels: Map<string, VoltageLevel> = new Map();
+  bays: Map<string, Bay> = new Map();
+  feeders: Map<string, IFeeder> = new Map();
+  lines: Map<string, Line> = new Map();
+
+  geographicalRegions: Map<string, GeographicalRegion> = new Map();
+  subgeographicalRegions: Map<string, SubGeographicalRegion> = new Map();
+
+  //connectivityNodes: Map<string, <T extends ConnectivityNode>> = new Map();
+  connectivityNodes: Map<string, IConnectivityNode> = new Map();
+
+  busbarSections: Map<string, BusbarSection> = new Map();
+  acLineSegments: Map<string, ACLineSegment> = new Map();
+
+  equivalentBranches: Map<string, EquivalentBranch> = new Map();
+
+  junctions: Map<string, Junction> = new Map();
+
+  cuts: Map<string, Cut> = new Map();
+  jumpers: Map<string, Jumper> = new Map();
+
+
+  powerTransformer: Map<string, PowerTransformer> = new Map();
+  powerTransformerEnds: Map<string, PowerTransformerEnd> = new Map();
+
+  tapChangerControls: Map<string, TapChangerControl> = new Map();
+  ratioTapChangers: Map<string, RatioTapChanger> = new Map();
+  ratioTapChangerTables: Map<string, RatioTapChangerTable> = new Map();
+
+  petersenCoils: Map<string, PetersenCoil> = new Map();
+
+
+  switches: Map<string, Switch> = new Map();
+  breakers: Map<string, Breaker> = new Map();
+  disconnectors: Map<string, Disconnector> = new Map();
+  loadBreakSwitches: Map<string, LoadBreakSwitch> = new Map();
+
+  energySources: Map<string, EnergySource> = new Map();
+  energyConsumers: Map<string, IEnergyConsumer> = new Map();
+  externalNetworkInjections: Map<string, ExternalNetworkInjection> = new Map();
+  synchronousMachine: Map<string, SynchronousMachine> = new Map();
+  asynchronousMachine: Map<string, AsynchronousMachine> = new Map();
+
+  // generation
+  generatingUnit: Map<string, GeneratingUnit> = new Map();
+  thermalGeneratingUnit: Map<string, ThermalGeneratingUnit> = new Map();
+  nuclearGeneratingUnit: Map<string, NuclearGeneratingUnit> = new Map();
+  hydroGeneratingUnit: Map<string, HydroGeneratingUnit> = new Map();
+  windGeneratingUnit: Map<string, WindGeneratingUnit> = new Map();
+  solarGeneratingUnit: Map<string, SolarGeneratingUnit> = new Map();
+  fossilFuel: FossilFuel[] = [];
+
+  reactiveCapabilityCurve: Map<string, ReactiveCapabilityCurve> = new Map();
+  curveData: CurveData[] = [];
+
+  regulatingControl: Map<string, RegulatingControl> = new Map();
+
+  terminals: Map<string, ITerminal> = new Map();
+
+  topologicalIslands: Map<string, TopologicalIsland> = new Map();
+  topologicalNodes: Map<string, TopologicalNode> = new Map();
+
+  operationalLimitSets: Map<string, OperationalLimitSet> = new Map();
+  operationalLimitTypes: Map<string, OperationalLimitType> = new Map();
+  currentLimits: Map<string, CurrentLimit> = new Map();
+
+  svPowerFlow: Array<SvPowerFlow> = []
+  svVoltage: Array<SvVoltage> = [];
+
+  svStatus: Array<SvStatus> = [];
+  svTapSteps: Array<SvTapStep> = [];
+
+  objects: Map<string, IIdentifiedObject> = new Map();
+
+
+  psrTypes: Map<string, PSRType> = new Map();
+
+  /** N-1 */
+  outages: Map<string, IOutage> = new Map();
+
+  /** Schaltmaßnahmen und -pläne */
+  switchingActions: Map<string, ISwitchingAction> = new Map();
+  switchingPlans: Map<string, ISwitchingPlan> = new Map();
+
+  /** benutzerdefinierte Ausfälle (ConnectivityNodes,...)*/
+  customFaults: Map<string, IFault> = new Map();
+
+  /** Assets */
+  assetDeployments: Map<string, AssetDeployment> = new Map();
+  assetOwners: Map<string, AssetOwner> = new Map();
+  facilities: Map<string, IFacility> = new Map();
+  assetHealthEvents: Map<string, AssetHealthEvent> = new Map();
+
+
+  /** AssetTypes */
+  overheadWireInfos: Map<string, OverheadWireInfo> = new Map();
+  cableInfos: Map<string, CableInfo> = new Map();
+  powerTransformer2WInfo: Map<string, PowerTransformer2WInfo> = new Map();
+  powerTransformer3WInfo: Map<string, PowerTransformer3WInfo> = new Map();
+
+  /** Analytics */
+  importanceScore: Map<string, EVImportanceScore> = new Map();
+  healthScore: Map<string, HealthScore> = new Map();
+
+  /** Grafik */
+  diagrams: Map<string, Diagram> = new Map();
+  diagramStyles: DiagramStyle[] = [];
+  diagramsArray: Diagram[] = [];
+  diagramSize: number = 0;
+
+  diagramObjects: Map<string, DiagramObject> = new Map();
+  diagramObjectPonts: DiagramObjectPoint[] = [];
+
+  /** Geo */
+  locations: Map<string, Location> = new Map();
+  coordinateSystems: Map<string, CoordinateSystem> = new Map();
+  positionPoints: PositionPoint[] = [];
+
+  /*    cimClassName2Class = getLoadClassConfigNeplan();*/
+
+  constructor() {
+    this.diagramStyles.push(new DiagramStyle(generateUUID(), DIAGRAM_LAYOUT_TYPES.NODE_BREAKER));
+    this.diagramStyles.push(new DiagramStyle(generateUUID(), DIAGRAM_LAYOUT_TYPES.BUS_BRANCH));
+    this.diagramStyles.push(new DiagramStyle(generateUUID(), DIAGRAM_LAYOUT_TYPES.GEOSCHEMATIC));
+  }
+
+  public getSubstation(uuid: string): Substation | undefined {
+    return this.substations.get(uuid);
+  }
+
+  public addSubstation(substation: Substation) {
+    this.substations.set(substation.getUUID(), substation);
+    this.addObject(substation);
+  }
+
+  public getBay(uuid: string): Bay | undefined {
+    return this.bays.get(uuid);
+  }
+
+  public addBay(bay: Bay) {
+    this.bays.set(bay.getUUID(), bay);
+    this.addObject(bay);
+  }
+
+
+  public getFeeder(uuid: string): IFeeder | undefined {
+    return this.feeders.get(uuid);
+  }
+
+  public addFeeder(feeder: IFeeder) {
+    this.feeders.set(feeder.getUUID(), feeder);
+    this.addObject(feeder);
+  }
+
+  public getConnectivityNode(uuid: string): IConnectivityNode | undefined {
+    return this.connectivityNodes.get(uuid);
+  }
+
+  public addConnectivityNode(connectivityNode: IConnectivityNode) {
+    this.connectivityNodes.set(connectivityNode.getUUID(), connectivityNode);
+    this.addObject(connectivityNode as unknown as IdentifiedObject);
+  }
+
+  public getOperationalLimitSet(uuid: string): OperationalLimitSet | undefined {
+    return this.operationalLimitSets.get(uuid);
+  }
+
+  public addOperationalLimitSet(operationalLimitSet: OperationalLimitSet) {
+    this.operationalLimitSets.set(operationalLimitSet.getUUID(), operationalLimitSet);
+    this.addObject(operationalLimitSet);
+  }
+
+  public getOperationalLimitTypes(): Map<string, OperationalLimitType> {
+    return this.operationalLimitTypes;
+  }
+
+  public getOperationalLimitType(uuid: string): OperationalLimitType | undefined {
+    return this.operationalLimitTypes.get(uuid);
+  }
+
+  public getOperationalLimitTypeByName(name: string): OperationalLimitType | undefined {
+    for (const type of this.operationalLimitTypes.values()) {
+      if (type.name === name) {
+        return type;
+      }
+    }
+    return;
+  }
+
+  public addOperationalLimitType(operationalLimitType: OperationalLimitType) {
+    this.operationalLimitTypes.set(operationalLimitType.getUUID(), operationalLimitType);
+    this.addObject(operationalLimitType);
+  }
+
+  public getCurrentLimit(uuid: string): CurrentLimit | undefined {
+    return this.currentLimits.get(uuid);
+  }
+
+  public addCurrentLimit(currentLimit: CurrentLimit) {
+    this.currentLimits.set(currentLimit.getUUID(), currentLimit);
+    this.addObject(currentLimit);
+  }
+
+
+  public getRegulatingControl(uuid: string): RegulatingControl | undefined {
+    return this.regulatingControl.get(uuid);
+  }
+
+  public addRegulatingControl(regulatingControl: RegulatingControl) {
+    this.regulatingControl.set(regulatingControl.mrid, regulatingControl);
+    this.addObject(regulatingControl);
+  }
+
+
+  public getVoltageLevel(uuid: string): VoltageLevel | undefined {
+    return this.voltageLevels.get(uuid);
+  }
+
+  public addVoltageLevel(voltageLevel: VoltageLevel) {
+    this.voltageLevels.set(voltageLevel.getUUID(), voltageLevel);
+    this.addObject(voltageLevel);
+  }
+
+
+  public getBusbarSection(uuid: string): BusbarSection | undefined {
+    return this.busbarSections.get(uuid);
+  }
+
+  public addBusbarSection(busbarSection: BusbarSection) {
+    this.busbarSections.set(busbarSection.getUUID(), busbarSection);
+    this.addObject(busbarSection);
+  }
+
+  public getDiagram(uuid: string): Diagram | undefined {
+    return this.diagrams.get(uuid);
+  }
+
+  public addDiagram(diagram: Diagram) {
+    this.diagrams.set(diagram.getUUID(), diagram);
+    this.addObject(diagram);
+    this.diagramSize = this.diagramSize + 1;
+    this.diagramsArray.push(diagram);
+  }
+
+  public getDiagramStyle(name: string): DiagramStyle | undefined {
+    for (const diagramStyle of this.diagramStyles) {
+      if (diagramStyle.name === name) {
+        return diagramStyle;
+      }
+    }
+    return;
+  }
+
+  public addDiagramStyle(diagramStyle: DiagramStyle) {
+    this.diagramStyles.push(diagramStyle);
+  }
+
+  public addFossilFuel(fossilFuel: FossilFuel) {
+    this.fossilFuel.push(fossilFuel);
+  }
+
+  public addCurveData(curveData: CurveData) {
+    this.curveData.push(curveData);
+  }
+
+  public addDiagramObjectPoint(diagramObjectPoint: DiagramObjectPoint) {
+    ;
+    this.diagramObjectPonts.push(diagramObjectPoint);
+    this.addObject(diagramObjectPoint);
+  }
+
+
+  public getLocation(uuid: string): Location | undefined {
+    return this.locations.get(uuid);
+  }
+
+  public addLocation(location: Location) {
+    this.locations.set(location.getUUID(), location);
+    this.addObject(location);
+  }
+
+  public getCoordinateSystem(uuid: string): CoordinateSystem | undefined {
+    return this.coordinateSystems.get(uuid);
+  }
+
+  public addCoordinateSystem(coordinateSystem: CoordinateSystem) {
+    this.coordinateSystems.set(coordinateSystem.getUUID(), coordinateSystem);
+    this.addObject(coordinateSystem);
+  }
+
+  public getVoltage(voltageNumber: number): Voltage {
+
+    // 0 = key, 1 = value
+    for (const entry of this.voltages.entries()) {
+      const voltage = entry[1];
+      if (voltage && voltage.value === voltageNumber) {
+        return voltage;
+      }
+    }
+    const voltage = new Voltage(voltageNumber, UnitMultiplier.k, UnitSymbol.V);
+    this.voltages.set(String(voltageNumber), voltage);
+
+    return voltage;
+  }
+
+
+  public getBaseVoltageByUUID(uuid: string): BaseVoltage | undefined {
+    return this.baseVoltages.get(uuid);
+  }
+
+  public getBaseVoltage(voltage: number): BaseVoltage | undefined {
+    // 0 = key, 1 = value
+    for (const entry of this.baseVoltages.entries()) {
+      const value = entry[1];
+      const nominalVoltage = value.nominalVoltage;
+      if (nominalVoltage && nominalVoltage.value === voltage) {
+        return value;
+      }
+    }
+    return;
+  }
+
+
+  public getLine(uuid: string): Line | undefined {
+    return this.lines.get(uuid);
+  }
+
+  public addLine(line: Line) {
+    this.lines.set(line.getUUID(), line);
+    this.addObject(line);
+  }
+
+  public addBaseVoltage(baseVoltage: BaseVoltage) {
+    this.baseVoltages.set(baseVoltage.getUUID(), baseVoltage);
+    this.addObject(baseVoltage);
+  }
+
+  public getACLineSegment(uuid: string): ACLineSegment | undefined {
+    return this.acLineSegments.get(uuid);
+  }
+
+  public addACLineSegment(acLineSegment: ACLineSegment) {
+    this.acLineSegments.set(acLineSegment.getUUID(), acLineSegment);
+    this.addObject(acLineSegment);
+  }
+
+  public getEquivalentBranch(uuid: string): EquivalentBranch | undefined {
+    return this.equivalentBranches.get(uuid);
+  }
+
+  public addEquivalentBranch(equivalentBranch: EquivalentBranch) {
+    this.equivalentBranches.set(equivalentBranch.mrid, equivalentBranch);
+    this.addObject(equivalentBranch);
+  }
+
+  public getJunction(uuid: string): Junction | undefined {
+    return this.junctions.get(uuid);
+  }
+
+  public addJunction(junction: Junction) {
+    this.junctions.set(junction.getUUID(), junction);
+    this.addObject(junction);
+  }
+
+  public getCut(uuid: string): Cut | undefined {
+    return this.cuts.get(uuid);
+  }
+
+  public addCut(cut: Cut) {
+    this.cuts.set(cut.getUUID(), cut);
+    this.addObject(cut);
+  }
+
+  public getJumper(uuid: string): Jumper | undefined {
+    return this.jumpers.get(uuid);
+  }
+
+  public addJumper(jumper: Jumper) {
+    this.jumpers.set(jumper.getUUID(), jumper);
+    this.addObject(jumper);
+  }
+
+  public getDisconnector(uuid: string): Disconnector | undefined {
+    return this.disconnectors.get(uuid);
+  }
+
+  public addDisconnector(disconnector: Disconnector) {
+    this.disconnectors.set(disconnector.getUUID(), disconnector);
+    this.addObject(disconnector);
+  }
+
+
+  public getSwitch(uuid: string): Switch | undefined {
+    return this.switches.get(uuid);
+  }
+
+  public addSwitch(swtch: Switch) {
+    this.switches.set(swtch.getUUID(), swtch);
+    this.addObject(swtch);
+  }
+
+  public getBreaker(uuid: string): Breaker | undefined {
+    return this.breakers.get(uuid);
+  }
+
+  public addBreaker(breaker: Breaker) {
+    this.breakers.set(breaker.getUUID(), breaker);
+    this.addObject(breaker);
+  }
+
+
+  public getLoadBreakSwitch(uuid: string): LoadBreakSwitch | undefined {
+    return this.loadBreakSwitches.get(uuid);
+  }
+
+  public addLoadBreakSwitch(loadBreakSwitch: LoadBreakSwitch) {
+    this.loadBreakSwitches.set(loadBreakSwitch.getUUID(), loadBreakSwitch);
+    this.addObject(loadBreakSwitch);
+  }
+
+
+  public getTerminal(uuid: string): ITerminal | undefined {
+    return this.terminals.get(uuid);
+  }
+
+  public addTerminal(terminal: ITerminal) {
+    this.terminals.set(terminal.getUUID(), terminal);
+    this.addObject(terminal);
+  }
+
+  public getExternalNetworkInjection(uuid: string): ExternalNetworkInjection | undefined {
+    return this.externalNetworkInjections.get(uuid);
+  }
+
+  public addExternalNetworkInjection(value: ExternalNetworkInjection) {
+    this.externalNetworkInjections.set(value.getUUID(), value);
+    this.addObject(value);
+  }
+
+  public addAnalyticScore(value: AnalyticScore) {
+    if (value instanceof HealthScore) {
+      this.healthScore.set(value.getUUID(), value);
+    } else if (value instanceof EVImportanceScore) {
+      this.importanceScore.set(value.getUUID(), value);
+    }
+    this.addObject(value);
+  }
+
+  public getAnalyticScore(uuid: string): AnalyticScore | undefined {
+    return this.objects.get(uuid) as AnalyticScore;
+  }
+
+  public addGeneratingUnit(value: GeneratingUnit) {
+    if (value instanceof ThermalGeneratingUnit) {
+      this.thermalGeneratingUnit.set(value.getUUID(), value);
+    } else if (value instanceof NuclearGeneratingUnit) {
+      this.nuclearGeneratingUnit.set(value.getUUID(), value);
+    } else if (value instanceof HydroGeneratingUnit) {
+      this.hydroGeneratingUnit.set(value.getUUID(), value);
+    } else if (value instanceof WindGeneratingUnit) {
+      this.windGeneratingUnit.set(value.getUUID(), value);
+    } else if (value instanceof SolarGeneratingUnit) {
+      this.solarGeneratingUnit.set(value.getUUID(), value);
+    } else {
+      this.generatingUnit.set(value.getUUID(), value);
+    }
+    this.addObject(value);
+  }
+
+  public getGeneratingUnit(uuid: string): GeneratingUnit | undefined {
+    return this.objects.get(uuid) as GeneratingUnit;
+  }
+
+  public getThermalGeneratingUnit(uuid: string): ThermalGeneratingUnit | undefined {
+    return this.thermalGeneratingUnit.get(uuid);
+  }
+
+  public getNuclearGeneratingUnit(uuid: string): NuclearGeneratingUnit | undefined {
+    return this.nuclearGeneratingUnit.get(uuid);
+  }
+
+  public getHydroGeneratingUnit(uuid: string): HydroGeneratingUnit | undefined {
+    return this.hydroGeneratingUnit.get(uuid);
+  }
+
+  public getWindGeneratingUnit(uuid: string): WindGeneratingUnit | undefined {
+    return this.windGeneratingUnit.get(uuid);
+  }
+
+  public getSolarGeneratingUnit(uuid: string): SolarGeneratingUnit | undefined {
+    return this.solarGeneratingUnit.get(uuid);
+  }
+
+  public getSynchronousMachine(uuid: string): SynchronousMachine | undefined {
+    return this.synchronousMachine.get(uuid);
+  }
+
+  public addSynchronousMachine(value: SynchronousMachine) {
+    this.synchronousMachine.set(value.getUUID(), value);
+    this.addObject(value);
+  }
+
+  public getAsynchronousMachine(uuid: string): AsynchronousMachine | undefined {
+    return this.asynchronousMachine.get(uuid);
+  }
+
+  public addAsynchronousMachine(value: AsynchronousMachine) {
+    this.asynchronousMachine.set(value.getUUID(), value);
+    this.addObject(value);
+  }
+
+  public addReactiveCapabilityCurve(value: ReactiveCapabilityCurve) {
+    this.reactiveCapabilityCurve.set(value.getUUID(), value);
+    this.addObject(value);
+  }
+
+  public getReactiveCapabilityCurve(uuid: string): ReactiveCapabilityCurve | undefined {
+    return this.reactiveCapabilityCurve.get(uuid);
+  }
+
+  public getEnergySource(uuid: string): EnergySource | undefined {
+    return this.energySources.get(uuid);
+  }
+
+  public addEnergySource(value: EnergySource) {
+    this.energySources.set(value.getUUID(), value);
+    this.addObject(value);
+  }
+
+  public addEnergyConsumer(value: IEnergyConsumer) {
+    this.energyConsumers.set(value.getUUID(), value);
+    this.addObject(value);
+  }
+
+  public getEnergyConsumer(uuid: string): IEnergyConsumer | undefined {
+    return this.energyConsumers.get(uuid);
+  }
+
+  public getEquipment(uuid: string): Equipment | undefined {
+    return this.objects.get(uuid) as Equipment;
+  }
+
+  public getConnectivityNodeContainer(uuid: string): ConnectivityNodeContainer | undefined {
+    return this.objects.get(uuid) as ConnectivityNodeContainer;
+  }
+
+  public getEquipmentContainer(uuid: string): EquipmentContainer {
+    return this.objects.get(uuid) as EquipmentContainer;
+  }
+
+  public getConductingEquipment(uuid: string): ConductingEquipment {
+    return this.objects.get(uuid) as ConductingEquipment;
+  }
+
+  public getDiagramObject(uuid: string): DiagramObject | undefined {
+    return this.diagramObjects.get(uuid);
+  }
+
+  public addDiagramObject(diagramobject: DiagramObject) {
+    this.diagramObjects.set(diagramobject.getUUID(), diagramobject);
+    this.addObject(diagramobject);
+  }
+
+  public addTopologicalIsland(value: TopologicalIsland) {
+    this.topologicalIslands.set(value.getUUID(), value);
+    this.addObject(value);
+  }
+
+  public getTopologicalNode(uuid: string): TopologicalNode | undefined {
+    return this.topologicalNodes.get(uuid);
+  }
+
+  public addTopologicalNode(value: TopologicalNode) {
+    this.topologicalNodes.set(value.getUUID(), value);
+    this.addObject(value);
+  }
+
+  public addPowerTransformer(value: PowerTransformer) {
+    this.powerTransformer.set(value.getUUID(), value);
+    this.addObject(value);
+  }
+
+  public getPowerTransformer(uuid: string): PowerTransformer | undefined {
+    return this.powerTransformer.get(uuid);
+  }
+
+  public addPetersenCoil(value: PetersenCoil) {
+    this.petersenCoils.set(value.getUUID(), value);
+    this.addObject(value);
+  }
+
+  public getPetersenCoil(uuid: string): PetersenCoil | undefined {
+    return this.petersenCoils.get(uuid);
+  }
+
+  public addPowerTransformerEnd(value: PowerTransformerEnd) {
+    this.powerTransformerEnds.set(value.getUUID(), value);
+    this.addObject(value);
+  }
+
+  public getPowerTransformerEnd(uuid: string): PowerTransformerEnd | undefined {
+    return this.powerTransformerEnds.get(uuid);
+  }
+
+  public addSvPowerFlow(value: SvPowerFlow) {
+    this.svPowerFlow.push(value);
+  }
+
+  public addSvVoltage(value: SvVoltage) {
+    this.svVoltage.push(value);
+  }
+
+  public addSvStatus(value: SvStatus) {
+    this.svStatus.push(value);
+  }
+
+  public addSvTapStep(value: SvTapStep) {
+    this.svTapSteps.push(value);
+  }
+
+
+  public getPsrType(uuid: string): PSRType | undefined {
+    return this.psrTypes.get(uuid);
+  }
+
+  public getPsrTypeAtName(name: string): PSRType | undefined {
+    for (const psrType of this.psrTypes.values()) {
+      if (psrType.name === name) return psrType;
+    }
+    return;
+  }
+
+  public addPsrType(psrType: PSRType) {
+    this.psrTypes.set(psrType.getUUID(), psrType);
+    this.addObject(psrType);
+  }
+
+
+  /* Assets */
+  public addFacility(value: IFacility) {
+    this.facilities.set(value.getUUID(), value);
+    this.addObject(value);
+  }
+
+  public getFacility(uuid: string): IFacility | undefined {
+    return this.facilities.get(uuid);
+  }
+
+  public addAssetDeployment(value: AssetDeployment) {
+    this.assetDeployments.set(value.getUUID(), value);
+    this.addObject(value);
+  }
+
+  /* Assets */
+  public addAssetHealthEvent(value: AssetHealthEvent) {
+    this.assetHealthEvents.set(value.getUUID(), value);
+    this.addObject(value);
+  }
+
+  public getAssetHealthEvent(uuid: string): AssetHealthEvent | undefined {
+    return this.assetHealthEvents.get(uuid);
+  }
+
+  /* AssetTypes */
+  public getCableInfo(uuid: string): CableInfo | undefined {
+    return this.cableInfos.get(uuid);
+  }
+
+  public addCableInfo(cableInfo: CableInfo) {
+    this.cableInfos.set(cableInfo.getUUID(), cableInfo);
+    this.addObject(cableInfo);
+  }
+
+  public getOverheadWireInfo(uuid: string): OverheadWireInfo | undefined {
+    return this.overheadWireInfos.get(uuid);
+  }
+
+  public addOverheadWireInfo(overheadWireInfo: OverheadWireInfo) {
+    this.overheadWireInfos.set(overheadWireInfo.getUUID(), overheadWireInfo);
+    this.addObject(overheadWireInfo);
+  }
+
+  /* AssetOwner.xml */
+  public addAssetOwner(value: AssetOwner) {
+    this.assetOwners.set(value.getUUID(), value);
+    this.addObject(value);
+  }
+
+  public getAssetOwner(uuid: string): AssetOwner | undefined {
+    return this.assetOwners.get(uuid);
+  }
+
+  public getWireInfoByName(name: string): WireInfo {
+    for (const value of this.overheadWireInfos.values()) {
+      if (value.name === name) {
+        return value;
+      }
+    }
+    for (const value of this.cableInfos.values()) {
+      if (value.name === name) {
+        return value;
+      }
+    }
+  }
+
+  public getPowerTransformer2WInfo(uuid: string): PowerTransformer2WInfo | undefined {
+    return this.powerTransformer2WInfo.get(uuid);
+  }
+
+  public addPowerTransformer2WInfo(powerTransformer2WInfo: PowerTransformer2WInfo) {
+    this.powerTransformer2WInfo.set(powerTransformer2WInfo.getUUID(), powerTransformer2WInfo);
+    this.addObject(powerTransformer2WInfo);
+  }
+
+  public getPowerTransformer3WInfo(uuid: string): PowerTransformer3WInfo | undefined {
+    return this.powerTransformer3WInfo.get(uuid);
+  }
+
+  public addPowerTransformer3WInfo(powerTransformer3WInfo: PowerTransformer3WInfo) {
+    this.powerTransformer3WInfo.set(powerTransformer3WInfo.getUUID(), powerTransformer3WInfo);
+    this.addObject(powerTransformer3WInfo);
+  }
+
+  public getPowerTransformer2WInfoByName(name: string): PowerTransformer2WInfo {
+    for (const value of this.powerTransformer2WInfo.values()) {
+      if (value.name === name) {
+        return value;
+      }
+    }
+  }
+
+  public getPowerTransformer3WInfoByName(name: string): PowerTransformer3WInfo {
+    for (const value of this.powerTransformer3WInfo.values()) {
+      if (value.name === name) {
+        return value;
+      }
+    }
+  }
+
+
+  public getGeographicalRegion(uuid: string): GeographicalRegion | undefined {
+    return this.geographicalRegions.get(uuid);
+  }
+
+  public addGeographicalRegion(value: GeographicalRegion) {
+    this.geographicalRegions.set(value.getUUID(), value);
+    this.addObject(value);
+  }
+
+  public getSubGeographicalRegion(uuid: string): SubGeographicalRegion | undefined {
+    return this.subgeographicalRegions.get(uuid);
+  }
+
+  public addSubGeographicalRegion(value: SubGeographicalRegion) {
+    this.subgeographicalRegions.set(value.getUUID(), value);
+    this.addObject(value);
+  }
+
+  public getObject(uuid: string): IdentifiedObject | undefined {
+    return this.objects.get(uuid) as IdentifiedObject;
+  }
+
+  private addObject(object: IIdentifiedObject) {
+    this.objects.set(object.getUUID(), object);
+  }
+
+  public toJSON(data: Map<string, IIdentifiedObject>): any[] {
+    const jsonData: any[] = [];
+    for (const value of data.values()) {
+      jsonData.push(value.toJSON());
+    }
+    return jsonData;
+  }
+
+  public sortData() {
+    for (const entry of this.powerTransformer.entries()) {
+      const value = entry[1];
+      if (value) {
+        value.sortTransformerEnds();
+      }
+    }
+
+    for (const entry of this.diagramObjects.entries()) {
+      const value = entry[1];
+      if (value) {
+        value.sortPoints();
+      }
+    }
+  }
+
+  public purgeData() {
+    this.voltages.clear();
+    this.baseVoltages.clear();
+
+    this.substations.clear();
+    this.voltageLevels.clear();
+    this.connectivityNodes.clear();
+    this.lines.clear();
+    this.bays.clear();
+    this.feeders.clear();
+
+    this.geographicalRegions.clear();
+    this.subgeographicalRegions.clear();
+
+    this.connectivityNodes.clear();
+
+    this.busbarSections.clear();
+    this.acLineSegments.clear();
+    this.equivalentBranches.clear();
+    this.junctions.clear();
+
+    this.cuts.clear();
+    this.jumpers.clear();
+
+    this.powerTransformer.clear();
+    this.powerTransformerEnds.clear();
+
+    this.tapChangerControls.clear();
+    this.ratioTapChangers.clear();
+    this.ratioTapChangerTables.clear();
+
+    this.petersenCoils.clear();
+
+    this.switches.clear();
+    this.breakers.clear();
+    this.disconnectors.clear();
+    this.loadBreakSwitches.clear();
+
+    this.energySources.clear();
+    this.energyConsumers.clear();
+    this.externalNetworkInjections.clear();
+
+    this.synchronousMachine.clear();
+    this.asynchronousMachine.clear();
+
+    this.generatingUnit.clear();
+    this.thermalGeneratingUnit.clear();
+    this.nuclearGeneratingUnit.clear();
+    this.hydroGeneratingUnit.clear();
+    this.windGeneratingUnit.clear();
+    this.solarGeneratingUnit.clear();
+    this.fossilFuel = [];
+
+    this.reactiveCapabilityCurve.clear();
+    this.curveData = []
+    this.regulatingControl.clear();
+
+    this.terminals.clear();
+
+    this.topologicalIslands.clear();
+    this.topologicalNodes.clear();
+
+    this.operationalLimitSets.clear();
+    this.operationalLimitTypes.clear();
+    this.currentLimits.clear();
+
+    this.regulatingControl.clear();
+
+    /** Outages */
+    this.outages.clear();
+    this.switchingPlans.clear();
+    this.switchingActions.clear();
+    this.customFaults.clear();
+
+    this.svPowerFlow = [];
+    this.svVoltage = [];
+
+    this.psrTypes.clear();
+
+    /** Assets */
+    this.assetDeployments.clear();
+    this.assetOwners.clear();
+    this.facilities.clear();
+    this.assetHealthEvents.clear();
+
+    /** AssetTypes */
+    this.overheadWireInfos.clear();
+    this.cableInfos.clear();
+    this.powerTransformer2WInfo.clear();
+    this.powerTransformer3WInfo.clear();
+
+    /** Grafik */
+    this.diagrams.clear();
+    this.diagramObjects.clear();
+    this.diagramsArray = [];
+    this.diagramObjectPonts = [];
+
+    /** Geo */
+    this.locations.clear();
+    this.coordinateSystems.clear();
+    this.positionPoints = [];
+
+    this.objects.clear();
+  }
+
+  /*    /!* parst und instanziiert das Modell *!/
+      resolveClassFusekiJSON(className: string, data: any){
+          this.cimClassName2Class.get(className.toLowerCase()).resolveClassFusekiJSON(data, this);
+      }*/
+
+  public serializeRDFXML(): Map<string, string> {
+    const rdfXmlSerializer = new RdfXmlSerializer(this);
+    return rdfXmlSerializer.exportCGMES();
+  }
+
+  public toCIMXML(xmlWriter: XMLWriter, modelEQUUID: string, profiles: string[], dependentModelUUIDs: string[], mas: string) {
+    // Millisekunden abschneiden
+    const dateTime = new Date().toJSON().slice(0, 19);
+    xmlWriter.startElementNS(RDF_XML.MD_NS_PREFIX, 'FullModel', RDF_XML.MD_NS);
+
+    writeElementAttribute(xmlWriter, RDF_XML.RDF_ABOUT, 'urn:uuid:' + modelEQUUID);
+    writeElement(xmlWriter, `${RDF_XML.MD_NS_PREFIX}:Model.created`, dateTime);
+    writeElement(xmlWriter, `${RDF_XML.MD_NS_PREFIX}:Model.description`, dateTime);
+    writeElement(xmlWriter, `${RDF_XML.MD_NS_PREFIX}:Model.version`, '1');
+    writeElement(xmlWriter, `${RDF_XML.MD_NS_PREFIX}:Model.modelingAuthoritySet`, mas);
+    if (dependentModelUUIDs && dependentModelUUIDs.length > 0) {
+      // <md:Model.DependentOn rdf:resource="urn:uuid:8d73742f-52b1-4f30-8a3b-2ee8efe66e07"/>
+      for (const dependentModelUUID of dependentModelUUIDs) {
+        xmlWriter.startElementNS(RDF_XML.MD_NS_PREFIX, 'Model.DependentOn', RDF_XML.MD_NS);
+        writeElementAttribute(xmlWriter, RDF_XML.RDF_RESRC, `urn:uuid:${dependentModelUUID}`);
+        xmlWriter.endElement();
+      }
+    }
+    for (const profileName of profiles) {
+      writeElement(xmlWriter, `${RDF_XML.MD_NS_PREFIX}:Model.profile`, profileName);
+    }
+    xmlWriter.endElement();
+  }
+
+
+  public getTapChangerControl(uuid: string): TapChangerControl | undefined {
+    return this.tapChangerControls.get(uuid);
+  }
+
+  public addTapChangerControl(tapChangerControl: TapChangerControl) {
+    this.tapChangerControls.set(tapChangerControl.getUUID(), tapChangerControl);
+    this.addObject(tapChangerControl);
+  }
+
+  public getRatioTapChanger(uuid: string): RatioTapChanger | undefined {
+    return this.ratioTapChangers.get(uuid);
+  }
+
+  public addRatioTapChanger(ratioTapChanger: RatioTapChanger) {
+    this.ratioTapChangers.set(ratioTapChanger.getUUID(), ratioTapChanger);
+    this.addObject(ratioTapChanger);
+  }
+
+  public getRatioTapChangerTable(uuid: string): RatioTapChangerTable | undefined {
+    return this.ratioTapChangerTables.get(uuid);
+  }
+
+  public addRatioTapChangerTable(ratioTapChangerTable: RatioTapChangerTable) {
+    this.ratioTapChangerTables.set(ratioTapChangerTable.getUUID(), ratioTapChangerTable);
+    this.addObject(ratioTapChangerTable);
+  }
+
+  resolveParsedAssociations() {
+    this.objects.forEach((cimInstance: IdentifiedObject) => {
+      cimInstance.resolveParsedAssociations(this);
+    });
+    this.positionPoints.forEach((cimInstance: IdentifiedObject) => {
+      cimInstance.resolveParsedAssociations(this);
+    });
+
+    this.customFaults.forEach((cimInstance: IFault) => {
+      cimInstance.resolveParsedAssociations(this);
+    });
+    this.outages.forEach((cimInstance: IOutage) => {
+      cimInstance.resolveParsedAssociations(this);
+    });
+    this.switchingPlans.forEach((cimInstance: SwitchingPlan) => {
+      cimInstance.resolveParsedAssociations(this);
+    });
+    this.switchingActions.forEach((cimInstance: ISwitchingAction) => {
+      cimInstance.resolveParsedAssociations(this);
+    });
+  }
+
+  public getCoordinateSystemByName(name: string): CoordinateSystem | undefined {
+    for (const value of this.coordinateSystems.values()) {
+      if (value.name === name) {
+        return value;
+      }
+    }
+    return;
+  }
+
+  /** N-1 Daten */
+  public addOutage(outage: IOutage) {
+    this.outages.set(outage.getUUID(), outage);
+  }
+
+  public getOutage(uuid: string): IOutage | undefined {
+    return this.outages.get(uuid);
+  }
+
+  public addCustomFault(fault: IFault) {
+    this.customFaults.set(fault.getUUID(), fault);
+  }
+
+  public getCustomFault(uuid: string): IFault | undefined {
+    return this.customFaults.get(uuid);
+  }
+
+  public addSwitchingAction(fault: ISwitchingAction) {
+    this.switchingActions.set(fault.getUUID(), fault);
+  }
+
+  public getSwitchingAction(uuid: string): ISwitchingAction | undefined {
+    return this.switchingActions.get(uuid);
+  }
+
+  public addSwitchingPlan(fault: ISwitchingPlan) {
+    this.switchingPlans.set(fault.getUUID(), fault);
+  }
+
+  public getSwitchingPlan(uuid: string): ISwitchingPlan | undefined {
+    return this.switchingPlans.get(uuid);
+  }
+
+}