Elements data update

Elements data update after fault calculation implemented.

6 files changed, 203 insertions, 3 deletions

diff --git a/Project/Fault.cpp b/Project/Fault.cpp
index 058b4ea..77ff6de 100644
--- a/Project/Fault.cpp
+++ b/Project/Fault.cpp
@@ -230,9 +230,144 @@ void Fault::UpdateElementsFault(double systemPowerBase)
             line->SetElectricalData(data);
         }
     }
-    
+
     for(auto it = m_transformerList.begin(), itEnd = m_transformerList.end(); it != itEnd; ++it) {
         Transformer* transformer = *it;
-        
+        if(transformer->IsOnline()) {
+            int n1 = static_cast<Bus*>(transformer->GetParentList()[0])->GetEletricalData().number;
+            int n2 = static_cast<Bus*>(transformer->GetParentList()[1])->GetEletricalData().number;
+            auto data = transformer->GetElectricalData();
+
+            std::complex<double> vPos[2] = { m_posFaultVoltagePos[n1], m_posFaultVoltagePos[n2] };
+            std::complex<double> vNeg[2] = { m_posFaultVoltageNeg[n1], m_posFaultVoltageNeg[n2] };
+            std::complex<double> vZero[2] = { m_posFaultVoltageZero[n1], m_posFaultVoltageZero[n2] };
+            std::complex<double> zPos(data.resistance, data.indReactance);
+            std::complex<double> zZero(data.zeroResistance, data.zeroIndReactance);
+
+            std::complex<double> transformerCurrentPos[2];
+            std::complex<double> transformerCurrentNeg[2];
+            std::complex<double> transformerCurrentZero[2];
+
+            if(data.turnsRatio == 1.0 && data.phaseShift == 0.0) {
+                transformerCurrentPos[0] = (vPos[0] - vPos[1]) / zPos;
+                transformerCurrentNeg[0] = (vNeg[0] - vNeg[1]) / zPos;
+                transformerCurrentZero[0] = (vZero[0] - vZero[1]) / zZero;
+                transformerCurrentPos[1] = (vPos[1] - vPos[0]) / zPos;
+                transformerCurrentNeg[1] = (vNeg[1] - vNeg[0]) / zPos;
+                transformerCurrentZero[1] = (vZero[1] - vZero[0]) / zZero;
+            } else {
+                double radPhaseShift = wxDegToRad(data.phaseShift);
+                std::complex<double> t = std::complex<double>(
+                    data.turnsRatio * std::cos(radPhaseShift), -data.turnsRatio * std::sin(radPhaseShift));
+
+                transformerCurrentPos[0] =
+                    vPos[0] * (1.0 / (std::pow(std::abs(t), 2.0) * zPos)) - vPos[1] * (1.0 / (std::conj(t) * zPos));
+                transformerCurrentNeg[0] =
+                    vNeg[0] * (1.0 / (std::pow(std::abs(t), 2.0) * zPos)) - vNeg[1] * (1.0 / (t * zPos));
+
+                transformerCurrentPos[1] = -vPos[0] * (1.0 / (t * zPos)) + vPos[1] / zPos;
+                transformerCurrentNeg[1] = -vNeg[0] * (1.0 / (std::conj(t) * zPos)) + vNeg[1] / zPos;
+            }
+
+            switch(data.connection) {
+                case GWYE_GWYE: {
+                    transformerCurrentZero[0] = (vZero[0] - vZero[1]) / zZero;
+                    transformerCurrentZero[1] = (vZero[1] - vZero[0]) / zZero;
+                    break;
+                }
+                case GWYE_DELTA: {
+                    transformerCurrentZero[0] = vZero[0] / zZero;
+                    transformerCurrentZero[1] = std::complex<double>(0.0, 0.0);
+                    break;
+                }
+                case DELTA_GWYE: {
+                    transformerCurrentZero[0] = std::complex<double>(0.0, 0.0);
+                    transformerCurrentZero[1] = vZero[1] / zZero;
+                    break;
+                }
+                default: {
+                    transformerCurrentZero[0] = std::complex<double>(0.0, 0.0);
+                    transformerCurrentZero[1] = std::complex<double>(0.0, 0.0);
+                    break;
+                }
+            }
+
+            data.faultCurrent[0][0] = transformerCurrentPos[0] + transformerCurrentNeg[0] + transformerCurrentZero[0];
+            data.faultCurrent[1][0] =
+                transformerCurrentPos[0] + a2 * transformerCurrentNeg[0] + a * transformerCurrentZero[0];
+            data.faultCurrent[2][0] =
+                transformerCurrentPos[0] + a * transformerCurrentNeg[0] + a2 * transformerCurrentZero[0];
+            data.faultCurrent[0][1] = transformerCurrentPos[1] + transformerCurrentNeg[1] + transformerCurrentZero[1];
+            data.faultCurrent[1][1] =
+                transformerCurrentPos[1] + a2 * transformerCurrentNeg[1] + a * transformerCurrentZero[1];
+            data.faultCurrent[2][1] =
+                transformerCurrentPos[1] + a * transformerCurrentNeg[1] + a2 * transformerCurrentZero[1];
+
+            transformer->SetElectricaData(data);
+        }
+    }
+
+    for(auto it = m_syncGeneratorList.begin(), itEnd = m_syncGeneratorList.end(); it != itEnd; ++it) {
+        SyncGenerator* syncGenerator = *it;
+        if(syncGenerator->IsOnline()) {
+            Bus* bus = static_cast<Bus*>(syncGenerator->GetParentList()[0]);
+            int n = bus->GetEletricalData().number;
+            std::complex<double> v = bus->GetEletricalData().voltage; // Pre-fault voltage.
+            auto data = syncGenerator->GetElectricalData();
+
+            std::complex<double> vPos = m_posFaultVoltagePos[n];
+            std::complex<double> vNeg = m_posFaultVoltageNeg[n];
+            std::complex<double> vZero = m_posFaultVoltageZero[n];
+
+            std::complex<double> zPos(data.positiveResistance, data.positiveReactance);
+            std::complex<double> zNeg(data.negativeResistance, data.negativeReactance);
+            std::complex<double> zZero(
+                data.zeroResistance + 3.0 * data.groundResistance, data.negativeReactance + 3.0 * data.groundReactance);
+
+            std::complex<double> syncGeneratorCurrentPos = (v - vPos) / zPos;
+            std::complex<double> syncGeneratorCurrentNeg = (-vNeg) / zNeg;
+            std::complex<double> syncGeneratorCurrentZero(0.0, 0.0);
+            if(data.groundNeutral) syncGeneratorCurrentZero = (-vZero) / zZero;
+
+            data.faultCurrent[0] = syncGeneratorCurrentPos + syncGeneratorCurrentNeg + syncGeneratorCurrentZero;
+            data.faultCurrent[1] =
+                syncGeneratorCurrentPos + a2 * syncGeneratorCurrentNeg + a * syncGeneratorCurrentZero;
+            data.faultCurrent[2] =
+                syncGeneratorCurrentPos + a * syncGeneratorCurrentNeg + a2 * syncGeneratorCurrentZero;
+
+            syncGenerator->SetElectricalData(data);
+        }
+    }
+
+    for(auto it = m_syncMotorList.begin(), itEnd = m_syncMotorList.end(); it != itEnd; ++it) {
+        SyncMotor* syncMotor = *it;
+        if(syncMotor->IsOnline()) {
+            Bus* bus = static_cast<Bus*>(syncMotor->GetParentList()[0]);
+            int n = bus->GetEletricalData().number;
+            std::complex<double> v = bus->GetEletricalData().voltage; // Pre-fault voltage.
+            auto data = syncMotor->GetElectricalData();
+
+            std::complex<double> vPos = m_posFaultVoltagePos[n];
+            std::complex<double> vNeg = m_posFaultVoltageNeg[n];
+            std::complex<double> vZero = m_posFaultVoltageZero[n];
+
+            std::complex<double> zPos(data.positiveResistance, data.positiveReactance);
+            std::complex<double> zNeg(data.negativeResistance, data.negativeReactance);
+            std::complex<double> zZero(
+                data.zeroResistance + 3.0 * data.groundResistance, data.negativeReactance + 3.0 * data.groundReactance);
+
+            std::complex<double> syncGeneratorCurrentPos = (v - vPos) / zPos;
+            std::complex<double> syncGeneratorCurrentNeg = (-vNeg) / zNeg;
+            std::complex<double> syncGeneratorCurrentZero(0.0, 0.0);
+            if(data.groundNeutral) syncGeneratorCurrentZero = (-vZero) / zZero;
+
+            data.faultCurrent[0] = syncGeneratorCurrentPos + syncGeneratorCurrentNeg + syncGeneratorCurrentZero;
+            data.faultCurrent[1] =
+                syncGeneratorCurrentPos + a2 * syncGeneratorCurrentNeg + a * syncGeneratorCurrentZero;
+            data.faultCurrent[2] =
+                syncGeneratorCurrentPos + a * syncGeneratorCurrentNeg + a2 * syncGeneratorCurrentZero;
+
+            syncMotor->SetElectricalData(data);
+        }
     }
 }
