Power System Platform  2026w23a-beta
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
DataReport Class Reference

Form that shows the results of power flow and fault calculations. More...

#include <DataReport.h>

Inheritance diagram for DataReport:
Inheritance graph
[legend]
Collaboration diagram for DataReport:
Collaboration graph
[legend]

Public Types

enum  GridSelection {
  GRID_ALL = 0 , GRID_PF , GRID_PFBUSES , GRID_PFBRANCHES ,
  GRID_FAULT , GRID_FAULTBUSES , GRID_FAULTBRANCHES , GRID_FAULTGENERATORS ,
  GRID_HARMCURRENT , GRID_HARMBUSES , GRID_HARMBRANCHES
}
 

Public Member Functions

 DataReport (wxWindow *parent, Workspace *workspace)
 
virtual void SetHeaders ()
 
virtual void CreateGrids ()
 
virtual void FillValues (GridSelection gridToFill=GRID_ALL)
 
virtual void SetRowsColours (wxGrid *grid, int rowStart=1, int colStart=0, int colEndTrim=0)
 
virtual void GridKeyHandler (wxGrid *grid, wxKeyEvent &event)
 
virtual void UpdateFontSize ()
 
virtual void UpdateCurrentGrid ()
 

Protected Member Functions

virtual void OnMouseWheel (wxMouseEvent &event)
 
virtual void OnTextPrecisionUpdate (wxCommandEvent &event)
 
virtual void OnMainNotebookChanged (wxNotebookEvent &event)
 
virtual void OnFontSizeSelected (wxCommandEvent &event)
 
virtual void OnHarmNotebookChanged (wxNotebookEvent &event)
 
virtual void OnFaultNotebookChanged (wxNotebookEvent &event)
 
virtual void OnPFNotebookChanged (wxNotebookEvent &event)
 
virtual void ClipboardButtonClick (wxCommandEvent &event)
 
virtual void ExportCSVButtonClick (wxCommandEvent &event)
 
virtual void OnHarmBranchesGridChanged (wxGridEvent &event)
 
virtual void OnHarmBusesGridChanged (wxGridEvent &event)
 
virtual void OnHarmCurrentGridChanged (wxGridEvent &event)
 
virtual void OnFaulrGridChanged (wxGridEvent &event)
 
virtual void OnFaultBranchesGridChanged (wxGridEvent &event)
 
virtual void OnFaultBusesGridChanged (wxGridEvent &event)
 
virtual void OnFaultGeneratorsGridChanged (wxGridEvent &event)
 
virtual void OnPFBranchesGridChanged (wxGridEvent &event)
 
virtual void OnPowerFlowGridChanged (wxGridEvent &event)
 
virtual void OnPFBusGridChanged (wxGridEvent &event)
 
virtual void OnGridFaultBranchesKeyDown (wxKeyEvent &event)
 
virtual void OnGridFaultBusesKeyDown (wxKeyEvent &event)
 
virtual void OnGridFaultGeneratorsKeyDown (wxKeyEvent &event)
 
virtual void OnGridFaultKeyDown (wxKeyEvent &event)
 
virtual void OnGridPFBranchesKeyDown (wxKeyEvent &event)
 
virtual void OnGridPFBusesKeyDown (wxKeyEvent &event)
 
virtual void OnGridPFKeyDown (wxKeyEvent &event)
 

Protected Attributes

Workspace * m_workspace = nullptr
 
bool m_changingValues = false
 
wxGrid * m_currentGrid = nullptr
 
int m_fontSize = 10
 
int m_precision = 4
 
wxArrayString m_voltageChoices
 
wxArrayString m_phaseVoltageChoices
 
wxArrayString m_activePowerChoices
 
wxArrayString m_reactivePowerChoices
 
wxArrayString m_resistanceChoices
 
wxArrayString m_indReactanceChoices
 
wxArrayString m_capSusceptanceChoices
 
wxArrayString m_currentChoices
 
wxColour m_headerColour
 
wxColour m_offlineColour
 
wxColour m_oddRowColour
 
wxColour m_evenRowColour
 

Detailed Description

Form that shows the results of power flow and fault calculations.

Author
Thales Lima Oliveira thale.nosp@m.s@uf.nosp@m.u.br
Date
05/10/2017

Definition at line 33 of file DataReport.h.

Member Enumeration Documentation

◆ GridSelection

enum DataReport::GridSelection

Definition at line 36 of file DataReport.h.

36 {
37 GRID_ALL = 0,
38 GRID_PF,
39 GRID_PFBUSES,
40 GRID_PFBRANCHES,
41 GRID_FAULT,
42 GRID_FAULTBUSES,
43 GRID_FAULTBRANCHES,
44 GRID_FAULTGENERATORS,
45 GRID_HARMCURRENT,
46 GRID_HARMBUSES,
47 GRID_HARMBRANCHES,
48 };

Constructor & Destructor Documentation

◆ DataReport()

DataReport::DataReport ( wxWindow *  parent,
Workspace *  workspace 
)

Definition at line 24 of file DataReport.cpp.

24 : DataReportBase(parent)
25{
26 m_workspace = workspace;
27
28 if (wxSystemSettings::GetAppearance().IsDark())
29 {
30 m_headerColour = wxColour(50, 50, 50);
31 m_offlineColour = wxColour(100, 100, 100);
32 m_oddRowColour = wxColour(70, 70, 70);
33 m_evenRowColour = wxColour(40, 40, 40);
34 } else
35 {
36 m_headerColour = wxColour(191, 223, 255);
37 m_offlineColour = wxColour(100, 100, 100);
38 m_oddRowColour = wxColour(220, 220, 220);
39 m_evenRowColour = wxColour(255, 255, 255);
40 }
41
42 m_fontSize = wxAtoi(m_choiceFontSize->GetStringSelection());
43 m_precision = wxAtoi(m_textCtrlPrecision->GetValue());
44
45 wxGrid* grids[] = { m_gridPowerFlow, m_gridPFBuses, m_gridPFBranches, m_gridFault, m_gridFaultBuses, m_gridFaultBranches, m_gridFaultGenerators, m_gridHarmCurrents, m_gridHarmBuses, m_gridHarmBranches };
46 for (auto grid : grids)
47 grid->Bind(wxEVT_MOUSEWHEEL, &DataReport::OnMouseWheel, this);
48
49 UpdateFontSize();
50 CreateGrids();
51 SetHeaders();
52 FillValues();
53
54 SetRowsColours(m_gridPowerFlow);
55 SetRowsColours(m_gridPFBuses);
56 SetRowsColours(m_gridPFBranches);
57 SetRowsColours(m_gridFault, 2);
58 SetRowsColours(m_gridFaultBuses, 2);
59 SetRowsColours(m_gridFaultBranches, 2);
60 SetRowsColours(m_gridFaultGenerators, 2);
61 SetRowsColours(m_gridHarmCurrents, 1, 2);
62 SetRowsColours(m_gridHarmBuses, 1, 2);
63 SetRowsColours(m_gridHarmBranches, 1, 4, 1);
64
65 UpdateCurrentGrid();
66}
DataReport
Form that shows the results of power flow and fault calculations.
Definition DataReport.h:34

◆ ~DataReport()

DataReport::~DataReport ( )
virtual

Definition at line 68 of file DataReport.cpp.

69{
70 wxGrid* grids[] = { m_gridPowerFlow, m_gridPFBuses, m_gridPFBranches, m_gridFault, m_gridFaultBuses, m_gridFaultBranches, m_gridFaultGenerators, m_gridHarmCurrents, m_gridHarmBuses, m_gridHarmBranches };
71 for (auto grid : grids)
72 grid->Unbind(wxEVT_MOUSEWHEEL, &DataReport::OnMouseWheel, this);
73}

Member Function Documentation

◆ ClipboardButtonClick()

void DataReport::ClipboardButtonClick ( wxCommandEvent &  event)
protectedvirtual

Definition at line 1556 of file DataReport.cpp.

1557{
1558 wxString plainText;
1559 wxString html;
1560 wxGrid* grid = m_currentGrid;
1561
1562 if (grid == nullptr) {
1563 wxMessageDialog msgDialog(this, _("Unable to copy to clipboard."), _("Error"), wxOK | wxCENTRE | wxICON_ERROR);
1564 msgDialog.ShowModal();
1565 return;
1566 }
1567
1568 int headerRows = 1;
1569
1570 if (grid == m_gridFault ||
1571 grid == m_gridFaultBuses ||
1572 grid == m_gridFaultBranches ||
1573 grid == m_gridFaultGenerators)
1574 {
1575 headerRows = 2;
1576 }
1577
1578 html << "<table style='border-collapse:collapse; "
1579 "font-family:Segoe UI, Arial, sans-serif; "
1580 "font-size:10pt;'>";
1581
1582 int rows = grid->GetNumberRows();
1583 int cols = grid->GetNumberCols();
1584
1585 for (int row = 0; row < rows; row++)
1586 {
1587 html << "<tr>";
1588
1589 for (int col = 0; col < cols; )
1590 {
1591 int rowspan = 1;
1592 int colspan = 1;
1593
1594 grid->GetCellSize(row, col, &rowspan, &colspan);
1595
1596 // Skip covered cells
1597 if (rowspan == 0 || colspan == 0)
1598 {
1599 col++;
1600 continue;
1601 }
1602
1603 wxString value = grid->GetCellValue(row, col);
1604
1605 // Plain text
1606 if (col > 0)
1607 plainText << "\t";
1608 plainText << value;
1609
1610 // Repeat value in plain text if merged horizontally
1611 for (int c = 1; c < colspan; c++)
1612 plainText << "\t" << value;
1613
1614 // Escape HTML
1615 wxString escaped = value;
1616 escaped.Replace("&", "&amp;");
1617 escaped.Replace("<", "&lt;");
1618 escaped.Replace(">", "&gt;");
1619
1620 bool isHeader = (row < headerRows);
1621
1622 if (isHeader)
1623 {
1624 html << "<th style='"
1625 "border:1px solid #c9d1e6;"
1626 "background-color:#BFDFFF;"
1627 "color:black;"
1628 "padding:5px 8px;"
1629 "text-align:center;'";
1630
1631 if (rowspan > 1)
1632 html << " rowspan='" << rowspan << "'";
1633 if (colspan > 1)
1634 html << " colspan='" << colspan << "'";
1635
1636 html << ">" << escaped << "</th>";
1637 }
1638 else
1639 {
1640 html << "<td style='"
1641 "border:1px solid #c9d1e6;"
1642 "padding:4px 8px;"
1643 "text-align:center;'";
1644
1645 if (rowspan > 1)
1646 html << " rowspan='" << rowspan << "'";
1647 if (colspan > 1)
1648 html << " colspan='" << colspan << "'";
1649
1650 html << ">" << escaped << "</td>";
1651 }
1652
1653 col += colspan;
1654 }
1655
1656 plainText << "\r\n";
1657 html << "</tr>";
1658 }
1659
1660 html << "</table>";
1661
1662
1663 if (wxTheClipboard->Open())
1664 {
1665 wxDataObjectComposite* data = new wxDataObjectComposite();
1666
1667 data->Add(new wxHTMLDataObject(html));
1668 data->Add(new wxTextDataObject(plainText));
1669
1670 wxTheClipboard->SetData(data);
1671 wxTheClipboard->Close();
1672 }
1673 else {
1674 wxMessageDialog msgDialog(this, _("Unable to copy to clipboard."), _("Error"), wxOK | wxCENTRE | wxICON_ERROR);
1675 msgDialog.ShowModal();
1676 }
1677}

◆ CreateGrids()

void DataReport::CreateGrids ( )
virtual

Definition at line 75 of file DataReport.cpp.

