From 41b81949a92aad043caa28b0e1144348d06921f8 Mon Sep 17 00:00:00 2001 From: Thales Lima Oliveira Date: Wed, 6 Sep 2017 20:11:37 -0300 Subject: Data report implementation start --- Project/DataReport.cpp | 383 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 383 insertions(+) create mode 100644 Project/DataReport.cpp (limited to 'Project/DataReport.cpp') diff --git a/Project/DataReport.cpp b/Project/DataReport.cpp new file mode 100644 index 0000000..173f476 --- /dev/null +++ b/Project/DataReport.cpp @@ -0,0 +1,383 @@ +#include "DataReport.h" +#include "Workspace.h" +#include "ElectricCalculation.h" + +DataReport::DataReport(wxWindow* parent, Workspace* workspace) : DataReportBase(parent) +{ + m_workspace = workspace; + CreateGrids(); + SetHeaders(); + FillValues(); + + Layout(); +} + +DataReport::~DataReport() {} +void DataReport::SetHeaders() +{ + // Headers choices fill + 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)")); + + // 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]); + + // 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 brances + 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->SetCellValue(0, 4, _("R (p.u.)")); + m_gridPFBranches->SetCellValue(0, 5, _("XL (p.u.)")); + m_gridPFBranches->SetCellValue(0, 6, _("B (p.u.)")); + m_gridPFBranches->SetCellValue(0, 7, _("TAP")); + m_gridPFBranches->SetCellValue(0, 8, _("Phase Shift")); + m_gridPFBranches->SetCellValue(0, 9, _("Online")); +} + +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(); + + // 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; + if(line->IsOnline()) { + auto data = line->GetElectricalData(); + + Bus* bus1 = static_cast(line->GetParentList()[0]); + Bus* bus2 = static_cast(line->GetParentList()[1]); + + m_gridPowerFlow->SetCellValue(rowNumber, 0, _("Line")); + m_gridPowerFlow->SetCellValue(rowNumber, 1, data.name); + m_gridPowerFlow->SetCellValue(rowNumber, 2, bus1->GetElectricalData().name); + m_gridPowerFlow->SetCellValue(rowNumber, 3, bus2->GetElectricalData().name); + 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)); + rowNumber++; + + m_gridPowerFlow->SetCellValue(rowNumber, 0, _("Line")); + m_gridPowerFlow->SetCellValue(rowNumber, 1, data.name); + m_gridPowerFlow->SetCellValue(rowNumber, 2, bus2->GetElectricalData().name); + m_gridPowerFlow->SetCellValue(rowNumber, 3, bus1->GetElectricalData().name); + 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)); + rowNumber++; + } + } + + for(auto it = transformerList.begin(), itEnd = transformerList.end(); it != itEnd; ++it) { + Transformer* transformer = *it; + if(transformer->IsOnline()) { + auto data = transformer->GetElectricalData(); + + Bus* bus1 = static_cast(transformer->GetParentList()[0]); + Bus* bus2 = static_cast(transformer->GetParentList()[1]); + + m_gridPowerFlow->SetCellValue(rowNumber, 0, _("Transformer")); + m_gridPowerFlow->SetCellValue(rowNumber, 1, data.name); + m_gridPowerFlow->SetCellValue(rowNumber, 2, bus1->GetElectricalData().name); + m_gridPowerFlow->SetCellValue(rowNumber, 3, bus2->GetElectricalData().name); + 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)); + rowNumber++; + + m_gridPowerFlow->SetCellValue(rowNumber, 0, _("Transformer")); + m_gridPowerFlow->SetCellValue(rowNumber, 1, data.name); + m_gridPowerFlow->SetCellValue(rowNumber, 2, bus2->GetElectricalData().name); + m_gridPowerFlow->SetCellValue(rowNumber, 3, bus1->GetElectricalData().name); + 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)); + 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); + + m_gridPFBranches->SetCellValue(rowNumber, 0, _("Line")); + m_gridPFBranches->SetCellValue(rowNumber, 1, data.name); + + wxString busName1 = "-"; + if(line->GetParentList()[0]) + busName1 = static_cast(line->GetParentList()[0])->GetElectricalData().name; + wxString busName2 = "-"; + if(line->GetParentList()[1]) + busName2 = static_cast(line->GetParentList()[1])->GetElectricalData().name; + m_gridPFBranches->SetCellValue(rowNumber, 2, busName1); + m_gridPFBranches->SetCellValue(rowNumber, 3, busName2); + + m_gridPFBranches->SetCellValue(rowNumber, 4, line->StringFromDouble(data.resistance)); + m_gridPFBranches->SetCellValue(rowNumber, 5, line->StringFromDouble(data.indReactance)); + m_gridPFBranches->SetCellValue(rowNumber, 6, line->StringFromDouble(data.capSusceptance)); + m_gridPFBranches->SetCellValue(rowNumber, 7, "-"); + m_gridPFBranches->SetCellValue(rowNumber, 8, "-"); + + wxString isOnline = _("Yes"); + if(!line->IsOnline()) isOnline = _("No"); + 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); + + m_gridPFBranches->SetCellValue(rowNumber, 0, _("Transformer")); + m_gridPFBranches->SetCellValue(rowNumber, 1, data.name); + + wxString busName1 = "-"; + if(transformer->GetParentList()[0]) + busName1 = static_cast(transformer->GetParentList()[0])->GetElectricalData().name; + wxString busName2 = "-"; + if(transformer->GetParentList()[1]) + busName2 = static_cast(transformer->GetParentList()[1])->GetElectricalData().name; + m_gridPFBranches->SetCellValue(rowNumber, 2, busName1); + m_gridPFBranches->SetCellValue(rowNumber, 3, busName2); + + m_gridPFBranches->SetCellValue(rowNumber, 4, transformer->StringFromDouble(data.resistance)); + m_gridPFBranches->SetCellValue(rowNumber, 5, transformer->StringFromDouble(data.indReactance)); + m_gridPFBranches->SetCellValue(rowNumber, 6, "-"); + m_gridPFBranches->SetCellValue(rowNumber, 7, transformer->StringFromDouble(data.turnsRatio)); + m_gridPFBranches->SetCellValue(rowNumber, 8, transformer->StringFromDouble(data.phaseShift)); + + wxString isOnline = _("Yes"); + if(!transformer->IsOnline()) isOnline = _("No"); + m_gridPFBranches->SetCellValue(rowNumber, 9, isOnline); + rowNumber++; + } + m_gridPFBranches->AutoSize(); + } + + m_changingValues = false; +} + +void DataReport::CreateGrids() +{ + wxColour headerColour(200, 200, 200); + wxFont headerFont = m_gridPowerFlow->GetLabelFont(); + headerFont.SetWeight(wxFONTWEIGHT_BOLD); + + ElectricCalculation eCalc; + eCalc.GetElementsFromList(m_workspace->GetElementList()); + + // Power Flow + // Header + m_gridPowerFlow->AppendCols(6); + m_gridPowerFlow->AppendRows(); + m_gridPowerFlow->HideColLabels(); + m_gridPowerFlow->HideRowLabels(); + for(int i = 0; i < 6; ++i) { + m_gridPowerFlow->SetCellBackgroundColour(0, i, headerColour); + m_gridPowerFlow->SetCellFont(0, i, headerFont); + } + m_gridPowerFlow->SetDefaultCellAlignment(wxALIGN_CENTRE, wxALIGN_CENTRE); + // Values + auto lineList = eCalc.GetLineList(); + for(auto it = lineList.begin(), itEnd = lineList.end(); it != itEnd; ++it) { + Line* line = *it; + if(line->IsOnline()) { + m_gridPowerFlow->AppendRows(2); + } + } + auto transformerList = eCalc.GetTransformerList(); + for(auto it = transformerList.begin(), itEnd = transformerList.end(); it != itEnd; ++it) { + Transformer* transformer = *it; + if(transformer->IsOnline()) { + m_gridPowerFlow->AppendRows(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, headerColour); + m_gridPFBuses->SetCellFont(0, i, headerFont); + } + m_gridPFBuses->SetDefaultCellAlignment(wxALIGN_CENTRE, wxALIGN_CENTRE); + // Values + auto busList = eCalc.GetBusList(); + 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, 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(); +} + +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); +} -- cgit From 93c3c0af32d08bbc22b43a03d81fad37fd8feb19 Mon Sep 17 00:00:00 2001 From: Thales Lima Oliveira Date: Fri, 8 Sep 2017 00:21:04 -0300 Subject: Some grid improvement --- Project/DataReport.cpp | 54 ++++++++++++++++++++++++++++++++++++++++++-------- 1 file changed, 46 insertions(+), 8 deletions(-) (limited to 'Project/DataReport.cpp') diff --git a/Project/DataReport.cpp b/Project/DataReport.cpp index 173f476..11b17e8 100644 --- a/Project/DataReport.cpp +++ b/Project/DataReport.cpp @@ -16,6 +16,8 @@ DataReport::~DataReport() {} void DataReport::SetHeaders() { // Headers choices fill + wxString omega = static_cast(L'\u03A9'); + m_voltageChoices.Add(_("Voltage (p.u.)")); m_voltageChoices.Add(_("Voltage (V)")); m_voltageChoices.Add(_("Voltage (kV)")); @@ -30,6 +32,15 @@ void DataReport::SetHeaders() 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)")); + // Power flow m_gridPowerFlow->SetCellValue(0, 0, _("Type")); m_gridPowerFlow->SetCellValue(0, 1, _("Name")); @@ -56,9 +67,12 @@ void DataReport::SetHeaders() m_gridPFBranches->SetCellValue(0, 1, _("Name")); m_gridPFBranches->SetCellValue(0, 2, _("From")); m_gridPFBranches->SetCellValue(0, 3, _("To")); - m_gridPFBranches->SetCellValue(0, 4, _("R (p.u.)")); - m_gridPFBranches->SetCellValue(0, 5, _("XL (p.u.)")); - m_gridPFBranches->SetCellValue(0, 6, _("B (p.u.)")); + 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")); @@ -228,6 +242,10 @@ void DataReport::FillValues(GridSelection gridToFill) Line* line = *it; auto data = line->GetPUElectricalData(basePower); + double vb = data.nominalVoltage; + if(data.nominalVoltageUnit == UNIT_kV) vb *= 1e3; + double zb = (vb * vb) / basePower; + m_gridPFBranches->SetCellValue(rowNumber, 0, _("Line")); m_gridPFBranches->SetCellValue(rowNumber, 1, data.name); @@ -240,9 +258,15 @@ void DataReport::FillValues(GridSelection gridToFill) m_gridPFBranches->SetCellValue(rowNumber, 2, busName1); m_gridPFBranches->SetCellValue(rowNumber, 3, busName2); - m_gridPFBranches->SetCellValue(rowNumber, 4, line->StringFromDouble(data.resistance)); - m_gridPFBranches->SetCellValue(rowNumber, 5, line->StringFromDouble(data.indReactance)); - m_gridPFBranches->SetCellValue(rowNumber, 6, line->StringFromDouble(data.capSusceptance)); + 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, "-"); @@ -255,6 +279,16 @@ void DataReport::FillValues(GridSelection gridToFill) 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; + m_gridPFBranches->SetCellValue(rowNumber, 0, _("Transformer")); m_gridPFBranches->SetCellValue(rowNumber, 1, data.name); @@ -267,8 +301,12 @@ void DataReport::FillValues(GridSelection gridToFill) m_gridPFBranches->SetCellValue(rowNumber, 2, busName1); m_gridPFBranches->SetCellValue(rowNumber, 3, busName2); - m_gridPFBranches->SetCellValue(rowNumber, 4, transformer->StringFromDouble(data.resistance)); - m_gridPFBranches->SetCellValue(rowNumber, 5, transformer->StringFromDouble(data.indReactance)); + 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)); -- cgit From 9e1f6849c929506a17fa12185c5c0185d5287177 Mon Sep 17 00:00:00 2001 From: Thales Lima Oliveira Date: Fri, 8 Sep 2017 22:02:09 -0300 Subject: More grid data implemented Some fault bugfixes --- Project/DataReport.cpp | 756 +++++++++++++++++++++++++++++++++++++++++-------- 1 file changed, 634 insertions(+), 122 deletions(-) (limited to 'Project/DataReport.cpp') diff --git a/Project/DataReport.cpp b/Project/DataReport.cpp index 11b17e8..bcde093 100644 --- a/Project/DataReport.cpp +++ b/Project/DataReport.cpp @@ -13,6 +13,156 @@ DataReport::DataReport(wxWindow* parent, Workspace* workspace) : DataReportBase( } DataReport::~DataReport() {} +void DataReport::CreateGrids() +{ + wxColour headerColour(200, 200, 200); + 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, 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, 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, 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, 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, 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, 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, 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 @@ -41,6 +191,10 @@ void DataReport::SetHeaders() 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")); @@ -50,6 +204,7 @@ void DataReport::SetHeaders() 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")); @@ -62,7 +217,7 @@ void DataReport::SetHeaders() m_gridPFBuses->SetCellEditor(0, 5, new wxGridCellChoiceEditor(m_reactivePowerChoices)); m_gridPFBuses->SetCellValue(0, 5, m_reactivePowerChoices[3]); - // Power flow brances + // Power flow branches m_gridPFBranches->SetCellValue(0, 0, _("Type")); m_gridPFBranches->SetCellValue(0, 1, _("Name")); m_gridPFBranches->SetCellValue(0, 2, _("From")); @@ -76,10 +231,76 @@ void DataReport::SetHeaders() 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) { + wxColour offlineColour(100, 100, 100); + m_changingValues = true; ElectricCalculation eCalc; eCalc.GetElementsFromList(m_workspace->GetElementList()); @@ -121,62 +342,96 @@ void DataReport::FillValues(GridSelection gridToFill) for(auto it = lineList.begin(), itEnd = lineList.end(); it != itEnd; ++it) { Line* line = *it; - if(line->IsOnline()) { - auto data = line->GetElectricalData(); - - Bus* bus1 = static_cast(line->GetParentList()[0]); - Bus* bus2 = static_cast(line->GetParentList()[1]); - - m_gridPowerFlow->SetCellValue(rowNumber, 0, _("Line")); - m_gridPowerFlow->SetCellValue(rowNumber, 1, data.name); - m_gridPowerFlow->SetCellValue(rowNumber, 2, bus1->GetElectricalData().name); - m_gridPowerFlow->SetCellValue(rowNumber, 3, bus2->GetElectricalData().name); - 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)); - rowNumber++; - m_gridPowerFlow->SetCellValue(rowNumber, 0, _("Line")); - m_gridPowerFlow->SetCellValue(rowNumber, 1, data.name); - m_gridPowerFlow->SetCellValue(rowNumber, 2, bus2->GetElectricalData().name); - m_gridPowerFlow->SetCellValue(rowNumber, 3, bus1->GetElectricalData().name); - 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)); - rowNumber++; + wxString busName1 = "-"; + if(line->GetParentList()[0]) + busName1 = static_cast(line->GetParentList()[0])->GetElectricalData().name; + wxString busName2 = "-"; + if(line->GetParentList()[1]) + busName2 = static_cast(line->GetParentList()[1])->GetElectricalData().name; + + wxString isOnline = _("Yes"); + wxColour textColour = m_gridPowerFlow->GetDefaultCellTextColour(); + if(!line->IsOnline()) { + isOnline = _("No"); + textColour = 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; - if(transformer->IsOnline()) { - auto data = transformer->GetElectricalData(); - - Bus* bus1 = static_cast(transformer->GetParentList()[0]); - Bus* bus2 = static_cast(transformer->GetParentList()[1]); - - m_gridPowerFlow->SetCellValue(rowNumber, 0, _("Transformer")); - m_gridPowerFlow->SetCellValue(rowNumber, 1, data.name); - m_gridPowerFlow->SetCellValue(rowNumber, 2, bus1->GetElectricalData().name); - m_gridPowerFlow->SetCellValue(rowNumber, 3, bus2->GetElectricalData().name); - 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)); - rowNumber++; + auto data = transformer->GetPUElectricalData(basePower); - m_gridPowerFlow->SetCellValue(rowNumber, 0, _("Transformer")); - m_gridPowerFlow->SetCellValue(rowNumber, 1, data.name); - m_gridPowerFlow->SetCellValue(rowNumber, 2, bus2->GetElectricalData().name); - m_gridPowerFlow->SetCellValue(rowNumber, 3, bus1->GetElectricalData().name); - 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)); - rowNumber++; + wxString busName1 = "-"; + if(transformer->GetParentList()[0]) + busName1 = static_cast(transformer->GetParentList()[0])->GetElectricalData().name; + wxString busName2 = "-"; + if(transformer->GetParentList()[1]) + busName2 = static_cast(transformer->GetParentList()[1])->GetElectricalData().name; + + wxString isOnline = _("Yes"); + wxColour textColour = m_gridPowerFlow->GetDefaultCellTextColour(); + if(!transformer->IsOnline()) { + isOnline = _("No"); + textColour = 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(); } @@ -246,15 +501,25 @@ void DataReport::FillValues(GridSelection gridToFill) if(data.nominalVoltageUnit == UNIT_kV) vb *= 1e3; double zb = (vb * vb) / basePower; - m_gridPFBranches->SetCellValue(rowNumber, 0, _("Line")); - m_gridPFBranches->SetCellValue(rowNumber, 1, data.name); - wxString busName1 = "-"; if(line->GetParentList()[0]) busName1 = static_cast(line->GetParentList()[0])->GetElectricalData().name; wxString busName2 = "-"; if(line->GetParentList()[1]) busName2 = static_cast(line->GetParentList()[1])->GetElectricalData().name; + wxString isOnline = _("Yes"); + wxColour textColour = m_gridPFBranches->GetDefaultCellTextColour(); + if(!line->IsOnline()) { + isOnline = _("No"); + textColour = 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); @@ -269,9 +534,6 @@ void DataReport::FillValues(GridSelection gridToFill) m_gridPFBranches->SetCellValue(rowNumber, 6, line->StringFromDouble(data.capSusceptance / k)); m_gridPFBranches->SetCellValue(rowNumber, 7, "-"); m_gridPFBranches->SetCellValue(rowNumber, 8, "-"); - - wxString isOnline = _("Yes"); - if(!line->IsOnline()) isOnline = _("No"); m_gridPFBranches->SetCellValue(rowNumber, 9, isOnline); rowNumber++; } @@ -289,15 +551,25 @@ void DataReport::FillValues(GridSelection gridToFill) } double zb = (vb * vb) / basePower; - m_gridPFBranches->SetCellValue(rowNumber, 0, _("Transformer")); - m_gridPFBranches->SetCellValue(rowNumber, 1, data.name); - wxString busName1 = "-"; if(transformer->GetParentList()[0]) busName1 = static_cast(transformer->GetParentList()[0])->GetElectricalData().name; wxString busName2 = "-"; if(transformer->GetParentList()[1]) busName2 = static_cast(transformer->GetParentList()[1])->GetElectricalData().name; + + wxString isOnline = _("Yes"); + wxColour textColour = m_gridPFBranches->GetDefaultCellTextColour(); + if(!transformer->IsOnline()) { + isOnline = _("No"); + textColour = 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); @@ -310,85 +582,325 @@ void DataReport::FillValues(GridSelection gridToFill) m_gridPFBranches->SetCellValue(rowNumber, 6, "-"); m_gridPFBranches->SetCellValue(rowNumber, 7, transformer->StringFromDouble(data.turnsRatio)); m_gridPFBranches->SetCellValue(rowNumber, 8, transformer->StringFromDouble(data.phaseShift)); - - wxString isOnline = _("Yes"); - if(!transformer->IsOnline()) isOnline = _("No"); m_gridPFBranches->SetCellValue(rowNumber, 9, isOnline); rowNumber++; } m_gridPFBranches->AutoSize(); } - m_changingValues = false; -} + // 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 / 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])))); -void DataReport::CreateGrids() -{ - wxColour headerColour(200, 200, 200); - wxFont headerFont = m_gridPowerFlow->GetLabelFont(); - headerFont.SetWeight(wxFONTWEIGHT_BOLD); + rowNumber++; + } + } + m_gridFault->AutoSize(); + } - ElectricCalculation eCalc; - eCalc.GetElementsFromList(m_workspace->GetElementList()); + // 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); - // Power Flow - // Header - m_gridPowerFlow->AppendCols(6); - m_gridPowerFlow->AppendRows(); - m_gridPowerFlow->HideColLabels(); - m_gridPowerFlow->HideRowLabels(); - for(int i = 0; i < 6; ++i) { - m_gridPowerFlow->SetCellBackgroundColour(0, i, headerColour); - m_gridPowerFlow->SetCellFont(0, i, headerFont); - } - m_gridPowerFlow->SetDefaultCellAlignment(wxALIGN_CENTRE, wxALIGN_CENTRE); - // Values - auto lineList = eCalc.GetLineList(); - for(auto it = lineList.begin(), itEnd = lineList.end(); it != itEnd; ++it) { - Line* line = *it; - if(line->IsOnline()) { - m_gridPowerFlow->AppendRows(2); + 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(); } - auto transformerList = eCalc.GetTransformerList(); - for(auto it = transformerList.begin(), itEnd = transformerList.end(); it != itEnd; ++it) { - Transformer* transformer = *it; - if(transformer->IsOnline()) { - m_gridPowerFlow->AppendRows(2); + + // 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 / vb; + + wxString busName1 = "-"; + if(line->GetParentList()[0]) + busName1 = static_cast(line->GetParentList()[0])->GetElectricalData().name; + wxString busName2 = "-"; + if(line->GetParentList()[1]) + busName2 = static_cast(line->GetParentList()[1])->GetElectricalData().name; + + wxString isOnline = _("Yes"); + wxColour textColour = m_gridFaultBranches->GetDefaultCellTextColour(); + if(!line->IsOnline()) { + isOnline = _("No"); + textColour = 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++; } - } - 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, headerColour); - m_gridPFBuses->SetCellFont(0, i, headerFont); - } - m_gridPFBuses->SetDefaultCellAlignment(wxALIGN_CENTRE, wxALIGN_CENTRE); - // Values - auto busList = eCalc.GetBusList(); - m_gridPFBuses->AppendRows(busList.size()); - m_gridPFBuses->AutoSize(); + for(auto it = transformerList.begin(), itEnd = transformerList.end(); it != itEnd; ++it) { + Transformer* transformer = *it; + auto data = transformer->GetPUElectricalData(basePower); - // 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, headerColour); - m_gridPFBranches->SetCellFont(0, i, headerFont); + double vb = transformer->GetValueFromUnit(data.primaryNominalVoltage, data.primaryNominalVoltageUnit); + double ibp = basePower / vb; + vb = transformer->GetValueFromUnit(data.secondaryNominalVoltage, data.secondaryNominalVoltageUnit); + double ibs = basePower / vb; + + wxString busName1 = "-"; + if(transformer->GetParentList()[0]) + busName1 = static_cast(transformer->GetParentList()[0])->GetElectricalData().name; + wxString busName2 = "-"; + if(transformer->GetParentList()[1]) + busName2 = static_cast(transformer->GetParentList()[1])->GetElectricalData().name; + + wxString isOnline = _("Yes"); + wxColour textColour = m_gridFaultBranches->GetDefaultCellTextColour(); + if(!transformer->IsOnline()) { + isOnline = _("No"); + textColour = 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(); } - m_gridPFBranches->SetDefaultCellAlignment(wxALIGN_CENTRE, wxALIGN_CENTRE); - // Values - m_gridPFBranches->AppendRows(lineList.size() + transformerList.size()); - m_gridPFBranches->AutoSize(); + m_changingValues = false; } void DataReport::OnPFBusGridChanged(wxGridEvent& event) -- cgit From 91b9c3f9909955443e74dedb248fc48fa984709b Mon Sep 17 00:00:00 2001 From: Thales Lima Oliveira Date: Sat, 9 Sep 2017 19:11:41 -0300 Subject: Data report fully implemented --- Project/DataReport.cpp | 110 ++++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 90 insertions(+), 20 deletions(-) (limited to 'Project/DataReport.cpp') diff --git a/Project/DataReport.cpp b/Project/DataReport.cpp index bcde093..01a1e1d 100644 --- a/Project/DataReport.cpp +++ b/Project/DataReport.cpp @@ -5,17 +5,30 @@ 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() { - wxColour headerColour(200, 200, 200); wxFont headerFont = m_gridPowerFlow->GetLabelFont(); headerFont.SetWeight(wxFONTWEIGHT_BOLD); @@ -33,7 +46,7 @@ void DataReport::CreateGrids() m_gridPowerFlow->HideColLabels(); m_gridPowerFlow->HideRowLabels(); for(int i = 0; i < 7; ++i) { - m_gridPowerFlow->SetCellBackgroundColour(0, i, headerColour); + m_gridPowerFlow->SetCellBackgroundColour(0, i, m_headerColour); m_gridPowerFlow->SetCellFont(0, i, headerFont); } m_gridPowerFlow->SetDefaultCellAlignment(wxALIGN_CENTRE, wxALIGN_CENTRE); @@ -48,7 +61,7 @@ void DataReport::CreateGrids() m_gridPFBuses->HideColLabels(); m_gridPFBuses->HideRowLabels(); for(int i = 0; i < 6; ++i) { - m_gridPFBuses->SetCellBackgroundColour(0, i, headerColour); + m_gridPFBuses->SetCellBackgroundColour(0, i, m_headerColour); m_gridPFBuses->SetCellFont(0, i, headerFont); } m_gridPFBuses->SetDefaultCellAlignment(wxALIGN_CENTRE, wxALIGN_CENTRE); @@ -63,7 +76,7 @@ void DataReport::CreateGrids() m_gridPFBranches->HideColLabels(); m_gridPFBranches->HideRowLabels(); for(int i = 0; i < 10; ++i) { - m_gridPFBranches->SetCellBackgroundColour(0, i, headerColour); + m_gridPFBranches->SetCellBackgroundColour(0, i, m_headerColour); m_gridPFBranches->SetCellFont(0, i, headerFont); } m_gridPFBranches->SetDefaultCellAlignment(wxALIGN_CENTRE, wxALIGN_CENTRE); @@ -79,7 +92,7 @@ void DataReport::CreateGrids() m_gridFault->HideRowLabels(); for(int i = 0; i < 2; ++i) { for(int j = 0; j < 7; ++j) { - m_gridFault->SetCellBackgroundColour(i, j, headerColour); + m_gridFault->SetCellBackgroundColour(i, j, m_headerColour); m_gridFault->SetCellFont(i, j, headerFont); } } @@ -103,7 +116,7 @@ void DataReport::CreateGrids() m_gridFaultBuses->HideRowLabels(); for(int i = 0; i < 2; ++i) { for(int j = 0; j < 7; ++j) { - m_gridFaultBuses->SetCellBackgroundColour(i, j, headerColour); + m_gridFaultBuses->SetCellBackgroundColour(i, j, m_headerColour); m_gridFaultBuses->SetCellFont(i, j, headerFont); } } @@ -124,7 +137,7 @@ void DataReport::CreateGrids() m_gridFaultBranches->HideRowLabels(); for(int i = 0; i < 2; ++i) { for(int j = 0; j < 11; ++j) { - m_gridFaultBranches->SetCellBackgroundColour(i, j, headerColour); + m_gridFaultBranches->SetCellBackgroundColour(i, j, m_headerColour); m_gridFaultBranches->SetCellFont(i, j, headerFont); } } @@ -149,7 +162,7 @@ void DataReport::CreateGrids() m_gridFaultGenerators->HideRowLabels(); for(int i = 0; i < 2; ++i) { for(int j = 0; j < 7; ++j) { - m_gridFaultGenerators->SetCellBackgroundColour(i, j, headerColour); + m_gridFaultGenerators->SetCellBackgroundColour(i, j, m_headerColour); m_gridFaultGenerators->SetCellFont(i, j, headerFont); } } @@ -299,8 +312,6 @@ void DataReport::SetHeaders() void DataReport::FillValues(GridSelection gridToFill) { - wxColour offlineColour(100, 100, 100); - m_changingValues = true; ElectricCalculation eCalc; eCalc.GetElementsFromList(m_workspace->GetElementList()); @@ -321,6 +332,7 @@ void DataReport::FillValues(GridSelection gridToFill) 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) { @@ -354,7 +366,7 @@ void DataReport::FillValues(GridSelection gridToFill) wxColour textColour = m_gridPowerFlow->GetDefaultCellTextColour(); if(!line->IsOnline()) { isOnline = _("No"); - textColour = offlineColour; + textColour = m_offlineColour; } for(int i = 0; i < 2; ++i) { for(int j = 0; j < 7; ++j) { @@ -403,7 +415,7 @@ void DataReport::FillValues(GridSelection gridToFill) wxColour textColour = m_gridPowerFlow->GetDefaultCellTextColour(); if(!transformer->IsOnline()) { isOnline = _("No"); - textColour = offlineColour; + textColour = m_offlineColour; } for(int i = 0; i < 2; ++i) { for(int j = 0; j < 7; ++j) { @@ -511,7 +523,7 @@ void DataReport::FillValues(GridSelection gridToFill) wxColour textColour = m_gridPFBranches->GetDefaultCellTextColour(); if(!line->IsOnline()) { isOnline = _("No"); - textColour = offlineColour; + textColour = m_offlineColour; } for(int j = 0; j < 10; ++j) { m_gridPFBranches->SetCellTextColour(rowNumber, j, textColour); @@ -562,7 +574,7 @@ void DataReport::FillValues(GridSelection gridToFill) wxColour textColour = m_gridPFBranches->GetDefaultCellTextColour(); if(!transformer->IsOnline()) { isOnline = _("No"); - textColour = offlineColour; + textColour = m_offlineColour; } for(int j = 0; j < 10; ++j) { m_gridPFBranches->SetCellTextColour(rowNumber, j, textColour); @@ -596,7 +608,7 @@ void DataReport::FillValues(GridSelection gridToFill) auto data = bus->GetElectricalData(); if(data.hasFault) { double vb = bus->GetValueFromUnit(data.nominalVoltage, data.nominalVoltageUnit); - double ib = basePower / vb; + double ib = basePower / (std::sqrt(3.0) * vb); m_gridFault->SetCellValue(rowNumber, 0, data.name); @@ -697,7 +709,7 @@ void DataReport::FillValues(GridSelection gridToFill) auto data = line->GetPUElectricalData(basePower); double vb = line->GetValueFromUnit(data.nominalVoltage, data.nominalVoltageUnit); - double ib = basePower / vb; + double ib = basePower / (std::sqrt(3.0) * vb); wxString busName1 = "-"; if(line->GetParentList()[0]) @@ -710,7 +722,7 @@ void DataReport::FillValues(GridSelection gridToFill) wxColour textColour = m_gridFaultBranches->GetDefaultCellTextColour(); if(!line->IsOnline()) { isOnline = _("No"); - textColour = offlineColour; + textColour = m_offlineColour; } for(int i = 0; i < 2; ++i) { for(int j = 0; j < 11; ++j) { @@ -799,9 +811,9 @@ void DataReport::FillValues(GridSelection gridToFill) auto data = transformer->GetPUElectricalData(basePower); double vb = transformer->GetValueFromUnit(data.primaryNominalVoltage, data.primaryNominalVoltageUnit); - double ibp = basePower / vb; + double ibp = basePower / (std::sqrt(3.0) * vb); vb = transformer->GetValueFromUnit(data.secondaryNominalVoltage, data.secondaryNominalVoltageUnit); - double ibs = basePower / vb; + double ibs = basePower / (std::sqrt(3.0) * vb); wxString busName1 = "-"; if(transformer->GetParentList()[0]) @@ -814,7 +826,7 @@ void DataReport::FillValues(GridSelection gridToFill) wxColour textColour = m_gridFaultBranches->GetDefaultCellTextColour(); if(!transformer->IsOnline()) { isOnline = _("No"); - textColour = offlineColour; + textColour = m_offlineColour; } for(int i = 0; i < 2; ++i) { for(int j = 0; j < 11; ++j) { @@ -900,9 +912,67 @@ void DataReport::FillValues(GridSelection gridToFill) 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); -- cgit