diff --git a/Project/Fault.h b/Project/Fault.h
index dfe0e75..c3caef7 100644
--- a/Project/Fault.h
+++ b/Project/Fault.h
@@ -2,16 +2,49 @@
 #define FAULT_H
 
 #include "ElectricCalculation.h"
+/**
+ * @class Fault
+ * @author Thales Lima Oliveira
+ * @date 10/01/2017
+ * @file Fault.h
+ * @brief Calculate the fault of the system and update the elements data.
+ */
 
 class Fault : public ElectricCalculation
 {
 public:
+    /**
+     * @brief Contructor.
+     * @param elementList List of elements in workspace
+     */
     Fault(std::vector<Element*> elementList);
+
+    /**
+     * @brief Default contructor. Use GetElementsFromList(std::vector<Element*> elementList).
+     */
     Fault();
+
+    /**
+     * @brief Destructor.
+     */
     ~Fault();
 
+    /**
+     * @brief Calculate the fault of the system. Return true if was possible the calculation.
+     * @param systemPowerBase System base of power.
+     */
     virtual bool RunFaultCalculation(double systemPowerBase);
+
+    /**
+     * @brief Update the data of the elements.
+     * @param systemPowerBase System base of power.
+     */
     virtual void UpdateElementsFault(double systemPowerBase);
+
+    /**
+     * @brief Get the error message generated in RunFaultCalculation(double systemPowerBase).
+     * @return Error message.
+     */
     virtual wxString GetErrorMessage() { return m_errorMsg; }
 
 protected:
diff --git a/Project/MainFrame.cpp b/Project/MainFrame.cpp
index ef9f327..254c081 100644
--- a/Project/MainFrame.cpp
+++ b/Project/MainFrame.cpp
@@ -151,6 +151,7 @@ void MainFrame::OnDisableSolutionClick(wxRibbonButtonBarEvent& event)
 }
 
 void MainFrame::OnDragClick(wxRibbonButtonBarEvent& event) {}