76{
77 wxFont headerFont = m_gridPowerFlow->GetLabelFont();
78 headerFont.SetWeight(wxFONTWEIGHT_BOLD);
79
80 ElectricCalculation eCalc;
81 eCalc.GetElementsFromList(m_workspace->GetElementList());
82 auto lineList = eCalc.GetLineList();
83 auto transformerList = eCalc.GetTransformerList();
84 auto busList = eCalc.GetBusList();
85 auto generatorList = eCalc.GetSyncGeneratorList();
86 auto harmCurrentSourceList = eCalc.GetHarmCurrentList();
87
88 // Power Flow
89 // Header
90 m_gridPowerFlow->AppendCols(7);
91 m_gridPowerFlow->AppendRows();
92 m_gridPowerFlow->HideColLabels();
93 m_gridPowerFlow->HideRowLabels();
94 for (int i = 0; i < 7; ++i) {
95 m_gridPowerFlow->SetCellBackgroundColour(0, i, m_headerColour);
96 m_gridPowerFlow->SetCellFont(0, i, headerFont);
97 }
98 m_gridPowerFlow->SetDefaultCellAlignment(wxALIGN_CENTRE, wxALIGN_CENTRE);
99 // Values
100 m_gridPowerFlow->AppendRows((lineList.size() + transformerList.size()) * 2);
101 m_gridPowerFlow->AutoSize();
102
103 // Power Flow buses
104 // Header
105 m_gridPFBuses->AppendCols(6);
106 m_gridPFBuses->AppendRows();
107 m_gridPFBuses->HideColLabels();
108 m_gridPFBuses->HideRowLabels();
109 for (int i = 0; i < 6; ++i) {
110 m_gridPFBuses->SetCellBackgroundColour(0, i, m_headerColour);
111 m_gridPFBuses->SetCellFont(0, i, headerFont);
112 }
113 m_gridPFBuses->SetDefaultCellAlignment(wxALIGN_CENTRE, wxALIGN_CENTRE);
114 // Values
115 m_gridPFBuses->AppendRows(busList.size());
116 m_gridPFBuses->AutoSize();
117
118 // Power flow branches
119 // Header
120 m_gridPFBranches->AppendCols(10);
121 m_gridPFBranches->AppendRows(1);
122 m_gridPFBranches->HideColLabels();
123 m_gridPFBranches->HideRowLabels();
124 for (int i = 0; i < 10; ++i) {
125 m_gridPFBranches->SetCellBackgroundColour(0, i, m_headerColour);
126 m_gridPFBranches->SetCellFont(0, i, headerFont);
127 }
128 m_gridPFBranches->SetDefaultCellAlignment(wxALIGN_CENTRE, wxALIGN_CENTRE);
129 // Values
130 m_gridPFBranches->AppendRows(lineList.size() + transformerList.size());
131 m_gridPFBranches->AutoSize();
132
133 // Fault
134 // Header
135 m_gridFault->AppendCols(7);
136 m_gridFault->AppendRows(2);
137 m_gridFault->HideColLabels();
138 m_gridFault->HideRowLabels();
139 for (int i = 0; i < 2; ++i) {
140 for (int j = 0; j < 7; ++j) {
141 m_gridFault->SetCellBackgroundColour(i, j, m_headerColour);
142 m_gridFault->SetCellFont(i, j, headerFont);
143 }
144 }
145 m_gridFault->SetDefaultCellAlignment(wxALIGN_CENTRE, wxALIGN_CENTRE);
146 m_gridFault->SetCellSize(0, 0, 2, 1);
147 m_gridFault->SetCellSize(0, 1, 1, 2);
148 m_gridFault->SetCellSize(0, 3, 1, 2);
149 m_gridFault->SetCellSize(0, 5, 1, 2);
150 // Values
151 for (auto it = busList.begin(), itEnd = busList.end(); it != itEnd; ++it) {
152 Bus* bus = *it;
153 if (bus->GetElectricalData().hasFault) m_gridFault->AppendRows();
154 }
155 m_gridFault->AutoSize();
156
157 // Fault buses
158 // Header
159 m_gridFaultBuses->AppendCols(7);
160 m_gridFaultBuses->AppendRows(2);
161 m_gridFaultBuses->HideColLabels();
162 m_gridFaultBuses->HideRowLabels();
163 for (int i = 0; i < 2; ++i) {
164 for (int j = 0; j < 7; ++j) {
165 m_gridFaultBuses->SetCellBackgroundColour(i, j, m_headerColour);
166 m_gridFaultBuses->SetCellFont(i, j, headerFont);
167 }
168 }
169 m_gridFaultBuses->SetDefaultCellAlignment(wxALIGN_CENTRE, wxALIGN_CENTRE);
170 m_gridFaultBuses->SetCellSize(0, 0, 2, 1);
171 m_gridFaultBuses->SetCellSize(0, 1, 1, 2);
172 m_gridFaultBuses->SetCellSize(0, 3, 1, 2);
173 m_gridFaultBuses->SetCellSize(0, 5, 1, 2);
174 // Values
175 m_gridFaultBuses->AppendRows(busList.size());
176 m_gridFaultBuses->AutoSize();
177
178 // Fault branches
179 // Header
180 m_gridFaultBranches->AppendCols(11);
181 m_gridFaultBranches->AppendRows(2);
182 m_gridFaultBranches->HideColLabels();
183 m_gridFaultBranches->HideRowLabels();
184 for (int i = 0; i < 2; ++i) {
185 for (int j = 0; j < 11; ++j) {
186 m_gridFaultBranches->SetCellBackgroundColour(i, j, m_headerColour);
187 m_gridFaultBranches->SetCellFont(i, j, headerFont);
188 }
189 }
190 m_gridFaultBranches->SetDefaultCellAlignment(wxALIGN_CENTRE, wxALIGN_CENTRE);
191 m_gridFaultBranches->SetCellSize(0, 0, 2, 1);
192 m_gridFaultBranches->SetCellSize(0, 1, 2, 1);
193 m_gridFaultBranches->SetCellSize(0, 2, 2, 1);
194 m_gridFaultBranches->SetCellSize(0, 3, 2, 1);
195 m_gridFaultBranches->SetCellSize(0, 10, 2, 1);
196 m_gridFaultBranches->SetCellSize(0, 4, 1, 2);
197 m_gridFaultBranches->SetCellSize(0, 6, 1, 2);
198 m_gridFaultBranches->SetCellSize(0, 8, 1, 2);
199 // Values
200 m_gridFaultBranches->AppendRows((lineList.size() + transformerList.size()) * 2);
201 m_gridFaultBranches->AutoSize();
202
203 // Fault generators
204 // Header
205 m_gridFaultGenerators->AppendCols(7);
206 m_gridFaultGenerators->AppendRows(2);
207 m_gridFaultGenerators->HideColLabels();
208 m_gridFaultGenerators->HideRowLabels();
209 for (int i = 0; i < 2; ++i) {
210 for (int j = 0; j < 7; ++j) {
211 m_gridFaultGenerators->SetCellBackgroundColour(i, j, m_headerColour);
212 m_gridFaultGenerators->SetCellFont(i, j, headerFont);
213 }
214 }
215 m_gridFaultGenerators->SetDefaultCellAlignment(wxALIGN_CENTRE, wxALIGN_CENTRE);
216 m_gridFaultGenerators->SetCellSize(0, 0, 2, 1);
217 m_gridFaultGenerators->SetCellSize(0, 1, 1, 2);
218 m_gridFaultGenerators->SetCellSize(0, 3, 1, 2);
219 m_gridFaultGenerators->SetCellSize(0, 5, 1, 2);
220 // Values
221 m_gridFaultGenerators->AppendRows(generatorList.size());
222 m_gridFaultGenerators->AutoSize();
223
224 // Harmonics currents
225 // Header
226 m_gridHarmCurrents->AppendCols(5);
227 m_gridHarmCurrents->AppendRows();
228 m_gridHarmCurrents->HideColLabels();
229 m_gridHarmCurrents->HideRowLabels();
230 for (int i = 0; i < 5; ++i) {
231 m_gridHarmCurrents->SetCellBackgroundColour(0, i, m_headerColour);
232 m_gridHarmCurrents->SetCellFont(0, i, headerFont);
233 }
234 m_gridHarmCurrents->SetDefaultCellAlignment(wxALIGN_CENTRE, wxALIGN_CENTRE);
235 // Values
236 int numRowDataHarmCurrent = 0;
237 for (auto* hSource : harmCurrentSourceList) {
238 numRowDataHarmCurrent += hSource->GetElectricalData().harmonicOrder.size();
239 }
240 m_gridHarmCurrents->AppendRows(numRowDataHarmCurrent);
241 m_gridHarmCurrents->AutoSize();
242
243 // Harmonics buses
244 // Header
245 m_gridHarmBuses->AppendCols(5);
246 m_gridHarmBuses->AppendRows();
247 m_gridHarmBuses->HideColLabels();
248 m_gridHarmBuses->HideRowLabels();
249 for (int i = 0; i < 5; ++i) {
250 m_gridHarmBuses->SetCellBackgroundColour(0, i, m_headerColour);
251 m_gridHarmBuses->SetCellFont(0, i, headerFont);
252 }
253 m_gridHarmBuses->SetDefaultCellAlignment(wxALIGN_CENTRE, wxALIGN_CENTRE);
254 // Values
255 int numRowDataHarmBuses = 0;
256 for (auto* bus : busList) {
257 numRowDataHarmBuses += bus->GetElectricalData().harmonicOrder.size();
258 }
259 m_gridHarmBuses->AppendRows(numRowDataHarmBuses);
260 m_gridHarmBuses->AutoSize();
261
262 // Harmonics branches currents
263 // Header
264 m_gridHarmBranches->AppendCols(8);
265 m_gridHarmBranches->AppendRows();
266 m_gridHarmBranches->HideColLabels();
267 m_gridHarmBranches->HideRowLabels();
268 for (int i = 0; i < 8; ++i) {
269 m_gridHarmBranches->SetCellBackgroundColour(0, i, m_headerColour);
270 m_gridHarmBranches->SetCellFont(0, i, headerFont);
271 }
272 m_gridHarmBranches->SetDefaultCellAlignment(wxALIGN_CENTRE, wxALIGN_CENTRE);
273 // Values
274 int numRowDataHarmBranches = 0;
275 for (auto* line : lineList) {
276 numRowDataHarmBranches += line->GetElectricalData().harmonicOrder.size();
277 }
278 for (auto* transformer : transformerList) {
279 numRowDataHarmBranches += transformer->GetElectricalData().harmonicOrder.size();
280 }
281 m_gridHarmBranches->AppendRows(numRowDataHarmBranches * 2.0);
282 m_gridHarmBranches->AutoSize();
283
284}
Bus
Node for power elements. All others power elements are connected through this.
Definition Bus.h:86
ElectricCalculation
Base class for electrical calculations providing general utility methods.
Definition ElectricCalculation.h:116
ElectricCalculation::GetSyncGeneratorList
const std::vector< SyncGenerator * > GetSyncGeneratorList() const
Get the synchronous generators of the system (use GetElementsFromList first).
Definition ElectricCalculation.h:328
ElectricCalculation::GetTransformerList
const std::vector< Transformer * > GetTransformerList() const
Get the transformers of the system (use GetElementsFromList first).
Definition ElectricCalculation.h:338
ElectricCalculation::GetLineList
const std::vector< Line * > GetLineList() const
Get the lines of the system (use GetElementsFromList first).
Definition ElectricCalculation.h:318
ElectricCalculation::GetBusList
const std::vector< Bus * > GetBusList() const
Get the buses of the system (use GetElementsFromList first).
Definition ElectricCalculation.h:298
ElectricCalculation::GetElementsFromList
virtual void GetElementsFromList(std::vector< Element * > elementList)
Separate the power elements from a generic list.
Definition ElectricCalculation.cpp:27
ElectricCalculation::GetHarmCurrentList
const std::vector< HarmCurrent * > GetHarmCurrentList() const
Get the harmonic current source of the system (use GetElementsFromList first).
Definition ElectricCalculation.h:343

◆ ExportCSVButtonClick()

void DataReport::ExportCSVButtonClick ( wxCommandEvent &  event)
protectedvirtual

Definition at line 1678 of file DataReport.cpp.

1679{
1680 std::vector<wxGrid*> grids = { m_gridPowerFlow, m_gridPFBuses, m_gridPFBranches,
1681 m_gridFault, m_gridFaultBuses, m_gridFaultBranches, m_gridFaultGenerators,
1682 m_gridHarmCurrents, m_gridHarmBuses, m_gridHarmBranches };
1683 ExportCSVForm expCSV(this, grids);
1684 expCSV.ShowModal();
1685}

◆ FillValues()

void DataReport::FillValues ( GridSelection  gridToFill = GRID_ALL)
virtual

Definition at line 451 of file DataReport.cpp.

