@enervance/insight-cim-model 1.0.2 → 1.0.3

package/dist/converter/integral7/utils.js

@@ -0,0 +1,1763 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepcopy = deepcopy;
+exports.ueberpruefeZeichenkette = ueberpruefeZeichenkette;
+exports.getName = getName;
+exports.getLineByAttribute = getLineByAttribute;
+exports.getLine = getLine;
+exports.getU = getU;
+exports.getTerminalUn = getTerminalUn;
+exports.getSchaltgruppe = getSchaltgruppe;
+exports.getSchaltgruppeAngleClock = getSchaltgruppeAngleClock;
+exports.getPkrTrafo = getPkrTrafo;
+exports.getUkrTrafo = getUkrTrafo;
+exports.getSrTrafo = getSrTrafo;
+exports.getSdauerTrafo = getSdauerTrafo;
+exports.getUrTrafo = getUrTrafo;
+exports.getX0R0Transformer = getX0R0Transformer;
+exports.calculateSigma = calculateSigma;
+exports.calculateR = calculateR;
+exports.calculateRatedIdc = calculateRatedIdc;
+exports.calculateX = calculateX;
+exports.calculateRSeriesCompensator = calculateRSeriesCompensator;
+exports.calculateXSeriesCompensator = calculateXSeriesCompensator;
+exports.calculateG = calculateG;
+exports.calculateB = calculateB;
+exports.calculateBPerSection = calculateBPerSection;
+exports.calculateB0PerSection = calculateB0PerSection;
+exports.calculateGPerSection = calculateGPerSection;
+exports.calculateG0PerSection = calculateG0PerSection;
+exports.calculateBC = calculateBC;
+exports.calculateG0ch = calculateG0ch;
+exports.calculateStatVarComRating = calculateStatVarComRating;
+exports.calculateShortCircuitCurrent = calculateShortCircuitCurrent;
+exports.transformShortCircuitCurrent = transformShortCircuitCurrent;
+exports.getTrafoPleer = getTrafoPleer;
+exports.getTrafoIleer = getTrafoIleer;
+exports.getTrafoIr = getTrafoIr;
+exports.getConductingEquipmentTerminalBySecNumber = getConductingEquipmentTerminalBySecNumber;
+exports.setTapChangerControl = setTapChangerControl;
+exports.getTapChangerStepCount = getTapChangerStepCount;
+exports.getTapChangerStepArray = getTapChangerStepArray;
+exports.getActiveReactivePower = getActiveReactivePower;
+exports.getActiveReactivePower2 = getActiveReactivePower2;
+exports.getPMech = getPMech;
+exports.getDescription = getDescription;
+exports.getNumber = getNumber;
+exports.generateFuelType = generateFuelType;
+exports.writeFile = writeFile;
+exports.generateNodeStream = generateNodeStream;
+exports.writeZipFile = writeZipFile;
+exports.getSchemaValue = getSchemaValue;
+exports.determineEquipmentContainer = determineEquipmentContainer;
+exports.createTempDirPath = createTempDirPath;
+exports.getIntegral7IDs = getIntegral7IDs;
+exports.putUUIDtoI7Ids = putUUIDtoI7Ids;
+exports.getPSRType = getPSRType;
+exports.createWriteStreamPromise = createWriteStreamPromise;
+exports.createRegulatingControl = createRegulatingControl;
+exports.calculateComplexZeroSequImpedanzenTrafo = calculateComplexZeroSequImpedanzenTrafo;
+exports.getGroundingCountFromWindingConnection = getGroundingCountFromWindingConnection;
+exports.getSpannungsband = getSpannungsband;
+exports.calculatePU2OHM = calculatePU2OHM;
+exports.getSpannungSchluessel = getSpannungSchluessel;
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs"));
+const INTEGRALPowerTransformer3WInfo_1 = require("../../model/extensions/integral/assetinfo/INTEGRALPowerTransformer3WInfo.js");
+const Bay_1 = require("../../model/core/Bay.js");
+const VoltageLevel_1 = require("../../model/core/VoltageLevel.js");
+const WindingConnection_1 = require("../../model/wires/WindingConnection.js");
+const common_utils_1 = require("../../utils2/common.utils.js");
+const FuelType_1 = require("../../model/generation/FuelType.js");
+const RegulatingControl_1 = require("../../model/wires/RegulatingControl.js");
+const FossilFuel_1 = require("../../model/generation/FossilFuel.js");
+const PSRType_1 = require("../../model/core/PSRType.js");
+const parser_utils_1 = require("../../utils2/parser.utils.js");
+const cim_class_names_1 = require("../../constants/cim-class-names.js");
+const complex_js_1 = tslib_1.__importDefault(require("complex.js"));
+const INTEGRALPowerTransformer2WInfo_1 = require("../../model/extensions/integral/assetinfo/INTEGRALPowerTransformer2WInfo.js");
+function deepcopy(converter) {
+    let converter_copy = undefined;
+    converter_copy = eval(`new ${converter.constructor.name}(getUUID(),)`);
+    return converter;
+}
+function ueberpruefeZeichenkette(str) {
+    if (str)
+        return str;
+    else
+        return '';
+}
+function getName(object) {
+    if (object.bezeichner?.length > 0) {
+        return object.bezeichner;
+    }
+    else if (object.name?.length > 0) {
+        return object.name;
+    }
+    else if (object.langname?.length > 0) {
+        return object.langname;
+    }
+    return 'NN';
+}
+function getLineByAttribute(cimModel, lineAttribute, attributeInstance) {
+    let line = undefined;
+    for (const stromkreis of cimModel.lines.values()) {
+        if (stromkreis[lineAttribute] === attributeInstance) {
+            line = stromkreis;
+            break;
+        }
+    }
+    return line;
+}
+function getLine(cimModel, bezeichner, kurzname) {
+    let line = undefined;
+    for (const stromkreis of cimModel.lines.values()) {
+        if (stromkreis.name === bezeichner || stromkreis.shortName === kurzname) {
+            line = stromkreis;
+            break;
+        }
+    }
+    // if(line === undefined){
+    //   const a = 1;
+    // }
+    return line;
+}
+function getU(un) {
+    let ret_val = (0, parser_utils_1.isNumericI7)(un) ? (0, parser_utils_1.convertToNumberI7)(un) : undefined;
+    return ret_val;
+}
+/**
+ * This method find connected BaseVoltages by traversing connected terminals (objectclass: Terminal) of this ce ConductingEquipment.
+ * @param cimModel the model to search.
+ * @param ce conducting equipment of interest.
+ * @returns set of BaseVoltage objects.
+ */ //TODO: If the terminal is part of a boundary node, then no connectivity node will be found and thus the basevoltage is not returned. How to search the connectivity nodes of the boundary set.
+function getTerminalUn(cimModel, bdf, ce) {
+    let ret_val = [];
+    const terminals = ce.terminals.size > 0 ? [...ce.terminals.keys()] : ce.terminalsUuid;
+    for (const terminalUUID of terminals) {
+        let baseVoltage = undefined;
+        const terminal = cimModel.getTerminal(terminalUUID);
+        if (terminal) {
+            if (terminal.connectivityNode) {
+                ret_val.push(terminal.connectivityNode.getBaseVoltage());
+            }
+            else if (terminal.connectivityNodeUUID) {
+                let cn = cimModel.getConnectivityNode(terminal.connectivityNodeUUID);
+                if (cn === undefined) {
+                    //node is listed in a boundary set...
+                    for (const bdframe of bdf) {
+                        if (cn === undefined) {
+                            cn = bdframe?.cimModel.getConnectivityNode(terminal.connectivityNodeUUID);
+                        }
+                    }
+                }
+                ret_val.push(cn?.getBaseVoltage());
+            }
+        }
+    }
+    return ret_val;
+}
+function getSchaltgruppe(schaltgr, endNumber, isNeutralGrounded) {
+    //let pos_max = endsRATEDVoltage.indexOf(Math.max(...endsRATEDVoltage));
+    //let translate = undefined;
+    //Aktuell wird ignoriert: Groß- und Kleinschreibung von Spannungsniveaus
+    switch (schaltgr) {
+        case 'DD0':
+            //endnumber don't care
+            return WindingConnection_1.WindingConnection.D;
+        case 'DD6':
+            //endnumber don't care
+            return WindingConnection_1.WindingConnection.D;
+        case 'DY5':
+        case 'DY6':
+        case 'DY7':
+        case 'DY11':
+        case 'DY11Y11':
+            if (endNumber === 1) {
+                return WindingConnection_1.WindingConnection.D;
+            }
+            else if (!isNeutralGrounded) {
+                return WindingConnection_1.WindingConnection.Y;
+            }
+            else {
+                return WindingConnection_1.WindingConnection.Yn;
+            }
+        case 'DZ0':
+        case 'DZ6':
+            if (endNumber === 1) {
+                return WindingConnection_1.WindingConnection.D;
+            }
+            else if (endNumber === 2 && !isNeutralGrounded) {
+                return WindingConnection_1.WindingConnection.Z;
+            }
+            else {
+                return WindingConnection_1.WindingConnection.Zn;
+            }
+        case 'Y0':
+            //Autotransformer:
+            return WindingConnection_1.WindingConnection.A;
+        case 'Y0D5':
+            if (endNumber == 1 || endNumber == 2) {
+                return WindingConnection_1.WindingConnection.A;
+            }
+            else {
+                return WindingConnection_1.WindingConnection.D;
+            }
+        case 'YD5':
+        case 'YD11':
+        case 'YD5D5':
+        case 'YD11D11':
+            if (endNumber === 1) {
+                if (isNeutralGrounded) {
+                    return WindingConnection_1.WindingConnection.Yn;
+                }
+                else {
+                    return WindingConnection_1.WindingConnection.Y;
+                }
+            }
+            else {
+                return WindingConnection_1.WindingConnection.D;
+            }
+        case 'YD5Y0':
+        case 'YD5Y6':
+            if (endNumber === 1 || endNumber == 3) {
+                if (isNeutralGrounded) {
+                    return WindingConnection_1.WindingConnection.Yn;
+                }
+                else {
+                    return WindingConnection_1.WindingConnection.Y;
+                }
+            }
+            else {
+                return WindingConnection_1.WindingConnection.D;
+            }
+        case 'YNd5': //N is ignored.
+        case 'YNd7d7': //N is ignored.
+            if (endNumber === 1 && !isNeutralGrounded) {
+                return WindingConnection_1.WindingConnection.Y;
+            }
+            else if (endNumber === 1 && isNeutralGrounded) {
+                return WindingConnection_1.WindingConnection.Yn;
+            }
+            else {
+                return WindingConnection_1.WindingConnection.D;
+            }
+        case 'YNyn6(d)':
+            if (endNumber === 1) {
+                return WindingConnection_1.WindingConnection.Y;
+            }
+            else {
+                return WindingConnection_1.WindingConnection.Y;
+            }
+        case 'YY0':
+        case 'YY6':
+            if (isNeutralGrounded) {
+                return WindingConnection_1.WindingConnection.Yn;
+            }
+            else {
+                return WindingConnection_1.WindingConnection.Y;
+            }
+        case 'YY0D1':
+        case 'YY0D5':
+        case 'YY0D11':
+            if (endNumber === 1 || endNumber === 2) {
+                if (isNeutralGrounded) {
+                    return WindingConnection_1.WindingConnection.Yn;
+                }
+                else {
+                    return WindingConnection_1.WindingConnection.Y;
+                }
+            }
+            else {
+                return WindingConnection_1.WindingConnection.D;
+            }
+        case 'YY0Y0':
+            if (isNeutralGrounded) {
+                return WindingConnection_1.WindingConnection.Yn;
+            }
+            else {
+                return WindingConnection_1.WindingConnection.Y;
+            }
+        case 'YZ5':
+        case 'YZ11':
+            if (endNumber === 1) {
+                if (isNeutralGrounded) {
+                    return WindingConnection_1.WindingConnection.Yn;
+                }
+                else {
+                    return WindingConnection_1.WindingConnection.Y;
+                }
+            }
+            else if (endNumber === 2) {
+                if (isNeutralGrounded) {
+                    return WindingConnection_1.WindingConnection.Zn;
+                }
+                else {
+                    return WindingConnection_1.WindingConnection.Z;
+                }
+            }
+            break;
+        default:
+            return WindingConnection_1.WindingConnection.Y;
+    }
+}
+function getSchaltgruppeAngleClock(schaltgr, endNumber) {
+    switch (schaltgr) {
+        case 'DD0':
+        case 'DZ0':
+        case 'Y0':
+        case 'YY0':
+        case 'YY0Y0':
+            return 0;
+        case 'YY0D1':
+            if (endNumber === 3) {
+                return 1;
+            }
+            else {
+                return 0;
+            }
+        case 'DY5':
+        case 'YD5':
+        case 'YD5Y0':
+        case 'YNd5':
+        case 'YZ5':
+            if (endNumber === 2) {
+                return 5;
+            }
+            else {
+                return 0;
+            }
+        case 'DD6':
+        case 'DY6':
+        case 'DZ6':
+        case 'YY6':
+        case 'YNyn6(d)':
+            if (endNumber === 1) {
+                return 0;
+            }
+            else {
+                return 6;
+            }
+        case 'Y0D5':
+        case 'YY0D5':
+            if (endNumber === 3) {
+                return 5;
+            }
+            else {
+                return 0;
+            }
+        case 'YD5D5':
+            if (endNumber === 1) {
+                return 0;
+            }
+            else {
+                return 5;
+            }
+        case 'YD5Y6':
+            if (endNumber === 1) {
+                return 0;
+            }
+            else if (endNumber === 2) {
+                return 5;
+            }
+            else {
+                return 6;
+            }
+        case 'DY7':
+        case 'YNd7d7':
+            if (endNumber === 1) {
+                return 0;
+            }
+            else {
+                return 7;
+            }
+        case 'DY11':
+        case 'DY11Y11':
+        case 'YD11':
+        case 'YD11D11':
+        case 'YZ11':
+            if (endNumber === 1) {
+                return 0;
+            }
+            else {
+                return 11;
+            }
+        case 'YY0D11':
+            if (endNumber === 3) {
+                return 11;
+            }
+            else {
+                return 0;
+            }
+        default:
+            return 0;
+    }
+}
+function getPkrTrafo(i7Data, powerTransformerInfo, suffix, isTrafo3W) {
+    const prop = `pkr${isTrafo3W ? suffix : ''}`; // fix für 2W Trafos
+    if (i7Data[prop] && i7Data[prop] !== 0) {
+        return i7Data[prop];
+    }
+    else if (powerTransformerInfo && powerTransformerInfo[prop] && powerTransformerInfo[prop] !== 0) {
+        return powerTransformerInfo[prop];
+    }
+    return 0;
+}
+function getUkrTrafo(i7Data, powerTransformerInfo, suffix, isTrafo3W) {
+    const prop = `ukr${isTrafo3W ? suffix : ''}`; // fix für 2W Trafos
+    if (i7Data[prop] && i7Data[prop] !== 0) {
+        return i7Data[prop];
+    }
+    else if (powerTransformerInfo && powerTransformerInfo[prop] && powerTransformerInfo[prop] !== 0) {
+        return powerTransformerInfo[prop];
+    }
+    return 0;
+}
+function getSrTrafo(i7Data, powerTransformerInfo, endNumber, isTrafo3W) {
+    const prop = `sr${isTrafo3W ? endNumber : ''}`; // fix für 2W Trafos
+    if (i7Data[prop] && i7Data[prop] !== 0) {
+        return i7Data[prop];
+    }
+    else if (powerTransformerInfo) {
+        const transformerEndInfo = powerTransformerInfo.getTransformerEndInfos().find(element => element.endNumber === endNumber);
+        if (transformerEndInfo && transformerEndInfo.ratedS) {
+            if (transformerEndInfo.ratedS.value && transformerEndInfo.ratedS.value !== 0) {
+                return transformerEndInfo.ratedS.value;
+            }
+        }
+        else if (powerTransformerInfo[prop] && powerTransformerInfo[prop] !== 0) {
+            return powerTransformerInfo[prop];
+        }
+    }
+    return undefined;
+}
+function getSdauerTrafo(i7Data, powerTransformerInfo, endNumber, isTrafo3W) {
+    let retVal = undefined;
+    const prop = `s_dauer${isTrafo3W ? '_' + endNumber : ''}`; // fix für 2W Trafos
+    if ((0, parser_utils_1.isNumericI7)(i7Data[prop] && i7Data[prop] !== 0)) {
+        retVal = i7Data[prop];
+    }
+    else if (powerTransformerInfo instanceof INTEGRALPowerTransformer2WInfo_1.INTEGRALPowerTransformer2WInfo && powerTransformerInfo !== undefined && (0, parser_utils_1.isNumericI7)(powerTransformerInfo.s_dauer) && powerTransformerInfo.s_dauer !== 0) {
+        retVal = powerTransformerInfo.s_dauer;
+    }
+    else if (powerTransformerInfo instanceof INTEGRALPowerTransformer3WInfo_1.INTEGRALPowerTransformer3WInfo && powerTransformerInfo !== undefined) {
+        switch (endNumber) {
+            case 1:
+                if ((0, parser_utils_1.isNumericI7)(powerTransformerInfo.s_dauer_1) &&
+                    powerTransformerInfo.s_dauer_1 !== 0) {
+                    retVal = powerTransformerInfo.s_dauer_1;
+                }
+                break;
+            case 2:
+                if ((0, parser_utils_1.isNumericI7)(powerTransformerInfo.s_dauer_2) &&
+                    powerTransformerInfo.s_dauer_2 !== 0) {
+                    retVal = powerTransformerInfo.s_dauer_2;
+                }
+                break;
+            case 3:
+                if ((0, parser_utils_1.isNumericI7)(powerTransformerInfo.s_dauer_3) &&
+                    powerTransformerInfo.s_dauer_3 !== 0) {
+                    retVal = powerTransformerInfo.s_dauer_3;
+                }
+                break;
+            default: retVal = undefined;
+        }
+    }
+    return retVal;
+}
+function getUrTrafo(i7Data, powerTransformerInfo, endNumber) {
+    const prop = `ur${endNumber}`;
+    if (i7Data[prop] && i7Data[prop] !== 0) {
+        return i7Data[prop];
+    }
+    else if (powerTransformerInfo) {
+        const transformerEndInfo = powerTransformerInfo?.getTransformerEndInfos().find(element => element.endNumber === endNumber);
+        if (transformerEndInfo && transformerEndInfo.ratedU) {
+            if (transformerEndInfo.ratedU && transformerEndInfo.ratedU.value !== 0) {
+                return transformerEndInfo.ratedU.value;
+            }
+        }
+        else if (powerTransformerInfo[prop] && powerTransformerInfo[prop] !== 0) {
+            return powerTransformerInfo[prop];
+        }
+    }
+    return 0;
+}
+function getX0R0Transformer(i7Data, powerTransformerInfo, varNameI7) {
+    let ret_val = undefined;
+    const prop = `${varNameI7}`;
+    if (i7Data[prop] !== undefined && (0, parser_utils_1.isNumericI7)(i7Data[prop])) { //read data from i7 net data object
+        ret_val = i7Data[prop];
+    }
+    else if (powerTransformerInfo !== undefined && powerTransformerInfo[prop] !== undefined && (0, parser_utils_1.isNumericI7)(powerTransformerInfo[prop])) { //read data from net data object type
+        ret_val = powerTransformerInfo[prop];
+    }
+    return ret_val;
+}
+/**
+ * @param fn Nennfrquenz in Hz
+ * @param pn Nennwirkleistung in MW
+ * @param kr Leistungszahl in MW/Hz
+ * @returns Statik Sigma des Generators. */
+function calculateSigma(fn, pn, kr) {
+    let sigma = 0;
+    try {
+        if (pn !== 0) {
+            sigma = (kr * 100 * fn) / (pn);
+        }
+    }
+    catch (e) {
+    }
+    return sigma;
+}
+/**
+ * @param un Nennspannung in kV
+ * @param pkr Kurzschlussverluste im Bemessungsbetrieb kW
+ * @param sr Bemessungsscheinleistung in MVA  */
+function calculateR(un, pkr, sr) {
+    const conversion_factor_un = Math.pow(10, 3);
+    const conversion_factor_pkr = Math.pow(10, 3);
+    const conversion_factor_sr = Math.pow(10, 6);
+    let ret_val = undefined;
+    try {
+        ret_val = (pkr * conversion_factor_pkr) * Math.pow((un * conversion_factor_un), 2) / Math.pow((sr * conversion_factor_sr), 2);
+        //ret_val = (pkr*conversion_factor_pkr) * Math.pow((un*conversion_factor_un), 2) / Math.pow((sr*conversion_factor_sr), 1); //TODO: Test (20220127)
+        //ret_val = Math.pow((un*conversion_factor_un), 2)/(pkr*conversion_factor_pkr); //TODO: Test (20220131)
+    }
+    catch (e) {
+        ret_val = undefined;
+    }
+    ret_val = Number.isNaN(ret_val) ? undefined : ret_val;
+    ret_val = Number.isFinite(ret_val) ? ret_val : 0;
+    return ret_val;
+}
+/**
+ * @param ur Bemessungsspannung (Gleichspannung) in kV
+ * @param pr Bemessungsleistung (Gleichstromseite) in MW
+ * @return idc Bemessungsstrom (Geichstrom) in A */
+function calculateRatedIdc(ur, pr) {
+    const conversion_factor_ur = Math.pow(10, 3);
+    const conversion_factor_pr = Math.pow(10, 6);
+    let ret_val = undefined;
+    try {
+        ret_val = (conversion_factor_pr * pr) / (conversion_factor_ur * ur);
+    }
+    catch (e) {
+        ret_val = undefined;
+    }
+    ret_val = Number.isNaN(ret_val) ? undefined : ret_val;
+    ret_val = Number.isFinite(ret_val) ? ret_val : 0;
+    return ret_val;
+}
+/**
+ * @param ur Nennspannung in kV
+ * @param ukr Kurzschlussspannung in %
+ * @param sr Bemessungsscheinleistung in MVA
+ * @param r Wirkwiderstand in Ohm*/
+function calculateX(ur, ukr, sr, r) {
+    const conversion_factor_ur = Math.pow(10, 3);
+    const conversion_factor_sr = Math.pow(10, 6);
+    const conversion_factor_ukr = Math.pow(10, -2);
+    let ret_val = undefined;
+    try {
+        ret_val = Math.sqrt(Math.pow((ukr * conversion_factor_ukr) * (Math.pow(ur * conversion_factor_ur, 2) / (sr * conversion_factor_sr)), 2) - Math.pow(r, 2));
+        //ret_val = (ukr * conversion_factor_ukr * ur * conversion_factor_ur) / (sr * conversion_factor_sr / (ur * conversion_factor_ur));
+    }
+    catch (e) {
+        ret_val = undefined;
+    }
+    ret_val = Number.isNaN(ret_val) ? undefined : ret_val;
+    ret_val = Number.isFinite(ret_val) ? ret_val : 0;
+    return ret_val;
+}
+/**
+ * @param ir Kurzschlussspannung in %
+ * @param pkr Kurzschlussspannung in kW */
+function calculateRSeriesCompensator(ir, pkr) {
+    const conversion_factor_Ir = Math.pow(10, 0);
+    const conversion_factor_pkr = Math.pow(10, 3);
+    let ret_val = undefined;
+    try {
+        ret_val = (pkr * conversion_factor_pkr) / (Math.pow(Math.sqrt(3) * ir * conversion_factor_Ir, 2));
+    }
+    catch (e) {
+        ret_val = undefined;
+    }
+    ret_val = Number.isNaN(ret_val) ? undefined : ret_val;
+    ret_val = Number.isFinite(ret_val) ? ret_val : 0;
+    return ret_val;
+}
+/**
+ * @param ur Bemessungsspannung in kV
+ * @param ukr Kurzschlussspannung in %
+ * @param ir Bemessungsstrom in A
+ * @param r Wirkwiderstand in Ohm */
+function calculateXSeriesCompensator(ur, ukr, ir, r) {
+    const conversion_factor_ur = Math.pow(10, 3);
+    const conversion_factor_ukr = Math.pow(10, -2);
+    let ret_val = undefined;
+    let z = undefined;
+    try {
+        z = (ukr * conversion_factor_ukr * ur * conversion_factor_ur) / (ir * Math.sqrt(3));
+    }
+    catch (e) {
+        z = undefined;
+    }
+    if (r !== undefined && r > 0) {
+        ret_val = Math.sqrt(Math.pow(z, 2) - Math.pow(r, 2));
+    }
+    else {
+        ret_val = z;
+    }
+    ret_val = Number.isNaN(ret_val) ? undefined : ret_val;
+    ret_val = Number.isFinite(ret_val) ? ret_val : 0;
+    return ret_val;
+}
+/**
+ * @param un Nennspannung in kV
+ * @param pLeer P0 Leerlaufverluste in kW */
+function calculateG(un, pLeer) {
+    const conversion_factor_un = Math.pow(10, 3);
+    const conversion_factor_pLeer = Math.pow(10, 3);
+    let ret_val = undefined;
+    try {
+        ret_val = (pLeer * conversion_factor_pLeer) / Math.pow((un * conversion_factor_un), 2);
+    }
+    catch (e) {
+        ret_val = undefined;
+    }
+    return ret_val;
+}
+/**
+ * @param un Nennspannung in kV
+ * @param iLeer Leerlaufstrom bezogen auf Wicklung mit dem grössten Sr in %
+ * @param pLeer P0 Leerlaufverluste in kW*/
+function calculateB(un, sr, iLeer, pLeer) {
+    const conversion_factor_un = Math.pow(10, 3);
+    const conversion_factor_sr = Math.pow(10, 6);
+    const conversion_factor_pLeer = Math.pow(10, 3);
+    const conversion_factor_iLeer = Math.pow(10, -2);
+    let ret_val = undefined;
+    try {
+        ret_val = -1 * (Math.sqrt(Math.pow((iLeer * conversion_factor_iLeer * sr * conversion_factor_sr) / Math.pow((un * conversion_factor_un), 2), 2) - Math.pow((pLeer * conversion_factor_pLeer) / Math.pow((un * conversion_factor_un), 2), 2)));
+    }
+    catch (e) {
+        ret_val = undefined;
+    }
+    return ret_val;
+}
+/**
+ * @param ur rated voltage in kV
+ * @param qr rated reactive power in MVar
+ * @param maxTap maximal step of the equipment.
+ */
+function calculateBPerSection(qr, ur, maxTap) {
+    const conversion_factor_ur = Math.pow(10, 3);
+    const conversion_factor_qr = Math.pow(10, 6);
+    let ret_val = undefined;
+    try {
+        ret_val = ((qr * conversion_factor_qr) / Math.pow((ur * conversion_factor_ur), 2)) / maxTap;
+    }
+    catch (e) {
+        ret_val = undefined;
+    }
+    return ret_val;
+}
+/**
+ * @param r0 zero sequence resistance in Ohm
+ * @param x0 zero sequence reactance in Ohm
+ */
+function calculateB0PerSection(/*r0:number, */ x0) {
+    let ret_val = undefined;
+    try {
+        //ret_val = -x0 / (Math.pow(r0,2) + Math.pow(x0,2));
+        ret_val = 1 / x0;
+    }
+    catch (e) {
+        ret_val = undefined;
+    }
+    return ret_val;
+}
+/**
+ * @param ur rated voltage in kV
+ * @param pr rated reactive power in MW
+ * @param maxTap maximal step of the equipment.
+ */
+function calculateGPerSection(pr, ur, maxTap) {
+    const conversion_factor_ur = Math.pow(10, 3);
+    const conversion_factor_pr = Math.pow(10, 3);
+    let ret_val = undefined;
+    try {
+        ret_val = ((pr * conversion_factor_pr) / Math.pow((ur * conversion_factor_ur), 2)) / maxTap;
+    }
+    catch (e) {
+        ret_val = undefined;
+    }
+    return ret_val;
+}
+/**
+ * @param r0 zero sequence resistance in Ohm
+ * @param x0 zero sequence reactance in Ohm
+ */
+function calculateG0PerSection(r0 /*, x0:number*/) {
+    let ret_val = undefined;
+    try {
+        //ret_val = r0 / (Math.pow(r0,2) + Math.pow(x0,2));
+        ret_val = 1 / r0;
+    }
+    catch (e) {
+        ret_val = undefined;
+    }
+    return ret_val;
+}
+/**
+ * @param c capacitance of a line in µF
+ * @param f frequency in Hz
+ * @returns susceptance of a line in S
+ */
+function calculateBC(c, f) {
+    const conversion_factor = Math.pow(10, -6);
+    let ret_val = undefined;
+    try {
+        ret_val = 2 * Math.PI * f * (c * conversion_factor);
+    }
+    catch (e) {
+        ret_val = undefined;
+    }
+    return ret_val;
+}
+/**
+ * @param r reactance of a line in ohm
+ * @returns conductance of a line in S
+ */
+function calculateG0ch(r) {
+    // const conversion_factor = 1;
+    // let ret_val = undefined;
+    return 0;
+    //always returns zero
+    // try {
+    //   ret_val = (1/r) * conversion_factor;
+    // } catch (e) {
+    //   ret_val = undefined;
+    // }
+    // return ret_val;
+}
+/**
+ * @param ur Rated voltage in kV
+ * @param qr Rated reactive power in MVar */
+function calculateStatVarComRating(ur, qr) {
+    const conversion_factor_ur = Math.pow(10, 3);
+    const conversion_factor_qr = Math.pow(10, 6);
+    let ret_val = undefined;
+    try {
+        ret_val = Math.pow((ur * conversion_factor_ur), 2) / (qr * conversion_factor_qr);
+    }
+    catch (e) {
+        ret_val = undefined;
+    }
+    return ret_val;
+}
+/**
+ * @param sk short circuit apparent power in GVA
+ * @param nomV nominal Voltage in kV */
+function calculateShortCircuitCurrent(sk, nomV) {
+    const conversion_factor_sk = Math.pow(10, 9);
+    const conversion_factor_nomV = Math.pow(10, 3);
+    let ret_val = undefined;
+    try {
+        ret_val = (sk * conversion_factor_sk) / (nomV * conversion_factor_nomV * Math.sqrt(3));
+    }
+    catch (e) {
+        ret_val = undefined;
+    }
+    ret_val = Number.isNaN(ret_val) ? undefined : ret_val;
+    ret_val = Number.isFinite(ret_val) ? ret_val : 0;
+    return ret_val;
+}
+/**
+ * @param ik short circuit current in kA */
+function transformShortCircuitCurrent(ik) {
+    const conversion_factor_ik = Math.pow(10, 3);
+    let ret_val = undefined;
+    try {
+        ret_val = ik * conversion_factor_ik;
+    }
+    catch (e) {
+        ret_val = undefined;
+    }
+    ret_val = Number.isNaN(ret_val) ? undefined : ret_val;
+    ret_val = Number.isFinite(ret_val) ? ret_val : 0;
+    return ret_val;
+}
+// Leerlaufverluste
+function getTrafoPleer(i7Data, powerTransformerInfo) {
+    if (i7Data['p_leer'] && i7Data['p_leer'] !== 0) {
+        return i7Data['p_leer'];
+    }
+    else if (powerTransformerInfo && powerTransformerInfo['pLeer'] && powerTransformerInfo['pLeer'] !== 0) {
+        return powerTransformerInfo['pLeer'];
+    }
+    return 0;
+}
+// Leerlaufstrom bezogen auf Wicklung mit dem grössten Sr in %
+function getTrafoIleer(i7Data, powerTransformerInfo) {
+    if (i7Data['i_leer'] && i7Data['i_leer'] !== 0) {
+        return i7Data['i_leer'];
+    }
+    else if (powerTransformerInfo && powerTransformerInfo['iLeer'] && powerTransformerInfo['iLeer'] !== 0) {
+        return powerTransformerInfo['iLeer'];
+    }
+    return 0;
+}
+/**
+ * @param ur Bemessungsspannung in kV
+ * @param sr Bemessungsscheinleistung in MVA  */
+function getTrafoIr(ur, sr) {
+    let conversion_factor_sr = Math.pow(10, 6);
+    let conversion_factor_ur = Math.pow(10, 3);
+    let ret_val = undefined;
+    try {
+        ret_val = ((sr * conversion_factor_sr) / (ur * conversion_factor_ur)) / Math.sqrt(3);
+    }
+    catch (e) {
+        ret_val = undefined;
+    }
+    return ret_val;
+}
+function getConductingEquipmentTerminalBySecNumber(conductingEquipment, sequenceNumber) {
+    for (const terminal of conductingEquipment.terminals.values()) {
+        if (terminal.sequenceNumber === sequenceNumber) {
+            return terminal;
+        }
+    }
+    return;
+}
+function setTapChangerControl(tapChanger, terminalUUID) {
+    if (tapChanger && terminalUUID) {
+        if (tapChanger.tapChangerControl) {
+            const tapChangerControl = tapChanger.tapChangerControl;
+            tapChangerControl.terminalUUID = terminalUUID;
+        }
+    }
+}
+function getTapChangerStepCount(min, max) {
+    let counter = 0;
+    for (let i = min; i < max; i++) {
+        counter++;
+    }
+    return counter;
+}
+function getTapChangerStepArray(min, max) {
+    const array = [];
+    for (let i = min; i <= max; i++) {
+        array.push(i);
+    }
+    return array;
+}
+function getActiveReactivePower(i7Data, mf) {
+    const flagInd = i7Data.flag_ind;
+    let s0 = (0, parser_utils_1.isNumericI7)(i7Data.s0) ? (0, parser_utils_1.convertToNumberI7)(i7Data.s0) : undefined;
+    const p0 = (0, parser_utils_1.isNumericI7)(i7Data.p0) ? (0, parser_utils_1.convertToNumberI7)(i7Data.p0) : undefined;
+    let cosPhi = (0, parser_utils_1.isNumericI7)(i7Data.cos_phi) ? (0, parser_utils_1.convertToNumberI7)(i7Data.cos_phi) : undefined;
+    const q0Ind = (0, parser_utils_1.isNumericI7)(i7Data.q0_ind) ? (0, parser_utils_1.convertToNumberI7)(i7Data.q0_ind) : undefined;
+    const q0Kap = (0, parser_utils_1.isNumericI7)(i7Data.q0_kap) ? (0, parser_utils_1.convertToNumberI7)(i7Data.q0_kap) : undefined;
+    const mf_p = mf && (0, parser_utils_1.isNumericI7)(mf.p) ? mf.p : 1;
+    const mf_q0_ind = mf && (0, parser_utils_1.isNumericI7)(mf.qInd) ? mf.qInd : 1;
+    const mf_q0_kap = mf && (0, parser_utils_1.isNumericI7)(mf.qKap) ? mf.qKap : 1;
+    const mf_cos_phi_ind = mf && (0, parser_utils_1.isNumericI7)(mf.cosPhiInd) ? mf.cosPhiInd : 1;
+    const mf_cos_phi_kap = mf && (0, parser_utils_1.isNumericI7)(mf.cosPhiKap) ? mf.cosPhiKap : 1;
+    let q0 = undefined;
+    let activePower = undefined;
+    let activePowerMf = undefined;
+    let reactivePower = undefined;
+    let reactivePowerMf = undefined;
+    if ((0, parser_utils_1.isNumericI7)(p0) && (0, parser_utils_1.isNumericI7)(cosPhi)) {
+        if (cosPhi <= 1 && (cosPhi > 0 || cosPhi < 0)) {
+            activePower = p0;
+        }
+        else if (cosPhi === 0) {
+            activePower = p0;
+            cosPhi = 1;
+        }
+        s0 = activePower / cosPhi;
+        q0 = Math.sqrt(Math.pow(s0, 2) - Math.pow(activePower, 2));
+        reactivePower = ((0, parser_utils_1.convertToBooleanI7)(i7Data.flag_ind) || (0, parser_utils_1.convertToBooleanI7)(i7Data.flag_ind) === undefined) ? q0 : q0 * -1;
+        if (mf) {
+            activePowerMf = activePower * mf_p;
+            reactivePowerMf = reactivePower * mf_p; //If p0 and cosphi is given then reactive power is directly proportional to mf_p.
+        }
+    }
+    else if ((0, parser_utils_1.isNumericI7)(p0) && !(0, parser_utils_1.isNumericI7)(q0Ind) && !(0, parser_utils_1.isNumericI7)(q0Kap) && !(0, parser_utils_1.isNumericI7)(s0) && !(0, parser_utils_1.isNumericI7)(cosPhi) && !(0, parser_utils_1.isNumericI7)(s0)) {
+        //Only p0 is given.
+        activePower = p0;
+        reactivePower = 0;
+        activePowerMf = activePower * mf_p;
+        reactivePowerMf = 0;
+    }
+    else if (!(0, parser_utils_1.isNumericI7)(p0) && ((0, parser_utils_1.isNumericI7)(q0Ind) || (0, parser_utils_1.isNumericI7)(q0Kap)) && !(0, parser_utils_1.isNumericI7)(s0) && !(0, parser_utils_1.isNumericI7)(cosPhi)) {
+        //Only q is given
+        activePower = 0;
+        activePowerMf = 0;
+        if (q0Ind && q0Kap) {
+            reactivePower = q0Ind - q0Kap;
+            reactivePowerMf = q0Ind * mf_q0_ind - q0Kap * mf_q0_kap;
+        }
+        else if (q0Ind && !q0Kap) {
+            reactivePower = q0Ind;
+            reactivePowerMf = reactivePower * mf_q0_ind;
+        }
+        else {
+            reactivePower = q0Kap * -1;
+            reactivePowerMf = reactivePower * mf_q0_kap;
+        }
+    }
+    else if ((0, parser_utils_1.isNumericI7)(p0) && (0, parser_utils_1.isNumericI7)(q0Ind) && (0, parser_utils_1.isNumericI7)(s0) && !(0, parser_utils_1.isNumericI7)(q0Kap) && !(0, parser_utils_1.isNumericI7)(cosPhi)) {
+        //p, qind and s is given
+        activePower = p0;
+        if (Math.pow(s0, 2) === Math.pow(p0, 2) + Math.pow(q0Ind, 2)) {
+            reactivePower = q0Ind;
+        }
+        else {
+            reactivePower = Math.sqrt(Math.pow(s0, 2) - Math.pow(activePower, 2));
+            reactivePower = ((0, parser_utils_1.convertToBooleanI7)(i7Data.flag_ind) || (0, parser_utils_1.convertToBooleanI7)(i7Data.flag_ind) === undefined) ? reactivePower : reactivePower * -1;
+        }
+        if (mf) {
+            activePowerMf = activePower * mf_p;
+            reactivePowerMf = reactivePower * mf_p; //If p0 and cosphi is given then reactive power is directly proportional to mf_p.
+        }
+    }
+    else if ((0, parser_utils_1.isNumericI7)(p0) && (0, parser_utils_1.isNumericI7)(q0Ind) && (0, parser_utils_1.isNumericI7)(q0Kap)) {
+        activePower = p0;
+        activePowerMf = p0 * mf_p;
+        reactivePower = q0Ind - q0Kap;
+        reactivePowerMf = q0Ind * mf_q0_ind - q0Kap * mf_q0_kap;
+    }
+    else if ((0, parser_utils_1.isNumericI7)(p0) && ((0, parser_utils_1.isNumericI7)(q0Ind) || (0, parser_utils_1.isNumericI7)(q0Kap))) {
+        activePower = p0;
+        activePowerMf = p0 * mf_p;
+        if (q0Ind && !q0Kap) {
+            reactivePower = q0Ind;
+            reactivePowerMf = reactivePower * mf_q0_ind;
+        }
+        else {
+            reactivePower = q0Kap * -1;
+            reactivePowerMf = reactivePower * mf_q0_kap;
+        }
+    }
+    else if (((0, parser_utils_1.isNumericI7)(q0Ind) || (0, parser_utils_1.isNumericI7)(q0Kap)) && (0, parser_utils_1.isNumericI7)(cosPhi)) {
+        if (q0Ind && q0Kap && (flagInd || flagInd === undefined)) {
+            reactivePower = q0Ind - q0Kap;
+            reactivePowerMf = q0Ind * mf_q0_ind - q0Kap * mf_q0_kap;
+        }
+        else if (q0Ind && !q0Kap) {
+            reactivePower = q0Ind;
+            reactivePowerMf = reactivePower * mf_q0_ind;
+        }
+        else {
+            reactivePower = q0Kap * -1;
+            reactivePowerMf = reactivePower * mf_q0_kap;
+        }
+        if (cosPhi < 1 && cosPhi >= 0) {
+            activePower = (reactivePower) / (Math.sqrt(1 / cosPhi - 1));
+        }
+        else if (cosPhi === 0) {
+            activePower = 0;
+        }
+    }
+    else if ((0, parser_utils_1.isNumericI7)(s0) && (0, parser_utils_1.isNumericI7)(cosPhi)) {
+        activePower = s0 * cosPhi;
+        activePowerMf = activePower * mf_p;
+        reactivePower = Math.sqrt(Math.pow(s0, 2) - Math.pow(activePower, 2));
+        reactivePowerMf = reactivePower * mf_p;
+    }
+    else if ((0, parser_utils_1.isNumericI7)(s0) && (0, parser_utils_1.isNumericI7)(p0)) {
+        activePower = p0;
+        activePowerMf = activePower * mf_p;
+        reactivePower = Math.sqrt(Math.pow(s0, 2) - Math.pow(activePower, 2));
+        reactivePowerMf = reactivePower * mf_p;
+    }
+    else if ((0, parser_utils_1.isNumericI7)(s0) && (0, parser_utils_1.isNumericI7)(q0Ind) && (0, parser_utils_1.isNumericI7)(q0Kap)) {
+        reactivePower = q0Ind - q0Kap;
+        reactivePowerMf = q0Ind * mf_q0_ind - q0Kap * mf_q0_kap;
+        activePower = (reactivePower) / (Math.sqrt(1 / cosPhi - 1));
+        activePowerMf = activePowerMf * mf_p;
+    }
+    else if ((0, parser_utils_1.isNumericI7)(s0) && ((0, parser_utils_1.isNumericI7)(q0Ind) || (0, parser_utils_1.isNumericI7)(q0Kap))) {
+        if (q0Ind && !q0Kap) {
+            reactivePower = q0Ind;
+            reactivePowerMf = reactivePower * mf_q0_ind;
+        }
+        else {
+            reactivePower = q0Kap * -1;
+            reactivePowerMf = reactivePower * mf_q0_kap;
+        }
+        activePower = (reactivePower) / (Math.sqrt(1 / cosPhi - 1));
+        activePowerMf = activePowerMf * mf_p;
+    }
+    //Overwrite values for reactivePower, in case of mfcosPhiInd of mf.cosPhiKap is given.
+    if (mf && ((0, parser_utils_1.isNumericI7)(mf_cos_phi_ind) || (0, parser_utils_1.isNumericI7)(mf_cos_phi_kap))) {
+        if ((0, parser_utils_1.isNumericI7)(mf.cosPhiInd) && (0, parser_utils_1.isNumericI7)(mf.cosPhiKap)) {
+            const inductiveReactivePowerMf = Math.sqrt((Math.pow(activePowerMf, 2) - Math.pow(activePowerMf * mf.cosPhiInd, 2)) / Math.pow(mf.cosPhiInd, 2));
+            const capacitivereactivePowerMf = -1 * Math.sqrt((Math.pow(activePowerMf, 2) - Math.pow(activePowerMf * mf.cosPhiKap, 2)) / Math.pow(mf.cosPhiKap, 2));
+            reactivePowerMf = inductiveReactivePowerMf - capacitivereactivePowerMf;
+        }
+        else if ((0, parser_utils_1.isNumericI7)(mf.cosPhiInd)) {
+            //compute inductive reactive power
+            reactivePowerMf = Math.sqrt((Math.pow(activePowerMf, 2) - Math.pow(activePowerMf * mf.cosPhiInd, 2)) / Math.pow(mf.cosPhiInd, 2));
+        }
+        else if ((0, parser_utils_1.isNumericI7)(mf.cosPhiKap)) {
+            //compute capacitive reactive power
+            reactivePowerMf = -1 * Math.sqrt((Math.pow(activePowerMf, 2) - Math.pow(activePowerMf * mf.cosPhiKap, 2)) / Math.pow(mf.cosPhiKap, 2));
+        }
+    }
+    return [activePower, reactivePower, Math.abs(activePowerMf), Math.abs(reactivePowerMf)];
+}
+function getActiveReactivePower2(i7Data, mf) {
+    //TODO: Ticket bei INTEGRAL erstellen und erfragen, wie die Priorisierung bei der Anwendung der MF und p0, q0, s0, cosphi ist.
+    const flagInd = i7Data.flag_ind;
+    let s0 = (0, parser_utils_1.isNumericI7)(i7Data.s0) ? (0, parser_utils_1.convertToNumberI7)(i7Data.s0) : undefined;
+    const p0 = (0, parser_utils_1.isNumericI7)(i7Data.p0) ? (0, parser_utils_1.convertToNumberI7)(i7Data.p0) : undefined;
+    const cosPhi = (0, parser_utils_1.isNumericI7)(i7Data.cos_phi) ? (0, parser_utils_1.convertToNumberI7)(i7Data.cos_phi) : undefined;
+    const q0Ind = (0, parser_utils_1.isNumericI7)(i7Data.q0_ind) ? (0, parser_utils_1.convertToNumberI7)(i7Data.q0_ind) : undefined;
+    const q0Kap = (0, parser_utils_1.isNumericI7)(i7Data.q0_kap) ? (0, parser_utils_1.convertToNumberI7)(i7Data.q0_kap) : undefined;
+    const mf_p = mf ? mf.p : 1;
+    const mf_q0_ind = mf ? mf.qInd : 1;
+    const mf_q0_kap = mf ? mf.qKap : 1;
+    let q0 = undefined;
+    let activePower = undefined;
+    let activePowerMf = undefined;
+    let reactivePower = undefined;
+    let reactivePowerMf = undefined;
+    if ((0, parser_utils_1.isNumericI7)(p0) && !(0, parser_utils_1.isNumericI7)(q0Ind) && !(0, parser_utils_1.isNumericI7)(q0Kap) && !(0, parser_utils_1.isNumericI7)(s0) && !(0, parser_utils_1.isNumericI7)(cosPhi)) {
+        //Only p0 is given.
+        activePower = p0;
+        reactivePower = 0;
+        activePowerMf = activePower * mf_p;
+        reactivePowerMf = 0;
+    }
+    else if (!(0, parser_utils_1.isNumericI7)(p0) && ((0, parser_utils_1.isNumericI7)(q0Ind) || (0, parser_utils_1.isNumericI7)(q0Kap)) && !(0, parser_utils_1.isNumericI7)(s0) && !(0, parser_utils_1.isNumericI7)(cosPhi)) {
+        activePower = 0;
+        activePowerMf = 0;
+        if (q0Ind && q0Kap) {
+            reactivePower = q0Ind - q0Kap;
+            reactivePowerMf = q0Ind * mf_q0_ind - q0Kap * mf_q0_kap;
+        }
+        else if (q0Ind && !q0Kap) {
+            reactivePower = q0Ind;
+            reactivePowerMf = reactivePower * mf_q0_ind;
+        }
+        else {
+            reactivePower = q0Kap * -1;
+            reactivePowerMf = reactivePower * mf_q0_kap;
+        }
+    }
+    else if ((0, parser_utils_1.isNumericI7)(p0) && (0, parser_utils_1.isNumericI7)(cosPhi)) {
+        if (cosPhi <= 1 && cosPhi > 0) {
+            activePower = p0;
+        }
+        else if (cosPhi === 0) {
+            activePower = 0;
+        }
+        s0 = activePower / cosPhi;
+        q0 = Math.sqrt(Math.pow(s0, 2) - Math.pow(activePower, 2));
+        reactivePower = ((0, parser_utils_1.convertToBooleanI7)(i7Data.flag_ind) || (0, parser_utils_1.convertToBooleanI7)(i7Data.flag_ind) === undefined) ? q0 : q0 * -1;
+        if (mf) {
+            activePowerMf = activePower * mf_p;
+            reactivePowerMf = reactivePower * mf_p; //If p0 and cosphi is given then reactive power is directly proportional to mf_p.
+        }
+    }
+    else if ((0, parser_utils_1.isNumericI7)(p0) && (0, parser_utils_1.isNumericI7)(q0Ind) && (0, parser_utils_1.isNumericI7)(q0Kap)) {
+        activePower = p0;
+        activePowerMf = p0 * mf_p;
+        reactivePower = q0Ind - q0Kap;
+        reactivePowerMf = q0Ind * mf_q0_ind - q0Kap * mf_q0_kap;
+    }
+    else if (((0, parser_utils_1.isNumericI7)(q0Ind) || (0, parser_utils_1.isNumericI7)(q0Kap)) && (0, parser_utils_1.isNumericI7)(cosPhi)) {
+        if (q0Ind && q0Kap && (flagInd || flagInd === undefined)) {
+            reactivePower = q0Ind - q0Kap;
+            reactivePowerMf = q0Ind * mf_q0_ind - q0Kap * mf_q0_kap;
+        }
+        else if (q0Ind && !q0Kap) {
+            reactivePower = q0Ind;
+            reactivePowerMf = reactivePower * mf_q0_ind;
+        }
+        else {
+            reactivePower = q0Kap * -1;
+            reactivePowerMf = reactivePower * mf_q0_kap;
+        }
+        if (cosPhi < 1 && cosPhi >= 0) {
+            activePower = (reactivePower) / (Math.sqrt(1 / cosPhi - 1));
+        }
+        else if (cosPhi === 0) {
+            activePower = 0;
+        }
+    }
+    else if ((0, parser_utils_1.isNumericI7)(s0) && (0, parser_utils_1.isNumericI7)(cosPhi)) {
+        activePower = s0 * cosPhi;
+        activePowerMf = activePower * mf_p;
+        reactivePower = Math.sqrt(Math.pow(s0, 2) - Math.pow(activePower, 2));
+        reactivePowerMf = reactivePower * mf_p;
+    }
+    else if ((0, parser_utils_1.isNumericI7)(s0) && (0, parser_utils_1.isNumericI7)(p0)) {
+        activePower = p0;
+        activePowerMf = activePower * mf_p;
+        reactivePower = Math.sqrt(Math.pow(s0, 2) - Math.pow(activePower, 2));
+        reactivePowerMf = reactivePower * mf_p;
+    }
+    else if ((0, parser_utils_1.isNumericI7)(s0) && (0, parser_utils_1.isNumericI7)(q0Ind) && (0, parser_utils_1.isNumericI7)(q0Kap)) {
+        reactivePower = q0Ind - q0Kap;
+        reactivePowerMf = q0Ind * mf_q0_ind - q0Kap * mf_q0_kap;
+        activePower = (reactivePower) / (Math.sqrt(1 / cosPhi - 1));
+        activePowerMf = activePowerMf * mf_p;
+    }
+    else if ((0, parser_utils_1.isNumericI7)(p0) && ((0, parser_utils_1.isNumericI7)(q0Ind) || (0, parser_utils_1.isNumericI7)(q0Kap))) {
+        activePower = p0;
+        activePowerMf = p0 * mf_p;
+        if (q0Ind && !q0Kap) {
+            reactivePower = q0Ind;
+            reactivePowerMf = reactivePower * mf_q0_ind;
+        }
+        else {
+            reactivePower = q0Kap * -1;
+            reactivePowerMf = reactivePower * mf_q0_kap;
+        }
+    }
+    else if ((0, parser_utils_1.isNumericI7)(s0) && ((0, parser_utils_1.isNumericI7)(q0Ind) || (0, parser_utils_1.isNumericI7)(q0Kap))) {
+        if (q0Ind && !q0Kap) {
+            reactivePower = q0Ind;
+            reactivePowerMf = reactivePower * mf_q0_ind;
+        }
+        else {
+            reactivePower = q0Kap * -1;
+            reactivePowerMf = reactivePower * mf_q0_kap;
+        }
+        activePower = (reactivePower) / (Math.sqrt(1 / cosPhi - 1));
+        activePowerMf = activePowerMf * mf_p;
+    }
+    //Overwrite values for reactivePower, in case of mfcosPhiInd of mf.cosPhiKap is given.
+    if (mf && (mf.cosPhiInd || mf.cosPhiKap)) {
+        if (mf.cosPhiInd && mf.cosPhiKap) {
+            const inductiveReactivePowerMf = Math.sqrt((Math.pow(activePowerMf, 2) - Math.pow(activePowerMf * mf.cosPhiInd, 2)) / Math.pow(mf.cosPhiInd, 2));
+            const capacitivereactivePowerMf = -1 * Math.sqrt((Math.pow(activePowerMf, 2) - Math.pow(activePowerMf * mf.cosPhiKap, 2)) / Math.pow(mf.cosPhiKap, 2));
+            reactivePowerMf = inductiveReactivePowerMf - capacitivereactivePowerMf;
+        }
+        else if (mf.cosPhiInd) {
+            //compute inductive reactive power
+            reactivePowerMf = Math.sqrt((Math.pow(activePowerMf, 2) - Math.pow(activePowerMf * mf.cosPhiInd, 2)) / Math.pow(mf.cosPhiInd, 2));
+        }
+        else if (mf.cosPhiKap) {
+            //compute capacitive reactive power
+            reactivePowerMf = -1 * Math.sqrt((Math.pow(activePowerMf, 2) - Math.pow(activePowerMf * mf.cosPhiKap, 2)) / Math.pow(mf.cosPhiKap, 2));
+        }
+    }
+    return [activePower, reactivePower, activePowerMf, reactivePowerMf];
+}
+/**
+ * Computation of mechanical power.
+ * @param sr rated apparent power in MVA
+ * @param efficiency percent value between 0..1
+ * @param powerFactor float value between 0..1
+ * @returns ret_val mechanical power in MW
+ */
+function getPMech(sr, efficiency, powerFactor) {
+    let ret_val = undefined;
+    if (sr !== undefined && powerFactor !== undefined) {
+        ret_val = sr * powerFactor * efficiency;
+    }
+    return ret_val;
+}
+function getDescription(object) {
+    if (object)
+        return ueberpruefeZeichenkette(object.description);
+    else
+        return '';
+}
+function getNumber(value) {
+    const numberValue = parseFloat(value);
+    if (!isNaN(numberValue)) {
+        return value;
+    }
+    return 0;
+}
+function generateFuelType(name, type, generatingUnit, cimModel) {
+    const fossilFuel = new FossilFuel_1.FossilFuel(common_utils_1.CommonUtils.generateUUID(), name);
+    switch (type) {
+        case 'coal':
+            fossilFuel.fossilFuelType = FuelType_1.FuelType.coal;
+            break;
+        case 'oil':
+            fossilFuel.fossilFuelType = FuelType_1.FuelType.oil;
+            break;
+        case 'lignite':
+            fossilFuel.fossilFuelType = FuelType_1.FuelType.lignite;
+            break;
+        case 'hardCoal':
+            fossilFuel.fossilFuelType = FuelType_1.FuelType.hardCoal;
+            break;
+        case 'oilShale':
+            fossilFuel.fossilFuelType = FuelType_1.FuelType.oilShale;
+            break;
+        case 'gas':
+            fossilFuel.fossilFuelType = FuelType_1.FuelType.gas;
+            break;
+    }
+    // generatingUnit.addFossilFuel(fossilFuel);
+    fossilFuel.thermalGeneratingUnit = generatingUnit;
+    cimModel.addFossilFuel(fossilFuel);
+}
+function writeFile(filePath, data) {
+    fs.writeFile(filePath, (typeof data === 'string') ? data : JSON.stringify(data), function (err) {
+        if (err) {
+            this.logger.info(err);
+        }
+    });
+}
+function generateNodeStream(zip) {
+    return new Promise((resolve, reject) => {
+        try {
+            resolve({
+                status: 'successful', message: 'ok', data: zip.generateNodeStream({
+                    type: 'nodebuffer',
+                    streamFiles: true,
+                    compression: "DEFLATE",
+                    compressionOptions: {
+                        level: 5
+                    }
+                })
+            });
+        }
+        catch (e) {
+            reject({ status: 'error', message: e.toString() });
+        }
+    });
+}
+function writeZipFile(data, path) {
+    return new Promise((resolve, reject) => {
+        try {
+            data.pipe(fs.createWriteStream(path))
+                .on('finish', function () {
+                // JSZip generates a readable stream with a "end" event,
+                // but is piped here in a writable stream which emits a "finish" event.
+                resolve({ status: 'successful', message: 'ok' });
+            });
+        }
+        catch (e) {
+            reject({ status: 'error', message: e.toString() });
+        }
+    });
+}
+/*export function writeZipFile(zip: JSZip, path: string): Promise<any> {
+  return new Promise((resolve, reject) => {
+    try {
+      zip
+        .generateNodeStream({type: 'nodebuffer', streamFiles: true})
+        .pipe(fs.createWriteStream(path))
+        .on('finish', function () {
+          // JSZip generates a readable stream with a "end" event,
+          // but is piped here in a writable stream which emits a "finish" event.
+          resolve();
+        });
+    } catch (e) {
+
+    }
+
+  });
+}*/
+/** Integral 7 Exporter */
+function getSchemaValue(variantenNr, schemaId, map) {
+    for (const entry of map.entries()) {
+        if (entry[0].variantenNr === variantenNr && entry[0].schemaId === schemaId) {
+            return entry[1];
+        }
+    }
+    return undefined;
+}
+function determineEquipmentContainer(equipmentContainerType, equipmentContainer, cimModel) {
+    let ret_val;
+    switch (equipmentContainerType) {
+        case ('Bay'): {
+            if (equipmentContainer instanceof Bay_1.Bay) {
+                ret_val = equipmentContainer;
+            }
+            else {
+                ret_val = undefined;
+            }
+            break;
+        }
+        case ('VoltageLevel'): {
+            if (equipmentContainer instanceof Bay_1.Bay) {
+                ret_val = equipmentContainer.getVoltageLevel();
+            }
+            else if (equipmentContainer instanceof VoltageLevel_1.VoltageLevel) {
+                ret_val = equipmentContainer;
+            }
+            else {
+                ret_val = undefined;
+            }
+            break;
+        }
+        case ('Substation'): {
+            if (equipmentContainer instanceof Bay_1.Bay) {
+                const voltageLevel = equipmentContainer.getVoltageLevel();
+                const subst_uuid = voltageLevel?.getSubstationUUID();
+                ret_val = cimModel.getObject(subst_uuid);
+            }
+            else if (equipmentContainer instanceof VoltageLevel_1.VoltageLevel) {
+                ret_val = cimModel.getObject(equipmentContainer.getSubstationUUID());
+            }
+            else {
+                ret_val = equipmentContainer;
+            }
+            break;
+        }
+        default: {
+            ret_val = undefined;
+        }
+    }
+    return ret_val;
+}
+async function createTempDirPath() {
+    const fs = require('fs');
+    const os = require('os');
+    const path = require('path');
+    return new Promise((resolve, reject) => {
+        const tempPath = path.join(os.tmpdir(), 'i7-');
+        fs.mkdtemp(tempPath, (err, folder) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve(folder);
+            }
+        });
+    });
+}
+function getIntegral7IDs(cimObjects, UUID2IntegralID) {
+    const ids = [];
+    for (const key of cimObjects.keys()) {
+        if (UUID2IntegralID.has(key)) {
+            ids.push(...UUID2IntegralID.get(key));
+        }
+    }
+    return ids;
+}
+function putUUIDtoI7Ids(uuid, i7ID, UUID2IntegralID) {
+    if (UUID2IntegralID.has(uuid)) {
+        UUID2IntegralID.get(uuid).push(i7ID);
+    }
+    else {
+        UUID2IntegralID.set(uuid, [i7ID]);
+    }
+}
+function getPSRType(cimModel, name, configUuid) {
+    let psrType = cimModel.getPsrTypeByName(name);
+    if (!psrType) {
+        psrType = new PSRType_1.PSRType(common_utils_1.CommonUtils.generateUUIDv5(cim_class_names_1.ClassNames.PSRType, configUuid, name), name);
+        cimModel.addPsrType(psrType);
+    }
+    return psrType;
+}
+async function createWriteStreamPromise(writeStream) {
+    return new Promise((resolve, reject) => {
+        writeStream.end();
+        writeStream.close();
+        writeStream.on('close', async () => {
+            resolve({ status: 'successful', message: 'ok' });
+        });
+    });
+}
+function createRegulatingControl(uuid, name, enabled, unitMultiplier, mode) {
+    const regulatingControl = new RegulatingControl_1.RegulatingControl(uuid, name);
+    regulatingControl.enabled = enabled;
+    regulatingControl.targetValueUnitMultiplier = unitMultiplier;
+    regulatingControl.mode = mode;
+    return regulatingControl;
+}
+/**Calculate Zero Sequence Impedanzen
+ * @param scZeroSepImp real and imaginary parts of the measured short circuit impedances for the powertransformer endings.
+ * @param idleZeroSeqImp real and imaginary parts of the measured no load impedances for the powertransformer endings.
+ * @param baseVoltage rated voltages of the powertransformer endings.
+ * */
+function calculateComplexZeroSequImpedanzenTrafo(scZeroSeqImp, idleZeroSeqImp, baseVoltage, groundingCount, powerTransformer) {
+    if (powerTransformer.getUUID() === 'ded62507-64b1-4828-88bb-da99d9f7fd45') {
+        const stop = true;
+    }
+    const conversion_factor_ur = Math.pow(10, 3);
+    const ur1 = baseVoltage[0];
+    const ur2 = baseVoltage[1];
+    const ur3 = baseVoltage[2];
+    let r00r1 = (0, parser_utils_1.isNumericI7)(idleZeroSeqImp[0]) ? (0, parser_utils_1.convertToNumberI7)(idleZeroSeqImp[0]) : 0;
+    let r00r1_undef = idleZeroSeqImp[0] == undefined ? true : false;
+    let x00r1 = (0, parser_utils_1.isNumericI7)(idleZeroSeqImp[1]) ? (0, parser_utils_1.convertToNumberI7)(idleZeroSeqImp[1]) : 0;
+    let x00r1_undef = idleZeroSeqImp[1] == undefined ? true : false;
+    let r00r2 = (0, parser_utils_1.isNumericI7)(idleZeroSeqImp[2]) ? (0, parser_utils_1.convertToNumberI7)(idleZeroSeqImp[2]) : 0;
+    let r00r2_undef = idleZeroSeqImp[2] == undefined ? true : false;
+    let x00r2 = (0, parser_utils_1.isNumericI7)(idleZeroSeqImp[3]) ? (0, parser_utils_1.convertToNumberI7)(idleZeroSeqImp[3]) : 0;
+    let x00r2_undef = idleZeroSeqImp[3] == undefined ? true : false;
+    let r0kr1 = (0, parser_utils_1.isNumericI7)(scZeroSeqImp[0]) ? (0, parser_utils_1.convertToNumberI7)(scZeroSeqImp[0]) : 0;
+    let r0kr1_undef = scZeroSeqImp[0] == undefined ? true : false;
+    let x0kr1 = (0, parser_utils_1.isNumericI7)(scZeroSeqImp[1]) ? (0, parser_utils_1.convertToNumberI7)(scZeroSeqImp[1]) : 0;
+    let x0kr1_undef = scZeroSeqImp[1] == undefined ? true : false;
+    let r0kr2 = (0, parser_utils_1.isNumericI7)(scZeroSeqImp[2]) ? (0, parser_utils_1.convertToNumberI7)(scZeroSeqImp[2]) : 0; //not needed. overdetermined eq
+    let r0kr2_undef = scZeroSeqImp[2] == undefined ? true : false;
+    let x0kr2 = (0, parser_utils_1.isNumericI7)(scZeroSeqImp[3]) ? (0, parser_utils_1.convertToNumberI7)(scZeroSeqImp[3]) : 0; //not needed. overdetermined eq
+    let x0kr2_undef = scZeroSeqImp[3] == undefined ? true : false;
+    let z01 = new complex_js_1.default(r00r1, x00r1);
+    let z02 = new complex_js_1.default(r00r2, x00r2);
+    let z01k = new complex_js_1.default(r0kr1, x0kr1);
+    let z02k = new complex_js_1.default(r0kr2, x0kr2);
+    let incidents = 0;
+    const impedanz = {
+        r01: 0,
+        r02: 0,
+        r03: 0,
+        x01: 0,
+        x02: 0,
+        x03: 0
+    };
+    let ret_val = undefined;
+    switch (baseVoltage.length) {
+        case (2): { //two-winding-powertransformer
+            switch (groundingCount) {
+                case (0): {
+                    if (ur1 >= ur2) {
+                        impedanz['r01'] = powerTransformer.powerTransformerEnd[0]?.r;
+                        impedanz['r02'] = 0;
+                        impedanz['r03'] = undefined;
+                        impedanz['x01'] = powerTransformer.powerTransformerEnd[0]?.x;
+                        impedanz['x02'] = 0;
+                        impedanz['x03'] = undefined;
+                    }
+                    else {
+                        impedanz['r01'] = 0;
+                        impedanz['r02'] = powerTransformer.powerTransformerEnd[1]?.r;
+                        impedanz['r03'] = undefined;
+                        impedanz['x01'] = 0;
+                        impedanz['x02'] = powerTransformer.powerTransformerEnd[1]?.x;
+                        impedanz['x03'] = undefined;
+                    }
+                    break;
+                }
+                case (1): {
+                    if (ur1 >= ur2) {
+                        impedanz['r01'] = r00r1;
+                        impedanz['r02'] = 0;
+                        impedanz['r03'] = undefined;
+                        impedanz['x01'] = x00r1;
+                        impedanz['x02'] = 0;
+                        impedanz['x03'] = undefined;
+                    }
+                    else {
+                        impedanz['r01'] = 0;
+                        impedanz['r02'] = r00r2;
+                        impedanz['r03'] = undefined;
+                        impedanz['x01'] = 0;
+                        impedanz['x02'] = x00r2;
+                        impedanz['x03'] = undefined;
+                    }
+                    break;
+                }
+                case (2): {
+                    //recover missing measured impedances if possible
+                    if (z01k.mul(z02) != z02k.mul(z01)) {
+                        if (r00r1_undef && x00r1_undef) { //z01 not given
+                            z01 = (z01k.mul(z02)).div(z02k);
+                            r00r1 = z01.re;
+                            x00r1 = z01.im;
+                            incidents++;
+                        }
+                        if (r00r2_undef && x00r2_undef) { //z02 not given
+                            z02 = (z01.mul(z02k)).div(z01k);
+                            r00r2 = z02.re;
+                            x00r2 = z02.im;
+                            incidents++;
+                        }
+                        if (r0kr1_undef && x0kr1_undef) { //z01k not given
+                            z01k = (z01.mul(z02k)).div(z02);
+                            r0kr1 = z01k.re;
+                            x0kr1 = z01k.im;
+                            incidents++;
+                        }
+                        if (r0kr2_undef && x0kr2_undef) { //z02k not given
+                            z02k = (z01k.mul(z02)).div(z01);
+                            r0kr2 = z02k.re;
+                            x0kr2 = z02k.im;
+                            incidents++;
+                        }
+                    }
+                    //calculate impedances for conversion
+                    if (ur1 >= ur2) {
+                        const z01OHM = new complex_js_1.default(r00r1, x00r1);
+                        const z02OHM = new complex_js_1.default(r00r2, x00r2).mul((Math.pow(ur1 * conversion_factor_ur, 2)) / (Math.pow(ur2 * conversion_factor_ur, 2)));
+                        const zsOHM = new complex_js_1.default(r0kr1, x0kr1);
+                        const z_osOHM = z01OHM.sub(zsOHM);
+                        const z_msOHM = z02OHM.sub(zsOHM).mul((Math.pow(ur2 * conversion_factor_ur, 2)) / (Math.pow(ur1 * conversion_factor_ur, 2)));
+                        impedanz['r01'] = (0, parser_utils_1.isNumericI7)(z_osOHM.re) ? z_osOHM.re : 0;
+                        impedanz['r02'] = (0, parser_utils_1.isNumericI7)(z_msOHM.re) ? z_msOHM.re : 0;
+                        impedanz['r03'] = undefined;
+                        impedanz['x01'] = (0, parser_utils_1.isNumericI7)(z_osOHM.im) ? z_osOHM.im : 0;
+                        impedanz['x02'] = (0, parser_utils_1.isNumericI7)(z_msOHM.im) ? z_msOHM.im : 0;
+                        impedanz['x03'] = undefined;
+                    }
+                    else {
+                        const z01OHM = new complex_js_1.default(r00r2, x00r2);
+                        const z02OHM = new complex_js_1.default(r00r1, x00r1).mul((Math.pow(ur2 * conversion_factor_ur, 2)) / (Math.pow(ur1 * conversion_factor_ur, 2)));
+                        const zsOHM = new complex_js_1.default(r0kr1, x0kr1);
+                        const z_osOHM = z02OHM.sub(zsOHM).mul((Math.pow(ur1 * conversion_factor_ur, 2)) / (Math.pow(ur2 * conversion_factor_ur, 2)));
+                        const z_msOHM = z01OHM.sub(zsOHM);
+                        impedanz['r01'] = (0, parser_utils_1.isNumericI7)(z_msOHM.re) ? z_msOHM.re : 0;
+                        impedanz['r02'] = (0, parser_utils_1.isNumericI7)(z_osOHM.re) ? z_osOHM.re : 0;
+                        impedanz['r03'] = undefined;
+                        impedanz['x01'] = (0, parser_utils_1.isNumericI7)(z_msOHM.im) ? z_msOHM.im : 0;
+                        impedanz['x02'] = (0, parser_utils_1.isNumericI7)(z_osOHM.im) ? z_osOHM.im : 0;
+                        impedanz['x03'] = undefined;
+                    }
+                    break;
+                }
+            }
+            ret_val = impedanz;
+            break;
+        }
+        case (3): { //three-winding-powertransformer
+            switch (groundingCount) {
+                case (0): {
+                    impedanz['r01'] = powerTransformer.powerTransformerEnd[0]?.r;
+                    impedanz['r02'] = powerTransformer.powerTransformerEnd[1]?.r;
+                    impedanz['r03'] = powerTransformer.powerTransformerEnd[2]?.r;
+                    impedanz['x01'] = powerTransformer.powerTransformerEnd[0]?.x;
+                    impedanz['x02'] = powerTransformer.powerTransformerEnd[1]?.x;
+                    impedanz['x03'] = powerTransformer.powerTransformerEnd[2]?.x;
+                    break;
+                }
+                case (1): {
+                    let z_osOHM = undefined;
+                    let z_msOHM = undefined;
+                    let z_usOHM = undefined;
+                    if (ur1 >= ur2) {
+                        z_osOHM = new complex_js_1.default(r00r1, x00r1);
+                        z_msOHM = z_osOHM.div(2).mul(Math.pow(ur2 / ur1, 2) /**100*/);
+                        z_usOHM = z_osOHM.div(2).mul(Math.pow(ur3 / ur1, 2) /**100*/);
+                    }
+                    else {
+                        z_msOHM = new complex_js_1.default(r00r2, x00r2);
+                        z_osOHM = z_osOHM.div(2).mul(Math.pow(ur1 / ur2, 2) /**100*/);
+                        z_usOHM = z_osOHM.div(2).mul(Math.pow(ur3 / ur2, 2) /**100*/);
+                    }
+                    impedanz['r01'] = z_osOHM.re;
+                    impedanz['r02'] = z_msOHM.re;
+                    impedanz['r03'] = z_usOHM.re;
+                    impedanz['x01'] = z_osOHM.im;
+                    impedanz['x02'] = z_msOHM.im;
+                    impedanz['x03'] = z_usOHM.im;
+                    break;
+                }
+                case (2): {
+                    if (z01k.mul(z02) != z02k.mul(z01)) {
+                        if (r00r1_undef && x00r1_undef) { //z01 not given
+                            z01 = (z01k.mul(z02)).div(z02k);
+                            r00r1 = z01.re;
+                            x00r1 = z01.im;
+                            incidents++;
+                        }
+                        if (r00r2_undef && x00r2_undef) { //z02 not given
+                            z02 = (z01.mul(z02k)).div(z01k);
+                            r00r2 = z02.re;
+                            x00r2 = z02.im;
+                            incidents++;
+                        }
+                        if (r0kr1_undef && x0kr1_undef) { //z01k not given
+                            z01k = (z01.mul(z02k)).div(z02);
+                            r0kr1 = z01k.re;
+                            x0kr1 = z01k.im;
+                            incidents++;
+                        }
+                        if (r0kr2_undef && x0kr2_undef) { //z02k not given
+                            z02k = (z01k.mul(z02)).div(z01);
+                            r0kr2 = z02k.re;
+                            x0kr2 = z02k.im;
+                            incidents++;
+                        }
+                    }
+                    if (ur1 >= ur2) {
+                        const z01OHM = new complex_js_1.default(r00r1, x00r1);
+                        const z02OHM = new complex_js_1.default(r00r2, x00r2).mul((Math.pow(ur1 * conversion_factor_ur, 2)) / (Math.pow(ur2 * conversion_factor_ur, 2)));
+                        const zsOHM = new complex_js_1.default(r0kr1, x0kr1);
+                        const ztOHM = (z02OHM.mul(z01OHM.sub(zsOHM))).sqrt();
+                        const z_osOHM = z01OHM.sub(ztOHM);
+                        const z_msOHM = z02OHM.sub(ztOHM).mul((Math.pow(ur2 * conversion_factor_ur, 2)) / (Math.pow(ur1 * conversion_factor_ur, 2)));
+                        const z_usOHM = ztOHM.mul((Math.pow(ur3 * conversion_factor_ur, 2)) / (Math.pow(ur1 * conversion_factor_ur, 2)));
+                        impedanz['r01'] = (0, parser_utils_1.isNumericI7)(z_osOHM.re) ? z_osOHM.re : 0;
+                        impedanz['r02'] = (0, parser_utils_1.isNumericI7)(z_msOHM.re) ? z_msOHM.re : 0;
+                        impedanz['r03'] = (0, parser_utils_1.isNumericI7)(z_usOHM.re) ? z_usOHM.re : 0;
+                        impedanz['x01'] = (0, parser_utils_1.isNumericI7)(z_osOHM.im) ? z_osOHM.im : 0;
+                        impedanz['x02'] = (0, parser_utils_1.isNumericI7)(z_msOHM.im) ? z_msOHM.im : 0;
+                        impedanz['x03'] = (0, parser_utils_1.isNumericI7)(z_usOHM.im) ? z_usOHM.im : 0;
+                    }
+                    else {
+                        const z01OHM = new complex_js_1.default(r00r2, x00r2);
+                        const z02OHM = new complex_js_1.default(r00r1, x00r1).mul((Math.pow(ur2 * conversion_factor_ur, 2)) / (Math.pow(ur1 * conversion_factor_ur, 2)));
+                        const zsOHM = new complex_js_1.default(r0kr1, x0kr1);
+                        const ztOHM = (z02OHM.mul(z01OHM.sub(zsOHM))).sqrt();
+                        const z_osOHM = z01OHM.sub(ztOHM);
+                        const z_msOHM = z02OHM.sub(ztOHM).mul((Math.pow(ur1 * conversion_factor_ur, 2)) / (Math.pow(ur2 * conversion_factor_ur, 2)));
+                        const z_usOHM = ztOHM.mul((Math.pow(ur3 * conversion_factor_ur, 2)) / (Math.pow(ur2 * conversion_factor_ur, 2)));
+                        impedanz['r01'] = (0, parser_utils_1.isNumericI7)(z_msOHM.re) ? z_msOHM.re : 0;
+                        impedanz['r02'] = (0, parser_utils_1.isNumericI7)(z_osOHM.re) ? z_osOHM.re : 0;
+                        impedanz['r03'] = (0, parser_utils_1.isNumericI7)(z_usOHM.re) ? z_usOHM.re : 0;
+                        impedanz['x01'] = (0, parser_utils_1.isNumericI7)(z_msOHM.im) ? z_msOHM.im : 0;
+                        impedanz['x02'] = (0, parser_utils_1.isNumericI7)(z_osOHM.im) ? z_osOHM.im : 0;
+                        impedanz['x03'] = (0, parser_utils_1.isNumericI7)(z_usOHM.im) ? z_usOHM.im : 0;
+                    }
+                    ret_val = impedanz;
+                    break;
+                }
+                case (3): {
+                    impedanz['r01'] = powerTransformer.powerTransformerEnd[0]?.r;
+                    impedanz['r02'] = powerTransformer.powerTransformerEnd[1]?.r;
+                    impedanz['r03'] = powerTransformer.powerTransformerEnd[2]?.r;
+                    impedanz['x01'] = powerTransformer.powerTransformerEnd[0]?.x;
+                    impedanz['x02'] = powerTransformer.powerTransformerEnd[1]?.x;
+                    impedanz['x03'] = powerTransformer.powerTransformerEnd[2]?.x;
+                    break;
+                }
+            }
+        }
+        default: {
+            ret_val = impedanz;
+        }
+    }
+    //calculation with complex numbers
+    return [ret_val, incidents <= 1];
+}
+function getGroundingCountFromWindingConnection(powerTransformer) {
+    let retVal = undefined;
+    let count = 0;
+    let count2 = 0;
+    let count3 = 0;
+    let powerTransformerEndCount = powerTransformer.powerTransformerEnd.length;
+    switch (powerTransformerEndCount) {
+        case (2): {
+            const powerTransformerEnd1 = powerTransformer.powerTransformerEnd[0];
+            const powerTransformerEnd2 = powerTransformer.powerTransformerEnd[1];
+            count = (powerTransformerEnd1.connectionKind.match('Y')?.length ? powerTransformerEnd1.connectionKind.match('Y')?.length : 0);
+            if (count == 0) {
+                count = (powerTransformerEnd1.connectionKind.match('Z')?.length ? powerTransformerEnd1.connectionKind.match('Z')?.length : 0);
+            }
+            count2 = (powerTransformerEnd2.connectionKind.match('Y')?.length ? powerTransformerEnd2.connectionKind.match('Y')?.length : 0);
+            if (count2 == 0) {
+                count2 = (powerTransformerEnd2.connectionKind.match('Z')?.length ? powerTransformerEnd2.connectionKind.match('Z')?.length : 0);
+            }
+            retVal = count + count2;
+            break;
+        }
+        case (3): {
+            const powerTransformerEnd1 = powerTransformer.powerTransformerEnd[0];
+            const powerTransformerEnd2 = powerTransformer.powerTransformerEnd[1];
+            const powerTransformerEnd3 = powerTransformer.powerTransformerEnd[2];
+            count = (powerTransformerEnd1.connectionKind.match('Y')?.length ? powerTransformerEnd1.connectionKind.match('Y')?.length : 0);
+            if (count == 0) {
+                count = (powerTransformerEnd1.connectionKind.match('Z')?.length ? powerTransformerEnd1.connectionKind.match('Z')?.length : 0);
+            }
+            count2 = (powerTransformerEnd2.connectionKind.match('Y')?.length ? powerTransformerEnd2.connectionKind.match('Y')?.length : 0);
+            if (count2 == 0) {
+                count2 = (powerTransformerEnd2.connectionKind.match('Z')?.length ? powerTransformerEnd2.connectionKind.match('Z')?.length : 0);
+            }
+            count3 = (powerTransformerEnd3.connectionKind.match('Y')?.length ? powerTransformerEnd3.connectionKind.match('Y')?.length : 0);
+            if (count3 == 0) {
+                count3 = (powerTransformerEnd3.connectionKind.match('Z')?.length ? powerTransformerEnd3.connectionKind.match('Z')?.length : 0);
+            }
+            retVal = count + count2 + count3;
+            break;
+        }
+        default:
+            retVal = 0;
+    }
+    return retVal;
+}
+function getSpannungsband(propName, knotenSpannungsband, defaultValue) {
+    if (knotenSpannungsband) {
+        switch (propName) {
+            case 'usoll': {
+                if ((0, parser_utils_1.isNumericI7)(knotenSpannungsband.usoll)) {
+                    return knotenSpannungsband.usoll;
+                }
+                else {
+                    const usoll = (knotenSpannungsband.umax + knotenSpannungsband.umin) / 2;
+                    if ((0, parser_utils_1.isNumericI7)(usoll) && isFinite(usoll)) {
+                        return usoll;
+                    }
+                    else {
+                        return defaultValue;
+                    }
+                }
+            }
+            case 'umax': {
+                if ((0, parser_utils_1.isNumericI7)(knotenSpannungsband.umax)) {
+                    return knotenSpannungsband.umax;
+                }
+                else {
+                    return defaultValue;
+                }
+            }
+            case 'umin': {
+                if ((0, parser_utils_1.isNumericI7)(knotenSpannungsband.umin)) {
+                    return knotenSpannungsband.umin;
+                }
+                else {
+                    return defaultValue;
+                }
+            }
+            default: {
+                return knotenSpannungsband.usoll;
+            }
+        }
+    }
+    else {
+        return defaultValue;
+    }
+}
+/**
+ * @param zpu per unit impedance
+ * @param ur rated voltage in kV
+ * @param sr rated apparent power in MVA */
+function calculatePU2OHM(zpu, ur, sr) {
+    const conversion_factor_ur = Math.pow(10, 3);
+    const conversion_factor_sr = Math.pow(10, 6);
+    let ret_val = undefined;
+    try {
+        ret_val = zpu * Math.pow((ur * conversion_factor_ur), 2) / (sr * conversion_factor_sr);
+    }
+    catch (e) {
+        ret_val = undefined;
+    }
+    ret_val = Number.isNaN(ret_val) ? undefined : ret_val;
+    ret_val = Number.isFinite(ret_val) ? ret_val : 0;
+    return ret_val;
+}
+function getSpannungSchluessel(value) {
+    let retVal = undefined;
+    if (value.split('.').length == 1) {
+        retVal = Number.parseFloat(value).toFixed(1);
+    }
+    else if (value.split('.').length > 1) {
+        const decimal = value.split('.')[1];
+        if (decimal.length == 1) {
+            retVal = value;
+        }
+        else if (decimal.length == 2 && Number.parseInt(decimal[0]) == 0 && Number.parseInt(decimal[1]) == 1) {
+            retVal = Number.parseFloat(value).toFixed(1);
+        }
+        else if (decimal.length >= 3 && Number.parseInt(decimal[0]) == 0 && Number.parseInt(decimal[1]) == 1 && Number.parseInt(decimal.substring(2, decimal.length)) == 0) {
+            retVal = Number.parseFloat(value).toFixed(1);
+        }
+        else if (decimal.length > 2 && Number.parseInt(decimal[0]) == 0 && Number.parseInt(decimal[1]) == 0) {
+            retVal = Number.parseFloat(value).toFixed(1);
+        }
+        else {
+            retVal = Number.parseFloat(value).toFixed(2);
+        }
+    }
+    return retVal;
+}
+//# sourceMappingURL=utils.js.map