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

Calculate the fault of the system and update the elements data. More...

#include <Fault.h>

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

Public Member Functions

 Fault (std::vector< Element * > elementList)
 Contructor.
 
 Fault ()
 Default contructor. Use GetElementsFromList(std::vector<Element*> elementList).
 
 ~Fault ()
 Destructor.
 
virtual bool RunFaultCalculation (double systemPowerBase)
 Calculate the fault of the system. Return true if was possible the calculation.
 
virtual bool RunSCPowerCalcutation (double systemPowerBase)
 Calculate the short-circuit power of the system. Return true if was possible the calculation.
 
virtual void UpdateElementsFault (double systemPowerBase)
 Update the data of the elements.
 
virtual wxString GetErrorMessage ()
 Get the error message generated in RunFaultCalculation(double systemPowerBase).
 
- Public Member Functions inherited from ElectricCalculation
 ElectricCalculation ()
 Constructor.
 
 ~ElectricCalculation ()
 Destructor.
 
virtual void GetElementsFromList (std::vector< Element * > elementList)
 Separate the power elements from a generic list.
 
virtual bool GetYBus (std::vector< std::vector< std::complex< double > > > &yBus, double systemPowerBase, YBusSequence sequence=POSITIVE_SEQ, bool includeSyncMachines=false, bool allLoadsAsImpedances=false, bool usePowerFlowVoltagesOnImpedances=false)
 Get the admittance matrix from the list of elements (use GetElementsFromList first).
 
virtual bool InvertMatrix (std::vector< std::vector< std::complex< double > > > matrix, std::vector< std::vector< std::complex< double > > > &inverse)
 Invert a matrix.
 
virtual void UpdateElementsPowerFlow (std::vector< std::complex< double > > voltage, std::vector< std::complex< double > > power, std::vector< BusType > busType, std::vector< ReactiveLimits > reactiveLimit, double systemPowerBase)
 Update the elements after the power flow calculation.
 
void ABCtoDQ0 (std::complex< double > complexValue, double angle, double &dValue, double &qValue)
 Convert a complex phasor in ABC representation to DQ components.
 
void DQ0toABC (double dValue, double qValue, double angle, std::complex< double > &complexValue)
 Convert DQ components to a complex phasor in ABC representation.
 
std::vector< std::complex< double > > GaussianElimination (std::vector< std::vector< std::complex< double > > > matrix, std::vector< std::complex< double > > array)
 Solve a linear system using Gaussian elimination (complex version).
 
std::vector< double > GaussianElimination (std::vector< std::vector< double > > matrix, std::vector< double > array)
 Solve a linear system using Gaussian elimination (real version).
 
Machines::SyncMachineModel GetMachineModel (SyncGenerator *generator)
 Get the synchronous machine model used by the generator based on user-defined parameters.
 
std::vector< std::complex< double > > ComplexMatrixTimesVector (std::vector< std::vector< std::complex< double > > > matrix, std::vector< std::complex< double > > vector)
 Multiply a complex matrix by a complex vector.
 
void GetLUDecomposition (std::vector< std::vector< std::complex< double > > > matrix, std::vector< std::vector< std::complex< double > > > &matrixL, std::vector< std::vector< std::complex< double > > > &matrixU)
 Compute the LU decomposition of a matrix.
 
std::vector< std::complex< double > > LUEvaluate (std::vector< std::vector< std::complex< double > > > u, std::vector< std::vector< std::complex< double > > > l, std::vector< std::complex< double > > b)
 Solve a linear system using LU decomposition.
 
bool GetParentBus (Element *childElement, Bus *&parentBus)
 Get the parent bus of a given shunt element.
 
bool GetParentBus (Element *childElement, Bus *&parentBus1, Bus *&parentBus2)
 Get the parent buses of a two-terminal element (branch).
 
bool CalculateEMTElementsAdmittance (const double &basePower, wxString &errorMsg)
 Calculate the admittance of EMT elements.
 
bool CalculateEMTElementsPower (const double &basePower, wxString &errorMsg, bool updateCurrent=true)
 Calculate the power of EMT elements.
 
double CalculateEMTPowerError (const std::vector< std::complex< double > > &voltage, std::vector< std::complex< double > > &power, const double &basePower, wxString &errorMsg)
 Calculate the power mismatch error for EMT simulation.
 
const std::vector< PowerElement * > GetPowerElementList () const
 Get the power elements of the system (use GetElementsFromList first).
 
const std::vector< Bus * > GetBusList () const
 Get the buses of the system (use GetElementsFromList first).
 
const std::vector< Capacitor * > GetCapacitorList () const
 Get the capacitors of the system (use GetElementsFromList first).
 
const std::vector< IndMotor * > GetIndMotorList () const
 Get the induction motors of the system (use GetElementsFromList first).
 
const std::vector< Inductor * > GetInductorList () const
 Get the inductors of the system (use GetElementsFromList first).
 
const std::vector< Line * > GetLineList () const
 Get the lines of the system (use GetElementsFromList first).
 
const std::vector< Load * > GetLoadList () const
 Get the loads of the system (use GetElementsFromList first).
 