452{
453 m_changingValues = true;
454 ElectricCalculation eCalc;
455 eCalc.GetElementsFromList(m_workspace->GetElementList());
456
457 double basePower = m_workspace->GetProperties()->GetSimulationPropertiesData().basePower;
458 switch (m_workspace->GetProperties()->GetSimulationPropertiesData().basePowerUnit) {
459 case ElectricalUnit::UNIT_kVA: {
460 basePower *= 1e3;
461 } break;
462 case ElectricalUnit::UNIT_MVA: {
463 basePower *= 1e6;
464 } break;
465 default:
466 break;
467 }
468
469 int rowNumber = 1;
470 auto lineList = eCalc.GetLineList();
471 auto transformerList = eCalc.GetTransformerList();
472 auto busList = eCalc.GetBusList();
473 auto generatorList = eCalc.GetSyncGeneratorList();
474 auto harmCurrentList = eCalc.GetHarmCurrentList();
475
476 // Power Flow
477 if (gridToFill == GRID_ALL || gridToFill == GRID_PF) {
478 double kActivePower = 1.0;
479 if (m_gridPowerFlow->GetCellValue(0, 4) == m_activePowerChoices[1])
480 kActivePower = basePower;
481 else if (m_gridPowerFlow->GetCellValue(0, 4) == m_activePowerChoices[2])
482 kActivePower = basePower / 1e3;
483 else if (m_gridPowerFlow->GetCellValue(0, 4) == m_activePowerChoices[3])
484 kActivePower = basePower / 1e6;
485
486 double kReactivePower = 1.0;
487 if (m_gridPowerFlow->GetCellValue(0, 5) == m_reactivePowerChoices[1])
488 kReactivePower = basePower;
489 else if (m_gridPowerFlow->GetCellValue(0, 5) == m_reactivePowerChoices[2])
490 kReactivePower = basePower / 1e3;
491 else if (m_gridPowerFlow->GetCellValue(0, 5) == m_reactivePowerChoices[3])
492 kReactivePower = basePower / 1e6;
493
494 for (auto it = lineList.begin(), itEnd = lineList.end(); it != itEnd; ++it) {
495 Line* line = *it;
496
497 wxString busName1 = "-";
498 if (line->GetParentList()[0])
499 busName1 = static_cast<Bus*>(line->GetParentList()[0])->GetElectricalData().name;
500 wxString busName2 = "-";
501 if (line->GetParentList()[1])
502 busName2 = static_cast<Bus*>(line->GetParentList()[1])->GetElectricalData().name;
503
504 wxString isOnline = _("Yes");
505 wxColour textColour = m_gridPowerFlow->GetDefaultCellTextColour();
506 if (!line->IsOnline()) {
507 isOnline = _("No");
508 textColour = m_offlineColour;
509 }
510 for (int i = 0; i < 2; ++i) {
511 for (int j = 0; j < 7; ++j) { m_gridPowerFlow->SetCellTextColour(rowNumber + i, j, textColour); }
512 }
513
514 auto data = line->GetPUElectricalData(basePower);
515
516 m_gridPowerFlow->SetCellValue(rowNumber, 0, _("Line"));
517 m_gridPowerFlow->SetCellValue(rowNumber, 1, data.name);
518 m_gridPowerFlow->SetCellValue(rowNumber, 2, busName1);
519 m_gridPowerFlow->SetCellValue(rowNumber, 3, busName2);
520 m_gridPowerFlow->SetCellValue(rowNumber, 4,
521 line->StringFromDouble(std::real(data.powerFlow[0]) * kActivePower, 0, m_precision));
522 m_gridPowerFlow->SetCellValue(rowNumber, 5,
523 line->StringFromDouble(std::imag(data.powerFlow[0]) * kReactivePower, 0, m_precision));
524 m_gridPowerFlow->SetCellValue(rowNumber, 6, isOnline);
525 rowNumber++;
526
527 m_gridPowerFlow->SetCellValue(rowNumber, 0, _("Line"));
528 m_gridPowerFlow->SetCellValue(rowNumber, 1, data.name);
529 m_gridPowerFlow->SetCellValue(rowNumber, 2, busName2);
530 m_gridPowerFlow->SetCellValue(rowNumber, 3, busName1);
531 m_gridPowerFlow->SetCellValue(rowNumber, 4,
532 line->StringFromDouble(std::real(data.powerFlow[1]) * kActivePower, 0, m_precision));
533 m_gridPowerFlow->SetCellValue(rowNumber, 5,
534 line->StringFromDouble(std::imag(data.powerFlow[1]) * kReactivePower, 0, m_precision));
535 m_gridPowerFlow->SetCellValue(rowNumber, 6, isOnline);
536 rowNumber++;
537 }
538
539 for (auto it = transformerList.begin(), itEnd = transformerList.end(); it != itEnd; ++it) {
540 Transformer* transformer = *it;
541 auto data = transformer->GetPUElectricalData(basePower);
542
543 wxString busName1 = "-";
544 if (transformer->GetParentList()[0])
545 busName1 = static_cast<Bus*>(transformer->GetParentList()[0])->GetElectricalData().name;
546 wxString busName2 = "-";
547 if (transformer->GetParentList()[1])
548 busName2 = static_cast<Bus*>(transformer->GetParentList()[1])->GetElectricalData().name;
549
550 wxString isOnline = _("Yes");
551 wxColour textColour = m_gridPowerFlow->GetDefaultCellTextColour();
552 if (!transformer->IsOnline()) {
553 isOnline = _("No");
554 textColour = m_offlineColour;
555 }
556 for (int i = 0; i < 2; ++i) {
557 for (int j = 0; j < 7; ++j) { m_gridPowerFlow->SetCellTextColour(rowNumber + i, j, textColour); }
558 }
559
560 m_gridPowerFlow->SetCellValue(rowNumber, 0, _("Transformer"));
561 m_gridPowerFlow->SetCellValue(rowNumber, 1, data.name);
562 m_gridPowerFlow->SetCellValue(rowNumber, 2, busName1);
563 m_gridPowerFlow->SetCellValue(rowNumber, 3, busName2);
564 m_gridPowerFlow->SetCellValue(rowNumber, 4,
565 transformer->StringFromDouble(std::real(data.powerFlow[0]) * kActivePower, 0, m_precision));
566 m_gridPowerFlow->SetCellValue(rowNumber, 5,
567 transformer->StringFromDouble(std::imag(data.powerFlow[0]) * kReactivePower, 0, m_precision));
568 m_gridPowerFlow->SetCellValue(rowNumber, 6, isOnline);
569 rowNumber++;
570
571 m_gridPowerFlow->SetCellValue(rowNumber, 0, _("Transformer"));
572 m_gridPowerFlow->SetCellValue(rowNumber, 1, data.name);
573 m_gridPowerFlow->SetCellValue(rowNumber, 2, busName2);
574 m_gridPowerFlow->SetCellValue(rowNumber, 3, busName1);
575 m_gridPowerFlow->SetCellValue(rowNumber, 4,
576 transformer->StringFromDouble(std::real(data.powerFlow[1]) * kActivePower, 0, m_precision));
577 m_gridPowerFlow->SetCellValue(rowNumber, 5,
578 transformer->StringFromDouble(std::imag(data.powerFlow[1]) * kReactivePower, 0, m_precision));
579 m_gridPowerFlow->SetCellValue(rowNumber, 6, isOnline);
580 rowNumber++;
581 }
582 m_gridPowerFlow->AutoSize();
583 m_gridPowerFlow->GetContainingSizer()->Layout();
584 }
585
586 // Power Flow buses
587 if (gridToFill == GRID_ALL || gridToFill == GRID_PFBUSES) {
588 double kActivePower = 1.0;
589 if (m_gridPFBuses->GetCellValue(0, 4) == m_activePowerChoices[1])
590 kActivePower = basePower;
591 else if (m_gridPFBuses->GetCellValue(0, 4) == m_activePowerChoices[2])
592 kActivePower = basePower / 1e3;
593 else if (m_gridPFBuses->GetCellValue(0, 4) == m_activePowerChoices[3])
594 kActivePower = basePower / 1e6;
595
596 double kReactivePower = 1.0;
597 if (m_gridPFBuses->GetCellValue(0, 5) == m_reactivePowerChoices[1])
598 kReactivePower = basePower;
599 else if (m_gridPFBuses->GetCellValue(0, 5) == m_reactivePowerChoices[2])
600 kReactivePower = basePower / 1e3;
601 else if (m_gridPFBuses->GetCellValue(0, 5) == m_reactivePowerChoices[3])
602 kReactivePower = basePower / 1e6;
603
604 rowNumber = 1;
605 for (auto it = busList.begin(), itEnd = busList.end(); it != itEnd; ++it) {
606 Bus* bus = *it;
607 auto data = bus->GetElectricalData();
608
609 double vb = std::abs(data.nominalVoltage);
610 if (data.nominalVoltageUnit == ElectricalUnit::UNIT_kV) vb *= 1e3;
611 double kVoltage = 1.0;
612 if (m_gridPFBuses->GetCellValue(0, 2) == m_voltageChoices[1])
613 kVoltage = vb;
614 else if (m_gridPFBuses->GetCellValue(0, 2) == m_voltageChoices[2])
615 kVoltage = vb / 1e3;
616
617 m_gridPFBuses->SetCellValue(rowNumber, 0, data.name);
618 wxString busTypeString = "";
619 switch (data.busType) {
620 case BUS_SLACK: {
621 busTypeString = _("Slack");
622 } break;
623 case BUS_PV: {
624 busTypeString = _("PV");
625 } break;
626 case BUS_PQ: {
627 busTypeString = _("PQ");
628 } break;
629 }
630 m_gridPFBuses->SetCellValue(rowNumber, 1, busTypeString);
631 m_gridPFBuses->SetCellValue(rowNumber, 2, bus->StringFromDouble(std::abs(data.voltage) * kVoltage, 0, m_precision));
632 m_gridPFBuses->SetCellValue(rowNumber, 3, bus->StringFromDouble(wxRadToDeg(std::arg(data.voltage)), 0, m_precision));
633 m_gridPFBuses->SetCellValue(rowNumber, 4, bus->StringFromDouble(std::real(data.power) * kActivePower, 0, m_precision));
634 m_gridPFBuses->SetCellValue(rowNumber, 5, bus->StringFromDouble(std::imag(data.power) * kReactivePower, 0, m_precision));
635 rowNumber++;
636 }
637 m_gridPFBuses->AutoSize();
638 m_gridPFBuses->GetContainingSizer()->Layout();
639 }
640
641 // Power flow branches
642 if (gridToFill == GRID_ALL || gridToFill == GRID_PFBRANCHES) {
643 rowNumber = 1;
644 for (auto it = lineList.begin(), itEnd = lineList.end(); it != itEnd; ++it) {
645 Line* line = *it;
646 auto data = line->GetPUElectricalData(basePower);
647
648 double vb = data.nominalVoltage;
649 if (data.nominalVoltageUnit == ElectricalUnit::UNIT_kV) vb *= 1e3;
650 double zb = (vb * vb) / basePower;
651
652 wxString busName1 = "-";
653 if (line->GetParentList()[0])
654 busName1 = static_cast<Bus*>(line->GetParentList()[0])->GetElectricalData().name;
655 wxString busName2 = "-";
656 if (line->GetParentList()[1])
657 busName2 = static_cast<Bus*>(line->GetParentList()[1])->GetElectricalData().name;
658 wxString isOnline = _("Yes");
659 wxColour textColour = m_gridPFBranches->GetDefaultCellTextColour();
660 if (!line->IsOnline()) {
661 isOnline = _("No");
662 textColour = m_offlineColour;
663 }
664 for (int j = 0; j < 10; ++j) { m_gridPFBranches->SetCellTextColour(rowNumber, j, textColour); }
665
666 m_gridPFBranches->SetCellValue(rowNumber, 0, _("Line"));
667 m_gridPFBranches->SetCellValue(rowNumber, 1, data.name);
668
669 m_gridPFBranches->SetCellValue(rowNumber, 2, busName1);
670 m_gridPFBranches->SetCellValue(rowNumber, 3, busName2);
671
672 double k = 1.0;
673 if (m_gridPFBranches->GetCellValue(0, 4) == m_resistanceChoices[1]) k = zb;
674 m_gridPFBranches->SetCellValue(rowNumber, 4, line->StringFromDouble(data.resistance * k, 0, m_precision));
675 k = 1.0;
676 if (m_gridPFBranches->GetCellValue(0, 5) == m_indReactanceChoices[1]) k = zb;
677 m_gridPFBranches->SetCellValue(rowNumber, 5, line->StringFromDouble(data.indReactance * k, 0, m_precision));
678 k = 1.0;
679 if (m_gridPFBranches->GetCellValue(0, 6) == m_capSusceptanceChoices[1]) k = zb;
680 m_gridPFBranches->SetCellValue(rowNumber, 6, line->StringFromDouble(data.capSusceptance / k, 0, m_precision));
681 m_gridPFBranches->SetCellValue(rowNumber, 7, "-");
682 m_gridPFBranches->SetCellValue(rowNumber, 8, "-");
683 m_gridPFBranches->SetCellValue(rowNumber, 9, isOnline);
684 rowNumber++;
685 }
686 for (auto it = transformerList.begin(), itEnd = transformerList.end(); it != itEnd; ++it) {
687 Transformer* transformer = *it;
688 auto data = transformer->GetPUElectricalData(basePower);
689
690 double vb = 0.0;
691 if (data.baseVoltage == 0) {
692 vb = data.primaryNominalVoltage;
693 if (data.primaryNominalVoltageUnit == ElectricalUnit::UNIT_kV) vb *= 1e3;
694 }
695 else {
696 vb = data.secondaryNominalVoltage;
697 if (data.secondaryNominalVoltageUnit == ElectricalUnit::UNIT_kV) vb *= 1e3;
698 }
699 double zb = (vb * vb) / basePower;
700
701 wxString busName1 = "-";
702 if (transformer->GetParentList()[0])
703 busName1 = static_cast<Bus*>(transformer->GetParentList()[0])->GetElectricalData().name;
704 wxString busName2 = "-";
705 if (transformer->GetParentList()[1])
706 busName2 = static_cast<Bus*>(transformer->GetParentList()[1])->GetElectricalData().name;
707
708 wxString isOnline = _("Yes");
709 wxColour textColour = m_gridPFBranches->GetDefaultCellTextColour();
710 if (!transformer->IsOnline()) {
711 isOnline = _("No");
712 textColour = m_offlineColour;
713 }
714 for (int j = 0; j < 10; ++j) { m_gridPFBranches->SetCellTextColour(rowNumber, j, textColour); }
715
716 m_gridPFBranches->SetCellValue(rowNumber, 0, _("Transformer"));
717 m_gridPFBranches->SetCellValue(rowNumber, 1, data.name);
718 m_gridPFBranches->SetCellValue(rowNumber, 2, busName1);
719 m_gridPFBranches->SetCellValue(rowNumber, 3, busName2);
720
721 double k = 1.0;
722 if (m_gridPFBranches->GetCellValue(0, 4) == m_resistanceChoices[1]) k = zb;
723 m_gridPFBranches->SetCellValue(rowNumber, 4, transformer->StringFromDouble(data.resistance * k, 0, m_precision));
724 k = 1.0;
725 if (m_gridPFBranches->GetCellValue(0, 5) == m_indReactanceChoices[1]) k = zb;
726 m_gridPFBranches->SetCellValue(rowNumber, 5, transformer->StringFromDouble(data.indReactance * k, 0, m_precision));
727 m_gridPFBranches->SetCellValue(rowNumber, 6, "-");
728 m_gridPFBranches->SetCellValue(rowNumber, 7, transformer->StringFromDouble(data.turnsRatio, 0, m_precision));
729 m_gridPFBranches->SetCellValue(rowNumber, 8, transformer->StringFromDouble(data.phaseShift, 0, m_precision));
730 m_gridPFBranches->SetCellValue(rowNumber, 9, isOnline);
731 rowNumber++;
732 }
733 m_gridPFBranches->AutoSize();
734 m_gridPFBranches->GetContainingSizer()->Layout();
735 }
736
737 // Fault
738 if (gridToFill == GRID_ALL || gridToFill == GRID_FAULT) {
739 rowNumber = 2;
740 for (auto it = busList.begin(), itEnd = busList.end(); it != itEnd; ++it) {
741 Bus* bus = *it;
742 auto data = bus->GetElectricalData();
743 if (data.hasFault) {
744 double vb = bus->GetValueFromUnit(data.nominalVoltage, data.nominalVoltageUnit);
745 double ib = basePower / (std::sqrt(3.0) * vb);
746
747 m_gridFault->SetCellValue(rowNumber, 0, data.name);
748
749 double kCurrent = 1.0;
750 if (m_gridFault->GetCellValue(1, 1) == m_currentChoices[1]) {
751 kCurrent = ib;
752 }
753 else if (m_gridFault->GetCellValue(1, 1) == m_currentChoices[2]) {
754 kCurrent = ib / 1e3;
755 }
756 m_gridFault->SetCellValue(rowNumber, 1,
757 bus->StringFromDouble(std::abs(data.faultCurrent[0]) * kCurrent, 0, m_precision));
758
759 m_gridFault->SetCellValue(rowNumber, 2,
760 bus->StringFromDouble(wxRadToDeg(std::arg(data.faultCurrent[0])), 0, m_precision));
761
762 kCurrent = 1.0;
763 if (m_gridFault->GetCellValue(1, 3) == m_currentChoices[1]) {
764 kCurrent = ib;
765 }
766 else if (m_gridFault->GetCellValue(1, 3) == m_currentChoices[2]) {
767 kCurrent = ib / 1e3;
768 }
769 m_gridFault->SetCellValue(rowNumber, 3,
770 bus->StringFromDouble(std::abs(data.faultCurrent[1]) * kCurrent, 0, m_precision));
771
772 m_gridFault->SetCellValue(rowNumber, 4,
773 bus->StringFromDouble(wxRadToDeg(std::arg(data.faultCurrent[1])), 0, m_precision));
774
775 kCurrent = 1.0;
776 if (m_gridFault->GetCellValue(1, 5) == m_currentChoices[1]) {
777 kCurrent = ib;
778 }
779 else if (m_gridFault->GetCellValue(1, 5) == m_currentChoices[2]) {
780 kCurrent = ib / 1e3;
781 }
782 m_gridFault->SetCellValue(rowNumber, 5,
783 bus->StringFromDouble(std::abs(data.faultCurrent[2]) * kCurrent, 0, m_precision));
784
785 m_gridFault->SetCellValue(rowNumber, 6,
786 bus->StringFromDouble(wxRadToDeg(std::arg(data.faultCurrent[2])), 0, m_precision));
787
788 rowNumber++;
789 }
790 }
791 m_gridFault->AutoSize();
792 m_gridFault->GetContainingSizer()->Layout();
793 }
794
795 // Fault buses
796 if (gridToFill == GRID_ALL || gridToFill == GRID_FAULTBUSES) {
797 rowNumber = 2;
798 for (auto it = busList.begin(), itEnd = busList.end(); it != itEnd; ++it) {
799 Bus* bus = *it;
800 auto data = bus->GetElectricalData();
801 double vb = bus->GetValueFromUnit(data.nominalVoltage, data.nominalVoltageUnit);
802
803 m_gridFaultBuses->SetCellValue(rowNumber, 0, data.name);
804 double kVoltage = 1.0;
805 if (m_gridFaultBuses->GetCellValue(1, 1) == m_voltageChoices[1]) {
806 kVoltage = vb;
807 }
808 else if (m_gridFaultBuses->GetCellValue(1, 1) == m_voltageChoices[2]) {
809 kVoltage = vb / 1e3;
810 }
811 m_gridFaultBuses->SetCellValue(rowNumber, 1,
812 bus->StringFromDouble(std::abs(data.faultVoltage[0]) * kVoltage, 0, m_precision));
813 m_gridFaultBuses->SetCellValue(rowNumber, 2,
814 bus->StringFromDouble(wxRadToDeg(std::arg(data.faultVoltage[0])), 0, m_precision));
815
816 kVoltage = 1.0;
817 if (m_gridFaultBuses->GetCellValue(1, 3) == m_voltageChoices[1]) {
818 kVoltage = vb;
819 }
820 else if (m_gridFaultBuses->GetCellValue(1, 3) == m_voltageChoices[2]) {
821 kVoltage = vb / 1e3;
822 }
823 m_gridFaultBuses->SetCellValue(rowNumber, 3,
824 bus->StringFromDouble(std::abs(data.faultVoltage[1]) * kVoltage, 0, m_precision));
825 m_gridFaultBuses->SetCellValue(rowNumber, 4,
826 bus->StringFromDouble(wxRadToDeg(std::arg(data.faultVoltage[1])), 0, m_precision));
827
828 kVoltage = 1.0;
829 if (m_gridFaultBuses->GetCellValue(1, 5) == m_voltageChoices[1]) {
830 kVoltage = vb;
831 }
832 else if (m_gridFaultBuses->GetCellValue(1, 5) == m_voltageChoices[2]) {
833 kVoltage = vb / 1e3;
834 }
835 m_gridFaultBuses->SetCellValue(rowNumber, 5,
836 bus->StringFromDouble(std::abs(data.faultVoltage[2]) * kVoltage, 0, m_precision));
837 m_gridFaultBuses->SetCellValue(rowNumber, 6,
838 bus->StringFromDouble(wxRadToDeg(std::arg(data.faultVoltage[2])), 0, m_precision));
839
840 rowNumber++;
841 }
842 m_gridFaultBuses->AutoSize();
843 m_gridFaultBuses->GetContainingSizer()->Layout();
844 }
845
846 // Fault branches
847 if (gridToFill == GRID_ALL || gridToFill == GRID_FAULTBRANCHES) {
848 rowNumber = 2;
849 for (auto it = lineList.begin(), itEnd = lineList.end(); it != itEnd; ++it) {
850 Line* line = *it;
851 auto data = line->GetPUElectricalData(basePower);
852
853 double vb = line->GetValueFromUnit(data.nominalVoltage, data.nominalVoltageUnit);
854 double ib = basePower / (std::sqrt(3.0) * vb);
855
856 wxString busName1 = "-";
857 if (line->GetParentList()[0])
858 busName1 = static_cast<Bus*>(line->GetParentList()[0])->GetElectricalData().name;
859 wxString busName2 = "-";
860 if (line->GetParentList()[1])
861 busName2 = static_cast<Bus*>(line->GetParentList()[1])->GetElectricalData().name;
862
863 wxString isOnline = _("Yes");
864 wxColour textColour = m_gridFaultBranches->GetDefaultCellTextColour();
865 if (!line->IsOnline()) {
866 isOnline = _("No");
867 textColour = m_offlineColour;
868 }
869 for (int i = 0; i < 2; ++i) {
870 for (int j = 0; j < 11; ++j) { m_gridFaultBranches->SetCellTextColour(rowNumber + i, j, textColour); }
871 }
872
873 m_gridFaultBranches->SetCellValue(rowNumber, 0, _("Line"));
874 m_gridFaultBranches->SetCellValue(rowNumber, 1, data.name);
875 m_gridFaultBranches->SetCellValue(rowNumber, 2, busName1);
876 m_gridFaultBranches->SetCellValue(rowNumber, 3, busName2);
877
878 double kCurrent = 1.0;
879 if (m_gridFaultBranches->GetCellValue(1, 4) == m_currentChoices[1]) {
880 kCurrent = ib;
881 }
882 else if (m_gridFaultBranches->GetCellValue(1, 4) == m_currentChoices[2]) {
883 kCurrent = ib / 1e3;
884 }
885 m_gridFaultBranches->SetCellValue(rowNumber, 4,
886 line->StringFromDouble(std::abs(data.faultCurrent[0][0]) * kCurrent, 0, m_precision));
887 m_gridFaultBranches->SetCellValue(rowNumber, 5,
888 line->StringFromDouble(wxRadToDeg(std::arg(data.faultCurrent[0][0])), 0, m_precision));
889 kCurrent = 1.0;
890 if (m_gridFaultBranches->GetCellValue(1, 6) == m_currentChoices[1]) {
891 kCurrent = ib;
892 }
893 else if (m_gridFaultBranches->GetCellValue(1, 6) == m_currentChoices[2]) {
894 kCurrent = ib / 1e3;
895 }
896 m_gridFaultBranches->SetCellValue(rowNumber, 6,
897 line->StringFromDouble(std::abs(data.faultCurrent[0][1]) * kCurrent, 0, m_precision));
898 m_gridFaultBranches->SetCellValue(rowNumber, 7,
899 line->StringFromDouble(wxRadToDeg(std::arg(data.faultCurrent[0][1])), 0, m_precision));
900 kCurrent = 1.0;
901 if (m_gridFaultBranches->GetCellValue(1, 8) == m_currentChoices[1]) {
902 kCurrent = ib;
903 }
904 else if (m_gridFaultBranches->GetCellValue(1, 8) == m_currentChoices[2]) {
905 kCurrent = ib / 1e3;
906 }
907 m_gridFaultBranches->SetCellValue(rowNumber, 8,
908 line->StringFromDouble(std::abs(data.faultCurrent[0][2]) * kCurrent, 0, m_precision));
909 m_gridFaultBranches->SetCellValue(rowNumber, 9,
910 line->StringFromDouble(wxRadToDeg(std::arg(data.faultCurrent[0][2])), 0, m_precision));
911 m_gridFaultBranches->SetCellValue(rowNumber, 10, isOnline);
912 rowNumber++;
913
914 m_gridFaultBranches->SetCellValue(rowNumber, 0, _("Line"));
915 m_gridFaultBranches->SetCellValue(rowNumber, 1, data.name);
916 m_gridFaultBranches->SetCellValue(rowNumber, 2, busName2);
917 m_gridFaultBranches->SetCellValue(rowNumber, 3, busName1);
918 kCurrent = 1.0;
919 if (m_gridFaultBranches->GetCellValue(1, 4) == m_currentChoices[1]) {
920 kCurrent = ib;
921 }
922 else if (m_gridFaultBranches->GetCellValue(1, 4) == m_currentChoices[2]) {
923 kCurrent = ib / 1e3;
924 }
925 m_gridFaultBranches->SetCellValue(rowNumber, 4,
926 line->StringFromDouble(std::abs(data.faultCurrent[1][0]) * kCurrent, 0, m_precision));
927 m_gridFaultBranches->SetCellValue(rowNumber, 5,
928 line->StringFromDouble(wxRadToDeg(std::arg(data.faultCurrent[1][0])), 0, m_precision));
929 kCurrent = 1.0;
930 if (m_gridFaultBranches->GetCellValue(1, 6) == m_currentChoices[1]) {
931 kCurrent = ib;
932 }
933 else if (m_gridFaultBranches->GetCellValue(1, 6) == m_currentChoices[2]) {
934 kCurrent = ib / 1e3;
935 }
936 m_gridFaultBranches->SetCellValue(rowNumber, 6,
937 line->StringFromDouble(std::abs(data.faultCurrent[1][1]) * kCurrent, 0, m_precision));
938 m_gridFaultBranches->SetCellValue(rowNumber, 7,
939 line->StringFromDouble(wxRadToDeg(std::arg(data.faultCurrent[1][1])), 0, m_precision));
940 kCurrent = 1.0;
941 if (m_gridFaultBranches->GetCellValue(1, 8) == m_currentChoices[1]) {
942 kCurrent = ib;
943 }
944 else if (m_gridFaultBranches->GetCellValue(1, 8) == m_currentChoices[2]) {
945 kCurrent = ib / 1e3;
946 }
947 m_gridFaultBranches->SetCellValue(rowNumber, 8,
948 line->StringFromDouble(std::abs(data.faultCurrent[1][2]) * kCurrent, 0, m_precision));
949 m_gridFaultBranches->SetCellValue(rowNumber, 9,
950 line->StringFromDouble(wxRadToDeg(std::arg(data.faultCurrent[1][2])), 0, m_precision));
951 m_gridFaultBranches->SetCellValue(rowNumber, 10, isOnline);
952 rowNumber++;
953 }
954
955 for (auto it = transformerList.begin(), itEnd = transformerList.end(); it != itEnd; ++it) {
956 Transformer* transformer = *it;
957 auto data = transformer->GetPUElectricalData(basePower);
958
959 double vb = transformer->GetValueFromUnit(data.primaryNominalVoltage, data.primaryNominalVoltageUnit);
960 double ibp = basePower / (std::sqrt(3.0) * vb);
961 vb = transformer->GetValueFromUnit(data.secondaryNominalVoltage, data.secondaryNominalVoltageUnit);
962 double ibs = basePower / (std::sqrt(3.0) * vb);
963
964 wxString busName1 = "-";
965 if (transformer->GetParentList()[0])
966 busName1 = static_cast<Bus*>(transformer->GetParentList()[0])->GetElectricalData().name;
967 wxString busName2 = "-";
968 if (transformer->GetParentList()[1])
969 busName2 = static_cast<Bus*>(transformer->GetParentList()[1])->GetElectricalData().name;
970
971 wxString isOnline = _("Yes");
972 wxColour textColour = m_gridFaultBranches->GetDefaultCellTextColour();
973 if (!transformer->IsOnline()) {
974 isOnline = _("No");
975 textColour = m_offlineColour;
976 }
977 for (int i = 0; i < 2; ++i) {
978 for (int j = 0; j < 11; ++j) { m_gridFaultBranches->SetCellTextColour(rowNumber + i, j, textColour); }
979 }
980
981 m_gridFaultBranches->SetCellValue(rowNumber, 0, _("Transformer"));
982 m_gridFaultBranches->SetCellValue(rowNumber, 1, data.name);
983 m_gridFaultBranches->SetCellValue(rowNumber, 2, busName1);
984 m_gridFaultBranches->SetCellValue(rowNumber, 3, busName2);
985
986 double kCurrent = 1.0;
987 if (m_gridFaultBranches->GetCellValue(1, 4) == m_currentChoices[1]) {
988 kCurrent = ibp;
989 }
990 else if (m_gridFaultBranches->GetCellValue(1, 4) == m_currentChoices[2]) {
991 kCurrent = ibp / 1e3;
992 }
993 m_gridFaultBranches->SetCellValue(
994 rowNumber, 4, transformer->StringFromDouble(std::abs(data.faultCurrent[0][0]) * kCurrent, 0, m_precision));
995 m_gridFaultBranches->SetCellValue(
996 rowNumber, 5, transformer->StringFromDouble(wxRadToDeg(std::arg(data.faultCurrent[0][0])), 0, m_precision));
997 kCurrent = 1.0;
998 if (m_gridFaultBranches->GetCellValue(1, 6) == m_currentChoices[1]) {
999 kCurrent = ibp;
1000 }
1001 else if (m_gridFaultBranches->GetCellValue(1, 6) == m_currentChoices[2]) {
1002 kCurrent = ibp / 1e3;
1003 }
1004 m_gridFaultBranches->SetCellValue(
1005 rowNumber, 6, transformer->StringFromDouble(std::abs(data.faultCurrent[0][1]) * kCurrent, 0, m_precision));
1006 m_gridFaultBranches->SetCellValue(
1007 rowNumber, 7, transformer->StringFromDouble(wxRadToDeg(std::arg(data.faultCurrent[0][1])), 0, m_precision));
1008 kCurrent = 1.0;
1009 if (m_gridFaultBranches->GetCellValue(1, 8) == m_currentChoices[1]) {
1010 kCurrent = ibp;
1011 }
1012 else if (m_gridFaultBranches->GetCellValue(1, 8) == m_currentChoices[2]) {
1013 kCurrent = ibp / 1e3;
1014 }
1015 m_gridFaultBranches->SetCellValue(
1016 rowNumber, 8, transformer->StringFromDouble(std::abs(data.faultCurrent[0][2]) * kCurrent, 0, m_precision));
1017 m_gridFaultBranches->SetCellValue(
1018 rowNumber, 9, transformer->StringFromDouble(wxRadToDeg(std::arg(data.faultCurrent[0][2])), 0, m_precision));
1019 m_gridFaultBranches->SetCellValue(rowNumber, 10, isOnline);
1020 rowNumber++;
1021
1022 m_gridFaultBranches->SetCellValue(rowNumber, 0, _("Transformer"));
1023 m_gridFaultBranches->SetCellValue(rowNumber, 1, data.name);
1024 m_gridFaultBranches->SetCellValue(rowNumber, 2, busName2);
1025 m_gridFaultBranches->SetCellValue(rowNumber, 3, busName1);
1026 kCurrent = 1.0;
1027 if (m_gridFaultBranches->GetCellValue(1, 4) == m_currentChoices[1]) {
1028 kCurrent = ibs;
1029 }
1030 else if (m_gridFaultBranches->GetCellValue(1, 4) == m_currentChoices[2]) {
1031 kCurrent = ibs / 1e3;
1032 }
1033 m_gridFaultBranches->SetCellValue(
1034 rowNumber, 4, transformer->StringFromDouble(std::abs(data.faultCurrent[1][0]) * kCurrent, 0, m_precision));
1035 m_gridFaultBranches->SetCellValue(
1036 rowNumber, 5, transformer->StringFromDouble(wxRadToDeg(std::arg(data.faultCurrent[1][0])), 0, m_precision));
1037 kCurrent = 1.0;
1038 if (m_gridFaultBranches->GetCellValue(1, 6) == m_currentChoices[1]) {
1039 kCurrent = ibs;
1040 }
1041 else if (m_gridFaultBranches->GetCellValue(1, 6) == m_currentChoices[2]) {
1042 kCurrent = ibs / 1e3;
1043 }
1044 m_gridFaultBranches->SetCellValue(
1045 rowNumber, 6, transformer->StringFromDouble(std::abs(data.faultCurrent[1][1]) * kCurrent, 0, m_precision));
1046 m_gridFaultBranches->SetCellValue(
1047 rowNumber, 7, transformer->StringFromDouble(wxRadToDeg(std::arg(data.faultCurrent[1][1])), 0, m_precision));
1048 kCurrent = 1.0;
1049 if (m_gridFaultBranches->GetCellValue(1, 8) == m_currentChoices[1]) {
1050 kCurrent = ibs;
1051 }
1052 else if (m_gridFaultBranches->GetCellValue(1, 8) == m_currentChoices[2]) {
1053 kCurrent = ibs / 1e3;
1054 }
1055 m_gridFaultBranches->SetCellValue(
1056 rowNumber, 8, transformer->StringFromDouble(std::abs(data.faultCurrent[1][2]) * kCurrent, 0, m_precision));
1057 m_gridFaultBranches->SetCellValue(
1058 rowNumber, 9, transformer->StringFromDouble(wxRadToDeg(std::arg(data.faultCurrent[1][2])), 0, m_precision));
1059 m_gridFaultBranches->SetCellValue(rowNumber, 10, isOnline);
1060 rowNumber++;
1061 }
1062
1063 m_gridFaultBranches->AutoSize();
1064 m_gridFaultBranches->GetContainingSizer()->Layout();
1065 }
1066
1067 // Fault generators
1068 if (gridToFill == GRID_ALL || gridToFill == GRID_FAULTGENERATORS) {
1069 rowNumber = 2;
1070 for (auto it = generatorList.begin(), itEnd = generatorList.end(); it != itEnd; ++it) {
1071 SyncGenerator* generator = *it;
1072 auto data = generator->GetPUElectricalData(basePower);
1073 double vb = generator->GetValueFromUnit(data.nominalVoltage, data.nominalVoltageUnit);
1074 double ib = basePower / (std::sqrt(3.0) * vb);
1075
1076 m_gridFaultGenerators->SetCellValue(rowNumber, 0, data.name);
1077
1078 double kCurrent = 1.0;
1079 if (m_gridFaultGenerators->GetCellValue(1, 1) == m_currentChoices[1])
1080 kCurrent = ib;
1081 else if (m_gridFaultGenerators->GetCellValue(1, 1) == m_currentChoices[2])
1082 kCurrent = ib / 1e3;
1083 m_gridFaultGenerators->SetCellValue(rowNumber, 1,
1084 generator->StringFromDouble(std::abs(data.faultCurrent[0]) * kCurrent, 0, m_precision));
1085 m_gridFaultGenerators->SetCellValue(
1086 rowNumber, 2, generator->StringFromDouble(wxRadToDeg(std::arg(data.faultCurrent[0])), 0, m_precision));
1087
1088 kCurrent = 1.0;
1089 if (m_gridFaultGenerators->GetCellValue(1, 3) == m_currentChoices[1])
1090 kCurrent = ib;
1091 else if (m_gridFaultGenerators->GetCellValue(1, 3) == m_currentChoices[2])
1092 kCurrent = ib / 1e3;
1093 m_gridFaultGenerators->SetCellValue(rowNumber, 3,
1094 generator->StringFromDouble(std::abs(data.faultCurrent[1]) * kCurrent, 0, m_precision));
1095 m_gridFaultGenerators->SetCellValue(
1096 rowNumber, 4, generator->StringFromDouble(wxRadToDeg(std::arg(data.faultCurrent[1])), 0, m_precision));
1097
1098 kCurrent = 1.0;
1099 if (m_gridFaultGenerators->GetCellValue(1, 5) == m_currentChoices[1])
1100 kCurrent = ib;
1101 else if (m_gridFaultGenerators->GetCellValue(1, 5) == m_currentChoices[2])
1102 kCurrent = ib / 1e3;
1103 m_gridFaultGenerators->SetCellValue(rowNumber, 5,
1104 generator->StringFromDouble(std::abs(data.faultCurrent[2]) * kCurrent, 0, m_precision));
1105 m_gridFaultGenerators->SetCellValue(
1106 rowNumber, 6, generator->StringFromDouble(wxRadToDeg(std::arg(data.faultCurrent[2])), 0, m_precision));
1107
1108 rowNumber++;
1109 }
1110 m_gridFaultGenerators->AutoSize();
1111 m_gridFaultGenerators->GetContainingSizer()->Layout();
1112 }
1113
1114 // Harmonic Currents
1115 if (gridToFill == GRID_ALL || gridToFill == GRID_HARMCURRENT) {
1116 rowNumber = 1;
1117 for (auto* hCurrent : harmCurrentList) {
1118 if (hCurrent->GetParentList()[0]) {
1119 auto busData = static_cast<Bus*>(hCurrent->GetParentList()[0])->GetElectricalData();
1120 double vb = hCurrent->GetValueFromUnit(busData.nominalVoltage, busData.nominalVoltageUnit);
1121 double ib = basePower / (std::sqrt(3.0) * vb);
1122
1123 auto data = hCurrent->GetPUElectricalData(basePower, vb);
1124 m_gridHarmCurrents->SetCellSize(rowNumber, 0, data.harmonicOrder.size(), 1);
1125 m_gridHarmCurrents->SetCellValue(rowNumber, 0, data.name);
1126 m_gridHarmCurrents->SetCellSize(rowNumber, 1, data.harmonicOrder.size(), 1);
1127 m_gridHarmCurrents->SetCellValue(rowNumber, 1, busData.name);
1128 int i = 0;
1129 for (auto& order : data.harmonicOrder) {
1130 m_gridHarmCurrents->SetCellValue(rowNumber, 2, wxString::Format(wxT("%d%s"), order, wxString(L'\u00BA')));
1131 double kCurrent = 1.0;
1132 if (m_gridHarmCurrents->GetCellValue(0, 3) == m_currentChoices[1]) {
1133 kCurrent = ib;
1134 }
1135 else if (m_gridHarmCurrents->GetCellValue(0, 3) == m_currentChoices[2]) {
1136 kCurrent = ib / 1e3;
1137 }
1138 m_gridHarmCurrents->SetCellValue(rowNumber, 3, hCurrent->StringFromDouble(data.injHarmCurrent[i] * kCurrent, 0, m_precision));
1139 m_gridHarmCurrents->SetCellValue(rowNumber, 4, hCurrent->StringFromDouble(data.injHarmAngle[i], 0, m_precision) + wxString(L'\u00B0'));
1140 i++;
1141 rowNumber++;
1142 }
1143 }
1144 else {
1145 auto data = hCurrent->GetElectricalData();
1146 m_gridHarmCurrents->SetCellSize(rowNumber, 0, data.harmonicOrder.size(), 1);
1147 m_gridHarmCurrents->SetCellValue(rowNumber, 0, data.name);
1148 m_gridHarmCurrents->SetCellSize(rowNumber, 1, data.harmonicOrder.size(), 1);
1149 m_gridHarmCurrents->SetCellValue(rowNumber, 1, "-");
1150 int i = 0;
1151 for (auto& order : data.harmonicOrder) {
1152 m_gridHarmCurrents->SetCellValue(rowNumber, 2, wxString::Format(wxT("%d%s"), order, wxString(L'\u00BA')));
1153 m_gridHarmCurrents->SetCellValue(rowNumber, 3, "?");
1154 m_gridHarmCurrents->SetCellValue(rowNumber, 4, hCurrent->StringFromDouble(data.injHarmAngle[i], 0, m_precision) + wxString(L'\u00B0'));
1155 i++;
1156 rowNumber++;
1157 }
1158
1159 }
1160 }
1161 m_gridHarmCurrents->AutoSize();
1162 m_gridHarmCurrents->GetContainingSizer()->Layout();
1163 }
1164
1165 // Harmonic Buses/Voltages
1166 if (gridToFill == GRID_ALL || gridToFill == GRID_HARMBUSES) {
1167 rowNumber = 1;
1168 for (auto* bus : busList) {
1169 auto data = bus->GetElectricalData();
1170 double vb = bus->GetValueFromUnit(data.nominalVoltage, data.nominalVoltageUnit);
1171
1172 const int harmonicCount = static_cast<int>(data.harmonicOrder.size());
1173 if (harmonicCount == 0)
1174 continue;
1175
1176 m_gridHarmBuses->SetCellSize(rowNumber, 0, harmonicCount, 1);
1177 m_gridHarmBuses->SetCellValue(rowNumber, 0, data.name);
1178 m_gridHarmBuses->SetCellSize(rowNumber, 1, harmonicCount, 1);
1179 m_gridHarmBuses->SetCellValue(rowNumber, 1, bus->StringFromDouble(data.thd, 0, m_precision) + wxT("%"));
1180 int i = 0;
1181 for (auto& order : data.harmonicOrder) {
1182 m_gridHarmBuses->SetCellValue(rowNumber, 2, wxString::Format(wxT("%d%s"), order, wxString(L'\u00BA')));
1183 wxString voltageStr = "";
1184 if (m_gridHarmBuses->GetCellValue(0, 3) == m_phaseVoltageChoices[0]) {
1185 voltageStr.Printf(wxString::Format("%%.%de", m_precision), std::abs(data.harmonicVoltage[i]));
1186 }
1187 else if (m_gridHarmBuses->GetCellValue(0, 3) == m_phaseVoltageChoices[1]) {
1188 voltageStr = bus->StringFromDouble(std::abs(data.harmonicVoltage[i]) * vb / sqrt(3.0), 0, m_precision);
1189 }
1190 else if (m_gridHarmBuses->GetCellValue(0, 3) == m_phaseVoltageChoices[2]) {
1191 voltageStr = bus->StringFromDouble(std::abs(data.harmonicVoltage[i]) * vb / (sqrt(3.0) * 1e3), 0, m_precision);
1192 }
1193 m_gridHarmBuses->SetCellValue(rowNumber, 3, voltageStr);
1194 m_gridHarmBuses->SetCellValue(rowNumber, 4, bus->StringFromDouble(wxRadToDeg(std::arg(data.harmonicVoltage[i])), 0, m_precision) + wxString(L'\u00B0'));
1195
1196 i++;
1197 rowNumber++;
1198 }
1199 }
1200 m_gridHarmBuses->AutoSize();
1201 m_gridHarmBuses->GetContainingSizer()->Layout();
1202 }
1203
1204 // Harmonic current branches
1205 if (gridToFill == GRID_ALL || gridToFill == GRID_HARMBRANCHES) {
1206 rowNumber = 1;
1207 for (auto* line : lineList) {
1208 auto data = line->GetPUElectricalData(basePower);
1209
1210 double vb = line->GetValueFromUnit(data.nominalVoltage, data.nominalVoltageUnit);
1211 double ib = basePower / (std::sqrt(3.0) * vb);
1212
1213 wxString busName1 = "-";
1214 if (line->GetParentList()[0])
1215 busName1 = static_cast<Bus*>(line->GetParentList()[0])->GetElectricalData().name;
1216 wxString busName2 = "-";
1217 if (line->GetParentList()[1])
1218 busName2 = static_cast<Bus*>(line->GetParentList()[1])->GetElectricalData().name;
1219
1220 wxString isOnline = _("Yes");
1221 wxColour textColour = m_gridHarmBranches->GetDefaultCellTextColour();
1222 if (!line->IsOnline()) {
1223 isOnline = _("No");
1224 textColour = m_offlineColour;
1225 }
1226
1227 const int harmonicCount = static_cast<int>(data.harmonicOrder.size());
1228 if (harmonicCount == 0)
1229 continue;
1230
1231 for (int side = 0; side < 2; ++side) {
1232 for (unsigned int i = 0; i < harmonicCount; ++i) {
1233 for (int j = 0; j < 8; ++j) { m_gridHarmBranches->SetCellTextColour(rowNumber + i, j, textColour); }
1234 }
1235
1236 m_gridHarmBranches->SetCellSize(rowNumber, 0, harmonicCount, 1);
1237 m_gridHarmBranches->SetCellValue(rowNumber, 0, _("Line"));
1238 m_gridHarmBranches->SetCellSize(rowNumber, 1, harmonicCount, 1);
1239 m_gridHarmBranches->SetCellValue(rowNumber, 1, data.name);
1240 m_gridHarmBranches->SetCellSize(rowNumber, 2, harmonicCount, 1);
1241 m_gridHarmBranches->SetCellValue(rowNumber, 2, side == 0 ? busName1 : busName2);
1242 m_gridHarmBranches->SetCellSize(rowNumber, 3, harmonicCount, 1);
1243 m_gridHarmBranches->SetCellValue(rowNumber, 3, side == 0 ? busName2 : busName1);
1244 m_gridHarmBranches->SetCellSize(rowNumber, 7, harmonicCount, 1);
1245 m_gridHarmBranches->SetCellValue(rowNumber, 7, isOnline);
1246
1247 int i = 0;
1248 for (auto& order : data.harmonicOrder) {
1249 m_gridHarmBranches->SetCellValue(rowNumber, 4, wxString::Format(wxT("%d%s"), order, wxString(L'\u00BA')));
1250 wxString currentStr = "";
1251 wxString angleStr = "";
1252 if (line->IsOnline()) {
1253 if (m_gridHarmBranches->GetCellValue(0, 5) == m_currentChoices[0]) {
1254 currentStr.Printf(wxString::Format("%%.%de", m_precision), std::abs(data.harmonicCurrent[side][i]));
1255 }
1256 else if (m_gridHarmBranches->GetCellValue(0, 5) == m_currentChoices[1]) {
1257 currentStr = line->StringFromDouble(std::abs(data.harmonicCurrent[side][i]) * ib, 0, m_precision);
1258 }
1259 else if (m_gridHarmBranches->GetCellValue(0, 5) == m_currentChoices[2]) {
1260 currentStr = line->StringFromDouble(std::abs(data.harmonicCurrent[side][i]) * ib / 1e3, 0, m_precision);
1261 }
1262 angleStr = line->StringFromDouble(wxRadToDeg(std::arg(data.harmonicCurrent[side][i])), 0, m_precision) + wxString(L'\u00B0');
1263 }
1264 else {
1265 currentStr = line->StringFromDouble(0.0, 0, m_precision);
1266 angleStr = line->StringFromDouble(0.0, 0, m_precision);
1267 }
1268
1269 m_gridHarmBranches->SetCellValue(rowNumber, 5, currentStr);
1270 m_gridHarmBranches->SetCellValue(rowNumber, 6, angleStr);
1271
1272 i++;
1273 rowNumber++;
1274 }
1275 }
1276 }
1277
1278 for (auto* transformer : transformerList) {
1279 auto data = transformer->GetPUElectricalData(basePower);
1280
1281 double vb = transformer->GetValueFromUnit(data.primaryNominalVoltage, data.primaryNominalVoltageUnit);
1282 double ibp = basePower / (std::sqrt(3.0) * vb);
1283 vb = transformer->GetValueFromUnit(data.secondaryNominalVoltage, data.secondaryNominalVoltageUnit);
1284 double ibs = basePower / (std::sqrt(3.0) * vb);
1285
1286 wxString busName1 = "-";
1287 if (transformer->GetParentList()[0])
1288 busName1 = static_cast<Bus*>(transformer->GetParentList()[0])->GetElectricalData().name;
1289 wxString busName2 = "-";
1290 if (transformer->GetParentList()[1])
1291 busName2 = static_cast<Bus*>(transformer->GetParentList()[1])->GetElectricalData().name;
1292
1293 wxString isOnline = _("Yes");
1294 wxColour textColour = m_gridHarmBranches->GetDefaultCellTextColour();
1295 if (!transformer->IsOnline()) {
1296 isOnline = _("No");
1297 textColour = m_offlineColour;
1298 }
1299
1300 const int harmonicCount = static_cast<int>(data.harmonicOrder.size());
1301 if (harmonicCount == 0)
1302 continue;
1303
1304 for (int side = 0; side < 2; ++side) {
1305 for (unsigned int i = 0; i < harmonicCount; ++i) {
1306 for (int j = 0; j < 8; ++j) { m_gridHarmBranches->SetCellTextColour(rowNumber + i, j, textColour); }
1307 }
1308 double ib = side == 0 ? ibp : ibs;
1309
1310 m_gridHarmBranches->SetCellSize(rowNumber, 0, harmonicCount, 1);
1311 m_gridHarmBranches->SetCellValue(rowNumber, 0, _("Transformer"));
1312 m_gridHarmBranches->SetCellSize(rowNumber, 1, harmonicCount, 1);
1313 m_gridHarmBranches->SetCellValue(rowNumber, 1, data.name);
1314 m_gridHarmBranches->SetCellSize(rowNumber, 2, harmonicCount, 1);
1315 m_gridHarmBranches->SetCellValue(rowNumber, 2, side == 0 ? busName1 : busName2);
1316 m_gridHarmBranches->SetCellSize(rowNumber, 3, harmonicCount, 1);
1317 m_gridHarmBranches->SetCellValue(rowNumber, 3, side == 0 ? busName2 : busName1);
1318 m_gridHarmBranches->SetCellSize(rowNumber, 7, harmonicCount, 1);
1319 m_gridHarmBranches->SetCellValue(rowNumber, 7, isOnline);
1320
1321 int i = 0;
1322 for (auto& order : data.harmonicOrder) {
1323 m_gridHarmBranches->SetCellValue(rowNumber, 4, wxString::Format(wxT("%d%s"), order, wxString(L'\u00BA')));
1324 wxString currentStr = "";
1325 wxString angleStr = "";
1326 if (transformer->IsOnline()) {
1327 if (m_gridHarmBranches->GetCellValue(0, 5) == m_currentChoices[0]) {
1328 currentStr.Printf(wxString::Format("%%.%de", m_precision), std::abs(data.harmonicCurrent[side][i]));
1329 }
1330 else if (m_gridHarmBranches->GetCellValue(0, 5) == m_currentChoices[1]) {
1331 currentStr = transformer->StringFromDouble(std::abs(data.harmonicCurrent[side][i]) * ib, 0, m_precision);
1332 }
1333 else if (m_gridHarmBranches->GetCellValue(0, 5) == m_currentChoices[2]) {
1334 currentStr = transformer->StringFromDouble(std::abs(data.harmonicCurrent[side][i]) * ib / 1e3, 0, m_precision);
1335 }
1336 angleStr = transformer->StringFromDouble(wxRadToDeg(std::arg(data.harmonicCurrent[side][i])), 0, m_precision) + wxString(L'\u00B0');
1337 }
1338 else {
1339 currentStr = transformer->StringFromDouble(0.0, 0, m_precision);
1340 angleStr = transformer->StringFromDouble(0.0, 0, m_precision);
1341 }
1342
1343 m_gridHarmBranches->SetCellValue(rowNumber, 5, currentStr);
1344 m_gridHarmBranches->SetCellValue(rowNumber, 6, angleStr);
1345
1346 i++;
1347 rowNumber++;
1348 }
1349 }
1350 }
1351
1352 m_gridHarmBranches->AutoSize();
1353 m_gridHarmBranches->GetContainingSizer()->Layout();
1354 }
1355
1356 m_changingValues = false;
1357}
BUS_SLACK
@ BUS_SLACK
Definition ElectricCalculation.h:45
Element::GetParentList
virtual std::vector< Element * > GetParentList() const
Get the parent list.
Definition Element.h:562
Element::IsOnline
bool IsOnline() const
Checks if the element is online or offline.
Definition Element.h:228
Element::StringFromDouble
static wxString StringFromDouble(double value, int minDecimal=1, int maxDecimals=13)
Convert a double value to string.
Definition Element.cpp:466
Line
Power line element.
Definition Line.h:64
SyncGenerator
Synchronous generator power element.
Definition SyncGenerator.h:146
Transformer
Two-winding transformer power element.
Definition Transformer.h:84

