Power System Platform  2026w34a-beta
Loading...
Searching...
No Matches
TransformerForm Class Reference

Form to edit the transformer power data and OLTC tap changer. More...

#include <TransformerForm.h>

Inheritance diagram for TransformerForm:
Collaboration diagram for TransformerForm:

Public Member Functions

 TransformerForm (wxWindow *parent, Transformer *transformer)
 
bool ValidateData ()
 

Protected Member Functions

virtual void OnCancelButtonClick (wxCommandEvent &event)
 
virtual void OnOKButtonClick (wxCommandEvent &event)
 
virtual void OnStabilityButtonClick (wxCommandEvent &event)
 
void OnEnableTapChangerCheck (wxCommandEvent &event)
 
void OnDiscreteTapCheck (wxCommandEvent &event)
 
void UpdateTapChangerFields ()
 

Protected Attributes

wxWindow * m_parent = nullptr
 
Transformer * m_transformer = nullptr
 

Detailed Description

Form to edit the transformer power data and OLTC tap changer.

Author
Thales Lima Oliveira thale.nosp@m.s@uf.nosp@m.u.br
Luiz Gonzaga Rocha Junior luizg.nosp@m.rj@g.nosp@m.mail..nosp@m.com
Date
05/10/2017

Definition at line 34 of file TransformerForm.h.

Constructor & Destructor Documentation

◆ TransformerForm()

TransformerForm::TransformerForm ( wxWindow *  parent,
Transformer *  transformer 
)

Definition at line 24 of file TransformerForm.cpp.

24 : TransformerFormBase(parent)
25{
26 m_choiceResistance->SetString(1, L'\u03A9');
27 m_choiceReactance->SetString(1, L'\u03A9');
28
29 // Reset connections choice labels (to be translated)
30 m_choiceConnection->SetString(0, _("Grounded Wye - Grounded Wye"));
31 m_choiceConnection->SetString(1, _("Wye - Grounded Wye"));
32 m_choiceConnection->SetString(2, _("Grounded Wye - Wye"));
33 m_choiceConnection->SetString(3, _("Wye - Wye"));
34 m_choiceConnection->SetString(4, _("Delta - Grounded Wye"));
35 m_choiceConnection->SetString(5, _("Delta - Wye"));
36 m_choiceConnection->SetString(6, _("Grounded Wye - Delta"));
37 m_choiceConnection->SetString(7, _("Wye - Delta"));
38 m_choiceConnection->SetString(8, _("Delta - Delta"));
39
40 SetSize(GetBestSize());
41 Layout();
42
43 m_parent = parent;
44 m_transformer = transformer;
45
46 TransformerElectricalData data = transformer->GetElectricalData();
47
48 m_textCtrlName->SetValue(data.name);
49
50 wxString primVoltStr = Transformer::StringFromDouble(data.primaryNominalVoltage);
51 switch (data.primaryNominalVoltageUnit) {
52 case ElectricalUnit::UNIT_V: {
53 primVoltStr += " V";
54 } break;
55 case ElectricalUnit::UNIT_kV: {
56 primVoltStr += " kV";
57 } break;
58 default:
59 break;
60 }
61 wxString secVoltStr = Transformer::StringFromDouble(data.secondaryNominalVoltage);
62 switch (data.secondaryNominalVoltageUnit) {
63 case ElectricalUnit::UNIT_V: {
64 secVoltStr += " V";
65 } break;
66 case ElectricalUnit::UNIT_kV: {
67 secVoltStr += " kV";
68 } break;
69 default:
70 break;
71 }
72 m_staticTextNominalVoltageValue->SetLabel(wxString::Format("%s / %s", primVoltStr, secVoltStr));
73
74 m_choiceBaseVoltage->SetString(0, primVoltStr);
75 m_choiceBaseVoltage->SetString(1, secVoltStr);
76 m_choiceBaseVoltage->SetSelection(data.baseVoltage);
77
78 m_textCtrlNominalPower->SetValue(Transformer::StringFromDouble(data.nominalPower));
79 switch (data.nominalPowerUnit) {
80 case ElectricalUnit::UNIT_VA: {
81 m_choiceNominalPower->SetSelection(0);
82 } break;
83 case ElectricalUnit::UNIT_kVA: {
84 m_choiceNominalPower->SetSelection(1);
85 } break;
86 case ElectricalUnit::UNIT_MVA: {
87 m_choiceNominalPower->SetSelection(2);
88 } break;
89 default:
90 break;
91 }
92
93 m_textCtrlResistance->SetValue(Transformer::StringFromDouble(data.resistance));
94 switch (data.resistanceUnit) {
95 case ElectricalUnit::UNIT_PU: {
96 m_choiceResistance->SetSelection(0);
97 } break;
98 case ElectricalUnit::UNIT_OHM: {
99 m_choiceResistance->SetSelection(1);
100 } break;
101 default:
102 break;
103 }
104
105 m_textCtrlReactance->SetValue(Transformer::StringFromDouble(data.indReactance));
106 switch (data.indReactanceUnit) {
107 case ElectricalUnit::UNIT_PU: {
108 m_choiceReactance->SetSelection(0);
109 } break;
110 case ElectricalUnit::UNIT_OHM: {
111 m_choiceReactance->SetSelection(1);
112 } break;
113 default:
114 break;
115 }
116
117 m_choiceConnection->SetSelection(data.connection);
118
119 m_textCtrlTurnRatio->SetValue(Transformer::StringFromDouble(data.turnsRatio));
120 m_textCtrlPhaseShift->SetValue(Transformer::StringFromDouble(data.phaseShift));
121
122 m_checkUseTransformerPower->SetValue(data.useTransformerPower);
123
124 m_textCtrlZeroResistance->SetValue(Transformer::StringFromDouble(data.zeroResistance));
125 m_textCtrlZeroReactance->SetValue(Transformer::StringFromDouble(data.zeroIndReactance));
126 m_textCtrlPrimResistance->SetValue(Transformer::StringFromDouble(data.primaryGrndResistance));
127 m_textCtrlPrimReactance->SetValue(Transformer::StringFromDouble(data.primaryGrndReactance));
128 m_textCtrlSecResistance->SetValue(Transformer::StringFromDouble(data.secondaryGrndResistance));
129 m_textCtrlSecReactance->SetValue(Transformer::StringFromDouble(data.secondaryGrndReactance));
130
131 // Tap Changer (OLTC) Tab
132 m_checkEnableTapChanger->SetValue(data.hasTapChanger);
133
134 wxArrayString busChoices;
135 wxString primLabel = _("Primary (Bus 1)");
136 wxString secLabel = _("Secondary (Bus 2)");
137 if (m_transformer->GetParentList().size() >= 2) {
138 Bus* b1 = dynamic_cast<Bus*>(m_transformer->GetParentList()[0]);
139 Bus* b2 = dynamic_cast<Bus*>(m_transformer->GetParentList()[1]);
140 if (b1) primLabel = wxString::Format(_("%s"), b1->GetElectricalData().name);
141 if (b2) secLabel = wxString::Format(_("%s"), b2->GetElectricalData().name);
142 }
143 busChoices.Add(primLabel);
144 busChoices.Add(secLabel);
145 m_choiceControlledBus->Append(busChoices);
146 m_choiceControlledBus->SetSelection(data.oltcControlledBus == 0 ? 0 : 1);
147 m_choiceControlledBus->SetMaxSize(wxSize(200, -1));
148
149 m_textCtrlTargetVoltage->SetValue(Transformer::StringFromDouble(data.oltcTargetVoltage));
150 m_textCtrlDeadband->SetValue(Transformer::StringFromDouble(data.oltcVoltageDeadband));
151 m_textCtrlMinTap->SetValue(Transformer::StringFromDouble(data.oltcMinTap));
152 m_textCtrlMaxTap->SetValue(Transformer::StringFromDouble(data.oltcMaxTap));
153 m_textCtrlTapStep->SetValue(Transformer::StringFromDouble(data.oltcTapStep));
154 m_checkDiscreteTap->SetValue(data.oltcIsDiscrete);
155
156 UpdateTapChangerFields();
157
158 SetSize(GetBestSize());
159 Layout();
160}
Node for power elements. All others power elements are connected through this.
Definition Bus.h:87
virtual std::vector< Element * > GetParentList() const
Get the parent list.
Definition Element.h:567
static wxString StringFromDouble(double value, int minDecimal=1, int maxDecimals=13)
Convert a double value to string.
Definition Element.cpp:548