const std::vector< SyncGenerator * > GetSyncGeneratorList () const
 Get the synchronous generators of the system (use GetElementsFromList first).
 
const std::vector< SyncMotor * > GetSyncMotorList () const
 Get the synchronous motors of the system (use GetElementsFromList first).
 
const std::vector< Transformer * > GetTransformerList () const
 Get the transformers of the system (use GetElementsFromList first).
 
const std::vector< HarmCurrent * > GetHarmCurrentList () const
 Get the harmonic current source of the system (use GetElementsFromList first).
 
const std::vector< EMTElement * > GetEMTElementList () const
 Get the electromagnetic element list of the system (use GetElementsFromList first).
 

Protected Attributes

wxString m_errorMsg = ""
 
double m_systemPowerBase
 
std::vector< std::vector< std::complex< double > > > m_zBusPos
 
std::vector< std::vector< std::complex< double > > > m_zBusNeg
 
std::vector< std::vector< std::complex< double > > > m_zBusZero
 
std::vector< std::complex< double > > m_posFaultVoltagePos
 
std::vector< std::complex< double > > m_posFaultVoltageNeg
 
std::vector< std::complex< double > > m_posFaultVoltageZero
 
std::complex< double > m_fCurrentA
 
std::complex< double > m_fCurrentB
 
std::complex< double > m_fCurrentC
 
std::vector< std::complex< double > > m_posFaultVoltageA
 
std::vector< std::complex< double > > m_posFaultVoltageB
 
std::vector< std::complex< double > > m_posFaultVoltageC
 
- Protected Attributes inherited from ElectricCalculation
std::vector< PowerElement * > m_powerElementList
 List of power elements in the system.
 
std::vector< Bus * > m_busList
 List of buses in the system.
 
std::vector< Capacitor * > m_capacitorList
 List of capacitor elements in the system.
 
std::vector< IndMotor * > m_indMotorList
 List of induction motors in the system.
 
std::vector< Inductor * > m_inductorList
 List of inductors in the system.
 
std::vector< Line * > m_lineList
 List of transmission lines in the system.
 
std::vector< Load * > m_loadList
 List of load elements in the system.
 
std::vector< SyncGenerator * > m_syncGeneratorList
 List of synchronous generators in the system.
 
std::vector< SyncMotor * > m_syncMotorList
 List of synchronous motors in the system.
 
std::vector< Transformer * > m_transformerList
 List of transformers in the system.
 
std::vector< HarmCurrent * > m_harmCurrentList
 List of harmonic current sources in the system.
 
std::vector< EMTElement * > m_emtElementList
 List of electromagnetic transient (EMT) elements in the system.
 

Additional Inherited Members

- Protected Member Functions inherited from ElectricCalculation
void GetNextConnection (const unsigned int &checkBusNumber, const std::vector< std::vector< std::complex< double > > > &yBus, std::vector< bool > &connToSlack)
 Recursively check if a bus is electrically connected to the slack bus.
 
void DistributeReactivePower (std::vector< ReactiveMachine > &machines, double qTotal)
 Distribute reactive power among synchronous machines connected to the same bus.
 

Detailed Description

Calculate the fault of the system and update the elements data.

Author
Thales Lima Oliveira
Date
10/01/2017

Definition at line 30 of file Fault.h.

Constructor & Destructor Documentation

◆ Fault() [1/2]

Fault::Fault ( std::vector< Element * >  elementList)

Contructor.

Parameters
elementListList of elements in workspace

Definition at line 24 of file Fault.cpp.

24{ GetElementsFromList(elementList); }
ElectricCalculation::GetElementsFromList
virtual void GetElementsFromList(std::vector< Element * > elementList)
Separate the power elements from a generic list.
Definition ElectricCalculation.cpp:27
Here is the call graph for this function:

◆ Fault() [2/2]

Fault::Fault ( )

Default contructor. Use GetElementsFromList(std::vector<Element*> elementList).

Definition at line 23 of file Fault.cpp.

23: ElectricCalculation() {}
ElectricCalculation::ElectricCalculation
ElectricCalculation()
Constructor.
Definition ElectricCalculation.cpp:25

◆ ~Fault()

Fault::~Fault ( )

Destructor.

Definition at line 25 of file Fault.cpp.

25{}

Member Function Documentation

◆ GetErrorMessage()

virtual wxString Fault::GetErrorMessage ( )
inlinevirtual

Get the error message generated in RunFaultCalculation(double systemPowerBase).

Returns
Error message.

Definition at line 71 of file Fault.h.

71{ return m_errorMsg; }

◆ RunFaultCalculation()

bool Fault::RunFaultCalculation ( double  systemPowerBase)
virtual

Calculate the fault of the system. Return true if was possible the calculation.

Parameters
systemPowerBaseSystem base of power.

Definition at line 26 of file Fault.cpp.