◆ GridKeyHandler()

void DataReport::GridKeyHandler ( wxGrid *  grid,
wxKeyEvent &  event 
)
virtual

Definition at line 1423 of file DataReport.cpp.

1424{
1425 if (event.GetKeyCode() == 'C' && event.GetModifiers() == wxMOD_CONTROL) { // Copy selection
1426 // [Ref.] https://forums.wxwidgets.org/viewtopic.php?t=2200
1427 wxString copyData = "";
1428 bool lineNotEmpty;
1429
1430 for (int i = 0; i < grid->GetNumberRows(); i++) {
1431 lineNotEmpty = false;
1432 for (int j = 0; j < grid->GetNumberCols(); j++) {
1433 if (grid->IsInSelection(i, j)) {
1434 if (lineNotEmpty == false) {
1435 if (copyData.IsEmpty() == false) {
1436 copyData.Append(wxT("\r\n")); // In Windows if copy to notepad need \r\n to new line.
1437 }
1438 lineNotEmpty = true;
1439 }
1440 else {
1441 copyData.Append(wxT("\t"));
1442 }
1443 copyData = copyData + grid->GetCellValue(i, j);
1444 }
1445 }
1446 }
1447
1448 if (wxTheClipboard->Open())
1449 {
1450 wxTheClipboard->SetData(new wxTextDataObject(copyData));
1451 wxTheClipboard->Close();
1452 }
1453 }
1454 else if (event.GetKeyCode() == 'A' && event.GetModifiers() == wxMOD_CONTROL) { // Select all
1455 grid->SelectAll();
1456 }
1457 event.Skip();
1458}