+
 void MainFrame::OnEnableSolutionClick(wxRibbonButtonBarEvent& event)
 {
     m_ribbonButtonBarContinuous->ToggleButton(ID_RIBBON_ENABLESOL, true);
@@ -158,7 +159,14 @@ void MainFrame::OnEnableSolutionClick(wxRibbonButtonBarEvent& event)
 }
 
 void MainFrame::OnExpImpClick(wxRibbonButtonBarEvent& event) {}
-void MainFrame::OnFaultClick(wxRibbonButtonBarEvent& event) {}
+
+void MainFrame::OnFaultClick(wxRibbonButtonBarEvent& event)
+{
+    if(Workspace* workspace = dynamic_cast<Workspace*>(m_auiNotebook->GetCurrentPage())) {
+        workspace->RunFault();
+    }
+}
+
 void MainFrame::OnFitClick(wxRibbonButtonBarEvent& event)
 {
     Workspace* workspace = static_cast<Workspace*>(m_auiNotebook->GetCurrentPage());
@@ -166,6 +174,7 @@ void MainFrame::OnFitClick(wxRibbonButtonBarEvent& event)
         workspace->Fit();
     }
 }
+
 void MainFrame::OnMoveClick(wxRibbonButtonBarEvent& event)
 {
     Workspace* workspace = static_cast<Workspace*>(m_auiNotebook->GetCurrentPage());
@@ -192,6 +201,7 @@ void MainFrame::OnMoveClick(wxRibbonButtonBarEvent& event)
         workspace->SetWorkspaceMode(MODE_MOVE_ELEMENT);
     }
 }
