1 files changed, 74 insertions, 60 deletions
diff --git a/Project/SyncGenerator.cpp b/Project/SyncGenerator.cpp
index 2579cef..5718090 100644
--- a/Project/SyncGenerator.cpp
+++ b/Project/SyncGenerator.cpp
@@ -59,69 +59,83 @@ bool SyncGenerator::ShowForm(wxWindow* parent, Element* element)
 SyncGeneratorElectricalData SyncGenerator::GetPUElectricalData(double systemPowerBase)
 {
     SyncGeneratorElectricalData data = m_electricalData;
-    switch(data.activePowerUnit) {
-        case UNIT_W: {
-            data.activePower = data.activePower / systemPowerBase;
-            data.activePowerUnit = UNIT_PU;
-        } break;
-        case UNIT_kW: {
-            data.activePower = (data.activePower * 1e3) / systemPowerBase;
-            data.activePowerUnit = UNIT_PU;
-        } break;
-        case UNIT_MW: {
-            data.activePower = (data.activePower * 1e6) / systemPowerBase;
-            data.activePowerUnit = UNIT_PU;
-        } break;
-        default:
-            break;
+    double machineBasePower = 1.0;
+    if(data.useMachineBase) {
+        machineBasePower = GetValueFromUnit(data.nominalPower, data.nominalPowerUnit);
     }
-    switch(data.reactivePowerUnit) {
-        case UNIT_VAr: {
-            data.reactivePower = data.reactivePower / systemPowerBase;
-            data.reactivePowerUnit = UNIT_PU;
-        } break;
-        case UNIT_kVAr: {
-            data.reactivePower = (data.reactivePower * 1e3) / systemPowerBase;
-            data.reactivePowerUnit = UNIT_PU;
-        } break;
-        case UNIT_MVAr: {
-            data.reactivePower = (data.reactivePower * 1e6) / systemPowerBase;
-            data.reactivePowerUnit = UNIT_PU;
-        } break;
-        default:
-            break;
+
+    // Active power
+    double activePower = GetValueFromUnit(data.activePower, data.activePowerUnit);
+    if(!m_online) activePower = 0.0;
+    if(data.activePowerUnit == UNIT_PU) {
+        if(data.useMachineBase) data.activePower = (activePower * machineBasePower) / systemPowerBase;
+    } else {
+        data.activePower = activePower / systemPowerBase;
     }
-    switch(data.maxReactiveUnit) {
-        case UNIT_VAr: {
-            data.maxReactive = data.maxReactive / systemPowerBase;
-            data.maxReactiveUnit = UNIT_PU;
-        } break;
-        case UNIT_kVAr: {
-            data.maxReactive = (data.maxReactive * 1e3) / systemPowerBase;
-            data.maxReactiveUnit = UNIT_PU;
-        } break;
-        case UNIT_MVAr: {
-            data.maxReactive = (data.maxReactive * 1e6) / systemPowerBase;
-            data.maxReactiveUnit = UNIT_PU;
-        } break;
-        default:
-            break;
+    data.activePowerUnit = UNIT_PU;
+
+    // Reactive power
+    double reactivePower = GetValueFromUnit(data.reactivePower, data.reactivePowerUnit);
+    if(!m_online) reactivePower = 0.0;
+    if(data.reactivePowerUnit == UNIT_PU) {
+        if(data.useMachineBase) data.reactivePower = (reactivePower * machineBasePower) / systemPowerBase;
+    } else {
+        data.reactivePower = reactivePower / systemPowerBase;
     }
-    switch(data.minReactiveUnit) {
-        case UNIT_VAr: {
-            data.minReactive = data.minReactive / systemPowerBase;
-            data.minReactiveUnit = UNIT_PU;
-        } break;
-        case UNIT_kVAr: {
-            data.minReactive = (data.minReactive * 1e3) / systemPowerBase;
-            data.minReactiveUnit = UNIT_PU;
-        } break;
-        case UNIT_MVAr: {
-            data.minReactive = (data.minReactive * 1e6) / systemPowerBase;
-            data.minReactiveUnit = UNIT_PU;
-        } break;
-        default:
-            break;
+    data.reactivePowerUnit = UNIT_PU;
+
+    // Max reactive power
+    double maxReactive = GetValueFromUnit(data.maxReactive, data.maxReactiveUnit);
+    if(data.maxReactiveUnit == UNIT_PU) {
+        if(data.useMachineBase) data.maxReactive = (maxReactive * machineBasePower) / systemPowerBase;
+    } else {
+        data.maxReactive = maxReactive / systemPowerBase;
+    }
+    data.maxReactiveUnit = UNIT_PU;
+
+    // Min reactive power
+    double minReactive = GetValueFromUnit(data.minReactive, data.minReactiveUnit);
+    if(data.minReactiveUnit == UNIT_PU) {
+        if(data.useMachineBase) data.minReactive = (minReactive * machineBasePower) / systemPowerBase;
+    } else {
+        data.minReactive = minReactive / systemPowerBase;
+    }
+    data.minReactiveUnit = UNIT_PU;
+
+    double baseVoltage = GetValueFromUnit(data.nominalVoltage, data.nominalVoltageUnit);
+    double systemBaseImpedance = (baseVoltage * baseVoltage) / systemPowerBase;
+    double machineBaseImpedance = (baseVoltage * baseVoltage) / machineBasePower;
+
+    // Fault data
+
+    // Pos. seq. resistance
+    double r1 = data.positiveResistance;
+    if(data.useMachineBase) data.positiveResistance = (r1 * machineBaseImpedance) / systemBaseImpedance;
+
+    // Pos. seq. reactance
+    double x1 = data.positiveReactance;
+    if(data.useMachineBase) data.positiveReactance = (x1 * machineBaseImpedance) / systemBaseImpedance;
+
+    // Neg. seq. resistance
+    double r2 = data.negativeResistance;
+    if(data.useMachineBase) data.negativeResistance = (r2 * machineBaseImpedance) / systemBaseImpedance;
+
+    // Neg. seq. reactance
+    double x2 = data.negativeReactance;
+    if(data.useMachineBase) data.negativeReactance = (x2 * machineBaseImpedance) / systemBaseImpedance;
+
+    // Zero seq. resistance
+    double r0 = data.zeroResistance;
+    if(data.useMachineBase) data.zeroResistance = (r0 * machineBaseImpedance) / systemBaseImpedance;
+
+    // Zero seq. reactance
+    double x0 = data.zeroReactance;
+    if(data.useMachineBase) data.zeroReactance = (x0 * machineBaseImpedance) / systemBaseImpedance;
+    
+    if(!m_online) {
+        data.faultCurrent[0] = std::complex<double>(0,0);
+        data.faultCurrent[1] = std::complex<double>(0,0);
+        data.faultCurrent[2] = std::complex<double>(0,0);
     }
 
     return data;