◆ OnFaulrGridChanged()

void DataReport::OnFaulrGridChanged ( wxGridEvent &  event)
protectedvirtual

Definition at line 1398 of file DataReport.cpp.

1399{
1400 if (!m_changingValues) FillValues(GRID_FAULT);
1401}

◆ OnFaultBranchesGridChanged()

void DataReport::OnFaultBranchesGridChanged ( wxGridEvent &  event)
protectedvirtual

Definition at line 1402 of file DataReport.cpp.

1403{
1404 if (!m_changingValues) FillValues(GRID_FAULTBRANCHES);
1405}

◆ OnFaultBusesGridChanged()

void DataReport::OnFaultBusesGridChanged ( wxGridEvent &  event)
protectedvirtual

Definition at line 1406 of file DataReport.cpp.

1407{
1408 if (!m_changingValues) FillValues(GRID_FAULTBUSES);
1409}

◆ OnFaultGeneratorsGridChanged()

void DataReport::OnFaultGeneratorsGridChanged ( wxGridEvent &  event)
protectedvirtual

Definition at line 1410 of file DataReport.cpp.

1411{
1412 if (!m_changingValues) FillValues(GRID_FAULTGENERATORS);
1413}

◆ OnFaultNotebookChanged()

void DataReport::OnFaultNotebookChanged ( wxNotebookEvent &  event)
protectedvirtual