+
 void MainFrame::OnOpenClick(wxRibbonButtonBarEvent& event)
 {
     wxFileDialog openFileDialog(
@@ -234,6 +244,7 @@ void MainFrame::OnPowerFlowClick(wxRibbonButtonBarEvent& event)
         workspace->RunPowerFlow();
     }
 }
+
 void MainFrame::OnProjectSettingsClick(wxRibbonButtonBarEvent& event) {}
 void MainFrame::OnRedoClick(wxRibbonButtonBarEvent& event) {}
 void MainFrame::OnResetVoltagesClick(wxRibbonButtonBarEvent& event) {}
diff --git a/Project/SyncMotor.h b/Project/SyncMotor.h
index d6e9bf1..7018e5d 100644
--- a/Project/SyncMotor.h
+++ b/Project/SyncMotor.h
@@ -32,6 +32,9 @@ struct SyncMotorElectricalData {
     double groundResistance = 0.0;
     double groundReactance = 0.0;
     bool groundNeutral = true;
+    // p.u. fault data
+    std::complex<double> faultCurrent[3] = { std::complex<double>(0.0, 0.0), std::complex<double>(0.0, 0.0),
+        std::complex<double>(0.0, 0.0) };
 
     // Stability
     bool plotSyncMachine = false;
diff --git a/Project/Workspace.cpp b/Project/Workspace.cpp
index e668bf3..d09efad 100644
--- a/Project/Workspace.cpp
+++ b/Project/Workspace.cpp
@@ -15,6 +15,7 @@
 #include "Text.h"
 
 #include "PowerFlow.h"
+#include "Fault.h"
 
 // Camera
 Camera::Camera()
@@ -1413,3 +1414,18 @@ std::vector<Element*> Workspace::GetAllElements() const
 
     return allElements;
 }
+
+bool Workspace::RunFault()
+{
+    Fault fault(m_elementList);
+    bool result = fault.RunFaultCalculation(100e6);
+    if(!result) {
+        wxMessageDialog msgDialog(this, fault.GetErrorMessage(), _("Error"), wxOK | wxCENTRE | wxICON_ERROR);
+        msgDialog.ShowModal();
+    }
+
+    UpdateTextElements();
+    Redraw();
+
+    return result;
+}
diff --git a/Project/Workspace.h b/Project/Workspace.h
index e4e0a37..f138410 100644
--- a/Project/Workspace.h
+++ b/Project/Workspace.h
@@ -28,6 +28,7 @@ class ElementDataObject;
 class Text;
 
 class PowerFlow;
+class Fault;
 
 enum WorkspaceMode {
     MODE_EDIT = 0,
@@ -103,6 +104,7 @@ public:
     void IncrementElementNumber(ElementID elementID) { m_elementNumber[elementID]++; }
 
     bool RunPowerFlow();
+    bool RunFault();
 
 protected:
     virtual void OnIdle(wxIdleEvent& event);