Merge pull request #34 from Thales1330/wip-datareport

Wip datareport

1 files changed, 1003 insertions, 0 deletions

diff --git a/Project/DataReport.cpp b/Project/DataReport.cpp
new file mode 100644
index 0000000..01a1e1d
--- /dev/null
+++ b/Project/DataReport.cpp
@@ -0,0 +1,1003 @@
+#include "DataReport.h"
+#include "Workspace.h"
+#include "ElectricCalculation.h"
+
+DataReport::DataReport(wxWindow* parent, Workspace* workspace) : DataReportBase(parent)
+{
+    m_workspace = workspace;
+
+    m_headerColour = wxColour(150, 150, 150);
+    m_offlineColour = wxColour(100, 100, 100);
+    m_oddRowColour = wxColour(220, 220, 220);
+    m_evenRowColour = wxColour(255, 255, 255);
+
+    CreateGrids();
+    SetHeaders();
+    FillValues();
+
+    SetRowsColours(m_gridPowerFlow);
+    SetRowsColours(m_gridPFBuses);
+    SetRowsColours(m_gridPFBranches);
+    SetRowsColours(m_gridFault, 2);
+    SetRowsColours(m_gridFaultBuses, 2);
+    SetRowsColours(m_gridFaultBranches, 2);
+    SetRowsColours(m_gridFaultGenerators, 2);
+
+    Layout();
+}
+
+DataReport::~DataReport() {}
+void DataReport::CreateGrids()
+{
+    wxFont headerFont = m_gridPowerFlow->GetLabelFont();
+    headerFont.SetWeight(wxFONTWEIGHT_BOLD);
+
+    ElectricCalculation eCalc;
+    eCalc.GetElementsFromList(m_workspace->GetElementList());
+    auto lineList = eCalc.GetLineList();
+    auto transformerList = eCalc.GetTransformerList();
+    auto busList = eCalc.GetBusList();
+    auto generatorList = eCalc.GetSyncGeneratorList();
+
+    // Power Flow
+    // Header
+    m_gridPowerFlow->AppendCols(7);
+    m_gridPowerFlow->AppendRows();
+    m_gridPowerFlow->HideColLabels();
+    m_gridPowerFlow->HideRowLabels();
+    for(int i = 0; i < 7; ++i) {
+        m_gridPowerFlow->SetCellBackgroundColour(0, i, m_headerColour);
+        m_gridPowerFlow->SetCellFont(0, i, headerFont);
+    }
+    m_gridPowerFlow->SetDefaultCellAlignment(wxALIGN_CENTRE, wxALIGN_CENTRE);
+    // Values
+    m_gridPowerFlow->AppendRows((lineList.size() + transformerList.size()) * 2);
+    m_gridPowerFlow->AutoSize();
+
+    // Power Flow buses
+    // Header
+    m_gridPFBuses->AppendCols(6);
+    m_gridPFBuses->AppendRows();
+    m_gridPFBuses->HideColLabels();
+    m_gridPFBuses->HideRowLabels();
+    for(int i = 0; i < 6; ++i) {
+        m_gridPFBuses->SetCellBackgroundColour(0, i, m_headerColour);
+        m_gridPFBuses->SetCellFont(0, i, headerFont);
+    }
+    m_gridPFBuses->SetDefaultCellAlignment(wxALIGN_CENTRE, wxALIGN_CENTRE);
+    // Values
+    m_gridPFBuses->AppendRows(busList.size());
+    m_gridPFBuses->AutoSize();
+
+    // Power flow branches
+    // Header
+    m_gridPFBranches->AppendCols(10);
+    m_gridPFBranches->AppendRows(1);
+    m_gridPFBranches->HideColLabels();
+    m_gridPFBranches->HideRowLabels();
+    for(int i = 0; i < 10; ++i) {
+        m_gridPFBranches->SetCellBackgroundColour(0, i, m_headerColour);
+        m_gridPFBranches->SetCellFont(0, i, headerFont);
+    }
+    m_gridPFBranches->SetDefaultCellAlignment(wxALIGN_CENTRE, wxALIGN_CENTRE);
+    // Values
+    m_gridPFBranches->AppendRows(lineList.size() + transformerList.size());
+    m_gridPFBranches->AutoSize();
+
+    // Fault
+    // Header
+    m_gridFault->AppendCols(7);
+    m_gridFault->AppendRows(2);
+    m_gridFault->HideColLabels();
+    m_gridFault->HideRowLabels();
+    for(int i = 0; i < 2; ++i) {
+        for(int j = 0; j < 7; ++j) {
+            m_gridFault->SetCellBackgroundColour(i, j, m_headerColour);
+            m_gridFault->SetCellFont(i, j, headerFont);
+        }
+    }
+    m_gridFault->SetDefaultCellAlignment(wxALIGN_CENTRE, wxALIGN_CENTRE);
+    m_gridFault->SetCellSize(0, 0, 2, 1);
+    m_gridFault->SetCellSize(0, 1, 1, 2);
+    m_gridFault->SetCellSize(0, 3, 1, 2);
+    m_gridFault->SetCellSize(0, 5, 1, 2);
+    // Values
+    for(auto it = busList.begin(), itEnd = busList.end(); it != itEnd; ++it) {
+        Bus* bus = *it;
+        if(bus->GetElectricalData().hasFault) m_gridFault->AppendRows();
+    }
+    m_gridFault->AutoSize();
+
+    // Fault buses
+    // Header
+    m_gridFaultBuses->AppendCols(7);
+    m_gridFaultBuses->AppendRows(2);
+    m_gridFaultBuses->HideColLabels();
+    m_gridFaultBuses->HideRowLabels();
+    for(int i = 0; i < 2; ++i) {
+        for(int j = 0; j < 7; ++j) {
+            m_gridFaultBuses->SetCellBackgroundColour(i, j, m_headerColour);
+            m_gridFaultBuses->SetCellFont(i, j, headerFont);
+        }
+    }
+    m_gridFaultBuses->SetDefaultCellAlignment(wxALIGN_CENTRE, wxALIGN_CENTRE);
+    m_gridFaultBuses->SetCellSize(0, 0, 2, 1);
+    m_gridFaultBuses->SetCellSize(0, 1, 1, 2);
+    m_gridFaultBuses->SetCellSize(0, 3, 1, 2);
+    m_gridFaultBuses->SetCellSize(0, 5, 1, 2);
+    // Values
+    m_gridFaultBuses->AppendRows(busList.size());
+    m_gridFaultBuses->AutoSize();
+
+    // Fault branches
+    // Header
+    m_gridFaultBranches->AppendCols(11);
+    m_gridFaultBranches->AppendRows(2);
+    m_gridFaultBranches->HideColLabels();
+    m_gridFaultBranches->HideRowLabels();
+    for(int i = 0; i < 2; ++i) {
+        for(int j = 0; j < 11; ++j) {
+            m_gridFaultBranches->SetCellBackgroundColour(i, j, m_headerColour);
+            m_gridFaultBranches->SetCellFont(i, j, headerFont);
+        }
+    }
+    m_gridFaultBranches->SetDefaultCellAlignment(wxALIGN_CENTRE, wxALIGN_CENTRE);
+    m_gridFaultBranches->SetCellSize(0, 0, 2, 1);
+    m_gridFaultBranches->SetCellSize(0, 1, 2, 1);
+    m_gridFaultBranches->SetCellSize(0, 2, 2, 1);
+    m_gridFaultBranches->SetCellSize(0, 3, 2, 1);
+    m_gridFaultBranches->SetCellSize(0, 10, 2, 1);
+    m_gridFaultBranches->SetCellSize(0, 4, 1, 2);
+    m_gridFaultBranches->SetCellSize(0, 6, 1, 2);
+    m_gridFaultBranches->SetCellSize(0, 8, 1, 2);
+    // Values
+    m_gridFaultBranches->AppendRows((lineList.size() + transformerList.size()) * 2);
+    m_gridFaultBranches->AutoSize();
+
+    // Fault generators
+    // Header
+    m_gridFaultGenerators->AppendCols(7);
+    m_gridFaultGenerators->AppendRows(2);
+    m_gridFaultGenerators->HideColLabels();
+    m_gridFaultGenerators->HideRowLabels();
+    for(int i = 0; i < 2; ++i) {
+        for(int j = 0; j < 7; ++j) {
+            m_gridFaultGenerators->SetCellBackgroundColour(i, j, m_headerColour);
+            m_gridFaultGenerators->SetCellFont(i, j, headerFont);
+        }
+    }
+    m_gridFaultGenerators->SetDefaultCellAlignment(wxALIGN_CENTRE, wxALIGN_CENTRE);
+    m_gridFaultGenerators->SetCellSize(0, 0, 2, 1);
+    m_gridFaultGenerators->SetCellSize(0, 1, 1, 2);
+    m_gridFaultGenerators->SetCellSize(0, 3, 1, 2);
+    m_gridFaultGenerators->SetCellSize(0, 5, 1, 2);
+    // Values
+    m_gridFaultGenerators->AppendRows(generatorList.size());
+    m_gridFaultGenerators->AutoSize();
+}
+
+void DataReport::SetHeaders()
+{
+    // Headers choices fill
+    wxString omega = static_cast<wxString>(L'\u03A9');
+
+    m_voltageChoices.Add(_("Voltage (p.u.)"));
+    m_voltageChoices.Add(_("Voltage (V)"));
+    m_voltageChoices.Add(_("Voltage (kV)"));
+
+    m_activePowerChoices.Add(_("Active Power (p.u.)"));
+    m_activePowerChoices.Add(_("Active Power (W)"));
+    m_activePowerChoices.Add(_("Active Power (kW)"));
+    m_activePowerChoices.Add(_("Active Power (MW)"));
+
+    m_reactivePowerChoices.Add(_("Reactive Power (p.u.)"));
+    m_reactivePowerChoices.Add(_("Reactive Power (VAr)"));
+    m_reactivePowerChoices.Add(_("Reactive Power (kVAr)"));
+    m_reactivePowerChoices.Add(_("Reactive Power (MVAr)"));
+
+    m_resistanceChoices.Add(_("R (p.u.)"));
+    m_resistanceChoices.Add(_("R (") + omega + wxT(")"));
+
+    m_indReactanceChoices.Add(_("XL (p.u.)"));
+    m_indReactanceChoices.Add(_("XL (") + omega + wxT(")"));
+
+    m_capSusceptanceChoices.Add(_("B (p.u.)"));
+    m_capSusceptanceChoices.Add(_("B (S)"));
+
+    m_currentChoices.Add(_("Current (p.u.)"));
+    m_currentChoices.Add(_("Current (A)"));
+    m_currentChoices.Add(_("Current (kA)"));
+
+    // Power flow
+    m_gridPowerFlow->SetCellValue(0, 0, _("Type"));
+    m_gridPowerFlow->SetCellValue(0, 1, _("Name"));
+    m_gridPowerFlow->SetCellValue(0, 2, _("From"));
+    m_gridPowerFlow->SetCellValue(0, 3, _("To"));
+    m_gridPowerFlow->SetCellEditor(0, 4, new wxGridCellChoiceEditor(m_activePowerChoices));
+    m_gridPowerFlow->SetCellValue(0, 4, m_activePowerChoices[3]);
+    m_gridPowerFlow->SetCellEditor(0, 5, new wxGridCellChoiceEditor(m_reactivePowerChoices));
+    m_gridPowerFlow->SetCellValue(0, 5, m_reactivePowerChoices[3]);
+    m_gridPowerFlow->SetCellValue(0, 6, _("Online"));
+
+    // Power flow buses
+    m_gridPFBuses->SetCellValue(0, 0, _("Name"));
+    m_gridPFBuses->SetCellValue(0, 1, _("Type"));
+    m_gridPFBuses->SetCellEditor(0, 2, new wxGridCellChoiceEditor(m_voltageChoices));
+    m_gridPFBuses->SetCellValue(0, 2, m_voltageChoices[0]);
+    m_gridPFBuses->SetCellValue(0, 3, _("Angle"));
+    m_gridPFBuses->SetCellEditor(0, 4, new wxGridCellChoiceEditor(m_activePowerChoices));
+    m_gridPFBuses->SetCellValue(0, 4, m_activePowerChoices[3]);
+    m_gridPFBuses->SetCellEditor(0, 5, new wxGridCellChoiceEditor(m_reactivePowerChoices));
+    m_gridPFBuses->SetCellValue(0, 5, m_reactivePowerChoices[3]);
+
+    // Power flow branches
+    m_gridPFBranches->SetCellValue(0, 0, _("Type"));
+    m_gridPFBranches->SetCellValue(0, 1, _("Name"));
+    m_gridPFBranches->SetCellValue(0, 2, _("From"));
+    m_gridPFBranches->SetCellValue(0, 3, _("To"));
+    m_gridPFBranches->SetCellEditor(0, 4, new wxGridCellChoiceEditor(m_resistanceChoices));
+    m_gridPFBranches->SetCellValue(0, 4, m_resistanceChoices[0]);
+    m_gridPFBranches->SetCellEditor(0, 5, new wxGridCellChoiceEditor(m_indReactanceChoices));
+    m_gridPFBranches->SetCellValue(0, 5, m_indReactanceChoices[0]);
+    m_gridPFBranches->SetCellEditor(0, 6, new wxGridCellChoiceEditor(m_capSusceptanceChoices));
+    m_gridPFBranches->SetCellValue(0, 6, m_capSusceptanceChoices[0]);
+    m_gridPFBranches->SetCellValue(0, 7, _("TAP"));
+    m_gridPFBranches->SetCellValue(0, 8, _("Phase Shift"));
+    m_gridPFBranches->SetCellValue(0, 9, _("Online"));
+
+    // Fault
+    m_gridFault->SetCellValue(0, 0, _("Fault bus name"));
+    m_gridFault->SetCellValue(0, 1, _("Phase A"));
+    m_gridFault->SetCellValue(0, 3, _("Phase B"));
+    m_gridFault->SetCellValue(0, 5, _("Phase C"));
+    m_gridFault->SetCellEditor(1, 1, new wxGridCellChoiceEditor(m_currentChoices));
+    m_gridFault->SetCellValue(1, 1, m_currentChoices[1]);
+    m_gridFault->SetCellValue(1, 2, _("Angle"));
+    m_gridFault->SetCellEditor(1, 3, new wxGridCellChoiceEditor(m_currentChoices));
+    m_gridFault->SetCellValue(1, 3, m_currentChoices[1]);
+    m_gridFault->SetCellValue(1, 4, _("Angle"));
+    m_gridFault->SetCellEditor(1, 5, new wxGridCellChoiceEditor(m_currentChoices));
+    m_gridFault->SetCellValue(1, 5, m_currentChoices[1]);
+    m_gridFault->SetCellValue(1, 6, _("Angle"));
+
+    // Fault buses
+    m_gridFaultBuses->SetCellValue(0, 0, _("Name"));
+    m_gridFaultBuses->SetCellValue(0, 1, _("Phase A"));
+    m_gridFaultBuses->SetCellValue(0, 3, _("Phase B"));
+    m_gridFaultBuses->SetCellValue(0, 5, _("Phase C"));
+    m_gridFaultBuses->SetCellEditor(1, 1, new wxGridCellChoiceEditor(m_voltageChoices));
+    m_gridFaultBuses->SetCellValue(1, 1, m_voltageChoices[0]);
+    m_gridFaultBuses->SetCellValue(1, 2, _("Angle"));
+    m_gridFaultBuses->SetCellEditor(1, 3, new wxGridCellChoiceEditor(m_voltageChoices));
+    m_gridFaultBuses->SetCellValue(1, 3, m_voltageChoices[0]);
+    m_gridFaultBuses->SetCellValue(1, 4, _("Angle"));
+    m_gridFaultBuses->SetCellEditor(1, 5, new wxGridCellChoiceEditor(m_voltageChoices));
+    m_gridFaultBuses->SetCellValue(1, 5, m_voltageChoices[0]);
+    m_gridFaultBuses->SetCellValue(1, 6, _("Angle"));
+
+    // Fault branches
+    m_gridFaultBranches->SetCellValue(0, 0, _("Type"));
+    m_gridFaultBranches->SetCellValue(0, 1, _("Name"));
+    m_gridFaultBranches->SetCellValue(0, 2, _("From"));
+    m_gridFaultBranches->SetCellValue(0, 3, _("To"));
+    m_gridFaultBranches->SetCellValue(0, 4, _("Phase A"));
+    m_gridFaultBranches->SetCellValue(0, 6, _("Phase B"));
+    m_gridFaultBranches->SetCellValue(0, 8, _("Phase C"));
+    m_gridFaultBranches->SetCellValue(0, 10, _("Online"));
+    m_gridFaultBranches->SetCellEditor(1, 4, new wxGridCellChoiceEditor(m_currentChoices));
+    m_gridFaultBranches->SetCellValue(1, 4, m_currentChoices[1]);
+    m_gridFaultBranches->SetCellValue(1, 5, _("Angle"));
+    m_gridFaultBranches->SetCellEditor(1, 6, new wxGridCellChoiceEditor(m_currentChoices));
+    m_gridFaultBranches->SetCellValue(1, 6, m_currentChoices[1]);
+    m_gridFaultBranches->SetCellValue(1, 7, _("Angle"));
+    m_gridFaultBranches->SetCellEditor(1, 8, new wxGridCellChoiceEditor(m_currentChoices));
+    m_gridFaultBranches->SetCellValue(1, 8, m_currentChoices[1]);
+    m_gridFaultBranches->SetCellValue(1, 9, _("Angle"));
+
+    // Fault generators
+    m_gridFaultGenerators->SetCellValue(0, 0, _("Name"));
+    m_gridFaultGenerators->SetCellValue(0, 1, _("Phase A"));
+    m_gridFaultGenerators->SetCellValue(0, 3, _("Phase B"));
+    m_gridFaultGenerators->SetCellValue(0, 5, _("Phase C"));
+    m_gridFaultGenerators->SetCellEditor(1, 1, new wxGridCellChoiceEditor(m_currentChoices));
+    m_gridFaultGenerators->SetCellValue(1, 1, m_currentChoices[1]);
+    m_gridFaultGenerators->SetCellValue(1, 2, _("Angle"));
+    m_gridFaultGenerators->SetCellEditor(1, 3, new wxGridCellChoiceEditor(m_currentChoices));
+    m_gridFaultGenerators->SetCellValue(1, 3, m_currentChoices[1]);
+    m_gridFaultGenerators->SetCellValue(1, 4, _("Angle"));
+    m_gridFaultGenerators->SetCellEditor(1, 5, new wxGridCellChoiceEditor(m_currentChoices));
+    m_gridFaultGenerators->SetCellValue(1, 5, m_currentChoices[1]);
+    m_gridFaultGenerators->SetCellValue(1, 6, _("Angle"));
+}
+
+void DataReport::FillValues(GridSelection gridToFill)
+{
+    m_changingValues = true;
+    ElectricCalculation eCalc;
+    eCalc.GetElementsFromList(m_workspace->GetElementList());
+
+    double basePower = m_workspace->GetProperties()->GetSimulationPropertiesData().basePower;
+    switch(m_workspace->GetProperties()->GetSimulationPropertiesData().basePowerUnit) {
+        case UNIT_kVA: {
+            basePower *= 1e3;
+        } break;
+        case UNIT_MVA: {
+            basePower *= 1e6;
+        } break;
+        default:
+            break;
+    }
+
+    int rowNumber = 1;
+    auto lineList = eCalc.GetLineList();
+    auto transformerList = eCalc.GetTransformerList();
+    auto busList = eCalc.GetBusList();
+    auto generatorList = eCalc.GetSyncGeneratorList();
+
+    // Power Flow
+    if(gridToFill == GRID_ALL || gridToFill == GRID_PF) {
+        double kActivePower = 1.0;
+        if(m_gridPowerFlow->GetCellValue(0, 4) == m_activePowerChoices[1])
+            kActivePower = basePower;
+        else if(m_gridPowerFlow->GetCellValue(0, 4) == m_activePowerChoices[2])
+            kActivePower = basePower / 1e3;
+        else if(m_gridPowerFlow->GetCellValue(0, 4) == m_activePowerChoices[3])
+            kActivePower = basePower / 1e6;
+
+        double kReactivePower = 1.0;
+        if(m_gridPowerFlow->GetCellValue(0, 5) == m_reactivePowerChoices[1])
+            kReactivePower = basePower;
+        else if(m_gridPowerFlow->GetCellValue(0, 5) == m_reactivePowerChoices[2])
+            kReactivePower = basePower / 1e3;
+        else if(m_gridPowerFlow->GetCellValue(0, 5) == m_reactivePowerChoices[3])
+            kReactivePower = basePower / 1e6;
+
+        for(auto it = lineList.begin(), itEnd = lineList.end(); it != itEnd; ++it) {
+            Line* line = *it;
+
+            wxString busName1 = "-";
+            if(line->GetParentList()[0])
+                busName1 = static_cast<Bus*>(line->GetParentList()[0])->GetElectricalData().name;
+            wxString busName2 = "-";
+            if(line->GetParentList()[1])
+                busName2 = static_cast<Bus*>(line->GetParentList()[1])->GetElectricalData().name;
+
+            wxString isOnline = _("Yes");
+            wxColour textColour = m_gridPowerFlow->GetDefaultCellTextColour();
+            if(!line->IsOnline()) {
+                isOnline = _("No");
+                textColour = m_offlineColour;
+            }
+            for(int i = 0; i < 2; ++i) {
+                for(int j = 0; j < 7; ++j) {
+                    m_gridPowerFlow->SetCellTextColour(rowNumber + i, j, textColour);
+                }
+            }
+
+            m_gridPowerFlow->SetCellValue(rowNumber, 9, isOnline);
+            auto data = line->GetPUElectricalData(basePower);
+
+            m_gridPowerFlow->SetCellValue(rowNumber, 0, _("Line"));
+            m_gridPowerFlow->SetCellValue(rowNumber, 1, data.name);
+            m_gridPowerFlow->SetCellValue(rowNumber, 2, busName1);
+            m_gridPowerFlow->SetCellValue(rowNumber, 3, busName2);
+            m_gridPowerFlow->SetCellValue(rowNumber, 4,
+                                          line->StringFromDouble(std::real(data.powerFlow[0]) * kActivePower));
+            m_gridPowerFlow->SetCellValue(rowNumber, 5,
+                                          line->StringFromDouble(std::imag(data.powerFlow[0]) * kReactivePower));
+            m_gridPowerFlow->SetCellValue(rowNumber, 6, isOnline);
+            rowNumber++;
+
+            m_gridPowerFlow->SetCellValue(rowNumber, 0, _("Line"));
+            m_gridPowerFlow->SetCellValue(rowNumber, 1, data.name);
+            m_gridPowerFlow->SetCellValue(rowNumber, 2, busName2);
+            m_gridPowerFlow->SetCellValue(rowNumber, 3, busName1);
+            m_gridPowerFlow->SetCellValue(rowNumber, 4,
+                                          line->StringFromDouble(std::real(data.powerFlow[1]) * kActivePower));
+            m_gridPowerFlow->SetCellValue(rowNumber, 5,
+                                          line->StringFromDouble(std::imag(data.powerFlow[1]) * kReactivePower));
+            m_gridPowerFlow->SetCellValue(rowNumber, 6, isOnline);
+            rowNumber++;
+        }
+
+        for(auto it = transformerList.begin(), itEnd = transformerList.end(); it != itEnd; ++it) {
+            Transformer* transformer = *it;
+            auto data = transformer->GetPUElectricalData(basePower);
+
+            wxString busName1 = "-";
+            if(transformer->GetParentList()[0])
+                busName1 = static_cast<Bus*>(transformer->GetParentList()[0])->GetElectricalData().name;
+            wxString busName2 = "-";
+            if(transformer->GetParentList()[1])
+                busName2 = static_cast<Bus*>(transformer->GetParentList()[1])->GetElectricalData().name;
+
+            wxString isOnline = _("Yes");
+            wxColour textColour = m_gridPowerFlow->GetDefaultCellTextColour();
+            if(!transformer->IsOnline()) {
+                isOnline = _("No");
+                textColour = m_offlineColour;
+            }
+            for(int i = 0; i < 2; ++i) {
+                for(int j = 0; j < 7; ++j) {
+                    m_gridPowerFlow->SetCellTextColour(rowNumber + i, j, textColour);
+                }
+            }
+
+            m_gridPowerFlow->SetCellValue(rowNumber, 0, _("Transformer"));
+            m_gridPowerFlow->SetCellValue(rowNumber, 1, data.name);
+            m_gridPowerFlow->SetCellValue(rowNumber, 2, busName1);
+            m_gridPowerFlow->SetCellValue(rowNumber, 3, busName2);
+            m_gridPowerFlow->SetCellValue(rowNumber, 4,
+                                          transformer->StringFromDouble(std::real(data.powerFlow[0]) * kActivePower));
+            m_gridPowerFlow->SetCellValue(rowNumber, 5,
+                                          transformer->StringFromDouble(std::imag(data.powerFlow[0]) * kReactivePower));
+            m_gridPowerFlow->SetCellValue(rowNumber, 6, isOnline);
+            rowNumber++;
+
+            m_gridPowerFlow->SetCellValue(rowNumber, 0, _("Transformer"));
+            m_gridPowerFlow->SetCellValue(rowNumber, 1, data.name);
+            m_gridPowerFlow->SetCellValue(rowNumber, 2, busName2);
+            m_gridPowerFlow->SetCellValue(rowNumber, 3, busName1);
+            m_gridPowerFlow->SetCellValue(rowNumber, 4,
+                                          transformer->StringFromDouble(std::real(data.powerFlow[1]) * kActivePower));
+            m_gridPowerFlow->SetCellValue(rowNumber, 5,
+                                          transformer->StringFromDouble(std::imag(data.powerFlow[1]) * kReactivePower));
+            m_gridPowerFlow->SetCellValue(rowNumber, 6, isOnline);
+            rowNumber++;
+        }
+        m_gridPowerFlow->AutoSize();
+    }
+
+    // Power Flow buses
+    if(gridToFill == GRID_ALL || gridToFill == GRID_PFBUSES) {
+        double kActivePower = 1.0;
+        if(m_gridPFBuses->GetCellValue(0, 4) == m_activePowerChoices[1])
+            kActivePower = basePower;
+        else if(m_gridPFBuses->GetCellValue(0, 4) == m_activePowerChoices[2])
+            kActivePower = basePower / 1e3;
+        else if(m_gridPFBuses->GetCellValue(0, 4) == m_activePowerChoices[3])
+            kActivePower = basePower / 1e6;
+
+        double kReactivePower = 1.0;
+        if(m_gridPFBuses->GetCellValue(0, 5) == m_reactivePowerChoices[1])
+            kReactivePower = basePower;
+        else if(m_gridPFBuses->GetCellValue(0, 5) == m_reactivePowerChoices[2])
+            kReactivePower = basePower / 1e3;
+        else if(m_gridPFBuses->GetCellValue(0, 5) == m_reactivePowerChoices[3])
+            kReactivePower = basePower / 1e6;
+
+        rowNumber = 1;
+        for(auto it = busList.begin(), itEnd = busList.end(); it != itEnd; ++it) {
+            Bus* bus = *it;
+            auto data = bus->GetElectricalData();
+
+            double vb = std::abs(data.nominalVoltage);
+            if(data.nominalVoltageUnit == UNIT_kV) vb *= 1e3;
+            double kVoltage = 1.0;
+            if(m_gridPFBuses->GetCellValue(0, 2) == m_voltageChoices[1])
+                kVoltage = vb;
+            else if(m_gridPFBuses->GetCellValue(0, 2) == m_voltageChoices[2])
+                kVoltage = vb / 1e3;
+
+            m_gridPFBuses->SetCellValue(rowNumber, 0, data.name);
+            wxString busTypeString = "";
+            switch(data.busType) {
+                case BUS_SLACK: {
+                    busTypeString = _("Slack");
+                } break;
+                case BUS_PV: {
+                    busTypeString = _("PV");
+                } break;
+                case BUS_PQ: {
+                    busTypeString = _("PQ");
+                } break;
+            }
+            m_gridPFBuses->SetCellValue(rowNumber, 1, busTypeString);
+            m_gridPFBuses->SetCellValue(rowNumber, 2, bus->StringFromDouble(std::abs(data.voltage) * kVoltage));
+            m_gridPFBuses->SetCellValue(rowNumber, 3, bus->StringFromDouble(wxRadToDeg(std::arg(data.voltage))));
+            m_gridPFBuses->SetCellValue(rowNumber, 4, bus->StringFromDouble(std::real(data.power) * kActivePower));
+            m_gridPFBuses->SetCellValue(rowNumber, 5, bus->StringFromDouble(std::imag(data.power) * kReactivePower));
+            rowNumber++;
+        }
+        m_gridPFBuses->AutoSize();
+    }
+
+    // Power flow branches
+    if(gridToFill == GRID_ALL || gridToFill == GRID_PFBRANCHES) {
+        rowNumber = 1;
+        for(auto it = lineList.begin(), itEnd = lineList.end(); it != itEnd; ++it) {
+            Line* line = *it;
+            auto data = line->GetPUElectricalData(basePower);
+
+            double vb = data.nominalVoltage;
+            if(data.nominalVoltageUnit == UNIT_kV) vb *= 1e3;
+            double zb = (vb * vb) / basePower;
+
+            wxString busName1 = "-";
+            if(line->GetParentList()[0])
+                busName1 = static_cast<Bus*>(line->GetParentList()[0])->GetElectricalData().name;
+            wxString busName2 = "-";
+            if(line->GetParentList()[1])
+                busName2 = static_cast<Bus*>(line->GetParentList()[1])->GetElectricalData().name;
+            wxString isOnline = _("Yes");
+            wxColour textColour = m_gridPFBranches->GetDefaultCellTextColour();
+            if(!line->IsOnline()) {
+                isOnline = _("No");
+                textColour = m_offlineColour;
+            }
+            for(int j = 0; j < 10; ++j) {
+                m_gridPFBranches->SetCellTextColour(rowNumber, j, textColour);
+            }
+
+            m_gridPFBranches->SetCellValue(rowNumber, 0, _("Line"));
+            m_gridPFBranches->SetCellValue(rowNumber, 1, data.name);
+
+            m_gridPFBranches->SetCellValue(rowNumber, 2, busName1);
+            m_gridPFBranches->SetCellValue(rowNumber, 3, busName2);
+
+            double k = 1.0;
+            if(m_gridPFBranches->GetCellValue(0, 4) == m_resistanceChoices[1]) k = zb;
+            m_gridPFBranches->SetCellValue(rowNumber, 4, line->StringFromDouble(data.resistance * k));
+            k = 1.0;
+            if(m_gridPFBranches->GetCellValue(0, 5) == m_indReactanceChoices[1]) k = zb;
+            m_gridPFBranches->SetCellValue(rowNumber, 5, line->StringFromDouble(data.indReactance * k));
+            k = 1.0;
+            if(m_gridPFBranches->GetCellValue(0, 6) == m_capSusceptanceChoices[1]) k = zb;
+            m_gridPFBranches->SetCellValue(rowNumber, 6, line->StringFromDouble(data.capSusceptance / k));
+            m_gridPFBranches->SetCellValue(rowNumber, 7, "-");
+            m_gridPFBranches->SetCellValue(rowNumber, 8, "-");
+            m_gridPFBranches->SetCellValue(rowNumber, 9, isOnline);
+            rowNumber++;
+        }
+        for(auto it = transformerList.begin(), itEnd = transformerList.end(); it != itEnd; ++it) {
+            Transformer* transformer = *it;
+            auto data = transformer->GetPUElectricalData(basePower);
+
+            double vb = 0.0;
+            if(data.baseVoltage == 0) {
+                vb = data.primaryNominalVoltage;
+                if(data.primaryNominalVoltageUnit == UNIT_kV) vb *= 1e3;
+            } else {
+                vb = data.secondaryNominalVoltage;
+                if(data.secondaryNominalVoltageUnit == UNIT_kV) vb *= 1e3;
+            }
+            double zb = (vb * vb) / basePower;
+
+            wxString busName1 = "-";
+            if(transformer->GetParentList()[0])
+                busName1 = static_cast<Bus*>(transformer->GetParentList()[0])->GetElectricalData().name;
+            wxString busName2 = "-";
+            if(transformer->GetParentList()[1])
+                busName2 = static_cast<Bus*>(transformer->GetParentList()[1])->GetElectricalData().name;
+
+            wxString isOnline = _("Yes");
+            wxColour textColour = m_gridPFBranches->GetDefaultCellTextColour();
+            if(!transformer->IsOnline()) {
+                isOnline = _("No");
+                textColour = m_offlineColour;
+            }
+            for(int j = 0; j < 10; ++j) {
+                m_gridPFBranches->SetCellTextColour(rowNumber, j, textColour);
+            }
+
+            m_gridPFBranches->SetCellValue(rowNumber, 0, _("Transformer"));
+            m_gridPFBranches->SetCellValue(rowNumber, 1, data.name);
+            m_gridPFBranches->SetCellValue(rowNumber, 2, busName1);
+            m_gridPFBranches->SetCellValue(rowNumber, 3, busName2);
+
+            double k = 1.0;
+            if(m_gridPFBranches->GetCellValue(0, 4) == m_resistanceChoices[1]) k = zb;
+            m_gridPFBranches->SetCellValue(rowNumber, 4, transformer->StringFromDouble(data.resistance * k));
+            k = 1.0;
+            if(m_gridPFBranches->GetCellValue(0, 5) == m_indReactanceChoices[1]) k = zb;
+            m_gridPFBranches->SetCellValue(rowNumber, 5, transformer->StringFromDouble(data.indReactance * k));
+            m_gridPFBranches->SetCellValue(rowNumber, 6, "-");
+            m_gridPFBranches->SetCellValue(rowNumber, 7, transformer->StringFromDouble(data.turnsRatio));
+            m_gridPFBranches->SetCellValue(rowNumber, 8, transformer->StringFromDouble(data.phaseShift));
+            m_gridPFBranches->SetCellValue(rowNumber, 9, isOnline);
+            rowNumber++;
+        }
+        m_gridPFBranches->AutoSize();
+    }
+
+    // Fault
+    if(gridToFill == GRID_ALL || gridToFill == GRID_FAULT) {
+        rowNumber = 2;
+        for(auto it = busList.begin(), itEnd = busList.end(); it != itEnd; ++it) {
+            Bus* bus = *it;
+            auto data = bus->GetElectricalData();
+            if(data.hasFault) {
+                double vb = bus->GetValueFromUnit(data.nominalVoltage, data.nominalVoltageUnit);
+                double ib = basePower / (std::sqrt(3.0) * vb);
+
+                m_gridFault->SetCellValue(rowNumber, 0, data.name);
+
+                double kCurrent = 1.0;
+                if(m_gridFault->GetCellValue(1, 1) == m_currentChoices[1]) {
+                    kCurrent = ib;
+                } else if(m_gridFault->GetCellValue(1, 1) == m_currentChoices[2]) {
+                    kCurrent = ib / 1e3;
+                }
+                m_gridFault->SetCellValue(rowNumber, 1,
+                                          bus->StringFromDouble(std::abs(data.faultCurrent[0]) * kCurrent));
+
+                m_gridFault->SetCellValue(rowNumber, 2,
+                                          bus->StringFromDouble(wxRadToDeg(std::arg(data.faultCurrent[0]))));
+
+                kCurrent = 1.0;
+                if(m_gridFault->GetCellValue(1, 3) == m_currentChoices[1]) {
+                    kCurrent = ib;
+                } else if(m_gridFault->GetCellValue(1, 3) == m_currentChoices[2]) {
+                    kCurrent = ib / 1e3;
+                }
+                m_gridFault->SetCellValue(rowNumber, 3,
+                                          bus->StringFromDouble(std::abs(data.faultCurrent[1]) * kCurrent));
+
+                m_gridFault->SetCellValue(rowNumber, 4,
+                                          bus->StringFromDouble(wxRadToDeg(std::arg(data.faultCurrent[1]))));
+
+                kCurrent = 1.0;
+                if(m_gridFault->GetCellValue(1, 5) == m_currentChoices[1]) {
+                    kCurrent = ib;
+                } else if(m_gridFault->GetCellValue(1, 5) == m_currentChoices[2]) {
+                    kCurrent = ib / 1e3;
+                }
+                m_gridFault->SetCellValue(rowNumber, 5,
+                                          bus->StringFromDouble(std::abs(data.faultCurrent[2]) * kCurrent));
+
+                m_gridFault->SetCellValue(rowNumber, 6,
+                                          bus->StringFromDouble(wxRadToDeg(std::arg(data.faultCurrent[2]))));
+
+                rowNumber++;
+            }
+        }
+        m_gridFault->AutoSize();
+    }
+
+    // Fault buses
+    if(gridToFill == GRID_ALL || gridToFill == GRID_FAULTBUSES) {
+        rowNumber = 2;
+        for(auto it = busList.begin(), itEnd = busList.end(); it != itEnd; ++it) {
+            Bus* bus = *it;
+            auto data = bus->GetElectricalData();
+            double vb = bus->GetValueFromUnit(data.nominalVoltage, data.nominalVoltageUnit);
+
+            m_gridFaultBuses->SetCellValue(rowNumber, 0, data.name);
+            double kVoltage = 1.0;
+            if(m_gridFaultBuses->GetCellValue(1, 1) == m_voltageChoices[1]) {
+                kVoltage = vb;
+            } else if(m_gridFaultBuses->GetCellValue(1, 1) == m_voltageChoices[2]) {
+                kVoltage = vb / 1e3;
+            }
+            m_gridFaultBuses->SetCellValue(rowNumber, 1,
+                                           bus->StringFromDouble(std::abs(data.faultVoltage[0]) * kVoltage));
+            m_gridFaultBuses->SetCellValue(rowNumber, 2,
+                                           bus->StringFromDouble(wxRadToDeg(std::arg(data.faultVoltage[0]))));
+
+            kVoltage = 1.0;
+            if(m_gridFaultBuses->GetCellValue(1, 3) == m_voltageChoices[1]) {
+                kVoltage = vb;
+            } else if(m_gridFaultBuses->GetCellValue(1, 3) == m_voltageChoices[2]) {
+                kVoltage = vb / 1e3;
+            }
+            m_gridFaultBuses->SetCellValue(rowNumber, 3,
+                                           bus->StringFromDouble(std::abs(data.faultVoltage[1]) * kVoltage));
+            m_gridFaultBuses->SetCellValue(rowNumber, 4,
+                                           bus->StringFromDouble(wxRadToDeg(std::arg(data.faultVoltage[1]))));
+
+            kVoltage = 1.0;
+            if(m_gridFaultBuses->GetCellValue(1, 5) == m_voltageChoices[1]) {
+                kVoltage = vb;
+            } else if(m_gridFaultBuses->GetCellValue(1, 5) == m_voltageChoices[2]) {
+                kVoltage = vb / 1e3;
+            }
+            m_gridFaultBuses->SetCellValue(rowNumber, 5,
+                                           bus->StringFromDouble(std::abs(data.faultVoltage[2]) * kVoltage));
+            m_gridFaultBuses->SetCellValue(rowNumber, 6,
+                                           bus->StringFromDouble(wxRadToDeg(std::arg(data.faultVoltage[2]))));
+
+            rowNumber++;
+        }
+        m_gridFaultBuses->AutoSize();
+    }
+
+    // Fault branches
+    if(gridToFill == GRID_ALL || gridToFill == GRID_FAULTBRANCHES) {
+        rowNumber = 2;
+        for(auto it = lineList.begin(), itEnd = lineList.end(); it != itEnd; ++it) {
+            Line* line = *it;
+            auto data = line->GetPUElectricalData(basePower);
+
+            double vb = line->GetValueFromUnit(data.nominalVoltage, data.nominalVoltageUnit);
+            double ib = basePower / (std::sqrt(3.0) * vb);
+
+            wxString busName1 = "-";
+            if(line->GetParentList()[0])
+                busName1 = static_cast<Bus*>(line->GetParentList()[0])->GetElectricalData().name;
+            wxString busName2 = "-";
+            if(line->GetParentList()[1])
+                busName2 = static_cast<Bus*>(line->GetParentList()[1])->GetElectricalData().name;
+
+            wxString isOnline = _("Yes");
+            wxColour textColour = m_gridFaultBranches->GetDefaultCellTextColour();
+            if(!line->IsOnline()) {
+                isOnline = _("No");
+                textColour = m_offlineColour;
+            }
+            for(int i = 0; i < 2; ++i) {
+                for(int j = 0; j < 11; ++j) {
+                    m_gridFaultBranches->SetCellTextColour(rowNumber + i, j, textColour);
+                }
+            }
+
+            m_gridFaultBranches->SetCellValue(rowNumber, 0, _("Line"));
+            m_gridFaultBranches->SetCellValue(rowNumber, 1, data.name);
+            m_gridFaultBranches->SetCellValue(rowNumber, 2, busName1);
+            m_gridFaultBranches->SetCellValue(rowNumber, 3, busName2);
+
+            double kCurrent = 1.0;
+            if(m_gridFaultBranches->GetCellValue(1, 4) == m_currentChoices[1]) {
+                kCurrent = ib;
+            } else if(m_gridFaultBranches->GetCellValue(1, 4) == m_currentChoices[2]) {
+                kCurrent = ib / 1e3;
+            }
+            m_gridFaultBranches->SetCellValue(rowNumber, 4,
+                                              line->StringFromDouble(std::abs(data.faultCurrent[0][0]) * kCurrent));
+            m_gridFaultBranches->SetCellValue(rowNumber, 5,
+                                              line->StringFromDouble(wxRadToDeg(std::arg(data.faultCurrent[0][0]))));
+            kCurrent = 1.0;
+            if(m_gridFaultBranches->GetCellValue(1, 6) == m_currentChoices[1]) {
+                kCurrent = ib;
+            } else if(m_gridFaultBranches->GetCellValue(1, 6) == m_currentChoices[2]) {
+                kCurrent = ib / 1e3;
+            }
+            m_gridFaultBranches->SetCellValue(rowNumber, 6,
+                                              line->StringFromDouble(std::abs(data.faultCurrent[0][1]) * kCurrent));
+            m_gridFaultBranches->SetCellValue(rowNumber, 7,
+                                              line->StringFromDouble(wxRadToDeg(std::arg(data.faultCurrent[0][1]))));
+            kCurrent = 1.0;
+            if(m_gridFaultBranches->GetCellValue(1, 8) == m_currentChoices[1]) {
+                kCurrent = ib;
+            } else if(m_gridFaultBranches->GetCellValue(1, 8) == m_currentChoices[2]) {
+                kCurrent = ib / 1e3;
+            }
+            m_gridFaultBranches->SetCellValue(rowNumber, 8,
+                                              line->StringFromDouble(std::abs(data.faultCurrent[0][2]) * kCurrent));
+            m_gridFaultBranches->SetCellValue(rowNumber, 9,
+                                              line->StringFromDouble(wxRadToDeg(std::arg(data.faultCurrent[0][2]))));
+            m_gridFaultBranches->SetCellValue(rowNumber, 10, isOnline);
+            rowNumber++;
+
+            m_gridFaultBranches->SetCellValue(rowNumber, 0, _("Line"));
+            m_gridFaultBranches->SetCellValue(rowNumber, 1, data.name);
+            m_gridFaultBranches->SetCellValue(rowNumber, 2, busName2);
+            m_gridFaultBranches->SetCellValue(rowNumber, 3, busName1);
+            kCurrent = 1.0;
+            if(m_gridFaultBranches->GetCellValue(1, 4) == m_currentChoices[1]) {
+                kCurrent = ib;
+            } else if(m_gridFaultBranches->GetCellValue(1, 4) == m_currentChoices[2]) {
+                kCurrent = ib / 1e3;
+            }
+            m_gridFaultBranches->SetCellValue(rowNumber, 4,
+                                              line->StringFromDouble(std::abs(data.faultCurrent[1][0]) * kCurrent));
+            m_gridFaultBranches->SetCellValue(rowNumber, 5,
+                                              line->StringFromDouble(wxRadToDeg(std::arg(data.faultCurrent[1][0]))));
+            kCurrent = 1.0;
+            if(m_gridFaultBranches->GetCellValue(1, 6) == m_currentChoices[1]) {
+                kCurrent = ib;
+            } else if(m_gridFaultBranches->GetCellValue(1, 6) == m_currentChoices[2]) {
+                kCurrent = ib / 1e3;
+            }
+            m_gridFaultBranches->SetCellValue(rowNumber, 6,
+                                              line->StringFromDouble(std::abs(data.faultCurrent[1][1]) * kCurrent));
+            m_gridFaultBranches->SetCellValue(rowNumber, 7,
+                                              line->StringFromDouble(wxRadToDeg(std::arg(data.faultCurrent[1][1]))));
+            kCurrent = 1.0;
+            if(m_gridFaultBranches->GetCellValue(1, 8) == m_currentChoices[1]) {
+                kCurrent = ib;
+            } else if(m_gridFaultBranches->GetCellValue(1, 8) == m_currentChoices[2]) {
+                kCurrent = ib / 1e3;
+            }
+            m_gridFaultBranches->SetCellValue(rowNumber, 8,
+                                              line->StringFromDouble(std::abs(data.faultCurrent[1][2]) * kCurrent));
+            m_gridFaultBranches->SetCellValue(rowNumber, 9,
+                                              line->StringFromDouble(wxRadToDeg(std::arg(data.faultCurrent[1][2]))));
+            m_gridFaultBranches->SetCellValue(rowNumber, 10, isOnline);
+            rowNumber++;
+        }
+
+        for(auto it = transformerList.begin(), itEnd = transformerList.end(); it != itEnd; ++it) {
+            Transformer* transformer = *it;
+            auto data = transformer->GetPUElectricalData(basePower);
+
+            double vb = transformer->GetValueFromUnit(data.primaryNominalVoltage, data.primaryNominalVoltageUnit);
+            double ibp = basePower / (std::sqrt(3.0) * vb);
+            vb = transformer->GetValueFromUnit(data.secondaryNominalVoltage, data.secondaryNominalVoltageUnit);
+            double ibs = basePower / (std::sqrt(3.0) * vb);
+
+            wxString busName1 = "-";
+            if(transformer->GetParentList()[0])
+                busName1 = static_cast<Bus*>(transformer->GetParentList()[0])->GetElectricalData().name;
+            wxString busName2 = "-";
+            if(transformer->GetParentList()[1])
+                busName2 = static_cast<Bus*>(transformer->GetParentList()[1])->GetElectricalData().name;
+
+            wxString isOnline = _("Yes");
+            wxColour textColour = m_gridFaultBranches->GetDefaultCellTextColour();
+            if(!transformer->IsOnline()) {
+                isOnline = _("No");
+                textColour = m_offlineColour;
+            }
+            for(int i = 0; i < 2; ++i) {
+                for(int j = 0; j < 11; ++j) {
+                    m_gridFaultBranches->SetCellTextColour(rowNumber + i, j, textColour);
+                }
+            }
+
+            m_gridFaultBranches->SetCellValue(rowNumber, 0, _("Transformer"));
+            m_gridFaultBranches->SetCellValue(rowNumber, 1, data.name);
+            m_gridFaultBranches->SetCellValue(rowNumber, 2, busName1);
+            m_gridFaultBranches->SetCellValue(rowNumber, 3, busName2);
+
+            double kCurrent = 1.0;
+            if(m_gridFaultBranches->GetCellValue(1, 4) == m_currentChoices[1]) {
+                kCurrent = ibp;
+            } else if(m_gridFaultBranches->GetCellValue(1, 4) == m_currentChoices[2]) {
+                kCurrent = ibp / 1e3;
+            }
+            m_gridFaultBranches->SetCellValue(
+                rowNumber, 4, transformer->StringFromDouble(std::abs(data.faultCurrent[0][0]) * kCurrent));
+            m_gridFaultBranches->SetCellValue(
+                rowNumber, 5, transformer->StringFromDouble(wxRadToDeg(std::arg(data.faultCurrent[0][0]))));
+            kCurrent = 1.0;
+            if(m_gridFaultBranches->GetCellValue(1, 6) == m_currentChoices[1]) {
+                kCurrent = ibp;
+            } else if(m_gridFaultBranches->GetCellValue(1, 6) == m_currentChoices[2]) {
+                kCurrent = ibp / 1e3;
+            }
+            m_gridFaultBranches->SetCellValue(
+                rowNumber, 6, transformer->StringFromDouble(std::abs(data.faultCurrent[0][1]) * kCurrent));
+            m_gridFaultBranches->SetCellValue(
+                rowNumber, 7, transformer->StringFromDouble(wxRadToDeg(std::arg(data.faultCurrent[0][1]))));
+            kCurrent = 1.0;
+            if(m_gridFaultBranches->GetCellValue(1, 8) == m_currentChoices[1]) {
+                kCurrent = ibp;
+            } else if(m_gridFaultBranches->GetCellValue(1, 8) == m_currentChoices[2]) {
+                kCurrent = ibp / 1e3;
+            }
+            m_gridFaultBranches->SetCellValue(
+                rowNumber, 8, transformer->StringFromDouble(std::abs(data.faultCurrent[0][2]) * kCurrent));
+            m_gridFaultBranches->SetCellValue(
+                rowNumber, 9, transformer->StringFromDouble(wxRadToDeg(std::arg(data.faultCurrent[0][2]))));
+            m_gridFaultBranches->SetCellValue(rowNumber, 10, isOnline);
+            rowNumber++;
+
+            m_gridFaultBranches->SetCellValue(rowNumber, 0, _("Transformer"));
+            m_gridFaultBranches->SetCellValue(rowNumber, 1, data.name);
+            m_gridFaultBranches->SetCellValue(rowNumber, 2, busName2);
+            m_gridFaultBranches->SetCellValue(rowNumber, 3, busName1);
+            kCurrent = 1.0;
+            if(m_gridFaultBranches->GetCellValue(1, 4) == m_currentChoices[1]) {
+                kCurrent = ibs;
+            } else if(m_gridFaultBranches->GetCellValue(1, 4) == m_currentChoices[2]) {
+                kCurrent = ibs / 1e3;
+            }
+            m_gridFaultBranches->SetCellValue(
+                rowNumber, 4, transformer->StringFromDouble(std::abs(data.faultCurrent[1][0]) * kCurrent));
+            m_gridFaultBranches->SetCellValue(
+                rowNumber, 5, transformer->StringFromDouble(wxRadToDeg(std::arg(data.faultCurrent[1][0]))));
+            kCurrent = 1.0;
+            if(m_gridFaultBranches->GetCellValue(1, 6) == m_currentChoices[1]) {
+                kCurrent = ibs;
+            } else if(m_gridFaultBranches->GetCellValue(1, 6) == m_currentChoices[2]) {
+                kCurrent = ibs / 1e3;
+            }
+            m_gridFaultBranches->SetCellValue(
+                rowNumber, 6, transformer->StringFromDouble(std::abs(data.faultCurrent[1][1]) * kCurrent));
+            m_gridFaultBranches->SetCellValue(
+                rowNumber, 7, transformer->StringFromDouble(wxRadToDeg(std::arg(data.faultCurrent[1][1]))));
+            kCurrent = 1.0;
+            if(m_gridFaultBranches->GetCellValue(1, 8) == m_currentChoices[1]) {
+                kCurrent = ibs;
+            } else if(m_gridFaultBranches->GetCellValue(1, 8) == m_currentChoices[2]) {
+                kCurrent = ibs / 1e3;
+            }
+            m_gridFaultBranches->SetCellValue(
+                rowNumber, 8, transformer->StringFromDouble(std::abs(data.faultCurrent[1][2]) * kCurrent));
+            m_gridFaultBranches->SetCellValue(
+                rowNumber, 9, transformer->StringFromDouble(wxRadToDeg(std::arg(data.faultCurrent[1][2]))));
+            m_gridFaultBranches->SetCellValue(rowNumber, 10, isOnline);
+            rowNumber++;
+        }
+
+        m_gridFaultBranches->AutoSize();
+    }
+
+    // Fault generators
+    if(gridToFill == GRID_ALL || gridToFill == GRID_FAULTGENERATORS) {
+        rowNumber = 2;
+        for(auto it = generatorList.begin(), itEnd = generatorList.end(); it != itEnd; ++it) {
+            SyncGenerator* generator = *it;
+            auto data = generator->GetPUElectricalData(basePower);
+            double vb = generator->GetValueFromUnit(data.nominalVoltage, data.nominalVoltageUnit);
+            double ib = basePower / (std::sqrt(3.0) * vb);
+
+            m_gridFaultGenerators->SetCellValue(rowNumber, 0, data.name);
+
+            double kCurrent = 1.0;
+            if(m_gridFaultGenerators->GetCellValue(1, 1) == m_currentChoices[1])
+                kCurrent = ib;
+            else if(m_gridFaultGenerators->GetCellValue(1, 1) == m_currentChoices[2])
+                kCurrent = ib / 1e3;
+            m_gridFaultGenerators->SetCellValue(rowNumber, 1,
+                                                generator->StringFromDouble(std::abs(data.faultCurrent[0]) * kCurrent));
+            m_gridFaultGenerators->SetCellValue(
+                rowNumber, 2, generator->StringFromDouble(wxRadToDeg(std::arg(data.faultCurrent[0]))));
+
+            kCurrent = 1.0;
+            if(m_gridFaultGenerators->GetCellValue(1, 3) == m_currentChoices[1])
+                kCurrent = ib;
+            else if(m_gridFaultGenerators->GetCellValue(1, 3) == m_currentChoices[2])
+                kCurrent = ib / 1e3;
+            m_gridFaultGenerators->SetCellValue(rowNumber, 3,
+                                                generator->StringFromDouble(std::abs(data.faultCurrent[1]) * kCurrent));
+            m_gridFaultGenerators->SetCellValue(
+                rowNumber, 4, generator->StringFromDouble(wxRadToDeg(std::arg(data.faultCurrent[1]))));
+
+            kCurrent = 1.0;
+            if(m_gridFaultGenerators->GetCellValue(1, 5) == m_currentChoices[1])
+                kCurrent = ib;
+            else if(m_gridFaultGenerators->GetCellValue(1, 5) == m_currentChoices[2])
+                kCurrent = ib / 1e3;
+            m_gridFaultGenerators->SetCellValue(rowNumber, 5,
+                                                generator->StringFromDouble(std::abs(data.faultCurrent[2]) * kCurrent));
+            m_gridFaultGenerators->SetCellValue(
+                rowNumber, 6, generator->StringFromDouble(wxRadToDeg(std::arg(data.faultCurrent[2]))));
+
+            rowNumber++;
+        }
+        m_gridFaultGenerators->AutoSize();
+    }
+    m_changingValues = false;
+}
+
+void DataReport::SetRowsColours(wxGrid* grid, int rowStart)
+{
+    for(int i = rowStart; i < grid->GetNumberRows(); ++i) {
+        wxGridCellAttr* attr = grid->GetOrCreateCellAttr(i, 0);
+        if((i - rowStart) % 2 == 0)
+            attr->SetBackgroundColour(m_evenRowColour);
+        else
+            attr->SetBackgroundColour(m_oddRowColour);
+        grid->SetRowAttr(i, attr);
+    }
+}
+
+void DataReport::OnPFBusGridChanged(wxGridEvent& event)
+{
+    if(!m_changingValues) FillValues(GRID_PFBUSES);
+}
+void DataReport::OnFaulrGridChanged(wxGridEvent& event)
+{
+    if(!m_changingValues) FillValues(GRID_FAULT);
+}
+void DataReport::OnFaultBranchesGridChanged(wxGridEvent& event)
+{
+    if(!m_changingValues) FillValues(GRID_FAULTBRANCHES);
+}
+void DataReport::OnFaultBusesGridChanged(wxGridEvent& event)
+{
+    if(!m_changingValues) FillValues(GRID_FAULTBUSES);
+}
+void DataReport::OnFaultGeneratorsGridChanged(wxGridEvent& event)
+{
+    if(!m_changingValues) FillValues(GRID_FAULTGENERATORS);
+}
+void DataReport::OnPFBranchesGridChanged(wxGridEvent& event)
+{
+    if(!m_changingValues) FillValues(GRID_PFBRANCHES);
+}
+void DataReport::OnPowerFlowGridChanged(wxGridEvent& event)
+{
+    if(!m_changingValues) FillValues(GRID_PF);
+}