Definition at line 1692 of file DataReport.cpp.

1693{
1694 UpdateCurrentGrid();
1695}

◆ OnFontSizeSelected()

void DataReport::OnFontSizeSelected ( wxCommandEvent &  event)
protectedvirtual

Definition at line 1707 of file DataReport.cpp.

1708{
1709 m_fontSize = wxAtoi(m_choiceFontSize->GetStringSelection());
1710 UpdateFontSize();
1711}

◆ OnGridFaultBranchesKeyDown()

virtual void DataReport::OnGridFaultBranchesKeyDown ( wxKeyEvent &  event)
inlineprotectedvirtual

Definition at line 81 of file DataReport.h.

81{ GridKeyHandler(m_gridFaultBranches, event); }

◆ OnGridFaultBusesKeyDown()

virtual void DataReport::OnGridFaultBusesKeyDown ( wxKeyEvent &  event)
inlineprotectedvirtual

Definition at line 82 of file DataReport.h.

82{ GridKeyHandler(m_gridFaultBuses, event); }

◆ OnGridFaultGeneratorsKeyDown()

virtual void DataReport::OnGridFaultGeneratorsKeyDown ( wxKeyEvent &  event)
inlineprotectedvirtual

Definition at line 83 of file DataReport.h.

83{ GridKeyHandler(m_gridFaultGenerators, event); }

