@enervance/insight-cim-model 0.0.277 → 0.0.279

package/dist/analysis/powerflow/powerflow.util.js

@@ -0,0 +1,1466 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getKrInfo = exports.PowerflowUtil = void 0;
+const ExternalNetworkInjection_1 = require("../../model/wires/ExternalNetworkInjection.js");
+const SynchronousMachine_1 = require("../../model/wires/SynchronousMachine.js");
+const PowerTransformer_1 = require("../../model/wires/PowerTransformer.js");
+const ACLineSegment_1 = require("../../model/wires/ACLineSegment.js");
+const EnergySource_1 = require("../../model/wires/EnergySource.js");
+const EnergyConsumer_1 = require("../../model/wires/EnergyConsumer.js");
+const ConnectivityNode_1 = require("../../model/core/ConnectivityNode.js");
+const TopologicalNode_1 = require("../../model/topology/TopologicalNode.js");
+const cim_model_assetinfo_util_1 = require("../../utils2/cim.model.assetinfo.util.js");
+const common_utils_1 = require("../../utils2/common.utils.js");
+const cim_constants_1 = require("../../constants/cim-constants.js");
+const Switch_1 = require("../../model/wires/Switch.js");
+const EquivalentBranch_1 = require("../../model/equivalents/EquivalentBranch.js");
+const LinearShuntCompensator_1 = require("../../model/wires/LinearShuntCompensator.js");
+class PowerflowUtil {
+    /**
+     * Ermittelt alle elektrischverbundene Elemente eines Netzes
+     * @param modelContainer das Netz als CIM Modell
+     * */
+    static getInterconnectedGrids(modelContainer, withSwitchSates = false) {
+        const results = new Array();
+        const visitedUUIDs = new Map();
+        let nextCn = PowerflowUtil.getNextNode(modelContainer.connectivityNodes, visitedUUIDs);
+        while (nextCn) {
+            const objectsFound = PowerflowUtil.breadthFirstSearch(nextCn, withSwitchSates);
+            const interconnectedGridElements = [...objectsFound.values()];
+            results.push({
+                interconnectedGridElements,
+                computabe: PowerflowUtil.isGridComputable(interconnectedGridElements),
+                interconnectedGridCounter: results.length + 1
+            });
+            for (const object of objectsFound.values()) {
+                visitedUUIDs.set(object.getUUID(), object);
+            }
+            nextCn = PowerflowUtil.getNextNode(modelContainer.connectivityNodes, visitedUUIDs);
+        }
+        return results;
+    }
+    static breadthFirstSearch(startCN, withSwitchSates = false) {
+        // const objectsFound = new Array<IConnectivityNode | IConductingEquipment>();
+        const objectsFound = new Map();
+        let nodesOnCurrentLevel = new Array();
+        let nodesOnNextLevel = new Array(startCN);
+        let terminalVisited = new Map();
+        let counter = 0;
+        while (nodesOnNextLevel.length) {
+            nodesOnCurrentLevel.length = 0;
+            nodesOnCurrentLevel = [...nodesOnNextLevel];
+            /** next level nodes leeren */
+            nodesOnNextLevel.length = 0;
+            for (const currentNode of nodesOnCurrentLevel) {
+                objectsFound.set(currentNode.getUUID(), currentNode);
+                // nodesVisited.push(currentNode.getUUID());
+                for (const terminal of currentNode.terminals.values()) {
+                    if (!terminal)
+                        continue;
+                    if (withSwitchSates && !terminal.isClosed())
+                        continue;
+                    /** Terminal traversierbar und nicht besucht */
+                    if (terminalVisited.has(terminal.getUUID()))
+                        continue;
+                    terminalVisited.set(terminal.getUUID(), terminal);
+                    const terminalConductingEquipment = terminal.conductingEquipment;
+                    if (!terminalConductingEquipment)
+                        continue;
+                    if (withSwitchSates && !terminal.isClosed())
+                        continue;
+                    if (!objectsFound.has(terminalConductingEquipment === null || terminalConductingEquipment === void 0 ? void 0 : terminalConductingEquipment.getUUID())) {
+                        nodesOnNextLevel.push(terminalConductingEquipment);
+                    }
+                    const terminalConnectivityNode = terminal.connectivityNode;
+                    if (!terminalConnectivityNode)
+                        continue;
+                    if (!objectsFound.has(terminalConnectivityNode.getUUID())) {
+                        nodesOnNextLevel.push(terminalConnectivityNode);
+                    }
+                }
+            }
+        }
+        return objectsFound;
+    }
+    /**
+     * bestimmt den nächsten unbesuchten Knoten für die Breitensuche.
+     * @param connectivityNodes alle ConnectivityNodes eines Netzmodells
+     * @param visitedUUIDs UUIDs aller abgearbeiteten Elemente
+     * */
+    static getNextNode(connectivityNodes, visitedUUIDs) {
+        return [...connectivityNodes.values()].find(it => !visitedUUIDs.has(it.getUUID()));
+    }
+    /** Prüft, ob das Netz rechenfähig ist. */
+    static isGridComputable(network) {
+        if (PowerflowUtil.isGeneratorsExists(network)) {
+            if (PowerflowUtil.isEnergySourcesConsumersExists(network)) {
+                if (PowerflowUtil.isBranchExists(network)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /** Prüft, ob im Teilnetz eine Slacks/Generators vorhanden sind */
+    static isGeneratorsExists(network) {
+        const t = network.find(it => (it instanceof ExternalNetworkInjection_1.ExternalNetworkInjection || it instanceof SynchronousMachine_1.SynchronousMachine));
+        return t ? true : false;
+    }
+    /** Prüft, ob im Teilnetz eine Slacks/Generators vorhanden sind */
+    static isBranchExists(network) {
+        const t = network.find(it => (it instanceof ACLineSegment_1.ACLineSegment || it instanceof PowerTransformer_1.PowerTransformer));
+        return t ? true : false;
+        //return network.find(it => (it instanceof ACLineSegment || it instanceof PowerTransformer)) ? true : false;
+    }
+    //Prüft, ob im Teilnetz NetzLasten/-einspeisungen vorhanden sind
+    static isEnergySourcesConsumersExists(network) {
+        const t = network.find(it => (it instanceof EnergySource_1.EnergySource || it instanceof EnergyConsumer_1.EnergyConsumer));
+        return t ? true : false;
+        // return network.find(it => (it instanceof EnergySource || it instanceof EnergyConsumer)) ? true : false;
+    }
+    static convertCIM2PandaPowerNetwork(network, nodeType, pandaDataFrame, defaultsConfig) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z;
+        const uuidToIndex = new Map();
+        const snMVA = pandaDataFrame._object.sn_mva;
+        /** key uuid -> (Typ EnergyConsumer/EnergySource => Objekte)*/
+        const tpLoadsNfeeders = new Map();
+        /** Buselemente anlegen */
+        const cimNodes = network.filter(it => it.constructor.name.includes(nodeType));
+        const busData = pandaDataFrame._object.bus._object;
+        for (const cimNode of cimNodes) {
+            const ppNodeType = 'b'; // per default Station
+            const baseV = PowerflowUtil.getBaseVoltageAsNumber(cimNode);
+            const baseVoltage = baseV <= 0 ? defaultsConfig.data.line.default_u : baseV;
+            /** name, vn_kv, type, zone, in_service, description, substat,f older_id,sernum,for_name,chr_name,pf_converged,pf_name,geo */
+            const bus = [
+                cimNode.mrid,
+                baseVoltage,
+                ppNodeType,
+                1,
+                true,
+                '',
+                '',
+                '',
+                '',
+                '',
+                '',
+                false,
+                cimNode.mrid,
+                null
+            ];
+            busData.data.push(bus);
+            if (cimNode.getUUID() === '5fa34a72-d1f0-4abc-b3ad-5e5a4b2e7fc7') {
+                console.log();
+            }
+            const idx = busData.data.length - 1;
+            busData.index.push(idx);
+            uuidToIndex.set(cimNode.mrid, idx);
+            // TODO refactoring/überarbeiten
+            const loadsNfeeders = new Map();
+            if (nodeType === 'ConnectivityNode') {
+                cimNode.determineLoadNFeeder(loadsNfeeders);
+            }
+            else {
+                cimNode.determineLoadNFeeder(loadsNfeeders);
+            }
+            tpLoadsNfeeders.set(cimNode.mrid, loadsNfeeders);
+        }
+        /** Lasten anlegen */
+        const loadData = pandaDataFrame._object.load._object;
+        for (const entry of tpLoadsNfeeders.entries()) {
+            const loadsNfeeders = entry[1];
+            for (const entry of loadsNfeeders.entries()) {
+                const key = entry[0];
+                if (key.includes('EnergyConsumer')) {
+                    const valuesArr = entry[1];
+                    for (let i = 0; i < valuesArr.length; i++) {
+                        const energyConsumer = valuesArr[i];
+                        for (const terminalValue of energyConsumer.terminals.values()) {
+                            const connectedNode = terminalValue.getConnectedNode();
+                            const busID = uuidToIndex.get(connectedNode === null || connectedNode === void 0 ? void 0 : connectedNode.mrid);
+                            if (!busID)
+                                continue;
+                            const p = energyConsumer.getP();
+                            const q = energyConsumer.getQ();
+                            const costPhi = energyConsumer.getCosPhi();
+                            /**  name, bus, p_mw,  q_mvar, const_z_percent,  const_i_percent, sn_mva, scaling, in_service,type, init_p_mw, init_q_mvar, cos_phi */
+                            const load = [
+                                energyConsumer.mrid,
+                                busID,
+                                p,
+                                q,
+                                0,
+                                0,
+                                snMVA,
+                                PowerflowUtil.scalingFactor,
+                                true,
+                                null,
+                                p,
+                                q,
+                                costPhi // cos_phi
+                            ];
+                            loadData.data.push(load);
+                            loadData.index.push(loadData.data.length - 1);
+                        }
+                    }
+                }
+            }
+        }
+        /** Ersatzleistungszahl */
+        const krInfo = getKrInfo(tpLoadsNfeeders);
+        const sgenData = pandaDataFrame._object.sgen._object;
+        /** Generatoren anlegen */
+        const genData = pandaDataFrame._object.gen._object;
+        /** Einspeisungen anlegen */
+        for (const loadsNfeeders of tpLoadsNfeeders.values()) {
+            for (const entry of loadsNfeeders.entries()) {
+                const key = entry[0];
+                const valuesArr = entry[1];
+                if (key.includes('EnergySource')) {
+                    for (let i = 0; i < valuesArr.length; i++) {
+                        const energySource = valuesArr[i];
+                        if (PowerflowUtil.synchronousMachineUUIDs.includes(energySource.getUUID()))
+                            continue;
+                        for (const terminalValue of energySource.terminals.values()) {
+                            const connectedNode = terminalValue.getConnectedNode();
+                            const busID = uuidToIndex.get(connectedNode === null || connectedNode === void 0 ? void 0 : connectedNode.mrid);
+                            if (busID !== undefined) {
+                                // "name","bus","p_mw","q_mvar",
+                                // "name","bus","p_mw","q_mvar","sn_mva","scaling","in_service","type","current_source", in_service_date
+                                // [1, 0.0, 0.0,false,true,null,21.7,12.7,1.0,null,null];
+                                // const sgen: any[] = [energySource.mrid, busID, p, q,  0, 1, true, (energySource.psrType?.name ?? ''), false, inServiceDate];
+                                let p = isNaN(energySource.activePower) ? 0 : energySource.activePower;
+                                let q = isNaN(energySource.reactivePower) ? 0 : energySource.reactivePower;
+                                const inServiceDate = (_a = energySource.getAsset()) === null || _a === void 0 ? void 0 : _a.getInServiceDate();
+                                const isGenerator = energySource.kr > 0;
+                                if (isGenerator) {
+                                    const baseVoltage = PowerflowUtil.getBaseVoltageAsNumber(connectedNode);
+                                    const slackWeight = energySource.kr / (krInfo === null || krInfo === void 0 ? void 0 : krInfo.krSum);
+                                    /** name, bus, vm_pu, va_degree, slack_weight, in_service, s_sc_max_mva,s_sc_min_mva,rx_min,rx_max,r0x0_max,x0x_max,r0x0_min,x0x_min,description */
+                                    const gen = [
+                                        energySource.getUUID(),
+                                        busID,
+                                        //p < 0 ? p * -1 : p, // p_mw
+                                        0,
+                                        1,
+                                        snMVA,
+                                        0,
+                                        0,
+                                        1,
+                                        //genWithHighestPrio?.getUUID() === synchronousMachine.getUUID() ? true : false, // slack
+                                        false,
+                                        true,
+                                        slackWeight ? slackWeight : 0,
+                                        'sync',
+                                        energySource.key
+                                    ]; // min_p_mw
+                                    genData.data.push(gen);
+                                    genData.index.push(genData.data.length - 1);
+                                }
+                                /** "name, bus, p_mw, q_mvar,sn_mva,scaling,in_service,type,current_source, in_service_date */
+                                const sgen = [
+                                    energySource.mrid,
+                                    busID,
+                                    p, q,
+                                    snMVA,
+                                    PowerflowUtil.scalingFactorRn,
+                                    true,
+                                    ((_c = (_b = energySource.psrType) === null || _b === void 0 ? void 0 : _b.name) !== null && _c !== void 0 ? _c : ''),
+                                    false,
+                                    inServiceDate
+                                ];
+                                sgenData.data.push(sgen);
+                                sgenData.index.push(sgenData.data.length - 1);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        /** Slacks */
+        const extNetData = pandaDataFrame._object.ext_grid._object;
+        const generators = network.filter(it => it instanceof SynchronousMachine_1.SynchronousMachine);
+        const generatorsWithoutControl = generators.filter(it => { var _a; return !((_a = it.regulatingControl) === null || _a === void 0 ? void 0 : _a.targetValue) && !it.generatingUnit; });
+        const genWithHighestPrio = generators.reduce((highest, current) => highest.referencePriority > current.referencePriority ? highest : current);
+        for (const synchronousMachine of krInfo.gensWithKrOnly) {
+            const str = `${synchronousMachine.mrid} ${synchronousMachine.key}`;
+            // TODO
+            console.log('GensWithKrOnly ist nicht implementiert', str);
+        }
+        for (const synchronousMachine of krInfo.gensWithTargetVoltageKr) {
+            const str = `${synchronousMachine.mrid}${synchronousMachine.key}`;
+            if (PowerflowUtil.synchronousMachineUUIDs.includes(synchronousMachine.getUUID()))
+                continue;
+            for (const terminalValue of synchronousMachine.terminals.values()) {
+                const connectedNode = terminalValue.getConnectedNode();
+                const busID = uuidToIndex.get(connectedNode === null || connectedNode === void 0 ? void 0 : connectedNode.mrid);
+                if (!busID) {
+                    console.log(`${str} keine BusID`);
+                    continue;
+                }
+                const baseVoltage = PowerflowUtil.getBaseVoltageAsNumber(connectedNode);
+                const targetValue = synchronousMachine.regulatingControl.targetValue;
+                const targetVoltage = targetValue / baseVoltage;
+                const p = synchronousMachine.p || 0;
+                if (synchronousMachine.controlEnabled === false) {
+                    console.log(`${str} kein controlEnabled`);
+                    continue;
+                }
+                const isSlack = (genWithHighestPrio === null || genWithHighestPrio === void 0 ? void 0 : genWithHighestPrio.getUUID()) === synchronousMachine.getUUID();
+                const generatingUnit = synchronousMachine.generatingUnit;
+                /** KR-Zahl => (governorSCD * nominalP ) / (100 * 50hz)  */
+                const kr = generatingUnit ? ((generatingUnit.governorSCD * generatingUnit.nominalP) / (100 * 50)) : 0;
+                const slackWeight = kr / (krInfo === null || krInfo === void 0 ? void 0 : krInfo.krSum);
+                if (isSlack) {
+                    if (p !== 0) {
+                        /** "name, bus, p_mw, q_mvar, sn_mva, scaling, in_service, type, current_source, in_service_date */
+                        const sgen = [
+                            common_utils_1.CommonUtils.generateUUID(),
+                            busID,
+                            p,
+                            0,
+                            snMVA,
+                            1,
+                            true,
+                            '',
+                            false,
+                            null // in_service_date
+                        ];
+                        sgenData.data.push(sgen);
+                        sgenData.index.push(sgenData.data.length - 1);
+                    }
+                    /** name, bus, vm_pu, va_degree, slack_weight, in_service, s_sc_max_mva,s_sc_min_mva,rx_min,rx_max,r0x0_max,x0x_max,r0x0_min,x0x_min,description */
+                    const slack = [
+                        synchronousMachine.getUUID(),
+                        busID,
+                        targetVoltage,
+                        0,
+                        slackWeight ? slackWeight : 0,
+                        true,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        '',
+                        synchronousMachine.key
+                    ]; // key
+                    extNetData.data.push(slack);
+                    extNetData.index.push(extNetData.data.length - 1);
+                }
+                else {
+                    /**  name,bus,p_mw,vm_pu,sn_mva,min_q_mvar,max_q_mvar,scaling,slack,in_service,slack_weight,type*/
+                    const gen = [
+                        synchronousMachine.getUUID(),
+                        busID,
+                        //p < 0 ? p * -1 : p, // p_mw
+                        p,
+                        targetVoltage,
+                        snMVA,
+                        synchronousMachine.minQ,
+                        synchronousMachine.maxQ,
+                        1,
+                        //genWithHighestPrio?.getUUID() === synchronousMachine.getUUID() ? true : false, // slack
+                        true,
+                        true,
+                        slackWeight ? slackWeight : 0,
+                        'sync',
+                        synchronousMachine.key
+                    ]; // min_p_mw
+                    genData.data.push(gen);
+                    genData.index.push(genData.data.length - 1);
+                }
+            }
+        }
+        for (const synchronousMachine of generatorsWithoutControl) {
+            if (PowerflowUtil.synchronousMachineUUIDs.includes(synchronousMachine.getUUID()))
+                continue;
+            for (const terminalValue of synchronousMachine.terminals.values()) {
+                const connectedNode = terminalValue.getConnectedNode();
+                const busID = uuidToIndex.get(connectedNode === null || connectedNode === void 0 ? void 0 : connectedNode.mrid);
+                if (busID !== undefined) {
+                    // "name","bus","p_mw","q_mvar",
+                    // "name","bus","p_mw","q_mvar","sn_mva","scaling","in_service","type","current_source", in_service_date
+                    // [1, 0.0, 0.0,false,true,null,21.7,12.7,1.0,null,null];
+                    // const sgen: any[] = [energySource.mrid, busID, p, q,  0, 1, true, (energySource.psrType?.name ?? ''), false, inServiceDate];
+                    let p = isNaN(synchronousMachine.p) ? 0 : synchronousMachine.p;
+                    let q = isNaN(synchronousMachine.q) ? 0 : synchronousMachine.q;
+                    /** "name, bus, p_mw, q_mvar,sn_mva,scaling,in_service,type,current_source, in_service_date */
+                    const sgen = [
+                        synchronousMachine.mrid,
+                        busID,
+                        p, q,
+                        snMVA,
+                        1,
+                        true,
+                        '',
+                        false,
+                        null
+                    ];
+                    sgenData.data.push(sgen);
+                    sgenData.index.push(sgenData.data.length - 1);
+                }
+            }
+        }
+        /*for (const loadsNfeeders of tpLoadsNfeeders.values()) {
+          for (const entry of loadsNfeeders.entries()) {
+            const key = entry[0];
+            if (key.includes('SynchronousMachine')) {
+              const valuesArr = entry[1];
+              for (let i = 0; i < valuesArr.length; i++) {
+    
+                const synchronousMachine = valuesArr[i] as SynchronousMachine;
+    
+                const str = `${synchronousMachine.mrid}${synchronousMachine.key}`;
+    
+                for (const terminalValue of synchronousMachine.terminals.values()) {
+                  const connectedNode = terminalValue.getConnectedNode();
+    
+                  const busID = uuidToIndex.get(connectedNode?.mrid);
+                  if (!busID) {
+                    console.log(`${str} keine BusID`);
+                    continue;
+                  }
+                  const baseV = PowerflowUtil.getBaseVoltageAsNumber(connectedNode);
+    
+    
+                  let targetValue = baseV;
+                  if (synchronousMachine.regulatingControl && synchronousMachine.regulatingControl.targetValue > 0) {
+                    targetValue = synchronousMachine.regulatingControl.targetValue;
+                  }
+    
+                  if (!synchronousMachine.regulatingControl?.targetValue) {
+                    console.log(`${str} kein targetValue`);
+                    continue;
+                  }
+    
+                  targetValue = !isNaN(targetValue) ? targetValue : baseV;
+    
+                  const baseVoltage = baseV <= 0 ? defaultsConfig.data.line.default_u : baseV;
+                  const targetVoltage = targetValue / baseVoltage;
+    
+                  const p = synchronousMachine.p || 0;
+                  const q = synchronousMachine.q || 0;
+    
+                  if (synchronousMachine.controlEnabled === false) {
+                    console.log(`${str} kein controlEnabled`);
+                    continue;
+                  }
+    
+                  const generatingUnit = synchronousMachine.generatingUnit;
+                  /!** KR-Zahl => (governorSCD * nominalP ) / (100 * 50hz)  *!/
+                  const kr = generatingUnit ? ((generatingUnit.governorSCD * generatingUnit.nominalP) / (100 * 50)) : 0;
+                  const slackWeight = kr / krInfo?.krSum;
+                  /!**  name,bus,p_mw,vm_pu,sn_mva,min_q_mvar,max_q_mvar,scaling,slack,in_service,slack_weight,type*!/
+                  const gen: any[] = [
+                    synchronousMachine.getUUID(), // name
+                    busID, // bus
+                    p * -1, // p_mw
+                    targetVoltage, // vm_pu
+                    synchronousMachine.ratedS, // sn_mva
+                    synchronousMachine.minQ, // min_q_mvar
+                    synchronousMachine.maxQ, // max_q_mvar
+                    1, // scaling
+                    genWithHighestPrio?.getUUID() === synchronousMachine.getUUID() ? true : false, // slack
+                    true, // in_service
+                    slackWeight ? slackWeight : 0, // slack_weight
+                    'sync', // type,
+                    synchronousMachine.key
+                  ]; // min_p_mw
+                  genData.data.push(gen);
+                  genData.index.push(genData.data.length - 1);
+                }
+    
+                console.log(`counter Ende ${counter++}`);
+              }
+            }
+          }
+        }*/
+        /** Stromkreisabschnitte anlegen */
+        const lineData = pandaDataFrame._object.line._object;
+        const lines = network.filter(it => it.constructor.name.includes('ACLineSegment'));
+        for (const l of lines) {
+            const acLineSegment = l;
+            const isConnected = acLineSegment.isConnected();
+            const connections = acLineSegment.getBusConnections();
+            if (connections.length !== 2)
+                continue;
+            const start = connections[0];
+            const ziel = connections[1];
+            if (!uuidToIndex.has(start.mrid) || !uuidToIndex.has(ziel.mrid))
+                continue;
+            const busFromID = uuidToIndex.get(start.mrid);
+            const busToID = uuidToIndex.get(ziel.mrid);
+            /** bei Fehlen der der Anschluesse wird der Stromkreisabschnitt ignoriert */
+            if (!(busFromID > -1 && busToID > -1)) {
+                console.log(`ACLineSegment uuid ${acLineSegment.mrid} name ${acLineSegment.name} is not connected`);
+                continue;
+            }
+            const infoImpedances = cim_model_assetinfo_util_1.CimModelAssetinfoUtil.getElectricPropertiesACLineSegmentFromInfo(acLineSegment);
+            const infoImpedance = (infoImpedances === null || infoImpedances === void 0 ? void 0 : infoImpedances.length) ? infoImpedances[0] : undefined;
+            const initCurrentLimit = acLineSegment.getCurrentLimit() ? acLineSegment.getCurrentLimit() : infoImpedance === null || infoImpedance === void 0 ? void 0 : infoImpedance.ratedCurrent;
+            const initX = +acLineSegment.x ? +acLineSegment.x : infoImpedance === null || infoImpedance === void 0 ? void 0 : infoImpedance.x;
+            const initR = +acLineSegment.r ? +acLineSegment.r : infoImpedance === null || infoImpedance === void 0 ? void 0 : infoImpedance.r;
+            /** Länge */
+            const initLength = +acLineSegment.length ? +acLineSegment.length : infoImpedance === null || infoImpedance === void 0 ? void 0 : infoImpedance.length;
+            const length = +initLength < 1 ? defaultsConfig['line'].default_length : +initLength;
+            /** Reactance / Reaktanz / Blindwiderstand */
+            const x = +initX === 0 ? defaultsConfig['line'].default_x : +initX / length;
+            /** Resistance / Wirkwiderstand */
+            const r = +initR === 0 ? defaultsConfig['line'].default_r : +initR / length;
+            const c = (Math.abs(acLineSegment.bch) / (2 * 50 * Math.PI * length) * Math.pow(1000, 3));
+            const g = 0;
+            /** CurrentLimt / Strombelastbarkeit */
+            const ir = (initCurrentLimit <= 0 ? defaultsConfig['line'].default_ir : initCurrentLimit) / 1000;
+            /** Typ des Stromkreisabschnittes. Default Freileitung
+             * cs - Kabel
+             * ol - Freileitung */
+            const type = ((_d = acLineSegment.psrType) === null || _d === void 0 ? void 0 : _d.name) === cim_constants_1.CimAssetAliasNames.Cable ? 'cs' : 'ol';
+            const baseVoltage = (_f = (_e = acLineSegment.baseVoltage) === null || _e === void 0 ? void 0 : _e.nominalVoltage) === null || _f === void 0 ? void 0 : _f.value;
+            const stdType = this.createPandaPowerTypeFromValues(pandaDataFrame, type, baseVoltage, ir, x, r, c);
+            /** PandaPower-Line-Objekt erstellen */
+            const line = [
+                acLineSegment.mrid,
+                null,
+                uuidToIndex.get(start.mrid),
+                uuidToIndex.get(ziel.mrid),
+                length,
+                r < 0.001 ? 0.001 : r,
+                x < 0.001 ? 0.001 : x,
+                c, g,
+                ir,
+                1,
+                1,
+                'cs',
+                isConnected,
+                0,
+                100,
+                '',
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                '',
+                null // geo
+            ];
+            lineData.data.push(line);
+            lineData.index.push(lineData.data.length - 1);
+        }
+        const xwardData = pandaDataFrame._object.xward._object;
+        /** ElementWithTargetVoltageKr  -> XWard */
+        for (const equivalentInjection of krInfo.wardsWithTargetVoltageKr) {
+            //console.log(`${equivalentInjection.mrid};${equivalentInjection.key};${equivalentInjection.regulationStatus};${equivalentInjection.regulationTarget};${(equivalentInjection as INTEGRALEquivalentInjection)?.kr};${equivalentInjection.p};${equivalentInjection.q}`);
+            for (const terminalValue of equivalentInjection.terminals.values()) {
+                const connectedNode = terminalValue.getConnectedNode();
+                const busID = uuidToIndex.get(connectedNode === null || connectedNode === void 0 ? void 0 : connectedNode.mrid);
+                if (busID !== undefined) {
+                    const baseV = PowerflowUtil.getBaseVoltageAsNumber(connectedNode);
+                    let targetValue = equivalentInjection.regulationTarget;
+                    targetValue = !isNaN(targetValue) ? targetValue : baseV;
+                    const baseVoltage = baseV <= 0 ? defaultsConfig.data.line.default_u : baseV;
+                    const targetVoltage = targetValue / baseVoltage;
+                    const p = equivalentInjection.p || 0;
+                    const q = equivalentInjection.q || 0;
+                    const kr = equivalentInjection === null || equivalentInjection === void 0 ? void 0 : equivalentInjection.kr;
+                    const slackWeight = kr / (krInfo === null || krInfo === void 0 ? void 0 : krInfo.krSum);
+                    const ps_mw = equivalentInjection === null || equivalentInjection === void 0 ? void 0 : equivalentInjection.p_bel;
+                    const qs_mvar = equivalentInjection === null || equivalentInjection === void 0 ? void 0 : equivalentInjection.q_bel;
+                    const pz_mw = equivalentInjection === null || equivalentInjection === void 0 ? void 0 : equivalentInjection.p_ki;
+                    const qz_mvar = equivalentInjection === null || equivalentInjection === void 0 ? void 0 : equivalentInjection.q_ki;
+                    // const r_ohm = (equivalentInjection as INTEGRALEquivalentInjection)?.rExt;
+                    // const x_ohm = (equivalentInjection as INTEGRALEquivalentInjection)?.xExt;
+                    const r_ohm = equivalentInjection.r;
+                    const x_ohm = equivalentInjection.x;
+                    const xward = [
+                        equivalentInjection.getUUID(),
+                        busID,
+                        ps_mw,
+                        qs_mvar,
+                        qz_mvar,
+                        pz_mw,
+                        r_ohm,
+                        x_ohm,
+                        targetVoltage,
+                        slackWeight,
+                        true,
+                        equivalentInjection.key // key
+                    ];
+                    xwardData.data.push(xward);
+                    xwardData.index.push(xwardData.data.length - 1);
+                }
+            }
+        }
+        for (const equivalentInjection of krInfo.wardsWithTargetVoltageOnly) {
+            //console.log(`${equivalentInjection.mrid};${equivalentInjection.key};${equivalentInjection.regulationStatus};${equivalentInjection.regulationTarget};${(equivalentInjection as INTEGRALEquivalentInjection)?.kr};${equivalentInjection.p};${equivalentInjection.q}`);
+            for (const terminalValue of equivalentInjection.terminals.values()) {
+                const connectedNode = terminalValue.getConnectedNode();
+                const busID = uuidToIndex.get(connectedNode === null || connectedNode === void 0 ? void 0 : connectedNode.mrid);
+                if (busID !== undefined) {
+                    const baseV = PowerflowUtil.getBaseVoltageAsNumber(connectedNode);
+                    let targetValue = equivalentInjection.regulationTarget;
+                    targetValue = !isNaN(targetValue) ? targetValue : baseV;
+                    const baseVoltage = baseV <= 0 ? defaultsConfig.data.line.default_u : baseV;
+                    const targetVoltage = targetValue / baseVoltage;
+                    const slackWeight = 0;
+                    const ps_mw = equivalentInjection === null || equivalentInjection === void 0 ? void 0 : equivalentInjection.p_bel;
+                    const qs_mvar = equivalentInjection === null || equivalentInjection === void 0 ? void 0 : equivalentInjection.q_bel;
+                    const pz_mw = equivalentInjection === null || equivalentInjection === void 0 ? void 0 : equivalentInjection.p_ki;
+                    const qz_mvar = equivalentInjection === null || equivalentInjection === void 0 ? void 0 : equivalentInjection.q_ki;
+                    const r_ohm = equivalentInjection.r;
+                    const x_ohm = equivalentInjection.x;
+                    /** name,bus,ps_mw,qs_mvar,qz_mvar,pz_mw,r_ohm,x_ohm,vm_pu,slack_weight,in_service */
+                    const xward = [
+                        equivalentInjection.getUUID(),
+                        busID,
+                        ps_mw,
+                        qs_mvar,
+                        qz_mvar,
+                        pz_mw,
+                        r_ohm,
+                        x_ohm,
+                        targetVoltage,
+                        slackWeight,
+                        true,
+                        equivalentInjection.key // key
+                    ];
+                    xwardData.data.push(xward);
+                    xwardData.index.push(xwardData.data.length - 1);
+                }
+            }
+        }
+        /** elementWithKrOnly  -> Gen */
+        for (const equivalentInjection of krInfo.wardsWithKrOnly) {
+            const str = `${equivalentInjection.mrid} ${equivalentInjection.key}`;
+            // TODO
+            console.log('WardsWithKrOnly ist nicht implementiert', str);
+        }
+        /** EquivalentBranch/Ersatzlängszweige anlegen */
+        const impedanceData = pandaDataFrame._object.impedance._object;
+        const equivalentBranches = network.filter(it => it instanceof EquivalentBranch_1.EquivalentBranch);
+        for (const equivalentBranch of equivalentBranches) {
+            //Prüfen, ob die Terminals geschlossen sind.
+            const isConnected = equivalentBranch.isConnected();
+            const connections = equivalentBranch.getBusConnections();
+            if (connections.length !== 2)
+                continue;
+            const start = connections[0];
+            const ziel = connections[1];
+            if (!uuidToIndex.has(start.mrid) || !uuidToIndex.has(ziel.mrid))
+                continue;
+            const r21 = equivalentBranch.r21 ? equivalentBranch.r21 : equivalentBranch.r;
+            const x21 = equivalentBranch.x21 ? equivalentBranch.x21 : equivalentBranch.x;
+            const zeroR12 = equivalentBranch.zeroR12;
+            const zeroX12 = equivalentBranch.zeroX12;
+            const zeroR21 = equivalentBranch.r21 ? equivalentBranch.r21 : zeroR12;
+            const zeroX21 = equivalentBranch.x21 ? equivalentBranch.x21 : zeroX12;
+            const snMVA = pandaDataFrame._object.sn_mva;
+            const z_base = Math.pow((_h = (_g = equivalentBranch.baseVoltage) === null || _g === void 0 ? void 0 : _g.nominalVoltage) === null || _h === void 0 ? void 0 : _h.value, 2) / snMVA;
+            const rft_pu = equivalentBranch.r / z_base;
+            const xft_pu = equivalentBranch.x / z_base;
+            const rtf_pu = r21 / z_base;
+            const xtf_pu = x21 / z_base;
+            const rft0_pu = zeroR12 / z_base;
+            const xft0_pu = zeroX12 / z_base;
+            const rtf0_pu = zeroR21 / z_base;
+            const xtf0_pu = zeroX21 / z_base;
+            const busFromID = uuidToIndex.get(start.mrid);
+            const busToID = uuidToIndex.get(ziel.mrid);
+            /** [name, from_bus, to_bus, rft_pu, xft_pu, rtf_pu, xtf_pu, sn_mva, in_service] */
+            /**  name, from_bus, to_bus, rft_pu, xft_pu, rtf_pu, xtf_pu, sn_mva, in_service*/
+            if (isNaN(rft_pu) || rft_pu === 0) {
+                console.log(`rft_pu ${rft_pu}`);
+            }
+            if (isNaN(xft_pu) || xft_pu === 0) {
+                console.log(`xft_pu ${xft_pu}`);
+            }
+            if (isNaN(rtf_pu) || rtf_pu === 0) {
+                console.log(`rtf_pu ${rtf_pu}`);
+            }
+            if (isNaN(xtf_pu) || xtf_pu === 0) {
+                console.log(`xtf_pu ${xtf_pu}`);
+            }
+            const data = [equivalentBranch.getUUID(), busFromID, busToID, rft_pu, xft_pu, rtf_pu, xtf_pu, snMVA, true, equivalentBranch.key];
+            impedanceData.data.push(data);
+            impedanceData.index.push(impedanceData.data.length - 1);
+        }
+        /** Transformatoren 2W anlegen */
+        const trafoData = pandaDataFrame._object.trafo._object;
+        const powerTransformers = network.filter(it => it.constructor.name.includes('PowerTransformer'));
+        for (const powerTransformer of powerTransformers) {
+            const trafoW2 = powerTransformer;
+            const connections = trafoW2.getBusConnections();
+            if (connections.length > 2)
+                continue; // Trafo 3W
+            const start = connections[0];
+            const ziel = connections[1];
+            if (!uuidToIndex.has(start.mrid) || !uuidToIndex.has(ziel.mrid))
+                continue;
+            const busFromID = uuidToIndex.get(start.mrid);
+            const busToID = uuidToIndex.get(ziel.mrid);
+            const powerTransformerEnd1 = trafoW2.powerTransformerEnd[0];
+            const powerTransformerEnd2 = trafoW2.powerTransformerEnd[1];
+            const w1_un = trafoW2.powerTransformerEnd[0].baseVoltage.nominalVoltage.value;
+            const w2_un = trafoW2.powerTransformerEnd[1].baseVoltage.nominalVoltage.value;
+            const s = trafoW2.powerTransformerEnd[0].ratedS;
+            const shiftDegree = isNaN(powerTransformerEnd1.phaseAngleClock) ? powerTransformerEnd2.phaseAngleClock : powerTransformerEnd1.phaseAngleClock;
+            if (powerTransformerEnd1.x === 0) {
+                console.log(`PowerTransformer ${trafoW2.getUUID()} x is not defined!`);
+                continue;
+            }
+            const trafoTypes = pandaDataFrame._object.std_types.trafo;
+            let stdType = PowerflowUtil.createStdTypeTrafo2WFromValues(pandaDataFrame._object.std_types.trafo, w1_un, w2_un, s);
+            if (!stdType) {
+                // console.log(`kein Trafo2W Assettype gefunden UUID ${trafoW2.mrid} S ${s} Ur1 ${w1_un} Ur2 ${w2_un}`);
+                /** Lege den fehlenden Trafotyp automatisch an. */
+                /** iron losses in kW */
+                let pfeKw = (powerTransformerEnd1.g * Math.pow(powerTransformerEnd1.ratedU, 2) +
+                    powerTransformerEnd2.g * Math.pow(powerTransformerEnd2.ratedU, 2)) * 1000;
+                // pfeKw = 0;
+                /** real component of short circuit voltage [%] */
+                const vkrPercent = Math.abs(powerTransformerEnd1.r) * powerTransformerEnd1.ratedS * 100 / Math.pow(powerTransformerEnd1.ratedU, 2) +
+                    Math.abs(powerTransformerEnd2.r) * powerTransformerEnd1.ratedS * 100 / Math.pow(powerTransformerEnd2.ratedU, 2);
+                /** short circuit voltage [%] */
+                const transformerEnd1SignX = Math.sign(powerTransformerEnd1.x) === 0 ? 1 : Math.sign(powerTransformerEnd1.x);
+                const transformerEnd2SignX = Math.sign(powerTransformerEnd2.x) === 0 ? 1 : Math.sign(powerTransformerEnd2.x);
+                let vkPercent = Math.pow(Math.pow(powerTransformerEnd1.r, 2) + Math.pow(powerTransformerEnd1.x, 2), 0.5) *
+                    (powerTransformerEnd1.ratedS * 1000) / (10 * Math.pow(powerTransformerEnd1.ratedU, 2)) +
+                    Math.pow(Math.pow(powerTransformerEnd2.r, 2) + Math.pow(powerTransformerEnd2.x, 2), 0.5) *
+                        (powerTransformerEnd1.ratedS * 1000 / (10 * Math.pow(powerTransformerEnd2.ratedU, 2)));
+                vkPercent = vkPercent * transformerEnd1SignX;
+                vkPercent = vkPercent * transformerEnd2SignX;
+                /** open loop losses in [%] */
+                let i0Percent = Math.pow(Math.pow(Math.pow(powerTransformerEnd1.b * Math.pow(powerTransformerEnd1.ratedU, 2), 2) +
+                    Math.pow(powerTransformerEnd1.g * Math.pow(powerTransformerEnd1.ratedU, 2), 2), 0.5) +
+                    Math.pow(powerTransformerEnd2.b * Math.pow(powerTransformerEnd2.ratedU, 2), 2) +
+                    Math.pow(powerTransformerEnd2.g * Math.pow(powerTransformerEnd2.ratedU, 2), 2), 0.5) * 100 / powerTransformerEnd1.ratedS;
+                //i0Percent = 0;
+                const shiftDegree = isNaN(powerTransformerEnd1.phaseAngleClock) ? powerTransformerEnd2.phaseAngleClock : powerTransformerEnd1.phaseAngleClock;
+                const vectorGroup = (powerTransformerEnd1.connectionKind + '') + (powerTransformerEnd2.connectionKind + '');
+                stdType = {
+                    key: `${trafoW2.mrid}`,
+                    value: {
+                        shift_degree: shiftDegree,
+                        vector_group: vectorGroup,
+                        vn_hv_kv: powerTransformerEnd1.ratedU,
+                        pfe_kw: pfeKw,
+                        i0_percent: i0Percent,
+                        vn_lv_kv: powerTransformerEnd2.ratedU,
+                        sn_mva: powerTransformerEnd1.ratedS,
+                        tap_step_degree: 0,
+                        tap_neutral: 0,
+                        tap_min: 0,
+                        vkr_percent: vkrPercent,
+                        tap_step_percent: 0.0,
+                        tap_side: 'hv',
+                        tap_phase_shifter: false,
+                        tap_max: 0,
+                        vk_percent: vkPercent
+                    }
+                };
+                // @ts-ignore
+                trafoTypes[`${trafoW2.mrid}`] = stdType.value;
+            }
+            if (busFromID > -1 && busToID > -1) {
+                /** name,std_type,hv_bus,lv_bus,sn_mva,vn_hv_kv,vn_lv_kv,vk_percent,vkr_percent,pfe_kw,i0_percent,
+                 * shift_degree,tap_side,tap_neutral,tap_min,tap_max,tap_step_percent,tap_step_degree,tap_pos,
+                 * tap_phase_shifter,parallel,df,in_service,tap_set_vm_pu,description,equipment,vector_group,
+                 * vk0_percent,vkr0_percent,mag0_percent,mag0_rx,si0_hv_partial*/
+                const trafo = [
+                    trafoW2.getUUID(),
+                    stdType.key,
+                    busFromID,
+                    busToID,
+                    stdType.value['sn_mva'],
+                    w1_un,
+                    w2_un,
+                    stdType.value['vk_percent'],
+                    stdType.value['vkr_percent'],
+                    stdType.value['pfe_kw'],
+                    stdType.value['i0_percent'],
+                    stdType.value['shift_degree'],
+                    'hv',
+                    stdType.value['tap_neutral'],
+                    stdType.value['tap_min'],
+                    stdType.value['tap_max'],
+                    1.3,
+                    stdType.value['tap_step_degree'],
+                    0,
+                    stdType.value['tap_phase_shifter'],
+                    1,
+                    1,
+                    true,
+                    1,
+                    '',
+                    '',
+                    '',
+                    '',
+                    0,
+                    0,
+                    0,
+                    1,
+                    start.mrid,
+                    ziel.mrid // lv_bus_uuid
+                ];
+                trafoData.data.push(trafo);
+                trafoData.index.push(trafoData.data.length - 1);
+            }
+        }
+        /** Transformatoren 3W anlegen */
+        const trafoData3W = pandaDataFrame._object.trafo3w._object;
+        for (const powerTransformer of powerTransformers) {
+            const trafoW3 = powerTransformer;
+            const connections = trafoW3.getBusConnections();
+            if (connections.length !== 3)
+                continue;
+            const busW1 = connections[0];
+            const busW2 = connections[1];
+            const busW3 = connections[2];
+            if (!(uuidToIndex.has(busW1.mrid) && uuidToIndex.has(busW2.mrid) && uuidToIndex.has(busW3.mrid)))
+                continue;
+            const powerTransformerEnd1 = trafoW3.powerTransformerEnd[0];
+            const powerTransformerEnd2 = trafoW3.powerTransformerEnd[1];
+            const powerTransformerEnd3 = trafoW3.powerTransformerEnd[2];
+            const busW1ID = uuidToIndex.get(busW1.mrid);
+            const busW2ID = uuidToIndex.get(busW2.mrid);
+            const busW3ID = uuidToIndex.get(busW3.mrid);
+            const w1Ur = (_l = (_k = (_j = trafoW3.powerTransformerEnd[0]) === null || _j === void 0 ? void 0 : _j.baseVoltage) === null || _k === void 0 ? void 0 : _k.nominalVoltage) === null || _l === void 0 ? void 0 : _l.value;
+            const w2Ur = (_p = (_o = (_m = trafoW3.powerTransformerEnd[1]) === null || _m === void 0 ? void 0 : _m.baseVoltage) === null || _o === void 0 ? void 0 : _o.nominalVoltage) === null || _p === void 0 ? void 0 : _p.value;
+            const w3Ur = (_s = (_r = (_q = trafoW3.powerTransformerEnd[2]) === null || _q === void 0 ? void 0 : _q.baseVoltage) === null || _r === void 0 ? void 0 : _r.nominalVoltage) === null || _s === void 0 ? void 0 : _s.value;
+            const w1Sr = (_t = trafoW3 === null || trafoW3 === void 0 ? void 0 : trafoW3.powerTransformerEnd[0]) === null || _t === void 0 ? void 0 : _t.ratedS;
+            const w2Sr = (_u = trafoW3 === null || trafoW3 === void 0 ? void 0 : trafoW3.powerTransformerEnd[1]) === null || _u === void 0 ? void 0 : _u.ratedS;
+            const w3Sr = (_v = trafoW3 === null || trafoW3 === void 0 ? void 0 : trafoW3.powerTransformerEnd[2]) === null || _v === void 0 ? void 0 : _v.ratedS;
+            const minSHvMv = Math.min(w1Sr, w2Sr);
+            const minSMvLv = Math.min(w2Sr, w3Sr);
+            const minSLvHv = Math.min(w1Sr, w3Sr);
+            const pfeKw = (powerTransformerEnd1.g * Math.pow(powerTransformerEnd1.ratedU, 2) +
+                powerTransformerEnd2.g * Math.pow(powerTransformerEnd2.ratedU, 2) +
+                powerTransformerEnd3.g * Math.pow(powerTransformerEnd3.ratedU, 2)) * 1000;
+            const vkrHvPercent = (powerTransformerEnd1.r + powerTransformerEnd2.r * Math.pow(powerTransformerEnd1.ratedU / powerTransformerEnd2.ratedU, 2)) *
+                minSHvMv * 100 / Math.pow(powerTransformerEnd1.ratedU, 2);
+            let vkrMvPercent = (powerTransformerEnd2.r + powerTransformerEnd3.r * Math.pow(powerTransformerEnd2.ratedU / powerTransformerEnd3.ratedU, 2)) *
+                minSMvLv * 100 / Math.pow(powerTransformerEnd2.ratedU, 2);
+            if (vkrMvPercent < 0) {
+                vkrMvPercent = 0;
+            }
+            const vkrLvPercent = (powerTransformerEnd3.r + powerTransformerEnd1.r * Math.pow(powerTransformerEnd3.ratedU / powerTransformerEnd1.ratedU, 2)) *
+                minSLvHv * 100 / Math.pow(powerTransformerEnd3.ratedU, 2);
+            const vkHvPercent = Math.pow(powerTransformerEnd1.r + powerTransformerEnd2.r * Math.pow(Math.pow((powerTransformerEnd1.ratedU / powerTransformerEnd2.ratedU), 2), 2) +
+                Math.pow(powerTransformerEnd1.x + powerTransformerEnd2.x * Math.pow(powerTransformerEnd1.ratedU / powerTransformerEnd2.ratedU, 2), 2), 0.5) *
+                minSHvMv * 100 / Math.pow(powerTransformerEnd1.ratedU, 2);
+            const vkMvPercent = Math.pow(powerTransformerEnd2.r + powerTransformerEnd3.r * Math.pow(Math.pow((powerTransformerEnd2.ratedU / powerTransformerEnd3.ratedU), 2), 2) +
+                Math.pow(powerTransformerEnd2.x + powerTransformerEnd3.x * Math.pow(powerTransformerEnd2.ratedU / powerTransformerEnd3.ratedU, 2), 2), 0.5) *
+                minSMvLv * 100 / Math.pow(powerTransformerEnd2.ratedU, 2);
+            const vkLvPercent = Math.pow(powerTransformerEnd3.r + powerTransformerEnd1.r * Math.pow(Math.pow((powerTransformerEnd3.ratedU / powerTransformerEnd1.ratedU), 2), 2) +
+                Math.pow(powerTransformerEnd3.x + powerTransformerEnd1.x * Math.pow(powerTransformerEnd3.ratedU / powerTransformerEnd1.ratedU, 2), 2), 0.5) *
+                minSLvHv * 100 / Math.pow(powerTransformerEnd3.ratedU, 2);
+            const i0Percent = (Math.pow(Math.pow(powerTransformerEnd1.b * Math.pow(powerTransformerEnd1.ratedU, 2), 2) +
+                Math.pow(powerTransformerEnd1.g * Math.pow(powerTransformerEnd1.ratedU, 2), 2), 0.5) +
+                Math.pow(Math.pow(powerTransformerEnd2.b * Math.pow(powerTransformerEnd2.ratedU, 2), 2) +
+                    Math.pow(powerTransformerEnd2.g * Math.pow(powerTransformerEnd2.ratedU, 2), 2), 0.5) +
+                Math.pow(Math.pow(powerTransformerEnd3.b * Math.pow(powerTransformerEnd3.ratedU, 2), 2) +
+                    Math.pow(powerTransformerEnd3.g * Math.pow(powerTransformerEnd3.ratedU, 2), 2), 0.5)) * 100 / powerTransformerEnd1.ratedS;
+            const shiftMvDegree = powerTransformerEnd2.phaseAngleClock * 30;
+            const shiftLvDegree = powerTransformerEnd3.phaseAngleClock * 30;
+            const vectorGroup = powerTransformerEnd1.connectionKind + '' + powerTransformerEnd2.connectionKind + '' + powerTransformerEnd3.connectionKind + '';
+            const stdType = {
+                key: `${trafoW3.mrid}`,
+                value: {
+                    'vector_group': vectorGroup,
+                    'vn_mv_kv': powerTransformerEnd2.ratedU,
+                    'vn_lv_kv': powerTransformerEnd3.ratedU,
+                    'shift_lv_degree': shiftLvDegree,
+                    'shift_mv_degree': shiftMvDegree,
+                    'pfe_kw': pfeKw,
+                    'vn_hv_kv': powerTransformerEnd1.ratedU,
+                    'i0_percent': i0Percent,
+                    'sn_lv_mva': powerTransformerEnd3.ratedS,
+                    'sn_hv_mva': powerTransformerEnd1.ratedS,
+                    'sn_mv_mva': powerTransformerEnd2.ratedS,
+                    'vkr_lv_percent': vkrLvPercent,
+                    'tap_neutral': 0,
+                    'tap_min': 0,
+                    'vk_mv_percent': vkMvPercent,
+                    'vkr_hv_percent': vkrHvPercent,
+                    'vk_lv_percent': vkLvPercent,
+                    'tap_max': 0,
+                    'vkr_mv_percent': vkrMvPercent,
+                    'tap_step_percent': 0,
+                    'tap_side': 'hv',
+                    'vk_hv_percent': vkHvPercent
+                }
+            };
+            if (!(busW1ID > -1 && busW2ID > -1 && busW3ID > -1))
+                continue;
+            /**
+             name,std_type,hv_bus,mv_bus,lv_bus,sn_hv_mva,sn_mv_mva,sn_lv_mva,vn_hv_kv,vn_mv_kv,vn_lv_kv,vk_hv_percent,
+             vk_mv_percent,vk_lv_percent,vkr_hv_percent,vkr_mv_percent,vkr_lv_percent,
+             pfe_kw,i0_percent,shift_mv_degree,
+             shift_lv_degree,tap_side,tap_neutral,
+             tap_min,tap_max,tap_step_percent,tap_step_degree,tap_pos,tap_at_star_point,
+             in_service
+             /** */
+            const trafo = [
+                trafoW3.mrid,
+                null,
+                busW1ID,
+                busW2ID,
+                busW3ID,
+                stdType.value['sn_hv_mva'],
+                stdType.value['sn_mv_mva'],
+                stdType.value['sn_lv_mva'],
+                stdType.value['vn_hv_kv'],
+                stdType.value['vn_mv_kv'],
+                stdType.value['vn_lv_kv'],
+                stdType.value['vk_hv_percent'],
+                stdType.value['vk_mv_percent'],
+                stdType.value['vk_lv_percent'],
+                stdType.value['vkr_hv_percent'],
+                stdType.value['vkr_mv_percent'],
+                stdType.value['vkr_lv_percent'],
+                stdType.value['pfe_kw'],
+                stdType.value['i0_percent'],
+                stdType.value['shift_mv_degree'],
+                stdType.value['shift_lv_degree'],
+                'hv',
+                stdType.value['tap_neutral'],
+                stdType.value['tap_min'],
+                stdType.value['tap_max'],
+                stdType.value['tap_step_percent'],
+                stdType.value['tap_step_degree'],
+                0,
+                false,
+                true,
+                busW1.mrid,
+                busW2.mrid,
+                busW3.mrid // lv_bus_uuid
+            ];
+            trafoData3W.data.push(trafo);
+            trafoData3W.index.push(trafoData3W.data.length - 1);
+        }
+        /** Laengsdrossel anlegen */
+        const seriesCompensators = network.filter(it => it.constructor.name.includes('SeriesCompensator'));
+        for (const sc of seriesCompensators) {
+            const seriesCompensator = sc;
+            const isConnected = seriesCompensator.isConnected();
+            const connections = seriesCompensator.getBusConnections();
+            if (connections.length !== 2)
+                continue;
+            const start = connections[0];
+            const ziel = connections[1];
+            if (!uuidToIndex.has(start.mrid) || !uuidToIndex.has(ziel.mrid))
+                continue;
+            const busFromID = uuidToIndex.get(start.mrid);
+            const busToID = uuidToIndex.get(ziel.mrid);
+            const z_base = Math.pow((_x = (_w = seriesCompensator.baseVoltage) === null || _w === void 0 ? void 0 : _w.nominalVoltage) === null || _x === void 0 ? void 0 : _x.value, 2) / snMVA;
+            const rft_pu = seriesCompensator.r / z_base;
+            const xft_pu = seriesCompensator.x / z_base;
+            const rtf_pu = seriesCompensator.r / z_base;
+            const xtf_pu = seriesCompensator.x / z_base;
+            const rft0_pu = seriesCompensator.r0 / z_base;
+            const xft0_pu = seriesCompensator.x0 / z_base;
+            const rtf0_pu = seriesCompensator.r0 / z_base;
+            const xtf0_pu = seriesCompensator.x0 / z_base;
+            /**  name, from_bus, to_bus, rft_pu, xft_pu, rtf_pu, xtf_pu, sn_mva, in_service */
+            /**  name, from_bus, to_bus, rft_pu, xft_pu, rtf_pu, xtf_pu, sn_mva, in_service */
+            if (isNaN(rft_pu) || rft_pu === 0) {
+                console.log(`rft_pu ${rft_pu}`);
+            }
+            if (isNaN(xft_pu) || xft_pu === 0) {
+                console.log(`xft_pu ${xft_pu}`);
+            }
+            if (isNaN(rtf_pu) || rtf_pu === 0) {
+                console.log(`rtf_pu ${rtf_pu}`);
+            }
+            if (isNaN(xtf_pu) || xtf_pu === 0) {
+                console.log(`xtf_pu ${xtf_pu}`);
+            }
+            const data = [seriesCompensator.getUUID(), busFromID, busToID, rft_pu, xft_pu, rtf_pu, xtf_pu, snMVA, true, seriesCompensator.key];
+            impedanceData.data.push(data);
+            impedanceData.index.push(impedanceData.data.length - 1);
+        }
+        /** Kompensationsanlagen anlegen */
+        const shuntData = pandaDataFrame._object.shunt._object;
+        const linearShuntCompensators = network.filter(it => it instanceof LinearShuntCompensator_1.LinearShuntCompensator);
+        for (const linearShuntCompensator of linearShuntCompensators) {
+            /** regelbare Kompensationsanlagen */
+            if (!((_y = linearShuntCompensator.regulatingControl) === null || _y === void 0 ? void 0 : _y.targetValue)) {
+                // console.log(`LinearShuntCompensator ${linearShuntCompensator.getUUID()} kein targetValue`);
+                //continue;
+            }
+            const targetValue = (_z = linearShuntCompensator.regulatingControl) === null || _z === void 0 ? void 0 : _z.targetValue;
+            /** bus, name, q_mvar, p_mw, vn_kv, step, max_step, in_service */
+            for (const terminalValue of linearShuntCompensator.terminals.values()) {
+                const connectedNode = terminalValue.getConnectedNode();
+                const baseV = PowerflowUtil.getBaseVoltageAsNumber(connectedNode);
+                const baseVoltage = baseV <= 0 ? defaultsConfig.data.line.default_u : baseV;
+                //const targetVoltage = targetValue / baseVoltage;
+                const baseVoltageNominal = linearShuntCompensator.nomU;
+                const baseVoltageNominalPowTwo = Math.pow(baseVoltageNominal, 2);
+                const busID = uuidToIndex.get(connectedNode === null || connectedNode === void 0 ? void 0 : connectedNode.mrid);
+                const p_real = linearShuntCompensator.gPerSection;
+                const p_imag = (linearShuntCompensator.bPerSection * baseVoltageNominalPowTwo) * -1;
+                const voltage_real = baseVoltageNominalPowTwo;
+                const voltage_imag = 0;
+                /*        eqssh_shunts = eqssh_shunts.rename(columns={
+                          'rdfId': sc['o_id'], 'rdfId_Terminal': sc['t'], 'connected': 'in_service', 'index_bus': 'bus',
+                          'nomU': 'vn_kv',
+                          'sections': 'step',
+                          'maximumSections': 'max_step'})
+                        y = eqssh_shunts['gPerSection'] + eqssh_shunts['bPerSection'] * 1j
+                        s = eqssh_shunts['vn_kv'] ** 2 * np.conj(y)
+                        eqssh_shunts['p_mw'] = s.values.real
+                        eqssh_shunts['q_mvar'] = s.values.imag*/
+                const p = p_real * voltage_imag + p_imag * voltage_real;
+                const q = p_real * voltage_real - p_imag * voltage_imag;
+                if (isNaN(linearShuntCompensator.sections)) {
+                    console.log();
+                }
+                /** [\"bus\",\"name\",\"q_mvar\",\"p_mw\",\"vn_kv\",\"step\",\"max_step\",\"in_service\"] */
+                const shunt = [
+                    busID,
+                    linearShuntCompensator.getUUID(),
+                    q,
+                    p,
+                    linearShuntCompensator.nomU,
+                    isNaN(linearShuntCompensator.sections) ? linearShuntCompensator.normalSections : linearShuntCompensator.sections,
+                    linearShuntCompensator.maximumSections,
+                    linearShuntCompensator.sections > 0 ? true : false // in_service
+                ];
+                /*        shuntData.data.push(shunt);
+                        shuntData.index.push(shuntData.data.length - 1);*/
+            }
+        }
+        /** Schaltelemente */
+        /** Speichert die berücksichtgten Schaltelemente
+         * Später wird diese Map verwendet, um spannungslose Switches zu bestimmen und ins Netzmodell aufzunehmen */
+        const consideredSwitches = new Map();
+        const switchData = pandaDataFrame._object.switch._object;
+        const switches = network.filter(it => it instanceof Switch_1.Switch);
+        for (const swtch of switches) {
+            consideredSwitches.set(swtch.mrid, swtch);
+            PowerflowUtil.addSwitch(swtch, uuidToIndex, switchData);
+        }
+        /** Junctions / Starre Schaltfelder  */
+        for (const networkElement of network) {
+            if (networkElement.constructor.name.includes('Junction')) {
+                consideredSwitches.set(networkElement.mrid, networkElement);
+                PowerflowUtil.addJunctionSwitch(networkElement, uuidToIndex, switchData);
+            }
+        }
+        return PowerflowUtil.toJsonPandaDataFrame(pandaDataFrame);
+    }
+    static fromJsonPandaDataFrame(pandaDataFrameJSON) {
+        const pandaDataFrame = JSON.parse(pandaDataFrameJSON);
+        //Bus
+        pandaDataFrame._object.bus._object = JSON.parse(pandaDataFrame._object.bus._object);
+        pandaDataFrame._object.bus._object['data'] = [];
+        pandaDataFrame._object.bus._object['index'] = [];
+        //Load
+        pandaDataFrame._object.load._object = JSON.parse(pandaDataFrame._object.load._object);
+        pandaDataFrame._object.load._object['data'] = [];
+        pandaDataFrame._object.load._object['index'] = [];
+        // sgen
+        pandaDataFrame._object.sgen._object = JSON.parse(pandaDataFrame._object.sgen._object);
+        pandaDataFrame._object.sgen._object['data'] = [];
+        pandaDataFrame._object.sgen._object['index'] = [];
+        // Motor
+        pandaDataFrame._object.motor._object = JSON.parse(pandaDataFrame._object.motor._object);
+        pandaDataFrame._object.motor._object['data'] = [];
+        pandaDataFrame._object.motor._object['index'] = [];
+        // asymmetric_load
+        pandaDataFrame._object.asymmetric_load._object = JSON.parse(pandaDataFrame._object.asymmetric_load._object);
+        pandaDataFrame._object.asymmetric_load._object['data'] = [];
+        pandaDataFrame._object.asymmetric_load._object['index'] = [];
+        // asymmetric_sgen
+        pandaDataFrame._object.asymmetric_sgen._object = JSON.parse(pandaDataFrame._object.asymmetric_sgen._object);
+        pandaDataFrame._object.asymmetric_sgen._object['data'] = [];
+        pandaDataFrame._object.asymmetric_sgen._object['index'] = [];
+        // storage
+        pandaDataFrame._object.storage._object = JSON.parse(pandaDataFrame._object.storage._object);
+        pandaDataFrame._object.storage._object['data'] = [];
+        pandaDataFrame._object.storage._object['index'] = [];
+        // gen
+        pandaDataFrame._object.gen._object = JSON.parse(pandaDataFrame._object.gen._object);
+        pandaDataFrame._object.gen._object['data'] = [];
+        pandaDataFrame._object.gen._object['index'] = [];
+        // Switch
+        pandaDataFrame._object.switch._object = JSON.parse(pandaDataFrame._object.switch._object);
+        pandaDataFrame._object.switch._object['data'] = [];
+        pandaDataFrame._object.switch._object['index'] = [];
+        // shunt
+        pandaDataFrame._object.shunt._object = JSON.parse(pandaDataFrame._object.shunt._object);
+        pandaDataFrame._object.shunt._object['data'] = [];
+        pandaDataFrame._object.shunt._object['index'] = [];
+        // ext_grid
+        pandaDataFrame._object.ext_grid._object = JSON.parse(pandaDataFrame._object.ext_grid._object);
+        pandaDataFrame._object.ext_grid._object['data'] = [];
+        pandaDataFrame._object.ext_grid._object['index'] = [];
+        //Line
+        pandaDataFrame._object.line._object = JSON.parse(pandaDataFrame._object.line._object);
+        pandaDataFrame._object.line._object['data'] = [];
+        pandaDataFrame._object.line._object['index'] = [];
+        // trafo
+        pandaDataFrame._object.trafo._object = JSON.parse(pandaDataFrame._object.trafo._object);
+        pandaDataFrame._object.trafo._object['data'] = [];
+        pandaDataFrame._object.trafo._object['index'] = [];
+        // trafo3w
+        pandaDataFrame._object.trafo3w._object = JSON.parse(pandaDataFrame._object.trafo3w._object);
+        pandaDataFrame._object.trafo3w._object['data'] = [];
+        pandaDataFrame._object.trafo3w._object['index'] = [];
+        // impedance
+        pandaDataFrame._object.impedance._object = JSON.parse(pandaDataFrame._object.impedance._object);
+        pandaDataFrame._object.impedance._object['data'] = [];
+        pandaDataFrame._object.impedance._object['index'] = [];
+        // dcline
+        pandaDataFrame._object.dcline._object = JSON.parse(pandaDataFrame._object.dcline._object);
+        pandaDataFrame._object.dcline._object['data'] = [];
+        pandaDataFrame._object.dcline._object['index'] = [];
+        // ward
+        pandaDataFrame._object.ward._object = JSON.parse(pandaDataFrame._object.ward._object);
+        pandaDataFrame._object.ward._object['data'] = [];
+        pandaDataFrame._object.ward._object['index'] = [];
+        // xward
+        pandaDataFrame._object.xward._object = JSON.parse(pandaDataFrame._object.xward._object);
+        pandaDataFrame._object.xward._object['data'] = [];
+        pandaDataFrame._object.xward._object['index'] = [];
+        // measurement
+        pandaDataFrame._object.measurement._object = JSON.parse(pandaDataFrame._object.measurement._object);
+        pandaDataFrame._object.measurement._object['data'] = [];
+        pandaDataFrame._object.measurement._object['index'] = [];
+        // pwl_cost
+        pandaDataFrame._object.pwl_cost._object = JSON.parse(pandaDataFrame._object.pwl_cost._object);
+        pandaDataFrame._object.pwl_cost._object['data'] = [];
+        pandaDataFrame._object.pwl_cost._object['index'] = [];
+        // poly_cost
+        pandaDataFrame._object.poly_cost._object = JSON.parse(pandaDataFrame._object.poly_cost._object);
+        pandaDataFrame._object.poly_cost._object['data'] = [];
+        pandaDataFrame._object.poly_cost._object['index'] = [];
+        // characteristic
+        pandaDataFrame._object.characteristic._object = JSON.parse(pandaDataFrame._object.characteristic._object);
+        pandaDataFrame._object.characteristic._object['data'] = [];
+        pandaDataFrame._object.characteristic._object['index'] = [];
+        // controller
+        pandaDataFrame._object.controller._object = JSON.parse(pandaDataFrame._object.controller._object);
+        pandaDataFrame._object.controller._object['data'] = [];
+        pandaDataFrame._object.controller._object['index'] = [];
+        // std_types
+        pandaDataFrame._object.std_types.line = {};
+        pandaDataFrame._object.std_types.trafo = {};
+        pandaDataFrame._object.std_types.trafo3w = {};
+        return pandaDataFrame;
+    }
+    /** Serialize PandaDataFrame to JSON */
+    static toJsonPandaDataFrame(pandasDataFrame) {
+        // Bus
+        pandasDataFrame._object.bus._object = String(JSON.stringify(pandasDataFrame._object.bus._object));
+        // Load
+        pandasDataFrame._object.load._object = String(JSON.stringify(pandasDataFrame._object.load._object));
+        // sgen
+        pandasDataFrame._object.sgen._object = String(JSON.stringify(pandasDataFrame._object.sgen._object));
+        // Motor
+        pandasDataFrame._object.motor._object = String(JSON.stringify(pandasDataFrame._object.motor._object));
+        // asymmetric_load
+        pandasDataFrame._object.asymmetric_load._object = String(JSON.stringify(pandasDataFrame._object.asymmetric_load._object));
+        // asymmetric_sgen
+        pandasDataFrame._object.asymmetric_sgen._object = String(JSON.stringify(pandasDataFrame._object.asymmetric_sgen._object));
+        // storage
+        pandasDataFrame._object.storage._object = String(JSON.stringify(pandasDataFrame._object.storage._object));
+        // gen
+        pandasDataFrame._object.gen._object = String(JSON.stringify(pandasDataFrame._object.gen._object));
+        // Switch
+        pandasDataFrame._object.switch._object = String(JSON.stringify(pandasDataFrame._object.switch._object));
+        // shunt
+        pandasDataFrame._object.shunt._object = String(JSON.stringify(pandasDataFrame._object.shunt._object));
+        // ext_grid Slack
+        pandasDataFrame._object.ext_grid._object = String(JSON.stringify(pandasDataFrame._object.ext_grid._object));
+        // Line
+        pandasDataFrame._object.line._object = String(JSON.stringify(pandasDataFrame._object.line._object));
+        // trafo
+        pandasDataFrame._object.trafo._object = String(JSON.stringify(pandasDataFrame._object.trafo._object));
+        // trafo3w
+        pandasDataFrame._object.trafo3w._object = String(JSON.stringify(pandasDataFrame._object.trafo3w._object));
+        // impedance
+        pandasDataFrame._object.impedance._object = String(JSON.stringify(pandasDataFrame._object.impedance._object));
+        // dcline
+        pandasDataFrame._object.dcline._object = String(JSON.stringify(pandasDataFrame._object.dcline._object));
+        // ward
+        pandasDataFrame._object.ward._object = String(JSON.stringify(pandasDataFrame._object.ward._object));
+        // xward
+        pandasDataFrame._object.xward._object = String(JSON.stringify(pandasDataFrame._object.xward._object));
+        // measurement
+        pandasDataFrame._object.measurement._object = String(JSON.stringify(pandasDataFrame._object.measurement._object));
+        // pwl_cost
+        pandasDataFrame._object.pwl_cost._object = String(JSON.stringify(pandasDataFrame._object.pwl_cost._object));
+        // poly_cost
+        pandasDataFrame._object.poly_cost._object = String(JSON.stringify(pandasDataFrame._object.poly_cost._object));
+        // characteristic
+        pandasDataFrame._object.characteristic._object = String(JSON.stringify(pandasDataFrame._object.characteristic._object));
+        // controller
+        pandasDataFrame._object.controller._object = String(JSON.stringify(pandasDataFrame._object.controller._object));
+    }
+    static getBaseVoltageAsNumber(node) {
+        var _a;
+        let baseKV = 0;
+        if (node instanceof ConnectivityNode_1.ConnectivityNode) {
+            const cn = node;
+            if (cn.connectivityNodeContainer) {
+                baseKV = cn.getBaseVoltageAsNumber();
+            }
+        }
+        else if (node instanceof TopologicalNode_1.TopologicalNode) {
+            const tp = node;
+            if (tp.baseVoltage) {
+                baseKV = (_a = tp.baseVoltage.nominalVoltage) === null || _a === void 0 ? void 0 : _a.value;
+            }
+        }
+        return baseKV;
+    }
+    static createPandaPowerTypeFromValues(pandasDataFrame, type, un, ir, x, r, c) {
+        const stdTypeLines = pandasDataFrame._object.std_types.line;
+        /** Pro Stromkreiabschnitt einen Typ anlegen,
+         * um nach jedem e.action Durchlauf ursprünglichen Zustand gerstellen zu können.
+         * Typen aus dem Betriebsmittelkatalog haben u.U. unterschiedliche Impedanzen. */
+        const uuid = common_utils_1.CommonUtils.generateUUID();
+        stdTypeLines[uuid] = {
+            type,
+            r_ohm_per_km: r,
+            q_mm2: '',
+            x_ohm_per_km: x,
+            c_nf_per_km: c,
+            max_i_ka: ir,
+            vn_kv: un,
+            name: uuid,
+            uuid,
+            artificial: true
+        };
+        return uuid;
+    }
+    static createStdTypeTrafo2WFromValues(types, w1Ur, w2Ur, s) {
+        const un1 = PowerflowUtil.getNominalVoltage(w1Ur);
+        const un2 = PowerflowUtil.getNominalVoltage(w2Ur);
+        for (const [key, value] of Object.entries(types)) {
+            const typData = types[key];
+            if (typData && typData['vn_hv_kv'] === un1 && typData['vn_lv_kv'] === un2 && typData['sn_mva'] === s) {
+                return { key, value };
+            }
+        }
+        return undefined;
+    }
+    static createStdTypeTrafo3WFromValues(types, w1Ur, w2Ur, w3Ur, w1Sr, w2Sr, w3Sr) {
+        const un1 = PowerflowUtil.getNominalVoltage(w1Ur);
+        const un2 = PowerflowUtil.getNominalVoltage(w2Ur);
+        const un3 = PowerflowUtil.getNominalVoltage(w3Ur);
+        for (const [key, value] of Object.entries(types)) {
+            // key -> Typname
+            const typData = types[key];
+            if (typData && typData['vn_hv_kv'] === un1 && typData['vn_mv_kv'] === un2 && typData['vn_lv_kv'] === un3) {
+                if (typData && typData['sn_hv_mva'] === w1Sr && typData['sn_mv_mva'] === w2Sr && typData['sn_lv_mva'] === w3Sr) {
+                    return { key, value };
+                }
+            }
+        }
+        return undefined;
+    }
+    /** Normiert Bemessungsspannung (Ur) zu Nennspannung (Un)
+     * +/- 7%
+     * z.B. Ur=115 => Un=110 */
+    static getNominalVoltage(ur) {
+        /** Un 380 +/- 7% kV*/
+        if (ur > 354 && ur < 407) {
+            return 380;
+        }
+        /** Un 220 +/- 7% kV*/
+        else if (ur > 204 && ur < 235) {
+            return 220;
+        }
+        /** Un 110 +/- 10% kV*/
+        else if (ur > 100 && ur < 121) {
+            return 110;
+        }
+        /** Un 30 +/- 10% kV*/
+        else if (ur > 26 && ur < 34) {
+            return 30;
+        }
+        /** Un 20 +/- 10% kV*/
+        else if (ur > 17 && ur < 23) {
+            return 20;
+        }
+        /** Un 10 +/- 10% kV*/
+        else if (ur > 8 && ur < 12) {
+            return 10;
+        }
+        /** Un 0.4 +/- 10% kV*/
+        else if (ur > 0.36 && ur < 0.44) {
+            return 0.4;
+        }
+        else {
+            /** Un 110 */
+            return 110;
+        }
+    }
+    static addSwitch(switchElement, uuidToIndex, ppSwitchData) {
+        const isClosed = switchElement.isClosed();
+        const isConnected = switchElement.isConnected();
+        const connections = switchElement.getBusConnections();
+        if (connections.length == 2) {
+            const start = connections[0];
+            const ziel = connections[1];
+            if (uuidToIndex.has(start === null || start === void 0 ? void 0 : start.mrid) && uuidToIndex.has(ziel === null || ziel === void 0 ? void 0 : ziel.mrid)) {
+                const busID1 = uuidToIndex.get(start.mrid);
+                const busID2 = uuidToIndex.get(ziel.mrid);
+                // "bus","element","et","type","closed","name","z_ohm", in_ka
+                // bus,element,et,type,closed,name,z_ohm,in_ka
+                // [1, 0.0, 0.0,false,true,null,21.7,12.7,1.0,null,null]
+                const switchEl = [busID1, busID2, 'b', 'LBS', (isClosed && isConnected), switchElement.mrid, 0, 1000];
+                ppSwitchData.data.push(switchEl);
+                ppSwitchData.index.push(ppSwitchData.data.length - 1);
+            }
+        }
+    }
+    /** Junctions werden als Bus-Bus Switch abgebildet
+     *  et="b", type="CB" */
+    static addJunctionSwitch(junction, uuidToIndex, ppSwitchData) {
+        const isConnected = junction.isConnected();
+        const connections = junction.getBusConnections();
+        if (connections.length == 2) {
+            const start = connections[0];
+            const ziel = connections[1];
+            if (uuidToIndex.has(start === null || start === void 0 ? void 0 : start.mrid) && uuidToIndex.has(ziel === null || ziel === void 0 ? void 0 : ziel.mrid)) {
+                const busID1 = uuidToIndex.get(start.mrid);
+                const busID2 = uuidToIndex.get(ziel.mrid);
+                // "bus","element","et","type","closed","name","z_ohm"
+                // [1, 0.0, 0.0,false,true,null,21.7,12.7,1.0,null,null]
+                const switchEl = [busID1, busID2, 'b', 'CB', isConnected, junction.mrid, 0];
+                ppSwitchData.data.push(switchEl);
+                ppSwitchData.index.push(ppSwitchData.data.length - 1);
+            }
+        }
+    }
+}
+exports.PowerflowUtil = PowerflowUtil;
+PowerflowUtil.scalingFactor = 0.2;
+PowerflowUtil.scalingFactorRn = 0.2;
+PowerflowUtil.synchronousMachineUUIDs = ["eafca6d1-4299-48bc-bf20-fe531c25871a", "720354d3-de47-4a0b-b40d-65a996668b88", "bcba52b6-8d94-4393-a6e4-cfbb5714ec78", "46b9e4e5-8a9d-4b82-8c84-428514bd397a", "b317798e-eca3-4a6d-bf26-a7e53cb09297"];
+function getKrInfo(tpLoadsNfeeders) {
+    var _a;
+    /** Ersatzleistungszahl */
+    let krSum = 0;
+    let elementWithHighestKr;
+    const wardsWithKrOnly = new Array();
+    const wardsWithTargetVoltageOnly = new Array();
+    const wardsWithTargetVoltageKr = new Array();
+    const gensWithKrOnly = new Array();
+    const gensWithTargetVoltageOnly = new Array();
+    const gensWithTargetVoltageKr = new Array();
+    const sgensWithKrOnly = new Array();
+    const sgensWithTargetVoltageOnly = new Array();
+    const sgensWithTargetVoltageKr = new Array();
+    for (const loadsNfeeders of tpLoadsNfeeders.values()) {
+        for (const entry of loadsNfeeders.entries()) {
+            const key = entry[0];
+            if (key.includes('INTEGRALEquivalentInjection')) {
+                const valuesArr = entry[1];
+                for (let i = 0; i < valuesArr.length; i++) {
+                    const equivalentInjection = valuesArr[i];
+                    if (PowerflowUtil.synchronousMachineUUIDs.includes(equivalentInjection.getUUID()))
+                        continue;
+                    const hasKr = !isNaN(equivalentInjection.kr);
+                    const hasTargetVoltage = !isNaN(equivalentInjection.regulationTarget);
+                    // Fall 1
+                    if (hasKr && hasTargetVoltage) {
+                        wardsWithTargetVoltageKr.push(equivalentInjection);
+                    }
+                    else if (hasTargetVoltage) {
+                        wardsWithTargetVoltageOnly.push(equivalentInjection);
+                    }
+                    else if (hasKr) {
+                        wardsWithKrOnly.push(equivalentInjection);
+                    }
+                    if (!hasKr)
+                        continue;
+                    krSum += equivalentInjection.kr;
+                    if (!elementWithHighestKr) {
+                        elementWithHighestKr = equivalentInjection;
+                    }
+                    else if (elementWithHighestKr.kr < equivalentInjection.kr) {
+                        elementWithHighestKr = equivalentInjection;
+                    }
+                }
+            }
+            else if (key.includes('SynchronousMachine')) {
+                const valuesArr = entry[1];
+                for (let i = 0; i < valuesArr.length; i++) {
+                    const synchronousMachine = valuesArr[i];
+                    if (PowerflowUtil.synchronousMachineUUIDs.includes(synchronousMachine.getUUID()))
+                        continue;
+                    if (synchronousMachine.normallyInService !== true)
+                        continue;
+                    const generatingUnit = synchronousMachine.generatingUnit;
+                    /** KR-Zahl => (governorSCD * nominalP ) / (100 * 50hz)  */
+                    // const kr = generatingUnit ? ((generatingUnit.governorSCD * generatingUnit.nominalP) / (100 * 50)) : 0;
+                    const hasKr = !isNaN(synchronousMachine.kr);
+                    const hasTargetVoltage = !isNaN((_a = synchronousMachine.regulatingControl) === null || _a === void 0 ? void 0 : _a.targetValue);
+                    // Fall 1
+                    if (hasKr && hasTargetVoltage) {
+                        gensWithTargetVoltageKr.push(synchronousMachine);
+                    }
+                    else if (hasTargetVoltage) {
+                        gensWithTargetVoltageOnly.push(synchronousMachine);
+                    }
+                    else if (hasKr) {
+                        gensWithKrOnly.push(synchronousMachine);
+                    }
+                    if (!hasKr)
+                        continue;
+                    krSum += synchronousMachine.kr;
+                    if (!elementWithHighestKr) {
+                        elementWithHighestKr = synchronousMachine;
+                    }
+                    else if (elementWithHighestKr.kr < synchronousMachine.kr) {
+                        elementWithHighestKr = synchronousMachine;
+                    }
+                }
+            }
+            else if (key.includes('EnergySource')) {
+                const valuesArr = entry[1];
+                for (let i = 0; i < valuesArr.length; i++) {
+                    const energySource = valuesArr[i];
+                    if (PowerflowUtil.synchronousMachineUUIDs.includes(energySource.getUUID()))
+                        continue;
+                    if (energySource.normallyInService !== true)
+                        continue;
+                    /** KR-Zahl => (governorSCD * nominalP ) / (100 * 50hz)  */
+                    const hasKr = !isNaN(energySource.kr);
+                    if (!hasKr)
+                        continue;
+                    sgensWithKrOnly.push(energySource);
+                    krSum += energySource.kr;
+                    if (!elementWithHighestKr) {
+                        elementWithHighestKr = energySource;
+                    }
+                    else if (elementWithHighestKr.kr < energySource.kr) {
+                        elementWithHighestKr = energySource;
+                    }
+                }
+            }
+        }
+    }
+    return {
+        krSum,
+        elementWithHighestKr,
+        wardsWithKrOnly,
+        wardsWithTargetVoltageOnly,
+        wardsWithTargetVoltageKr,
+        gensWithKrOnly,
+        gensWithTargetVoltageOnly,
+        gensWithTargetVoltageKr,
+        sgensWithKrOnly
+    };
+}
+exports.getKrInfo = getKrInfo;
+//# sourceMappingURL=powerflow.util.js.map