@enervance/insight-cim-model 1.0.0-dev2 → 1.0.0-dev4

package/dist/util/util-create.js

@@ -1,72 +1,51 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createGeoregion = createGeoregion;
-exports.createSubgeoregion = createSubgeoregion;
-exports.getGeoregionByName = getGeoregionByName;
-exports.getSubgeoregionByName = getSubgeoregionByName;
-exports.createSvStatus = createSvStatus;
-exports.createSvPowerFlow = createSvPowerFlow;
-exports.createBaseVoltageIfNotExists = createBaseVoltageIfNotExists;
-exports.createBaseVoltage = createBaseVoltage;
-exports.createNotation = createNotation;
-exports.createCurrentLimit = createCurrentLimit;
-exports.createOperationalLimitTypeIfNotExists = createOperationalLimitTypeIfNotExists;
-exports.createConnection = createConnection;
-exports.getConnectedTerminal = getConnectedTerminal;
-exports.createRatioTapChangerTablePoint = createRatioTapChangerTablePoint;
-exports.createPhaseTapChangerTablePoint = createPhaseTapChangerTablePoint;
-exports.createNewFacilityStatement = createNewFacilityStatement;
-exports.createACDCConverterNeg = createACDCConverterNeg;
-exports.createBay = createBay;
-exports.createFacility = createFacility;
-const PhaseTapChangerTablePoint_1 = require("../model/wires/PhaseTapChangerTablePoint");
-const GeographicalRegion_1 = require("../model/core/GeographicalRegion");
-const SubGeographicalRegion_1 = require("../model/core/SubGeographicalRegion");
-const common_utils_1 = require("../utils2/common.utils");
-const SvPowerFlow_1 = require("../model/statevariables/SvPowerFlow");
-const UnitMultiplier_1 = require("../model/domain/UnitMultiplier");
-const SvStatus_1 = require("../model/statevariables/SvStatus");
-const BaseVoltage_1 = require("../model/core/BaseVoltage");
-const UnitSymbol_1 = require("../model/domain/UnitSymbol");
-const Terminal_1 = require("../model/core/Terminal");
-const OperationalLimitSet_1 = require("../model/operationallimits/OperationalLimitSet");
-const CurrentLimit_1 = require("../model/operationallimits/CurrentLimit");
-const OperationalLimitDirectionKind_1 = require("../model/operationallimits/OperationalLimitDirectionKind");
-const OperationalLimitType_1 = require("../model/operationallimits/OperationalLimitType");
-const LimitTypeKind_1 = require("../model/operationallimits/LimitTypeKind");
-const PhaseCode_1 = require("../model/core/PhaseCode");
-const ConnectivityNode_1 = require("../model/core/ConnectivityNode");
-const RatioTapChangerTablePoint_1 = require("../model/wires/RatioTapChangerTablePoint");
-const CurrentFlow_1 = require("../model/domain/CurrentFlow");
-const sparql_building_block_1 = require("./sparql/sparql-building-block");
-const CsConverter_1 = require("../model/dc/CsConverter");
-const VsConverter_1 = require("../model/dc/VsConverter");
-const DCNode_1 = require("../model/dc/DCNode");
-const ACDCConverterDCTerminal_1 = require("../model/dc/ACDCConverterDCTerminal");
-const DCPolarityKind_1 = require("../model/dc/DCPolarityKind");
-const parser_utils_1 = require("../utils2/parser.utils");
-const utils_1 = require("../converter/integral7/utils");
-const cim_class_names_1 = require("../constants/cim-class-names");
-const util_graph2tree_1 = require("./collection/util-graph2tree");
-const Bay_1 = require("../model/core/Bay");
-const Disconnector_1 = require("../model/wires/Disconnector");
-const Breaker_1 = require("../model/wires/Breaker");
-const Switch_1 = require("../model/wires/Switch");
-const Facility_1 = require("../model/assets/Facility");
-function createGeoregion(uuid, name, shortName, description, cimModel) {
-    const region = new GeographicalRegion_1.GeographicalRegion((0, parser_utils_1.getUUID)(uuid), name, shortName, description);
+import { PhaseTapChangerTablePoint } from '../model/wires/PhaseTapChangerTablePoint';
+import { GeographicalRegion } from '../model/core/GeographicalRegion';
+import { SubGeographicalRegion } from '../model/core/SubGeographicalRegion';
+import { CommonUtils } from '../utils2/common.utils';
+import { SvPowerFlow } from '../model/statevariables/SvPowerFlow';
+import { UnitMultiplier } from '../model/domain/UnitMultiplier';
+import { SvStatus } from '../model/statevariables/SvStatus';
+import { BaseVoltage } from '../model/core/BaseVoltage';
+import { UnitSymbol } from '../model/domain/UnitSymbol';
+import { Terminal } from '../model/core/Terminal';
+import { OperationalLimitSet } from '../model/operationallimits/OperationalLimitSet';
+import { CurrentLimit } from '../model/operationallimits/CurrentLimit';
+import { OperationalLimitDirectionKind } from '../model/operationallimits/OperationalLimitDirectionKind';
+import { OperationalLimitType } from '../model/operationallimits/OperationalLimitType';
+import { LimitTypeKind } from '../model/operationallimits/LimitTypeKind';
+import { PhaseCode } from '../model/core/PhaseCode';
+import { ConnectivityNode } from '../model/core/ConnectivityNode';
+import { RatioTapChangerTablePoint } from '../model/wires/RatioTapChangerTablePoint';
+import { CurrentFlow } from '../model/domain/CurrentFlow';
+import { NS_PREFIX_CIM, NS_PREFIX_RDF } from './sparql/sparql-building-block';
+import { CsConverter } from '../model/dc/CsConverter';
+import { VsConverter } from '../model/dc/VsConverter';
+import { DCNode } from '../model/dc/DCNode';
+import { ACDCConverterDCTerminal } from '../model/dc/ACDCConverterDCTerminal';
+import { DCPolarityKind } from '../model/dc/DCPolarityKind';
+import { getUUID, isNumericI7 } from '../utils2/parser.utils';
+import { getName } from '../converter/integral7/utils';
+import { ClassNames } from '../constants/cim-class-names';
+import { getAnyBayObject } from './collection/util-graph2tree';
+import { Bay } from '../model/core/Bay';
+import { Disconnector } from '../model/wires/Disconnector';
+import { Breaker } from '../model/wires/Breaker';
+import { Switch } from '../model/wires/Switch';
+import { Facility } from '../model/assets/Facility';
+export function createGeoregion(uuid, name, shortName, description, cimModel) {
+    const region = new GeographicalRegion(getUUID(uuid), name, shortName, description);
     if (cimModel)
         cimModel.addGeographicalRegion(region);
     return region;
 }
-function createSubgeoregion(uuid, name, shortName, description, region, cimModel) {
-    const subregion = new SubGeographicalRegion_1.SubGeographicalRegion((0, parser_utils_1.getUUID)(uuid), name, shortName, description);
+export function createSubgeoregion(uuid, name, shortName, description, region, cimModel) {
+    const subregion = new SubGeographicalRegion(getUUID(uuid), name, shortName, description);
     subregion.region = region;
     region.addSubGeographicalRegion(subregion);
     cimModel.addSubGeographicalRegion(subregion);
     return subregion;
 }
-function getGeoregionByName(cimModel, name) {
+export function getGeoregionByName(cimModel, name) {
     for (const region of cimModel.geographicalRegions.values()) {
         if (region.name === name) {
             return region;
@@ -74,7 +53,7 @@ function getGeoregionByName(cimModel, name) {
     }
     return;
 }
-function getSubgeoregionByName(cimModel, name) {
+export function getSubgeoregionByName(cimModel, name) {
     for (const region of cimModel.subgeographicalRegions.values()) {
         if (region.name === name) {
             return region;
@@ -82,23 +61,23 @@ function getSubgeoregionByName(cimModel, name) {
     }
     return;
 }
-function createSvStatus(cimModel, inBetrieb, conductingEquipment) {
-    const svStatus = new SvStatus_1.SvStatus(common_utils_1.CommonUtils.generateUUID());
+export function createSvStatus(cimModel, inBetrieb, conductingEquipment) {
+    const svStatus = new SvStatus(CommonUtils.generateUUID());
     svStatus.inService = inBetrieb;
     svStatus.conductingEquipmentUUID = conductingEquipment.mrid;
     // conductingEquipment.svStatus = svStatus;
     cimModel.addSvStatus(svStatus);
     return svStatus;
 }
-function createSvPowerFlow(cimModel, p, q, terminalUUID) {
-    const svPowerFlow = new SvPowerFlow_1.SvPowerFlow(common_utils_1.CommonUtils.generateUUID());
+export function createSvPowerFlow(cimModel, p, q, terminalUUID) {
+    const svPowerFlow = new SvPowerFlow(CommonUtils.generateUUID());
     svPowerFlow.p = p ? p : 0;
     svPowerFlow.q = q ? q : 0;
     svPowerFlow.terminalUUID = terminalUUID;
     cimModel.addSvPowerFlow(svPowerFlow);
     return svPowerFlow;
 }
-function createBaseVoltageIfNotExists(cimModel, nominalVoltage, configUuid, exportFramesBoundary) {
+export function createBaseVoltageIfNotExists(cimModel, nominalVoltage, configUuid, exportFramesBoundary) {
     let baseVoltage = undefined;
     if (nominalVoltage) {
         if (exportFramesBoundary) {
@@ -118,15 +97,15 @@ function createBaseVoltageIfNotExists(cimModel, nominalVoltage, configUuid, expo
     }
     return baseVoltage;
 }
-function createBaseVoltage(cimModel, nominalVoltage, configUuid) {
-    const name = `${nominalVoltage} ${UnitMultiplier_1.UnitMultiplier.k}${UnitSymbol_1.UnitSymbol.V}`;
+export function createBaseVoltage(cimModel, nominalVoltage, configUuid) {
+    const name = `${nominalVoltage} ${UnitMultiplier.k}${UnitSymbol.V}`;
     const shortName = name;
-    const baseVoltage = new BaseVoltage_1.BaseVoltage(common_utils_1.CommonUtils.generateUUIDv5(cim_class_names_1.ClassNames.BaseVoltage, configUuid, String(nominalVoltage)), name, shortName, `Base voltage defined by I7 ${name}`);
+    const baseVoltage = new BaseVoltage(CommonUtils.generateUUIDv5(ClassNames.BaseVoltage, configUuid, String(nominalVoltage)), name, shortName, `Base voltage defined by I7 ${name}`);
     baseVoltage.nominalVoltage = cimModel.getVoltage(nominalVoltage);
     cimModel.addBaseVoltage(baseVoltage);
     return baseVoltage;
 }
-function createNotation(arg0, length, shorten_start) {
+export function createNotation(arg0, length, shorten_start) {
     let str_length;
     if (length !== undefined && length >= 0) {
         str_length = length;
@@ -155,10 +134,10 @@ function createNotation(arg0, length, shorten_start) {
     }
     return full_str;
 }
-function createCurrentLimit(cimModel, ir, terminal, name) {
-    const currentLimit = new CurrentLimit_1.CurrentLimit(common_utils_1.CommonUtils.generateUUID(), `CR ${name}`);
-    currentLimit.value = new CurrentFlow_1.CurrentFlow(ir, UnitMultiplier_1.UnitMultiplier.none, UnitSymbol_1.UnitSymbol.A);
-    const operationalLimitSet = new OperationalLimitSet_1.OperationalLimitSet(common_utils_1.CommonUtils.generateUUID(), `OLS ${name}`);
+export function createCurrentLimit(cimModel, ir, terminal, name) {
+    const currentLimit = new CurrentLimit(CommonUtils.generateUUID(), `CR ${name}`);
+    currentLimit.value = new CurrentFlow(ir, UnitMultiplier.none, UnitSymbol.A);
+    const operationalLimitSet = new OperationalLimitSet(CommonUtils.generateUUID(), `OLS ${name}`);
     currentLimit.operationalLimitSet = operationalLimitSet;
     currentLimit.operationalLimitSet.addOperationalLimit(currentLimit);
     operationalLimitSet.terminal = terminal;
@@ -168,27 +147,27 @@ function createCurrentLimit(cimModel, ir, terminal, name) {
     cimModel.addCurrentLimit(currentLimit);
     cimModel.addOperationalLimitSet(operationalLimitSet);
 }
-function createOperationalLimitTypeIfNotExists(cimModel, name) {
+export function createOperationalLimitTypeIfNotExists(cimModel, name) {
     let operationalLimitType = cimModel.getOperationalLimitTypeByName(name);
     if (!operationalLimitType) {
-        operationalLimitType = new OperationalLimitType_1.OperationalLimitType(common_utils_1.CommonUtils.generateUUID(), name);
-        operationalLimitType.direction = OperationalLimitDirectionKind_1.OperationalLimitDirectionKind.absoluteValue;
-        operationalLimitType.limitType = LimitTypeKind_1.LimitTypeKind.patl;
+        operationalLimitType = new OperationalLimitType(CommonUtils.generateUUID(), name);
+        operationalLimitType.direction = OperationalLimitDirectionKind.absoluteValue;
+        operationalLimitType.limitType = LimitTypeKind.patl;
         cimModel.addOperationalLimitType(operationalLimitType);
     }
     return operationalLimitType;
 }
-function createConnection(cimModel, conductingEquipment, object, phase, sequenceNumber) {
+export function createConnection(cimModel, conductingEquipment, object, phase, sequenceNumber) {
     // console.log(`${conductingEquipment.description} start ${object.constructor.name} ${object instanceof ConnectivityNode} / ${object instanceof Terminal}`);
     let terminal;
-    if (object instanceof ConnectivityNode_1.ConnectivityNode) {
+    if (object instanceof ConnectivityNode) {
         const cn = object;
-        terminal = new Terminal_1.Terminal(common_utils_1.CommonUtils.generateUUID(), 'T');
+        terminal = new Terminal(CommonUtils.generateUUID(), 'T');
         terminal.connectivityNodeUUID = cn.mrid;
         cn.addTerminalUUID(terminal.mrid);
         cimModel.addTerminal(terminal);
     }
-    else if (object instanceof Terminal_1.Terminal) {
+    else if (object instanceof Terminal) {
         terminal = object;
     }
     if (terminal) {
@@ -206,15 +185,15 @@ function createConnection(cimModel, conductingEquipment, object, phase, sequence
  * @param phase
  * @param sequenceNumber
  * */
-function getConnectedTerminal(cimModel, connectionObject, connectedObject, phase, sequenceNumber) {
+export function getConnectedTerminal(cimModel, connectionObject, connectedObject, phase, sequenceNumber) {
     if (connectedObject) {
         return createConnection(cimModel, connectionObject, connectedObject, phase, sequenceNumber);
     }
 }
-function createRatioTapChangerTablePoint(ratioTapChangerTable, step, ratio, configUuid) {
-    const key = ratioTapChangerTable?.getUUID() + step;
-    const uuid = common_utils_1.CommonUtils.generateUUIDv5(cim_class_names_1.ClassNames.RatioTapChangerTablePoint, configUuid, key);
-    const ratioTapChangerTablePoint = new RatioTapChangerTablePoint_1.RatioTapChangerTablePoint(uuid);
+export function createRatioTapChangerTablePoint(ratioTapChangerTable, step, ratio, configUuid) {
+    const key = (ratioTapChangerTable === null || ratioTapChangerTable === void 0 ? void 0 : ratioTapChangerTable.getUUID()) + step;
+    const uuid = CommonUtils.generateUUIDv5(ClassNames.RatioTapChangerTablePoint, configUuid, key);
+    const ratioTapChangerTablePoint = new RatioTapChangerTablePoint(uuid);
     ratioTapChangerTablePoint.step = step;
     ratioTapChangerTablePoint.ratio = ratio;
     ratioTapChangerTablePoint.ratioTapChangerTableUUID = ratioTapChangerTable.mrid;
@@ -223,10 +202,10 @@ function createRatioTapChangerTablePoint(ratioTapChangerTable, step, ratio, conf
     return ratioTapChangerTablePoint;
 }
 /** TODO impedanzen */
-function createPhaseTapChangerTablePoint(phaseTapChanger, phaseTapChangerTable, step, ratio, angle, ratioTapChanger) {
+export function createPhaseTapChangerTablePoint(phaseTapChanger, phaseTapChangerTable, step, ratio, angle, ratioTapChanger) {
     let typePhaseTapChanger = undefined;
     typePhaseTapChanger = phaseTapChanger ? phaseTapChanger.constructor.name : undefined;
-    const phaseTapChangerTablePoint = new PhaseTapChangerTablePoint_1.PhaseTapChangerTablePoint(common_utils_1.CommonUtils.generateUUID());
+    const phaseTapChangerTablePoint = new PhaseTapChangerTablePoint(CommonUtils.generateUUID());
     phaseTapChangerTablePoint.step = step; //DONE
     phaseTapChangerTablePoint.ratio = ratio / 100; //DONE
     phaseTapChangerTablePoint.angle = angle; //DONE
@@ -239,10 +218,10 @@ function createPhaseTapChangerTablePoint(phaseTapChanger, phaseTapChangerTable,
     phaseTapChangerTable.addPhaseTapChangerTablePoint(phaseTapChangerTablePoint);
     return phaseTapChangerTablePoint;
 }
-function createNewFacilityStatement(baseIRI, graphURI) {
+export function createNewFacilityStatement(baseIRI, graphURI) {
     const insertStatement = `
-            ${sparql_building_block_1.NS_PREFIX_RDF}
-            ${sparql_building_block_1.NS_PREFIX_CIM}
+            ${NS_PREFIX_RDF}
+            ${NS_PREFIX_CIM}
              INSERT DATA
              {
                 GRAPH <${graphURI}>
@@ -261,19 +240,20 @@ function createNewFacilityStatement(baseIRI, graphURI) {
         `;
     return insertStatement;
 }
-function createACDCConverterNeg(cimModel, int7hguekopf, type, acdcConverter, dcConverterUnit, configUuid) {
+export function createACDCConverterNeg(cimModel, int7hguekopf, type, acdcConverter, dcConverterUnit, configUuid) {
+    var _a;
     let converter = undefined;
     if (type === 'CsConverter') {
-        converter = new CsConverter_1.CsConverter();
-        converter.name = createNotation([(0, utils_1.getName)(int7hguekopf), '_neg', '_CSC'], 32, true);
+        converter = new CsConverter();
+        converter.name = createNotation([getName(int7hguekopf), '_neg', '_CSC'], 32, true);
         converter.ratedUdc = acdcConverter.ratedUdc;
         converter.ratedIdc = acdcConverter.ratedIdc;
         converter.maxUdc = acdcConverter.maxUdc;
         converter.minUdc = acdcConverter.minUdc;
     }
     else if (type === 'VsConverter') {
-        converter = new VsConverter_1.VsConverter();
-        converter.name = createNotation([(0, utils_1.getName)(int7hguekopf), '_neg', '_VSC'], 32, true);
+        converter = new VsConverter();
+        converter.name = createNotation([getName(int7hguekopf), '_neg', '_VSC'], 32, true);
         converter.ratedUdc = acdcConverter.ratedUdc;
         converter.maxUdc = acdcConverter.maxUdc;
         converter.minUdc = acdcConverter.minUdc;
@@ -281,7 +261,7 @@ function createACDCConverterNeg(cimModel, int7hguekopf, type, acdcConverter, dcC
     /** EQ */
     converter.shortName = createNotation([acdcConverter.shortName, '_neg'], 12, true);
     converter.description = acdcConverter.description;
-    converter.mrid = (0, parser_utils_1.getUUID)(int7hguekopf.guid_dcconvertern);
+    converter.mrid = getUUID(int7hguekopf.guid_dcconvertern);
     converter.equipmentContainer = dcConverterUnit;
     /** Create Bay and connect negative hvdc converter connection*/
     const pcc = cimModel.getConnectivityNode(acdcConverter.pccTerminal.getConnectivityNodeUUID());
@@ -292,21 +272,21 @@ function createACDCConverterNeg(cimModel, int7hguekopf, type, acdcConverter, dcC
     }*/
     if (bay !== undefined) {
         let bayKey = bay.getUUID();
-        let bayNegUUID = common_utils_1.CommonUtils.generateUUIDv5(cim_class_names_1.ClassNames.Terminal, configUuid, bayKey);
-        let bayNeg = new Bay_1.Bay(bayNegUUID, bay.getName() + '_neg', '2nd DCCU', 'bay 2nd DCCU');
+        let bayNegUUID = CommonUtils.generateUUIDv5(ClassNames.Terminal, configUuid, bayKey);
+        let bayNeg = new Bay(bayNegUUID, bay.getName() + '_neg', '2nd DCCU', 'bay 2nd DCCU');
         bayNeg.voltageLevel = bay.voltageLevel;
         bay.voltageLevel.addBay(bayNeg);
         cimModel.addBay(bayNeg);
-        const bayObjects = (0, util_graph2tree_1.getAnyBayObject)(pcc, bay);
+        const bayObjects = getAnyBayObject(pcc, bay);
         const bayObjectsNeg = [];
         for (const obj of bayObjects) {
-            if (obj instanceof Terminal_1.Terminal) {
+            if (obj instanceof Terminal) {
                 //create Terminal
                 let key = obj.getUUID();
-                let uUid = common_utils_1.CommonUtils.generateUUIDv5(cim_class_names_1.ClassNames.Terminal, configUuid, key);
+                let uUid = CommonUtils.generateUUIDv5(ClassNames.Terminal, configUuid, key);
                 let terminalNeg = undefined;
                 if (bayObjectsNeg.find(elem => elem.mrid == uUid) === undefined) {
-                    terminalNeg = new Terminal_1.Terminal(uUid, obj.getName());
+                    terminalNeg = new Terminal(uUid, obj.getName());
                     if (acdcConverter.pccTerminal.getUUID() === obj.getUUID()) {
                         converter.pccTerminal = terminalNeg;
                         terminalNeg.conductingEquipment = converter;
@@ -321,10 +301,10 @@ function createACDCConverterNeg(cimModel, int7hguekopf, type, acdcConverter, dcC
                 }
                 //create connectivityNode
                 key = obj.getConnectivityNode().getUUID();
-                uUid = common_utils_1.CommonUtils.generateUUIDv5(cim_class_names_1.ClassNames.ConnectivityNode, configUuid, key);
+                uUid = CommonUtils.generateUUIDv5(ClassNames.ConnectivityNode, configUuid, key);
                 let cN = undefined;
                 if (bayObjectsNeg.find(elem => elem.mrid == uUid) === undefined) {
-                    cN = new ConnectivityNode_1.ConnectivityNode(uUid, obj.getConnectivityNode().getName());
+                    cN = new ConnectivityNode(uUid, obj.getConnectivityNode().getName());
                     terminalNeg.connectivityNode = cN;
                     cN.addTerminal(terminalNeg);
                     cN.connectivityNodeContainer = bayNeg;
@@ -341,22 +321,22 @@ function createACDCConverterNeg(cimModel, int7hguekopf, type, acdcConverter, dcC
                 key = obj.getConductingEquipment().getUUID();
                 let sW = undefined;
                 uUid = undefined;
-                if (obj.getConductingEquipment() instanceof Breaker_1.Breaker) {
-                    uUid = common_utils_1.CommonUtils.generateUUIDv5(cim_class_names_1.ClassNames.Breaker, configUuid, key);
+                if (obj.getConductingEquipment() instanceof Breaker) {
+                    uUid = CommonUtils.generateUUIDv5(ClassNames.Breaker, configUuid, key);
                 }
-                else if (obj.getConductingEquipment() instanceof Disconnector_1.Disconnector) {
-                    uUid = common_utils_1.CommonUtils.generateUUIDv5(cim_class_names_1.ClassNames.Disconnector, configUuid, key);
+                else if (obj.getConductingEquipment() instanceof Disconnector) {
+                    uUid = CommonUtils.generateUUIDv5(ClassNames.Disconnector, configUuid, key);
                 }
                 if (bayObjectsNeg.find(elem => elem.mrid == uUid) === undefined) {
-                    if (obj.getConductingEquipment() instanceof Breaker_1.Breaker) {
-                        uUid = common_utils_1.CommonUtils.generateUUIDv5(cim_class_names_1.ClassNames.Breaker, configUuid, key);
-                        sW = new Breaker_1.Breaker(uUid, obj.getConductingEquipment().getName());
+                    if (obj.getConductingEquipment() instanceof Breaker) {
+                        uUid = CommonUtils.generateUUIDv5(ClassNames.Breaker, configUuid, key);
+                        sW = new Breaker(uUid, obj.getConductingEquipment().getName());
                         sW.open = obj.getConductingEquipment().open;
                         cimModel.addBreaker(sW);
                     }
-                    else if (obj.getConductingEquipment() instanceof Disconnector_1.Disconnector) {
-                        uUid = common_utils_1.CommonUtils.generateUUIDv5(cim_class_names_1.ClassNames.Disconnector, configUuid, key);
-                        sW = new Disconnector_1.Disconnector(uUid, obj.getConductingEquipment().getName());
+                    else if (obj.getConductingEquipment() instanceof Disconnector) {
+                        uUid = CommonUtils.generateUUIDv5(ClassNames.Disconnector, configUuid, key);
+                        sW = new Disconnector(uUid, obj.getConductingEquipment().getName());
                         sW.open = obj.getConductingEquipment().open;
                         cimModel.addDisconnector(sW);
                     }
@@ -381,7 +361,7 @@ function createACDCConverterNeg(cimModel, int7hguekopf, type, acdcConverter, dcC
         let term1 = undefined; //terminal with connection to connectivity node that is a busbar section
         let cN1 = undefined; //connectivity node that is a busbar section
         for (const obj of bayObjects) {
-            if (obj instanceof Switch_1.Switch) {
+            if (obj instanceof Switch) {
                 for (const term of obj.getTerminals().values()) {
                     if (bayObjects.indexOf(term) < 0) { //TODO: define condition for terms belonging to boundary set i.e. proof that cN1 has a busbar section connected
                         cN1 = cimModel.getConnectivityNode(term.getConnectivityNodeUUID());
@@ -392,15 +372,15 @@ function createACDCConverterNeg(cimModel, int7hguekopf, type, acdcConverter, dcC
         }
         let sWNeg = undefined; //terminal with connection to connectivity node that is a busbar section
         for (const obj of bayObjectsNeg) {
-            if (obj instanceof Switch_1.Switch) {
+            if (obj instanceof Switch) {
                 if (obj.getTerminals().size < 2) {
                     sWNeg = obj; //the switch with less than two terminals needs a connection to connectivity node that is a busbar section two connect newly created bay for negative converter
                 }
             }
         }
         let key = term1.getUUID();
-        let uUid = common_utils_1.CommonUtils.generateUUIDv5(cim_class_names_1.ClassNames.Terminal, configUuid, key);
-        let termNeg = new Terminal_1.Terminal(uUid, term1.getName());
+        let uUid = CommonUtils.generateUUIDv5(ClassNames.Terminal, configUuid, key);
+        let termNeg = new Terminal(uUid, term1.getName());
         termNeg.connectivityNode = cN1;
         termNeg.conductingEquipment = sWNeg;
         termNeg.phases = term1.phases;
@@ -410,36 +390,36 @@ function createACDCConverterNeg(cimModel, int7hguekopf, type, acdcConverter, dcC
         cimModel.addTerminal(termNeg);
     }
     else {
-        converter.pccTerminal = createConnection(cimModel, converter, cimModel.getConnectivityNode(acdcConverter.pccTerminal.getConnectivityNodeUUID()), PhaseCode_1.PhaseCode.ABC, 1);
+        converter.pccTerminal = createConnection(cimModel, converter, cimModel.getConnectivityNode(acdcConverter.pccTerminal.getConnectivityNodeUUID()), PhaseCode.ABC, 1);
     }
     /** Bemessungsleistung (Gleichstromseite) in MW
      * im CS-Fall S = P?
      * Abhängig vom  */
-    converter.baseS = (0, parser_utils_1.isNumericI7)(acdcConverter.baseS) ? acdcConverter.baseS / 2 : acdcConverter.baseS;
-    acdcConverter.baseS = (0, parser_utils_1.isNumericI7)(acdcConverter.baseS) ? acdcConverter.baseS / 2 : acdcConverter.baseS;
+    converter.baseS = isNumericI7(acdcConverter.baseS) ? acdcConverter.baseS / 2 : acdcConverter.baseS;
+    acdcConverter.baseS = isNumericI7(acdcConverter.baseS) ? acdcConverter.baseS / 2 : acdcConverter.baseS;
     /** Bemessungsspannung (Gleichstromseite) in kV*/
     //converter.ratedUdc = isNumericI7(acdcConverter.ratedUdc) ? acdcConverter.ratedUdc/2 * -1 : acdcConverter.ratedUdc;
     converter.ratedUdc = acdcConverter.ratedUdc;
     //acdcConverter.ratedUdc = isNumericI7(acdcConverter.ratedUdc) ? acdcConverter.ratedUdc/2 : acdcConverter.ratedUdc;
     /** spannungsabhängige Wirk-Verluste in kW bei Leerlauf mit Bemessungsspannung in kV*/
-    converter.idleLoss = (0, parser_utils_1.isNumericI7)(acdcConverter.idleLoss) ? acdcConverter.idleLoss / 2 : acdcConverter.idleLoss;
-    acdcConverter.idleLoss = (0, parser_utils_1.isNumericI7)(acdcConverter.idleLoss) ? acdcConverter.idleLoss / 2 : acdcConverter.idleLoss;
+    converter.idleLoss = isNumericI7(acdcConverter.idleLoss) ? acdcConverter.idleLoss / 2 : acdcConverter.idleLoss;
+    acdcConverter.idleLoss = isNumericI7(acdcConverter.idleLoss) ? acdcConverter.idleLoss / 2 : acdcConverter.idleLoss;
     //converter.maxUdc = isNumericI7(acdcConverter.maxUdc) ? acdcConverter.maxUdc/2 * -1 : acdcConverter.maxUdc; // +5% * ratedUdc
     converter.maxUdc = acdcConverter.maxUdc; // +5% * ratedUdc
     //acdcConverter.maxUdc = isNumericI7(acdcConverter.maxUdc) ? acdcConverter.maxUdc/2 : acdcConverter.maxUdc;
     //converter.minUdc = isNumericI7(converter.minUdc/2) ? converter.minUdc/2 * -1 : converter.minUdc; // -5% * ratedUdc
     converter.minUdc = converter.minUdc; // -5% * ratedUdc
     //acdcConverter.minUdc = isNumericI7(converter.minUdc/2) ? converter.minUdc/2 : converter.minUdc;
-    converter.resistiveLoss = (0, parser_utils_1.isNumericI7)(acdcConverter.resistiveLoss / 2) ? acdcConverter.resistiveLoss / 2 : acdcConverter.resistiveLoss;
-    acdcConverter.resistiveLoss = (0, parser_utils_1.isNumericI7)(acdcConverter.resistiveLoss / 2) ? acdcConverter.resistiveLoss / 2 : acdcConverter.resistiveLoss;
-    converter.switchingLoss = (0, parser_utils_1.isNumericI7)(acdcConverter.switchingLoss / 2) ? acdcConverter.switchingLoss / 2 : acdcConverter.switchingLoss;
-    acdcConverter.switchingLoss = (0, parser_utils_1.isNumericI7)(acdcConverter.switchingLoss / 2) ? acdcConverter.switchingLoss / 2 : acdcConverter.switchingLoss;
+    converter.resistiveLoss = isNumericI7(acdcConverter.resistiveLoss / 2) ? acdcConverter.resistiveLoss / 2 : acdcConverter.resistiveLoss;
+    acdcConverter.resistiveLoss = isNumericI7(acdcConverter.resistiveLoss / 2) ? acdcConverter.resistiveLoss / 2 : acdcConverter.resistiveLoss;
+    converter.switchingLoss = isNumericI7(acdcConverter.switchingLoss / 2) ? acdcConverter.switchingLoss / 2 : acdcConverter.switchingLoss;
+    acdcConverter.switchingLoss = isNumericI7(acdcConverter.switchingLoss / 2) ? acdcConverter.switchingLoss / 2 : acdcConverter.switchingLoss;
     /** SSH profile export*/
-    converter.p = (0, parser_utils_1.isNumericI7)(acdcConverter.p / 2) ? acdcConverter.p / 2 : acdcConverter.p;
-    acdcConverter.p = (0, parser_utils_1.isNumericI7)(acdcConverter.p / 2) ? acdcConverter.p / 2 : acdcConverter.p;
-    converter.q = (0, parser_utils_1.isNumericI7)(acdcConverter.q / 2) ? acdcConverter.q / 2 : acdcConverter.q;
-    acdcConverter.q = (0, parser_utils_1.isNumericI7)(acdcConverter.q / 2) ? acdcConverter.q / 2 : acdcConverter.q;
-    acdcConverter.q = (0, parser_utils_1.isNumericI7)(acdcConverter.q / 2) ? acdcConverter.q / 2 : acdcConverter.q;
+    converter.p = isNumericI7(acdcConverter.p / 2) ? acdcConverter.p / 2 : acdcConverter.p;
+    acdcConverter.p = isNumericI7(acdcConverter.p / 2) ? acdcConverter.p / 2 : acdcConverter.p;
+    converter.q = isNumericI7(acdcConverter.q / 2) ? acdcConverter.q / 2 : acdcConverter.q;
+    acdcConverter.q = isNumericI7(acdcConverter.q / 2) ? acdcConverter.q / 2 : acdcConverter.q;
+    acdcConverter.q = isNumericI7(acdcConverter.q / 2) ? acdcConverter.q / 2 : acdcConverter.q;
     if (type === 'CsConverter') {
         converter.operatingMode = acdcConverter.operatingMode;
         converter.maxAlpha = acdcConverter.maxAlpha;
@@ -450,19 +430,19 @@ function createACDCConverterNeg(cimModel, int7hguekopf, type, acdcConverter, dcC
     else if (type === 'VsConverter') {
         converter.pPccControl = acdcConverter.pPccControl;
         converter.qPccControl = acdcConverter.qPccControl;
-        converter.targetPpcc = (0, parser_utils_1.isNumericI7)(acdcConverter.targetPpcc / 2) ? acdcConverter.targetPpcc / 2 : acdcConverter.targetPpcc;
-        acdcConverter.targetPpcc = (0, parser_utils_1.isNumericI7)(acdcConverter.targetPpcc / 2) ? acdcConverter.targetPpcc / 2 : acdcConverter.targetPpcc;
+        converter.targetPpcc = isNumericI7(acdcConverter.targetPpcc / 2) ? acdcConverter.targetPpcc / 2 : acdcConverter.targetPpcc;
+        acdcConverter.targetPpcc = isNumericI7(acdcConverter.targetPpcc / 2) ? acdcConverter.targetPpcc / 2 : acdcConverter.targetPpcc;
         converter.targetUpcc = acdcConverter.targetUpcc;
-        converter.targetQpcc = (0, parser_utils_1.isNumericI7)(acdcConverter.targetQpcc / 2) ? acdcConverter.targetQpcc / 2 : acdcConverter.targetQpcc;
-        acdcConverter.targetQpcc = (0, parser_utils_1.isNumericI7)(acdcConverter.targetQpcc / 2) ? acdcConverter.targetQpcc / 2 : acdcConverter.targetQpcc;
+        converter.targetQpcc = isNumericI7(acdcConverter.targetQpcc / 2) ? acdcConverter.targetQpcc / 2 : acdcConverter.targetQpcc;
+        acdcConverter.targetQpcc = isNumericI7(acdcConverter.targetQpcc / 2) ? acdcConverter.targetQpcc / 2 : acdcConverter.targetQpcc;
         //(converter as VsConverter).targetUdc = isNumericI7((acdcConverter as VsConverter).targetUdc/2) ? (acdcConverter as VsConverter).targetUdc/2 : (acdcConverter as VsConverter).targetUdc;
         converter.targetUdc = acdcConverter.targetUdc;
         //(acdcConverter as VsConverter).targetUdc = isNumericI7((acdcConverter as VsConverter).targetUdc/2) ? (acdcConverter as VsConverter).targetUdc/2 : (acdcConverter as VsConverter).targetUdc;
-        converter.qShare = (0, parser_utils_1.isNumericI7)(acdcConverter.qShare / 2) ? acdcConverter.qShare / 2 : acdcConverter.qShare;
-        acdcConverter.qShare = (0, parser_utils_1.isNumericI7)(acdcConverter.qShare / 2) ? acdcConverter.qShare / 2 : acdcConverter.qShare;
+        converter.qShare = isNumericI7(acdcConverter.qShare / 2) ? acdcConverter.qShare / 2 : acdcConverter.qShare;
+        acdcConverter.qShare = isNumericI7(acdcConverter.qShare / 2) ? acdcConverter.qShare / 2 : acdcConverter.qShare;
         converter.pPccControl = acdcConverter.pPccControl;
         converter.capabilityCurve = acdcConverter.capabilityCurve;
-        converter.capabilityCurve?.VsConverterDCSides.set(converter.getUUID(), converter);
+        (_a = converter.capabilityCurve) === null || _a === void 0 ? void 0 : _a.VsConverterDCSides.set(converter.getUUID(), converter);
         for (const curveData of cimModel.getCurveDataByCapabilityCurve(converter.capabilityCurve.getUUID())) {
             curveData.xvalue = curveData.xvalue / 2;
             curveData.y1value = curveData.y1value / 2;
@@ -472,12 +452,12 @@ function createACDCConverterNeg(cimModel, int7hguekopf, type, acdcConverter, dcC
     /** Status */
     converter.normallyInService = acdcConverter.normallyInService;
     /** Topologie DC Seite*/
-    const dcNode = new DCNode_1.DCNode((0, parser_utils_1.getUUID)(int7hguekopf.guid_dcnoden), createNotation([(0, utils_1.getName)(int7hguekopf), '_neg', '_DCN'], 32, true));
+    const dcNode = new DCNode(getUUID(int7hguekopf.guid_dcnoden), createNotation([getName(int7hguekopf), '_neg', '_DCN'], 32, true));
     dcNode.dcEquipmentContainer = dcConverterUnit;
     acdcConverter.equipmentContainer.dCNodes.set(dcNode.getUUID(), dcNode);
-    const acDCConverterDCTerminal = new ACDCConverterDCTerminal_1.ACDCConverterDCTerminal((0, parser_utils_1.getUUID)(int7hguekopf.guid_dcterminaln), createNotation([(0, utils_1.getName)(int7hguekopf), '_neg', '_ACDCC-DCT'], 32, true));
+    const acDCConverterDCTerminal = new ACDCConverterDCTerminal(getUUID(int7hguekopf.guid_dcterminaln), createNotation([getName(int7hguekopf), '_neg', '_ACDCC-DCT'], 32, true));
     acDCConverterDCTerminal.dCConductingEquipment = converter;
-    acDCConverterDCTerminal.polarity = DCPolarityKind_1.DCPolarityKind.negative;
+    acDCConverterDCTerminal.polarity = DCPolarityKind.negative;
     converter.dCTerminals.set(acDCConverterDCTerminal.getUUID(), acDCConverterDCTerminal);
     acDCConverterDCTerminal.dcNode = dcNode;
     dcNode.dcTerminals.set(acDCConverterDCTerminal.getUUID(), acDCConverterDCTerminal);
@@ -491,15 +471,15 @@ function createACDCConverterNeg(cimModel, int7hguekopf, type, acdcConverter, dcC
     cimModel.addACDCConverterDCTerminal(acDCConverterDCTerminal);
     return converter;
 }
-function createBay(uuid, name, voltageLevel, cimModel) {
-    const bay = new Bay_1.Bay(uuid, name);
+export function createBay(uuid, name, voltageLevel, cimModel) {
+    const bay = new Bay(uuid, name);
     bay.voltageLevel = voltageLevel;
     voltageLevel.addBay(bay);
     cimModel.addBay(bay);
     return bay;
 }
-function createFacility(uuid, name, baseModel, psr) {
-    const facilitiy = new Facility_1.Facility(uuid, name);
+export function createFacility(uuid, name, baseModel, psr) {
+    const facilitiy = new Facility(uuid, name);
     facilitiy.baseIRI = baseModel.getBaseIRI();
     facilitiy.addPowerSystemResource(psr);
     baseModel.addFacility(facilitiy);