◆ OnGridFaultKeyDown()

virtual void DataReport::OnGridFaultKeyDown ( wxKeyEvent &  event)
inlineprotectedvirtual

Definition at line 84 of file DataReport.h.

84{ GridKeyHandler(m_gridFault, event); }

◆ OnGridPFBranchesKeyDown()

virtual void DataReport::OnGridPFBranchesKeyDown ( wxKeyEvent &  event)
inlineprotectedvirtual

Definition at line 85 of file DataReport.h.

85{ GridKeyHandler(m_gridPFBranches, event); }

◆ OnGridPFBusesKeyDown()

virtual void DataReport::OnGridPFBusesKeyDown ( wxKeyEvent &  event)
inlineprotectedvirtual

Definition at line 86 of file DataReport.h.

86{ GridKeyHandler(m_gridPFBuses, event); }

◆ OnGridPFKeyDown()

virtual void DataReport::OnGridPFKeyDown ( wxKeyEvent &  event)
inlineprotectedvirtual

Definition at line 87 of file DataReport.h.

87{ GridKeyHandler(m_gridPowerFlow, event); }

◆ OnHarmBranchesGridChanged()

void DataReport::OnHarmBranchesGridChanged ( wxGridEvent &  event)
protectedvirtual

Definition at line 1552 of file DataReport.cpp.

1553{
1554 if (!m_changingValues) FillValues(GRID_HARMBRANCHES);
1555}

◆ OnHarmBusesGridChanged()

void DataReport::OnHarmBusesGridChanged ( wxGridEvent &  event)
protectedvirtual

Definition at line 1548 of file DataReport.cpp.

1549{
1550 if (!m_changingValues) FillValues(GRID_HARMBUSES);
1551}

◆ OnHarmCurrentGridChanged()

void DataReport::OnHarmCurrentGridChanged ( wxGridEvent &  event)
protectedvirtual

Definition at line 1544 of file DataReport.cpp.

1545{
1546 if (!m_changingValues) FillValues(GRID_HARMCURRENT);
1547}

◆ OnHarmNotebookChanged()

void DataReport::OnHarmNotebookChanged ( wxNotebookEvent &  event)
protectedvirtual

Definition at line 1697 of file DataReport.cpp.

1698{
1699 UpdateCurrentGrid();
1700}

◆ OnMainNotebookChanged()

void DataReport::OnMainNotebookChanged ( wxNotebookEvent &  event)
protectedvirtual

Definition at line 1702 of file DataReport.cpp.

1703{
1704 UpdateCurrentGrid();
1705}

◆ OnMouseWheel()

void DataReport::OnMouseWheel ( wxMouseEvent &  event)
protectedvirtual

Definition at line 1724 of file DataReport.cpp.

1725{
1726 if (event.ControlDown()) {
1727 if (event.GetWheelRotation() > 0) {
1728 size_t newSelection = m_choiceFontSize->GetSelection() + 1;
1729 if (newSelection < m_choiceFontSize->GetCount()) {
1730 m_choiceFontSize->SetSelection(newSelection);
1731 m_fontSize = wxAtoi(m_choiceFontSize->GetStringSelection());
1732 UpdateFontSize();
1733 }
1734 }
1735 else {
1736 size_t newSelection = m_choiceFontSize->GetSelection() - 1;
1737 if (newSelection >= 0) {
1738 m_choiceFontSize->SetSelection(newSelection);
1739 m_fontSize = wxAtoi(m_choiceFontSize->GetStringSelection());
1740 UpdateFontSize();
1741 }
1742 }
1743 }
1744
1745 event.Skip();
1746}

◆ OnPFBranchesGridChanged()

void DataReport::OnPFBranchesGridChanged ( wxGridEvent &  event)
protectedvirtual

Definition at line 1414 of file DataReport.cpp.

1415{
1416 if (!m_changingValues) FillValues(GRID_PFBRANCHES);
1417}

◆ OnPFBusGridChanged()

void DataReport::OnPFBusGridChanged ( wxGridEvent &  event)
protectedvirtual

Definition at line 1394 of file DataReport.cpp.

1395{
1396 if (!m_changingValues) FillValues(GRID_PFBUSES);
1397}

◆ OnPFNotebookChanged()

void DataReport::OnPFNotebookChanged ( wxNotebookEvent &  event)
protectedvirtual

Definition at line 1687 of file DataReport.cpp.

1688{
1689 UpdateCurrentGrid();
1690}

◆ OnPowerFlowGridChanged()

void DataReport::OnPowerFlowGridChanged ( wxGridEvent &  event)
protectedvirtual

Definition at line 1418 of file DataReport.cpp.

1419{
1420 if (!m_changingValues) FillValues(GRID_PF);
1421}

◆ OnTextPrecisionUpdate()

void DataReport::OnTextPrecisionUpdate ( wxCommandEvent &  event)
protectedvirtual

Definition at line 1713 of file DataReport.cpp.

1714{
1715 long precision = m_precision;
1716 if (m_textCtrlPrecision->GetValue().ToLong(&precision)) {
1717 if (precision >= 0) {
1718 m_precision = precision;
1719 FillValues(GRID_ALL);
1720 }
1721 }
1722
1723}

◆ SetHeaders()

void DataReport::SetHeaders ( )
virtual

Definition at line 286 of file DataReport.cpp.