◆ ~TransformerForm()

TransformerForm::~TransformerForm ( )
virtual

Definition at line 194 of file TransformerForm.cpp.

194{}

Member Function Documentation

◆ OnCancelButtonClick()

void TransformerForm::OnCancelButtonClick ( wxCommandEvent &  event)
protectedvirtual

Definition at line 195 of file TransformerForm.cpp.

195{ EndModal(wxID_CANCEL); }

◆ OnDiscreteTapCheck()

void TransformerForm::OnDiscreteTapCheck ( wxCommandEvent &  event)
protected

Definition at line 167 of file TransformerForm.cpp.

168{
169 UpdateTapChangerFields();
170}

◆ OnEnableTapChangerCheck()

void TransformerForm::OnEnableTapChangerCheck ( wxCommandEvent &  event)
protected

Definition at line 162 of file TransformerForm.cpp.

163{
164 UpdateTapChangerFields();
165}

◆ OnOKButtonClick()

void TransformerForm::OnOKButtonClick ( wxCommandEvent &  event)
protectedvirtual

Definition at line 196 of file TransformerForm.cpp.

197{
198 if (ValidateData()) EndModal(wxID_OK);
199}

◆ OnStabilityButtonClick()

void TransformerForm::OnStabilityButtonClick ( wxCommandEvent &  event)
protectedvirtual

Definition at line 200 of file TransformerForm.cpp.

201{
202 if (ValidateData()) {
203 SwitchingForm swForm(m_parent, m_transformer);
204 swForm.SetTitle(_("Transfomer: Switching"));
205 swForm.ShowModal();
206 EndModal(wxID_OK);
207 }
208}
Form to edit the switching data of power elements for electromechanical transient studies.

◆ UpdateTapChangerFields()

void TransformerForm::UpdateTapChangerFields ( )
protected

Definition at line 172 of file TransformerForm.cpp.

173{
174 bool enable = m_checkEnableTapChanger->GetValue();
175 m_staticTextControlledBus->Enable(enable);
176 m_choiceControlledBus->Enable(enable);
177 m_staticTextTargetVoltage->Enable(enable);
178 m_textCtrlTargetVoltage->Enable(enable);
179 m_staticTextDeadband->Enable(enable);
180 m_textCtrlDeadband->Enable(enable);
181 m_staticTextMinTap->Enable(enable);
182 m_textCtrlMinTap->Enable(enable);
183 m_staticTextMaxTap->Enable(enable);
184 m_textCtrlMaxTap->Enable(enable);
185 m_checkDiscreteTap->Enable(enable);
186
187 m_textCtrlTurnRatio->Enable(!enable);
188
189 bool discrete = enable && m_checkDiscreteTap->GetValue();
190 //m_staticTextTapStep->Enable(discrete);
191 m_textCtrlTapStep->Enable(discrete);
192}

◆ ValidateData()

bool TransformerForm::ValidateData ( )

Definition at line 210 of file TransformerForm.cpp.

211{
212 TransformerElectricalData data = m_transformer->GetElectricalData();
213
214 data.name = m_textCtrlName->GetValue();
215 data.baseVoltage = m_choiceBaseVoltage->GetSelection();
216
217 if (!m_transformer->DoubleFromString(m_parent, m_textCtrlNominalPower->GetValue(), data.nominalPower,
218 _("Value entered incorrectly in the field \"Nominal power\".")))
219 return false;
220 switch (m_choiceNominalPower->GetSelection()) {
221 case 0: {
222 data.nominalPowerUnit = ElectricalUnit::UNIT_VA;
223 } break;
224 case 1: {
225 data.nominalPowerUnit = ElectricalUnit::UNIT_kVA;
226 } break;
227 case 2: {
228 data.nominalPowerUnit = ElectricalUnit::UNIT_MVA;
229 } break;
230 }
231
232 if (!m_transformer->DoubleFromString(m_parent, m_textCtrlResistance->GetValue(), data.resistance,
233 _("Value entered incorrectly in the field \"Resistance\".")))
234 return false;
235 switch (m_choiceResistance->GetSelection()) {
236 case 0: {
237 data.resistanceUnit = ElectricalUnit::UNIT_PU;
238 } break;
239 case 1: {
240 data.resistanceUnit = ElectricalUnit::UNIT_OHM;
241 } break;
242 }
243
244 if (!m_transformer->DoubleFromString(m_parent, m_textCtrlReactance->GetValue(), data.indReactance,
245 _("Value entered incorrectly in the field \"Indutive reactance\".")))
246 return false;
247 switch (m_choiceReactance->GetSelection()) {
248 case 0: {
249 data.indReactanceUnit = ElectricalUnit::UNIT_PU;
250 } break;
251 case 1: {
252 data.indReactanceUnit = ElectricalUnit::UNIT_OHM;
253 } break;
254 }
255
256 switch (m_choiceConnection->GetSelection()) {
257 case 0: {
258 data.connection = GWYE_GWYE;
259 } break;
260 case 1: {
261 data.connection = WYE_GWYE;
262 } break;
263 case 2: {
264 data.connection = GWYE_WYE;
265 } break;
266 case 3: {
267 data.connection = WYE_WYE;
268 } break;
269 case 4: {
270 data.connection = DELTA_GWYE;
271 } break;
272 case 5: {
273 data.connection = DELTA_WYE;
274 } break;
275 case 6: {
276 data.connection = GWYE_DELTA;
277 } break;
278 case 7: {
279 data.connection = WYE_DELTA;
280 } break;
281 case 8: {
282 data.connection = DELTA_DELTA;
283 } break;
284 }
285
286 if (!m_transformer->DoubleFromString(m_parent, m_textCtrlTurnRatio->GetValue(), data.turnsRatio,
287 _("Value entered incorrectly in the field \"Turns ratio\".")))
288 return false;
289
290 if (!m_transformer->DoubleFromString(m_parent, m_textCtrlPhaseShift->GetValue(), data.phaseShift,
291 _("Value entered incorrectly in the field \"Phase shift\".")))
292 return false;
293
294 data.useTransformerPower = m_checkUseTransformerPower->GetValue();
295
296 if (!m_transformer->DoubleFromString(m_parent, m_textCtrlZeroResistance->GetValue(), data.zeroResistance,
297 _("Value entered incorrectly in the field \"Zero sequence resistance\".")))
298 return false;
299
300 if (!m_transformer->DoubleFromString(
301 m_parent, m_textCtrlZeroReactance->GetValue(), data.zeroIndReactance,
302 _("Value entered incorrectly in the field \"Zero sequence indutive reactance\".")))
303 return false;
304
305 if (!m_transformer->DoubleFromString(m_parent, m_textCtrlPrimResistance->GetValue(), data.primaryGrndResistance,
306 _("Value entered incorrectly in the field \"Primary ground resistance\".")))
307 return false;
308
309 if (!m_transformer->DoubleFromString(m_parent, m_textCtrlPrimReactance->GetValue(), data.primaryGrndReactance,
310 _("Value entered incorrectly in the field \"Primary ground reactance\".")))
311 return false;
312
313 if (!m_transformer->DoubleFromString(m_parent, m_textCtrlSecResistance->GetValue(), data.secondaryGrndResistance,
314 _("Value entered incorrectly in the field \"Secondary ground resistance\".")))
315 return false;
316
317 if (!m_transformer->DoubleFromString(m_parent, m_textCtrlSecReactance->GetValue(), data.secondaryGrndReactance,
318 _("Value entered incorrectly in the field \"Secondary ground reactance\".")))
319 return false;
320
321 data.hasTapChanger = m_checkEnableTapChanger->GetValue();
322 if (data.hasTapChanger) {
323 data.oltcControlledBus = (m_choiceControlledBus->GetSelection() == 0) ? 0 : 1;
324
325 if (!m_transformer->DoubleFromString(m_parent, m_textCtrlTargetVoltage->GetValue(), data.oltcTargetVoltage,
326 _("Value entered incorrectly in the field \"Target voltage\".")))
327 return false;
328 if (data.oltcTargetVoltage <= 0.0) {
329 wxMessageBox(_("Target voltage must be greater than 0."), _("Error"), wxOK | wxICON_ERROR, m_parent);
330 return false;
331 }
332
333 if (!m_transformer->DoubleFromString(m_parent, m_textCtrlDeadband->GetValue(), data.oltcVoltageDeadband,
334 _("Value entered incorrectly in the field \"Voltage deadband\".")))
335 return false;
336 if (data.oltcVoltageDeadband < 0.0) {
337 wxMessageBox(_("Voltage deadband cannot be negative."), _("Error"), wxOK | wxICON_ERROR, m_parent);
338 return false;
339 }
340
341 if (!m_transformer->DoubleFromString(m_parent, m_textCtrlMinTap->GetValue(), data.oltcMinTap,
342 _("Value entered incorrectly in the field \"Minimum tap\".")))
343 return false;
344 if (data.oltcMinTap <= 0.0) {
345 wxMessageBox(_("Minimum tap must be greater than 0."), _("Error"), wxOK | wxICON_ERROR, m_parent);
346 return false;
347 }
348
349 if (!m_transformer->DoubleFromString(m_parent, m_textCtrlMaxTap->GetValue(), data.oltcMaxTap,
350 _("Value entered incorrectly in the field \"Maximum tap\".")))
351 return false;
352 if (data.oltcMaxTap < data.oltcMinTap) {
353 wxMessageBox(_("Maximum tap must be greater than or equal to minimum tap."), _("Error"), wxOK | wxICON_ERROR, m_parent);
354 return false;
355 }
356
357 data.oltcIsDiscrete = m_checkDiscreteTap->GetValue();
358
359 if (!m_transformer->DoubleFromString(m_parent, m_textCtrlTapStep->GetValue(), data.oltcTapStep,
360 _("Value entered incorrectly in the field \"Tap step size\".")))
361 return false;
362 if (data.oltcTapStep < 0.0) {
363 wxMessageBox(_("Tap step size cannot be negative."), _("Error"), wxOK | wxICON_ERROR, m_parent);
364 return false;
365 }
366
367 // Adjust current tap to the configured OLTC limits.
368 data.turnsRatio = std::clamp(data.turnsRatio, data.oltcMinTap, data.oltcMaxTap);
369
370 // Align the current tap with the configured discrete tap step.
371 if (data.oltcIsDiscrete && data.oltcTapStep > 1e-4) {
372 data.turnsRatio = 1.0 + std::round((data.turnsRatio - 1.0) / data.oltcTapStep) * data.oltcTapStep;
373 data.turnsRatio = std::clamp(data.turnsRatio, data.oltcMinTap, data.oltcMaxTap);
374 }
375 }
376 data.nominalTurnsRatio = data.turnsRatio;
377
378 m_transformer->SetElectricaData(data);
379 return true;
380}
static bool DoubleFromString(wxWindow *parent, wxString strValue, double &value, wxString errorMsg)
Get a double value from a string. Show a error message if the conversion fail.
Definition Element.cpp:520

Member Data Documentation

◆ m_parent

wxWindow* TransformerForm::m_parent = nullptr
protected

Definition at line 49 of file TransformerForm.h.

◆ m_transformer

Transformer* TransformerForm::m_transformer = nullptr
protected

Definition at line 50 of file TransformerForm.h.


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