27{
28 m_systemPowerBase = systemPowerBase;
29 int numberOfBuses = static_cast<int>(m_busList.size());
30 if (numberOfBuses == 0) {
31 m_errorMsg = _("There is no buses in the system.");
32 return false;
33 }
34
35 // Pre-fault voltages (power flow solution).
36 std::vector<std::complex<double> > preFaultVoltages;
37 preFaultVoltages.resize(m_busList.size());
38
39 // Get adimittance matrices first to setup disconnected buses.
40 std::vector<std::vector<std::complex<double> > > yBusPos;
41 GetYBus(yBusPos, systemPowerBase, POSITIVE_SEQ, true, true);
42 std::vector<std::vector<std::complex<double> > > yBusNeg;
43 GetYBus(yBusNeg, systemPowerBase, NEGATIVE_SEQ, true, true);
44 std::vector<std::vector<std::complex<double> > > yBusZero;
45 GetYBus(yBusZero, systemPowerBase, ZERO_SEQ, true, true);
46
47 // Get fault parameters.
48 int fNumber = -1;
49 int nBusFaulted = 0;
50 FaultData fType = FaultData::FAULT_THREEPHASE;
51 FaultData fLocation = FaultData::FAULT_LINE_A;
52 std::complex<double> fImpedance = std::complex<double>(0.0, 0.0);
53 for (auto it = m_busList.begin(), itEnd = m_busList.end(); it != itEnd; ++it) {
54 Bus* bus = *it;
55 BusElectricalData data = bus->GetElectricalData();
56 if (data.number >= 0)
57 preFaultVoltages[data.number] = data.voltage;
58
59 if (data.hasFault && data.isConnected) {
60 fNumber = data.number;
61 fType = data.faultType;
62 fLocation = data.faultLocation;
63 fImpedance = std::complex<double>(data.faultResistance, data.faultReactance);
64 nBusFaulted++;
65 }
66 }
67 if (fNumber == -1) {
68 m_errorMsg = _("There is no fault in the system or the faulty bus is disconnected.");
69 return false;
70 }
71 else if (nBusFaulted > 1) {
72 wxMessageDialog msgDialog(nullptr, _("There is more than one fault in the system, and this can lead to inconsistent results.\nDo you wish to proceed?"), _("Warning"), wxYES_NO | wxCENTRE | wxICON_WARNING);
73 if (msgDialog.ShowModal() == wxID_NO) {
74 m_errorMsg = _("Fault calculation was cancelled by the user.");
75 return false;
76 }
77 }
78
79
80
81 // Calculate the impedance matrices.
82 if (!InvertMatrix(yBusPos, m_zBusPos)) {
83 m_errorMsg = _("Fail to invert the positive sequence admittance matrix.");
84 return false;
85 }
86 if (!InvertMatrix(yBusNeg, m_zBusNeg)) {
87 m_errorMsg = _("Fail to invert the negative sequence admittance matrix.");
88 return false;
89 }
90 if (!InvertMatrix(yBusZero, m_zBusZero)) {
91 m_errorMsg = _("Fail to invert the zero sequence admittance matrix.");
92 return false;
93 }
94
95 // Fault calculation.
96 std::complex<double> fCurrentPos = std::complex<double>(0.0, 0.0);
97 std::complex<double> fCurrentNeg = std::complex<double>(0.0, 0.0);
98 std::complex<double> fCurrentZero = std::complex<double>(0.0, 0.0);
99
100 std::complex<double> preFaultVoltage = preFaultVoltages[fNumber];
101 std::complex<double> a = std::complex<double>(-0.5, 0.866025403784);
102 std::complex<double> a2 = std::complex<double>(-0.5, -0.866025403784);
103
104 switch (fType) {
105 case FaultData::FAULT_THREEPHASE: {
106 fCurrentPos = preFaultVoltage / (m_zBusPos[fNumber][fNumber] + fImpedance);
107 } break;
108 case FaultData::FAULT_2LINE: {
109 fCurrentPos = preFaultVoltage / (m_zBusPos[fNumber][fNumber] + m_zBusNeg[fNumber][fNumber] + fImpedance);
110
111 switch (fLocation) {
112 case FaultData::FAULT_LINE_A: {
113 fCurrentNeg = -a2 * fCurrentPos;
114 } break;
115 case FaultData::FAULT_LINE_B: {
116 fCurrentNeg = -fCurrentPos;
117 } break;
118 case FaultData::FAULT_LINE_C: {
119 fCurrentNeg = -a * fCurrentPos;
120 } break;
121 default:
122 break;
123 }
124 } break;
125 case FaultData::FAULT_2LINE_GROUND: {
126 std::complex<double> z1 = m_zBusPos[fNumber][fNumber];
127 std::complex<double> z2 = m_zBusNeg[fNumber][fNumber];
128 std::complex<double> z0 = m_zBusZero[fNumber][fNumber];
129 std::complex<double> zf_3 = std::complex<double>(3.0, 0.0) * fImpedance;
130
131 fCurrentPos = (preFaultVoltage * (z2 + z0 + zf_3)) / (z1 * z2 + z2 * z0 + z2 * zf_3 + z1 * z0 + z1 * zf_3);
132
133 switch (fLocation) {
134 case FaultData::FAULT_LINE_A: {
135 fCurrentNeg = -a2 * ((preFaultVoltage - z1 * fCurrentPos) / z2);
136 fCurrentZero = -a * ((preFaultVoltage - z1 * fCurrentPos) / (z0 + zf_3));
137 } break;
138 case FaultData::FAULT_LINE_B: {
139 fCurrentNeg = -((preFaultVoltage - z1 * fCurrentPos) / z2);
140 fCurrentZero = -((preFaultVoltage - z1 * fCurrentPos) / (z0 + zf_3));
141 } break;
142 case FaultData::FAULT_LINE_C: {
143 fCurrentNeg = -a * ((preFaultVoltage - z1 * fCurrentPos) / z2);
144 fCurrentZero = -a2 * ((preFaultVoltage - z1 * fCurrentPos) / (z0 + zf_3));
145 } break;
146 default:
147 break;
148 }
149 } break;
150 case FaultData::FAULT_LINE_GROUND: {
151 fCurrentPos =
152 preFaultVoltage / (m_zBusPos[fNumber][fNumber] + m_zBusNeg[fNumber][fNumber] +
153 m_zBusZero[fNumber][fNumber] + std::complex<double>(3.0, 0.0) * fImpedance);
154 switch (fLocation) {
155 case FaultData::FAULT_LINE_A: {
156 fCurrentNeg = fCurrentPos;
157 fCurrentZero = fCurrentPos;
158 } break;
159 case FaultData::FAULT_LINE_B: {
160 fCurrentNeg = a * fCurrentPos;
161 fCurrentZero = a2 * fCurrentPos;
162 } break;
163 case FaultData::FAULT_LINE_C: {
164 fCurrentNeg = a2 * fCurrentPos;
165 fCurrentZero = a * fCurrentPos;
166 } break;
167 default:
168 break;
169 }
170 } break;
171 default:
172 break;
173 }
174
175 // Convert sequence currents to ABC. [Iabc] = [A]*[I012]
176 m_fCurrentA = fCurrentZero + fCurrentPos + fCurrentNeg;
177 m_fCurrentB = fCurrentZero + a2 * fCurrentPos + a * fCurrentNeg;
178 m_fCurrentC = fCurrentZero + a * fCurrentPos + a2 * fCurrentNeg;
179
180 // Pos-fault voltages calculation
181 m_posFaultVoltagePos.clear();
182 m_posFaultVoltageNeg.clear();
183 m_posFaultVoltageZero.clear();
184 m_posFaultVoltageA.clear();
185 m_posFaultVoltageB.clear();
186 m_posFaultVoltageC.clear();
187
188 int connectedBusIndex = 0;
189 for (int i = 0; i < numberOfBuses; ++i) {
190 if (std::abs(preFaultVoltages[i]) > 1e-6) { // Only connected buses
191 m_posFaultVoltagePos.push_back(preFaultVoltages[i] - m_zBusPos[connectedBusIndex][fNumber] * fCurrentPos);
192 m_posFaultVoltageNeg.push_back(-m_zBusNeg[connectedBusIndex][fNumber] * fCurrentNeg);
193 m_posFaultVoltageZero.push_back(-m_zBusZero[connectedBusIndex][fNumber] * fCurrentZero);
194 connectedBusIndex++;
195 }
196 else {
197 m_posFaultVoltagePos.push_back(std::complex<double>(0.0, 0.0));
198 m_posFaultVoltageNeg.push_back(std::complex<double>(0.0, 0.0));
199 m_posFaultVoltageZero.push_back(std::complex<double>(0.0, 0.0));
200 }
201
202 // V012 -> Vabc
203 m_posFaultVoltageA.push_back(m_posFaultVoltageZero[i] + m_posFaultVoltagePos[i] + m_posFaultVoltageNeg[i]);
204 m_posFaultVoltageB.push_back(m_posFaultVoltageZero[i] + a2 * m_posFaultVoltagePos[i] +
205 a * m_posFaultVoltageNeg[i]);
206 m_posFaultVoltageC.push_back(m_posFaultVoltageZero[i] + a * m_posFaultVoltagePos[i] +
207 a2 * m_posFaultVoltageNeg[i]);
208 }
209
210 UpdateElementsFault(systemPowerBase);
211 return true;
212}
POSITIVE_SEQ
@ POSITIVE_SEQ
Definition ElectricCalculation.h:68
NEGATIVE_SEQ
@ NEGATIVE_SEQ
Definition ElectricCalculation.h:69
FaultData
FaultData
Information about fault (type and location).
Definition PowerElement.h:28
FaultData::FAULT_LINE_GROUND
@ FAULT_LINE_GROUND
FaultData::FAULT_2LINE_GROUND
@ FAULT_2LINE_GROUND
FaultData::FAULT_THREEPHASE
@ FAULT_THREEPHASE
Bus
Node for power elements. All others power elements are connected through this.
Definition Bus.h:87
ElectricCalculation::m_busList
std::vector< Bus * > m_busList
List of buses in the system.
Definition ElectricCalculation.h:370
ElectricCalculation::GetYBus
virtual bool GetYBus(std::vector< std::vector< std::complex< double > > > &yBus, double systemPowerBase, YBusSequence sequence=POSITIVE_SEQ, bool includeSyncMachines=false, bool allLoadsAsImpedances=false, bool usePowerFlowVoltagesOnImpedances=false)
Get the admittance matrix from the list of elements (use GetElementsFromList first).
Definition ElectricCalculation.cpp:81
ElectricCalculation::InvertMatrix
virtual bool InvertMatrix(std::vector< std::vector< std::complex< double > > > matrix, std::vector< std::vector< std::complex< double > > > &inverse)
Invert a matrix.
Definition ElectricCalculation.cpp:792
Fault::UpdateElementsFault
virtual void UpdateElementsFault(double systemPowerBase)
Update the data of the elements.
Definition Fault.cpp:214
Here is the call graph for this function:

◆ RunSCPowerCalcutation()

bool Fault::RunSCPowerCalcutation ( double  systemPowerBase)
virtual

Calculate the short-circuit power of the system. Return true if was possible the calculation.

Parameters
systemPowerBaseSystem base of power.

Definition at line 428 of file Fault.cpp.

429{
430 // Get adimittance matrix.
431 std::vector<std::vector<std::complex<double> > > yBusPos;
432 GetYBus(yBusPos, systemPowerBase, POSITIVE_SEQ, true, true);
433
434 // Calculate the impedance matrix.
435 if (!InvertMatrix(yBusPos, m_zBusPos)) {
436 m_errorMsg = _("Fail to invert the positive sequence admittance matrix.");
437 return false;
438 }
439
440 // Set the SC power.
441 for (auto it = m_busList.begin(), itEnd = m_busList.end(); it != itEnd; ++it) {
442 Bus* bus = *it;
443 auto data = bus->GetElectricalData();
444 if (data.isConnected) {
445 int n = data.number;
446 data.scPower = 1.0 / std::abs(m_zBusPos[n][n]);
447 bus->SetElectricalData(data);
448 }
449 }
450
451 return true;
452}
Here is the call graph for this function:

◆ UpdateElementsFault()

void Fault::UpdateElementsFault ( double  systemPowerBase)
virtual

Update the data of the elements.

Parameters
systemPowerBaseSystem base of power.

Definition at line 214 of file Fault.cpp.

215{
216 std::complex<double> a = std::complex<double>(-0.5, 0.866025403784);
217 std::complex<double> a2 = std::complex<double>(-0.5, -0.866025403784);
218
219 std::complex<double> vpf = std::complex<double>(0.0, 0.0);
220
221
222 for (auto it = m_busList.begin(), itEnd = m_busList.end(); it != itEnd; ++it) {
223 Bus* bus = *it;
224 auto data = bus->GetElectricalData();
225 if (data.hasFault) {
226 data.faultCurrent[0] = m_fCurrentA;
227 data.faultCurrent[1] = m_fCurrentB;
228 data.faultCurrent[2] = m_fCurrentC;
229
230 vpf = data.voltage;
231 }
232 else {
233 data.faultCurrent[0] = data.faultCurrent[1] = data.faultCurrent[2] = std::complex<double>(0.0, 0.0);
234 }
235 data.faultVoltage[0] = data.number >= 0 ? m_posFaultVoltageA[data.number] : 0.0;
236 data.faultVoltage[1] = data.number >= 0 ? m_posFaultVoltageB[data.number] : 0.0;
237 data.faultVoltage[2] = data.number >= 0 ? m_posFaultVoltageC[data.number] : 0.0;
238 bus->SetElectricalData(data);
239 }
240
241 for (auto it = m_lineList.begin(), itEnd = m_lineList.end(); it != itEnd; ++it) {
242 Line* line = *it;
243 if (line->IsOnline()) {
244 int n1 = static_cast<Bus*>(line->GetParentList()[0])->GetElectricalData().number;
245 int n2 = static_cast<Bus*>(line->GetParentList()[1])->GetElectricalData().number;
246 auto data = line->GetElectricalData();
247 auto puData = line->GetPUElectricalData(m_systemPowerBase);
248 std::complex<double> vPos[2] = { n1 >= 0 ? m_posFaultVoltagePos[n1] : 0.0, n2 >= 0 ? m_posFaultVoltagePos[n2] : 0.0 };
249 std::complex<double> vNeg[2] = { n1 >= 0 ? m_posFaultVoltageNeg[n1] : 0.0, n2 >= 0 ? m_posFaultVoltageNeg[n2] : 0.0 };
250 std::complex<double> vZero[2] = { n1 >= 0 ? m_posFaultVoltageZero[n1] : 0.0, n2 >= 0 ? m_posFaultVoltageZero[n2] : 0.0 };
251 std::complex<double> zPos(puData.resistance, puData.indReactance);
252 std::complex<double> bPos(0.0, puData.capSusceptance / 2.0);
253 std::complex<double> zZero(puData.zeroResistance, puData.zeroIndReactance);
254 std::complex<double> bZero(0.0, puData.zeroCapSusceptance / 2.0);
255
256 std::complex<double> lineCurrentPos[2];
257 std::complex<double> lineCurrentNeg[2];
258 std::complex<double> lineCurrentZero[2];
259
260 lineCurrentPos[0] = ((vPos[0] - vPos[1]) / zPos) + (vPos[0] * bPos);
261 lineCurrentNeg[0] = ((vNeg[0] - vNeg[1]) / zPos) + (vNeg[0] * bPos);
262 lineCurrentZero[0] = ((vZero[0] - vZero[1]) / zZero) + (vZero[0] * bZero);
263 lineCurrentPos[1] = ((vPos[1] - vPos[0]) / zPos) + (vPos[1] * bPos);
264 lineCurrentNeg[1] = ((vNeg[1] - vNeg[0]) / zPos) + (vNeg[1] * bPos);
265 lineCurrentZero[1] = ((vZero[1] - vZero[0]) / zZero) + (vZero[1] * bZero);
266
267 data.faultCurrent[0][0] = lineCurrentZero[0] + lineCurrentPos[0] + lineCurrentNeg[0];
268 data.faultCurrent[0][1] = lineCurrentZero[0] + a2 * lineCurrentPos[0] + a * lineCurrentNeg[0];
269 data.faultCurrent[0][2] = lineCurrentZero[0] + a * lineCurrentPos[0] + a2 * lineCurrentNeg[0];
270 data.faultCurrent[1][0] = lineCurrentZero[1] + lineCurrentPos[1] + lineCurrentNeg[1];
271 data.faultCurrent[1][1] = lineCurrentZero[1] + a2 * lineCurrentPos[1] + a * lineCurrentNeg[1];
272 data.faultCurrent[1][2] = lineCurrentZero[1] + a * lineCurrentPos[1] + a2 * lineCurrentNeg[1];
273
274 line->SetElectricalData(data);
275 }
276 }
277
278 for (auto it = m_transformerList.begin(), itEnd = m_transformerList.end(); it != itEnd; ++it) {
279 Transformer* transformer = *it;
280 if (transformer->IsOnline()) {
281 int n1 = static_cast<Bus*>(transformer->GetParentList()[0])->GetElectricalData().number;
282 int n2 = static_cast<Bus*>(transformer->GetParentList()[1])->GetElectricalData().number;
283 auto data = transformer->GetElectricalData();
284 auto puData = transformer->GetPUElectricalData(m_systemPowerBase);
285
286 std::complex<double> vPos[2] = { n1 >= 0 ? m_posFaultVoltagePos[n1] : 0.0, n2 >= 0 ? m_posFaultVoltagePos[n2] : 0.0 };
287 std::complex<double> vNeg[2] = { n1 >= 0 ? m_posFaultVoltageNeg[n1] : 0.0, n2 >= 0 ? m_posFaultVoltageNeg[n2] : 0.0 };
288 std::complex<double> vZero[2] = { n1 >= 0 ? m_posFaultVoltageZero[n1] : 0.0, n2 >= 0 ? m_posFaultVoltageZero[n2] : 0.0 };
289 std::complex<double> zPos(puData.resistance, puData.indReactance);
290 std::complex<double> zZero(puData.zeroResistance, puData.zeroIndReactance);
291
292 std::complex<double> transformerCurrentPos[2];
293 std::complex<double> transformerCurrentNeg[2];
294 std::complex<double> transformerCurrentZero[2];
295
296 if (data.turnsRatio == 1.0 && data.phaseShift == 0.0) {
297 transformerCurrentPos[0] = (vPos[0] - vPos[1]) / zPos;
298 transformerCurrentNeg[0] = (vNeg[0] - vNeg[1]) / zPos;
299 transformerCurrentZero[0] = (vZero[0] - vZero[1]) / zZero;
300 transformerCurrentPos[1] = (vPos[1] - vPos[0]) / zPos;
301 transformerCurrentNeg[1] = (vNeg[1] - vNeg[0]) / zPos;
302 transformerCurrentZero[1] = (vZero[1] - vZero[0]) / zZero;
303 }
304 else {
305 double radPhaseShift = wxDegToRad(data.phaseShift);
306 std::complex<double> t = std::complex<double>(data.turnsRatio * std::cos(radPhaseShift),
307 -data.turnsRatio * std::sin(radPhaseShift));
308
309 transformerCurrentPos[0] =
310 vPos[0] * (1.0 / (std::pow(std::abs(t), 2.0) * zPos)) - vPos[1] * (1.0 / (std::conj(t) * zPos));
311 transformerCurrentNeg[0] =
312 vNeg[0] * (1.0 / (std::pow(std::abs(t), 2.0) * zPos)) - vNeg[1] * (1.0 / (t * zPos));
313
314 transformerCurrentPos[1] = -vPos[0] * (1.0 / (t * zPos)) + vPos[1] / zPos;
315 transformerCurrentNeg[1] = -vNeg[0] * (1.0 / (std::conj(t) * zPos)) + vNeg[1] / zPos;
316 }
317
318 switch (data.connection) {
319 case GWYE_GWYE: {
320 transformerCurrentZero[0] = (vZero[0] - vZero[1]) / zZero;
321 transformerCurrentZero[1] = (vZero[1] - vZero[0]) / zZero;
322 break;
323 }
324 case GWYE_DELTA: {
325 transformerCurrentZero[0] = vZero[0] / zZero;
326 transformerCurrentZero[1] = std::complex<double>(0.0, 0.0);
327 break;
328 }
329 case DELTA_GWYE: {
330 transformerCurrentZero[0] = std::complex<double>(0.0, 0.0);
331 transformerCurrentZero[1] = vZero[1] / zZero;
332 break;
333 }
334 default: {
335 transformerCurrentZero[0] = std::complex<double>(0.0, 0.0);
336 transformerCurrentZero[1] = std::complex<double>(0.0, 0.0);
337 break;
338 }
339 }
340
341 data.faultCurrent[0][0] = transformerCurrentZero[0] + transformerCurrentPos[0] + transformerCurrentNeg[0];
342 data.faultCurrent[0][1] =
343 transformerCurrentZero[0] + a2 * transformerCurrentPos[0] + a * transformerCurrentNeg[0];
344 data.faultCurrent[0][2] =
345 transformerCurrentZero[0] + a * transformerCurrentPos[0] + a2 * transformerCurrentNeg[0];
346 data.faultCurrent[1][0] = transformerCurrentZero[1] + transformerCurrentPos[1] + transformerCurrentNeg[1];
347 data.faultCurrent[1][1] =
348 transformerCurrentZero[1] + a2 * transformerCurrentPos[1] + a * transformerCurrentNeg[1];
349 data.faultCurrent[1][2] =
350 transformerCurrentZero[1] + a * transformerCurrentPos[1] + a2 * transformerCurrentNeg[1];
351
352 transformer->SetElectricaData(data);
353 }
354 }
355
356 for (auto it = m_syncGeneratorList.begin(), itEnd = m_syncGeneratorList.end(); it != itEnd; ++it) {
357 SyncGenerator* syncGenerator = *it;
358 if (syncGenerator->IsOnline()) {
359 Bus* bus = static_cast<Bus*>(syncGenerator->GetParentList()[0]);
360 int n = bus->GetElectricalData().number;
361 std::complex<double> v = bus->GetElectricalData().voltage; // Pre-fault voltage.
362 auto data = syncGenerator->GetElectricalData();
363 auto puData = syncGenerator->GetPUElectricalData(m_systemPowerBase);
364
365 std::complex<double> vPos = n >= 0 ? m_posFaultVoltagePos[n] : 0.0;
366 std::complex<double> vNeg = n >= 0 ? m_posFaultVoltageNeg[n] : 0.0;
367 std::complex<double> vZero = n >= 0 ? m_posFaultVoltageZero[n] : 0.0;
368
369 std::complex<double> zPos(puData.positiveResistance, puData.positiveReactance);
370 std::complex<double> zNeg(puData.negativeResistance, puData.negativeReactance);
371 std::complex<double> zZero(puData.zeroResistance + 3.0 * puData.groundResistance,
372 puData.zeroReactance + 3.0 * puData.groundReactance);
373
374 // Internal voltage
375 //std::complex<double> i = std::complex<double>(puData.activePower, -puData.reactivePower) / std::conj(v);
376 //std::complex<double> e = v + zPos * i;
377
378 //std::complex<double> syncGeneratorCurrentPos = n >= 0 ? (e - vPos) / zPos : 0.0;
379 std::complex<double> syncGeneratorCurrentPos = n >= 0 ? (v - vPos) / zPos : 0.0;
380 std::complex<double> syncGeneratorCurrentNeg = n >= 0 ? (-vNeg) / zNeg : 0.0;
381 std::complex<double> syncGeneratorCurrentZero(0.0, 0.0);
382 if (data.groundNeutral) syncGeneratorCurrentZero = n >= 0 ? (-vZero) / zZero : 0.0;
383
384 data.faultCurrent[0] = syncGeneratorCurrentZero + syncGeneratorCurrentPos + syncGeneratorCurrentNeg;
385 data.faultCurrent[1] =
386 syncGeneratorCurrentZero + a2 * syncGeneratorCurrentPos + a * syncGeneratorCurrentNeg;
387 data.faultCurrent[2] =
388 syncGeneratorCurrentZero + a * syncGeneratorCurrentPos + a2 * syncGeneratorCurrentNeg;
389
390 syncGenerator->SetElectricalData(data);
391 }
392 }
393
394 for (auto it = m_syncMotorList.begin(), itEnd = m_syncMotorList.end(); it != itEnd; ++it) {
395 SyncMotor* syncMotor = *it;
396 if (syncMotor->IsOnline()) {
397 Bus* bus = static_cast<Bus*>(syncMotor->GetParentList()[0]);
398 int n = bus->GetElectricalData().number;
399 std::complex<double> v = bus->GetElectricalData().voltage; // Pre-fault voltage.
400 auto data = syncMotor->GetElectricalData();
401 auto puData = syncMotor->GetPUElectricalData(m_systemPowerBase);
402
403 std::complex<double> vPos = n >= 0 ? m_posFaultVoltagePos[n] : 0.0;
404 std::complex<double> vNeg = n >= 0 ? m_posFaultVoltageNeg[n] : 0.0;
405 std::complex<double> vZero = n >= 0 ? m_posFaultVoltageZero[n] : 0.0;
406
407 std::complex<double> zPos(puData.positiveResistance, puData.positiveReactance);
408 std::complex<double> zNeg(puData.negativeResistance, puData.negativeReactance);
409 std::complex<double> zZero(puData.zeroResistance + 3.0 * puData.groundResistance,
410 puData.zeroReactance + 3.0 * puData.groundReactance);
411
412 std::complex<double> syncMotorCurrentPos = n >= 0 ? (v - vPos) / zPos : 0.0;
413 std::complex<double> syncMotorCurrentNeg = n >= 0 ? (-vNeg) / zNeg : 0.0;
414 std::complex<double> syncMotorCurrentZero(0.0, 0.0);
415 if (data.groundNeutral) syncMotorCurrentZero = n >= 0 ? (-vZero) / zZero : 0.0;
416
417 data.faultCurrent[0] = syncMotorCurrentZero + syncMotorCurrentPos + syncMotorCurrentNeg;
418 data.faultCurrent[1] =
419 syncMotorCurrentZero + a2 * syncMotorCurrentPos + a * syncMotorCurrentNeg;
420 data.faultCurrent[2] =
421 syncMotorCurrentZero + a * syncMotorCurrentPos + a2 * syncMotorCurrentNeg;
422
423 syncMotor->SetElectricalData(data);
424 }
425 }
426}
ElectricCalculation::m_lineList
std::vector< Line * > m_lineList
List of transmission lines in the system.
Definition ElectricCalculation.h:378
ElectricCalculation::m_transformerList
std::vector< Transformer * > m_transformerList
List of transformers in the system.
Definition ElectricCalculation.h:386
ElectricCalculation::m_syncGeneratorList
std::vector< SyncGenerator * > m_syncGeneratorList
List of synchronous generators in the system.
Definition ElectricCalculation.h:382
ElectricCalculation::m_syncMotorList
std::vector< SyncMotor * > m_syncMotorList
List of synchronous motors in the system.
Definition ElectricCalculation.h:384
Element::GetParentList
virtual std::vector< Element * > GetParentList() const
Get the parent list.
Definition Element.h:567
Element::IsOnline
bool IsOnline() const
Checks if the element is online or offline.
Definition Element.h:229
Line
Power line element.
Definition Line.h:64
SyncGenerator
Synchronous generator power element.
Definition SyncGenerator.h:146
SyncMotor
Synchronous motor (synchronous compensator) power element.
Definition SyncMotor.h:135
Transformer
Two-winding transformer power element with OLTC support.
Definition Transformer.h:96
Here is the call graph for this function:
Here is the caller graph for this function:

Member Data Documentation

◆ m_errorMsg

wxString Fault::m_errorMsg = ""
protected

Definition at line 73 of file Fault.h.

◆ m_fCurrentA

std::complex<double> Fault::m_fCurrentA
protected

Definition at line 85 of file Fault.h.

◆ m_fCurrentB

std::complex<double> Fault::m_fCurrentB
protected

Definition at line 86 of file Fault.h.

◆ m_fCurrentC

std::complex<double> Fault::m_fCurrentC
protected

Definition at line 87 of file Fault.h.

◆ m_posFaultVoltageA

std::vector<std::complex<double> > Fault::m_posFaultVoltageA
protected

Definition at line 89 of file Fault.h.

◆ m_posFaultVoltageB

std::vector<std::complex<double> > Fault::m_posFaultVoltageB
protected

Definition at line 90 of file Fault.h.

◆ m_posFaultVoltageC

std::vector<std::complex<double> > Fault::m_posFaultVoltageC
protected

Definition at line 91 of file Fault.h.

◆ m_posFaultVoltageNeg

std::vector<std::complex<double> > Fault::m_posFaultVoltageNeg
protected

Definition at line 82 of file Fault.h.

◆ m_posFaultVoltagePos

std::vector<std::complex<double> > Fault::m_posFaultVoltagePos
protected

Definition at line 81 of file Fault.h.

◆ m_posFaultVoltageZero

std::vector<std::complex<double> > Fault::m_posFaultVoltageZero
protected

Definition at line 83 of file Fault.h.

◆ m_systemPowerBase

double Fault::m_systemPowerBase
protected

Definition at line 75 of file Fault.h.

◆ m_zBusNeg

std::vector<std::vector<std::complex<double> > > Fault::m_zBusNeg
protected

Definition at line 78 of file Fault.h.

◆ m_zBusPos

std::vector<std::vector<std::complex<double> > > Fault::m_zBusPos
protected

Definition at line 77 of file Fault.h.

◆ m_zBusZero

std::vector<std::vector<std::complex<double> > > Fault::m_zBusZero
protected

Definition at line 79 of file Fault.h.

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