287{
288 // Headers choices fill
289 wxString omega = static_cast<wxString>(L'\u03A9');
290
291 m_voltageChoices.Add(_("Voltage (p.u.)"));
292 m_voltageChoices.Add(_("Voltage (V)"));
293 m_voltageChoices.Add(_("Voltage (kV)"));
294
295 m_phaseVoltageChoices.Add(_("Phase Voltage (p.u.)"));
296 m_phaseVoltageChoices.Add(_("Phase Voltage (V)"));
297 m_phaseVoltageChoices.Add(_("Phase Voltage (kV)"));
298
299 m_activePowerChoices.Add(_("Active Power (p.u.)"));
300 m_activePowerChoices.Add(_("Active Power (W)"));
301 m_activePowerChoices.Add(_("Active Power (kW)"));
302 m_activePowerChoices.Add(_("Active Power (MW)"));
303
304 m_reactivePowerChoices.Add(_("Reactive Power (p.u.)"));
305 m_reactivePowerChoices.Add(_("Reactive Power (var)"));
306 m_reactivePowerChoices.Add(_("Reactive Power (kvar)"));
307 m_reactivePowerChoices.Add(_("Reactive Power (Mvar)"));
308
309 m_resistanceChoices.Add(_("R (p.u.)"));
310 m_resistanceChoices.Add(_("R (") + omega + wxT(")"));
311
312 m_indReactanceChoices.Add(_("XL (p.u.)"));
313 m_indReactanceChoices.Add(_("XL (") + omega + wxT(")"));
314
315 m_capSusceptanceChoices.Add(_("B (p.u.)"));
316 m_capSusceptanceChoices.Add(_("B (S)"));
317
318 m_currentChoices.Add(_("Current (p.u.)"));
319 m_currentChoices.Add(_("Current (A)"));
320 m_currentChoices.Add(_("Current (kA)"));
321
322 // Power flow
323 m_gridPowerFlow->SetCellValue(0, 0, _("Type"));
324 m_gridPowerFlow->SetCellValue(0, 1, _("Name"));
325 m_gridPowerFlow->SetCellValue(0, 2, _("From"));
326 m_gridPowerFlow->SetCellValue(0, 3, _("To"));
327 m_gridPowerFlow->SetCellEditor(0, 4, new wxGridCellChoiceEditor(m_activePowerChoices));
328 m_gridPowerFlow->SetCellValue(0, 4, m_activePowerChoices[3]);
329 m_gridPowerFlow->SetCellEditor(0, 5, new wxGridCellChoiceEditor(m_reactivePowerChoices));
330 m_gridPowerFlow->SetCellValue(0, 5, m_reactivePowerChoices[3]);
331 m_gridPowerFlow->SetCellValue(0, 6, _("Online"));
332
333 // Power flow buses
334 m_gridPFBuses->SetCellValue(0, 0, _("Name"));
335 m_gridPFBuses->SetCellValue(0, 1, _("Type"));
336 m_gridPFBuses->SetCellEditor(0, 2, new wxGridCellChoiceEditor(m_voltageChoices));
337 m_gridPFBuses->SetCellValue(0, 2, m_voltageChoices[0]);
338 m_gridPFBuses->SetCellValue(0, 3, _("Angle"));
339 m_gridPFBuses->SetCellEditor(0, 4, new wxGridCellChoiceEditor(m_activePowerChoices));
340 m_gridPFBuses->SetCellValue(0, 4, m_activePowerChoices[3]);
341 m_gridPFBuses->SetCellEditor(0, 5, new wxGridCellChoiceEditor(m_reactivePowerChoices));
342 m_gridPFBuses->SetCellValue(0, 5, m_reactivePowerChoices[3]);
343
344 // Power flow branches
345 m_gridPFBranches->SetCellValue(0, 0, _("Type"));
346 m_gridPFBranches->SetCellValue(0, 1, _("Name"));
347 m_gridPFBranches->SetCellValue(0, 2, _("From"));
348 m_gridPFBranches->SetCellValue(0, 3, _("To"));
349 m_gridPFBranches->SetCellEditor(0, 4, new wxGridCellChoiceEditor(m_resistanceChoices));
350 m_gridPFBranches->SetCellValue(0, 4, m_resistanceChoices[0]);
351 m_gridPFBranches->SetCellEditor(0, 5, new wxGridCellChoiceEditor(m_indReactanceChoices));
352 m_gridPFBranches->SetCellValue(0, 5, m_indReactanceChoices[0]);
353 m_gridPFBranches->SetCellEditor(0, 6, new wxGridCellChoiceEditor(m_capSusceptanceChoices));
354 m_gridPFBranches->SetCellValue(0, 6, m_capSusceptanceChoices[0]);
355 m_gridPFBranches->SetCellValue(0, 7, _("TAP"));
356 m_gridPFBranches->SetCellValue(0, 8, _("Phase Shift"));
357 m_gridPFBranches->SetCellValue(0, 9, _("Online"));
358
359 // Fault
360 m_gridFault->SetCellValue(0, 0, _("Fault bus name"));
361 m_gridFault->SetCellValue(0, 1, _("Phase A"));
362 m_gridFault->SetCellValue(0, 3, _("Phase B"));
363 m_gridFault->SetCellValue(0, 5, _("Phase C"));
364 m_gridFault->SetCellEditor(1, 1, new wxGridCellChoiceEditor(m_currentChoices));
365 m_gridFault->SetCellValue(1, 1, m_currentChoices[1]);
366 m_gridFault->SetCellValue(1, 2, _("Angle"));
367 m_gridFault->SetCellEditor(1, 3, new wxGridCellChoiceEditor(m_currentChoices));
368 m_gridFault->SetCellValue(1, 3, m_currentChoices[1]);
369 m_gridFault->SetCellValue(1, 4, _("Angle"));
370 m_gridFault->SetCellEditor(1, 5, new wxGridCellChoiceEditor(m_currentChoices));
371 m_gridFault->SetCellValue(1, 5, m_currentChoices[1]);
372 m_gridFault->SetCellValue(1, 6, _("Angle"));
373
374 // Fault buses
375 m_gridFaultBuses->SetCellValue(0, 0, _("Name"));
376 m_gridFaultBuses->SetCellValue(0, 1, _("Phase A"));
377 m_gridFaultBuses->SetCellValue(0, 3, _("Phase B"));
378 m_gridFaultBuses->SetCellValue(0, 5, _("Phase C"));
379 m_gridFaultBuses->SetCellEditor(1, 1, new wxGridCellChoiceEditor(m_voltageChoices));
380 m_gridFaultBuses->SetCellValue(1, 1, m_voltageChoices[0]);
381 m_gridFaultBuses->SetCellValue(1, 2, _("Angle"));
382 m_gridFaultBuses->SetCellEditor(1, 3, new wxGridCellChoiceEditor(m_voltageChoices));
383 m_gridFaultBuses->SetCellValue(1, 3, m_voltageChoices[0]);
384 m_gridFaultBuses->SetCellValue(1, 4, _("Angle"));
385 m_gridFaultBuses->SetCellEditor(1, 5, new wxGridCellChoiceEditor(m_voltageChoices));
386 m_gridFaultBuses->SetCellValue(1, 5, m_voltageChoices[0]);
387 m_gridFaultBuses->SetCellValue(1, 6, _("Angle"));
388
389 // Fault branches
390 m_gridFaultBranches->SetCellValue(0, 0, _("Type"));
391 m_gridFaultBranches->SetCellValue(0, 1, _("Name"));
392 m_gridFaultBranches->SetCellValue(0, 2, _("From"));
393 m_gridFaultBranches->SetCellValue(0, 3, _("To"));
394 m_gridFaultBranches->SetCellValue(0, 4, _("Phase A"));
395 m_gridFaultBranches->SetCellValue(0, 6, _("Phase B"));
396 m_gridFaultBranches->SetCellValue(0, 8, _("Phase C"));
397 m_gridFaultBranches->SetCellValue(0, 10, _("Online"));
398 m_gridFaultBranches->SetCellEditor(1, 4, new wxGridCellChoiceEditor(m_currentChoices));
399 m_gridFaultBranches->SetCellValue(1, 4, m_currentChoices[1]);
400 m_gridFaultBranches->SetCellValue(1, 5, _("Angle"));
401 m_gridFaultBranches->SetCellEditor(1, 6, new wxGridCellChoiceEditor(m_currentChoices));
402 m_gridFaultBranches->SetCellValue(1, 6, m_currentChoices[1]);
403 m_gridFaultBranches->SetCellValue(1, 7, _("Angle"));
404 m_gridFaultBranches->SetCellEditor(1, 8, new wxGridCellChoiceEditor(m_currentChoices));
405 m_gridFaultBranches->SetCellValue(1, 8, m_currentChoices[1]);
406 m_gridFaultBranches->SetCellValue(1, 9, _("Angle"));
407
408 // Fault generators
409 m_gridFaultGenerators->SetCellValue(0, 0, _("Name"));
410 m_gridFaultGenerators->SetCellValue(0, 1, _("Phase A"));
411 m_gridFaultGenerators->SetCellValue(0, 3, _("Phase B"));
412 m_gridFaultGenerators->SetCellValue(0, 5, _("Phase C"));
413 m_gridFaultGenerators->SetCellEditor(1, 1, new wxGridCellChoiceEditor(m_currentChoices));
414 m_gridFaultGenerators->SetCellValue(1, 1, m_currentChoices[1]);
415 m_gridFaultGenerators->SetCellValue(1, 2, _("Angle"));
416 m_gridFaultGenerators->SetCellEditor(1, 3, new wxGridCellChoiceEditor(m_currentChoices));
417 m_gridFaultGenerators->SetCellValue(1, 3, m_currentChoices[1]);
418 m_gridFaultGenerators->SetCellValue(1, 4, _("Angle"));
419 m_gridFaultGenerators->SetCellEditor(1, 5, new wxGridCellChoiceEditor(m_currentChoices));
420 m_gridFaultGenerators->SetCellValue(1, 5, m_currentChoices[1]);
421 m_gridFaultGenerators->SetCellValue(1, 6, _("Angle"));
422
423 // Harmonic Currents
424 m_gridHarmCurrents->SetCellValue(0, 0, _("Name"));
425 m_gridHarmCurrents->SetCellValue(0, 1, _("Bus"));
426 m_gridHarmCurrents->SetCellValue(0, 2, _("Harmonic"));
427 m_gridHarmCurrents->SetCellEditor(0, 3, new wxGridCellChoiceEditor(m_currentChoices));
428 m_gridHarmCurrents->SetCellValue(0, 3, m_currentChoices[1]);
429 m_gridHarmCurrents->SetCellValue(0, 4, _("Angle"));
430
431 // Harmonic Buses
432 m_gridHarmBuses->SetCellValue(0, 0, _("Name"));
433 m_gridHarmBuses->SetCellValue(0, 1, _("THD"));
434 m_gridHarmBuses->SetCellValue(0, 2, _("Harmonic"));
435 m_gridHarmBuses->SetCellEditor(0, 3, new wxGridCellChoiceEditor(m_phaseVoltageChoices));
436 m_gridHarmBuses->SetCellValue(0, 3, m_phaseVoltageChoices[0]);
437 m_gridHarmBuses->SetCellValue(0, 4, _("Angle"));
438
439 // Harmonic branches currents
440 m_gridHarmBranches->SetCellValue(0, 0, _("Type"));
441 m_gridHarmBranches->SetCellValue(0, 1, _("Name"));
442 m_gridHarmBranches->SetCellValue(0, 2, _("From"));
443 m_gridHarmBranches->SetCellValue(0, 3, _("To"));
444 m_gridHarmBranches->SetCellValue(0, 4, _("Harmonic"));
445 m_gridHarmBranches->SetCellEditor(0, 5, new wxGridCellChoiceEditor(m_currentChoices));
446 m_gridHarmBranches->SetCellValue(0, 5, m_currentChoices[1]);
447 m_gridHarmBranches->SetCellValue(0, 6, _("Angle"));
448 m_gridHarmBranches->SetCellValue(0, 7, _("Online"));
449}

◆ SetRowsColours()

void DataReport::SetRowsColours ( wxGrid *  grid,
int  rowStart = 1,
int  colStart = 0,
int  colEndTrim = 0 
)
virtual

Definition at line 1374 of file DataReport.cpp.

1375{
1376 for (int i = rowStart; i < grid->GetNumberRows(); ++i)
1377 {
1378 wxColour colour =
1379 ((i - rowStart) % 2 == 0) ?
1380 m_evenRowColour :
1381 m_oddRowColour;
1382
1383 for (int j = colStart; j < (grid->GetNumberCols() - colEndTrim); ++j)
1384 {
1385 wxGridCellAttr* attr = new wxGridCellAttr;
1386
1387 attr->SetBackgroundColour(colour);
1388
1389 grid->SetAttr(i, j, attr);
1390 }
1391 }
1392}

◆ UpdateCurrentGrid()

void DataReport::UpdateCurrentGrid ( )
virtual

Definition at line 1490 of file DataReport.cpp.

1491{
1492 int mainSlection = m_notebookDataReport->GetSelection();
1493 if (mainSlection != wxNOT_FOUND) {
1494 switch (mainSlection) {
1495 case 0: // Power Flow
1496 {
1497 int selection = m_notebookPowerFlow->GetSelection();
1498 if (selection == 0) {
1499 m_currentGrid = m_gridPowerFlow;
1500 }
1501 else if (selection == 1) {
1502 m_currentGrid = m_gridPFBuses;
1503 }
1504 else if (selection == 2) {
1505 m_currentGrid = m_gridPFBranches;
1506 }
1507 break;
1508 }
1509 case 1: // Fault
1510 {
1511 int selection = m_notebookFault->GetSelection();
1512 if (selection == 0) {
1513 m_currentGrid = m_gridFault;
1514 }
1515 else if (selection == 1) {
1516 m_currentGrid = m_gridFaultBuses;
1517 }
1518 else if (selection == 2) {
1519 m_currentGrid = m_gridFaultBranches;
1520 }
1521 else if (selection == 3) {
1522 m_currentGrid = m_gridFaultGenerators;
1523 }
1524 break;
1525 }
1526 case 2: // Harmonics
1527 {
1528 int selection = m_notebookHarmCurrents->GetSelection();
1529 if (selection == 0) {
1530 m_currentGrid = m_gridHarmCurrents;
1531 }
1532 else if (selection == 1) {
1533 m_currentGrid = m_gridHarmBuses;
1534 }
1535 else if (selection == 2) {
1536 m_currentGrid = m_gridHarmBranches;
1537 }
1538 break;
1539 }
1540 }
1541 }
1542}

◆ UpdateFontSize()

void DataReport::UpdateFontSize ( )
virtual

Definition at line 1459 of file DataReport.cpp.

1460{
1461 wxFont font = m_gridPowerFlow->GetFont();
1462 font.SetPointSize(m_fontSize);
1463
1464 wxFont headerFont = font;
1465 headerFont.SetWeight(wxFONTWEIGHT_BOLD);
1466
1467 wxGrid* grids[] = { m_gridPowerFlow, m_gridPFBuses, m_gridPFBranches, m_gridFault, m_gridFaultBuses, m_gridFaultBranches, m_gridFaultGenerators, m_gridHarmCurrents, m_gridHarmBuses, m_gridHarmBranches };
1468
1469 for (auto* grid : grids) {
1470 grid->SetLabelFont(headerFont);
1471 grid->SetDefaultCellFont(font);
1472 // Set font for all cells in header (first row)
1473 for (int col = 0; col < grid->GetNumberCols(); ++col) {
1474 grid->SetCellFont(0, col, headerFont);
1475 if (grid == m_gridFault ||
1476 grid == m_gridFaultBuses ||
1477 grid == m_gridFaultBranches ||
1478 grid == m_gridFaultGenerators)
1479 {
1480 grid->SetCellFont(1, col, headerFont);
1481 }
1482 }
1483 grid->SetFont(font);
1484 grid->AutoSize();
1485 grid->GetContainingSizer()->Layout();
1486 grid->ForceRefresh();
1487 }
1488}

Member Data Documentation

◆ m_activePowerChoices

wxArrayString DataReport::m_activePowerChoices
protected

Definition at line 98 of file DataReport.h.

◆ m_capSusceptanceChoices

wxArrayString DataReport::m_capSusceptanceChoices
protected

Definition at line 102 of file DataReport.h.

◆ m_changingValues

bool DataReport::m_changingValues = false
protected

Definition at line 89 of file DataReport.h.

◆ m_currentChoices

wxArrayString DataReport::m_currentChoices
protected

Definition at line 103 of file DataReport.h.

◆ m_currentGrid

wxGrid* DataReport::m_currentGrid = nullptr
protected

Definition at line 91 of file DataReport.h.

◆ m_evenRowColour

wxColour DataReport::m_evenRowColour
protected

Definition at line 109 of file DataReport.h.

◆ m_fontSize

int DataReport::m_fontSize = 10
protected

Definition at line 92 of file DataReport.h.

◆ m_headerColour

wxColour DataReport::m_headerColour
protected

Definition at line 106 of file DataReport.h.

◆ m_indReactanceChoices

wxArrayString DataReport::m_indReactanceChoices
protected

Definition at line 101 of file DataReport.h.

◆ m_oddRowColour

wxColour DataReport::m_oddRowColour
protected

Definition at line 108 of file DataReport.h.

◆ m_offlineColour

wxColour DataReport::m_offlineColour
protected

Definition at line 107 of file DataReport.h.

◆ m_phaseVoltageChoices

wxArrayString DataReport::m_phaseVoltageChoices
protected

Definition at line 97 of file DataReport.h.

◆ m_precision

int DataReport::m_precision = 4
protected

Definition at line 93 of file DataReport.h.

◆ m_reactivePowerChoices

wxArrayString DataReport::m_reactivePowerChoices
protected

Definition at line 99 of file DataReport.h.

◆ m_resistanceChoices

wxArrayString DataReport::m_resistanceChoices
protected

Definition at line 100 of file DataReport.h.

◆ m_voltageChoices

wxArrayString DataReport::m_voltageChoices
protected

Definition at line 96 of file DataReport.h.

◆ m_workspace

Workspace* DataReport::m_workspace = nullptr
protected

Definition at line 88 of file DataReport.h.

The documentation for this class was generated from the following files: