Calculate the power flow (including OLTC tap adjustment). More...

#include <PowerFlow.h>

Inheritance diagram for PowerFlow:

Collaboration diagram for PowerFlow:

Public Member Functions
	PowerFlow (std::vector< Element * > elementList)

virtual bool	InitPowerFlow (std::vector< BusType > &busType, std::vector< std::complex< double > > &voltage, std::vector< std::complex< double > > &power, std::vector< std::complex< double > > &loadPower, std::vector< ReactiveLimits > &reactiveLimit, double systemPowerBase=100e6, double initAngle=0.0)

virtual bool	RunGaussSeidel (double systemPowerBase=100e6, int maxIteration=5000, double error=1e-6, double initAngle=0.0, double accFactor=1.0)

virtual bool	RunNewtonRaphson (double systemPowerBase=100e6, int maxIteration=5000, double error=1e-6, double initAngle=0.0, double inertia=1.0)

virtual bool	RunGaussNewton (double systemPowerBase=100e6, int maxIteration=5000, double error=1e-6, double initAngle=0.0, double accFactor=1.0, double gaussTol=1e-2, double inertia=1.0)

virtual wxString	GetErrorMessage ()

virtual int	GetIterations ()

virtual void	ResetVoltages ()

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 Member Functions
void	GetNumPVPQ (std::vector< BusType > busType, int &numPQ, int &numPV)

std::vector< std::vector< double > >	CalculateJacobianMatrix (const std::vector< std::complex< double > > &voltage, const std::vector< std::complex< double > > &power, const std::vector< BusType > &busType, int numPV, int numPQ)

bool	CheckReactiveLimits (std::vector< BusType > &busType, std::vector< ReactiveLimits > &reactiveLimit, std::vector< std::complex< double > > &power, std::vector< std::complex< double > > loadPower)

double	GaussSeidel (std::vector< BusType > busType, std::vector< std::complex< double > > &voltage, std::vector< std::complex< double > > oldVoltage, std::vector< std::complex< double > > &power, double accFactor)

void	NewtonRaphson (std::vector< BusType > busType, std::vector< std::complex< double > > &voltage, std::vector< std::complex< double > > power, int numPV, int numPQ, std::vector< double > dPdQ, double inertia)

bool	CalculateMotorsReactivePower (std::vector< std::complex< double > > voltage, std::vector< std::complex< double > > &power)

bool	HasInvalidValue (const std::vector< std::complex< double > > &voltage)

bool	AdjustTapChangers (const std::vector< std::complex< double > > &voltage, double systemPowerBase)

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.

Protected Attributes
std::vector< std::vector< std::complex< double > > >	m_yBus

wxString	m_errorMsg = ""

int	m_numberOfBuses = 0

int	m_iterations = 0

int	m_tapAdjustmentsCount = 0

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.

Detailed Description

Calculate the power flow (including OLTC tap adjustment).

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: 06/10/2017

Definition at line 36 of file PowerFlow.h.

Constructor & Destructor Documentation

◆ PowerFlow() [1/2]

PowerFlow::PowerFlow ( )

Definition at line 20 of file PowerFlow.cpp.

20: ElectricCalculation() {}

ElectricCalculation::ElectricCalculation

ElectricCalculation()

Constructor.

Definition ElectricCalculation.cpp:25

◆ PowerFlow() [2/2]

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

Definition at line 21 of file PowerFlow.cpp.

21: ElectricCalculation() { GetElementsFromList(elementList); }

ElectricCalculation::GetElementsFromList

virtual void GetElementsFromList(std::vector< Element * > elementList)

Separate the power elements from a generic list.

Definition ElectricCalculation.cpp:27

◆ ~PowerFlow()

PowerFlow::~PowerFlow ( )

Definition at line 22 of file PowerFlow.cpp.

22{}

Member Function Documentation

◆ AdjustTapChangers()

bool PowerFlow::AdjustTapChangers	(	const std::vector< std::complex< double > > &	voltage,
		double	systemPowerBase
	)

protected

Definition at line 930 of file PowerFlow.cpp.

{
    if (m_tapAdjustmentsCount >= 40) {
        // Limit total adjustments to avoid infinite cycling
        return false;
    }
 
    bool anyAdjusted = false;
 
    for (Transformer* transformer : m_transformerList) {
        if (!transformer->IsOnline() || transformer->GetParentList().size() < 2) continue;
 
        TransformerElectricalData data = transformer->GetElectricalData();
        if (!data.hasTapChanger) continue;
 
        Bus* bus1 = static_cast<Bus*>(transformer->GetParentList()[0]);
        Bus* bus2 = static_cast<Bus*>(transformer->GetParentList()[1]);
        if (!bus1 || !bus2) continue;
 
        int n1 = bus1->GetElectricalData().number;
        int n2 = bus2->GetElectricalData().number;
 
        int nCtrl = (data.oltcControlledBus == 0) ? n1 : n2;
        bool isPrimary = (data.oltcControlledBus == 0);
 
        if (nCtrl < 0 || nCtrl >= (int)voltage.size()) continue;
 
        double vCtrl = std::abs(voltage[nCtrl]);
        double vTarget = data.oltcTargetVoltage;
        double deadband = std::max(data.oltcVoltageDeadband, 1e-4);
 
        if (data.oltcIsDiscrete && data.oltcTapStep > 1e-4) {
            deadband = std::max(deadband, 0.5 * data.oltcTapStep * vCtrl);
        }
 
        double vDiff = vCtrl - vTarget;
        if (std::abs(vDiff) <= deadband) continue;
 
        double currentTap = data.turnsRatio;
        if (currentTap <= 1e-4) currentTap = 1.0;
 
 
        //tex:
        // Model in PSP-UFU has ideal turns ratio $a$ on side 1 (Primary):
        //
        // $$\frac{V_1}{a} \approx V_2$$
        // $$V_2 \approx \frac{V_1}{a}, \qquad V_1 \approx aV_2$$
        //
        // Secondary (side 2):
        //
        // $$\frac{dV_2}{da} \approx -\frac{V_2}{a}$$
        //
        // $$\Delta V_2 \approx -\frac{V_2}{a}\Delta a$$
        // $$\Rightarrow\quad
        // \Delta a \approx -\frac{a}{V_2}\Delta V_2
        // = \frac{a}{V_2}(V_2 - V_{\mathrm{target}})
        // = \frac{a}{V_2}v_{\mathrm{Diff}}$$
        //
        // Primary (side 1):
        //
        // $$\frac{dV_1}{da} \approx \frac{V_1}{a}$$
        //
        // $$\Delta V_1 \approx \frac{V_1}{a}\Delta a$$
        // $$\Rightarrow\quad
        // \Delta a \approx \frac{a}{V_1}\Delta V_1
        // = -\frac{a}{V_1}(V_1 - V_{\mathrm{target}})
        // = -\frac{a}{V_1}v_{\mathrm{Diff}}$$
 
        double damping = 0.8;
        double deltaTap = (isPrimary ? -1.0 : 1.0) * (currentTap / std::max(vCtrl, 0.1)) * vDiff * damping;
 
        if (data.oltcIsDiscrete && data.oltcTapStep > 1e-4) {
            double step = data.oltcTapStep;
            double numSteps = std::round(deltaTap / step);
            if (numSteps == 0.0) {
                numSteps = (deltaTap > 0.0) ? 1.0 : -1.0;
            }
            deltaTap = numSteps * step;
        }
 
        double newTap = currentTap + deltaTap;
 
        // Limit to min/max range
        if (newTap < data.oltcMinTap) newTap = data.oltcMinTap;
        if (newTap > data.oltcMaxTap) newTap = data.oltcMaxTap;
 
        if (data.oltcIsDiscrete && data.oltcTapStep > 1e-4) {
            double step = data.oltcTapStep;
            newTap = 1.0 + std::round((newTap - 1.0) / step) * step;
            if (newTap < data.oltcMinTap) newTap = data.oltcMinTap;
            if (newTap > data.oltcMaxTap) newTap = data.oltcMaxTap;
        }
 
        if (std::abs(newTap - currentTap) > 1e-5) {
            data.turnsRatio = newTap;
            transformer->SetElectricaData(data);
            anyAdjusted = true;
        }
    }
 
    if (anyAdjusted) {
        m_tapAdjustmentsCount++;
        GetYBus(m_yBus, systemPowerBase);
    }
 
    return anyAdjusted;
}

◆ CalculateJacobianMatrix()

std::vector< std::vector< double > > PowerFlow::CalculateJacobianMatrix	(	const std::vector< std::complex< double > > &	voltage,
		const std::vector< std::complex< double > > &	power,
		const std::vector< BusType > &	busType,
		int	numPV,
		int	numPQ
	)

protected

Definition at line 759 of file PowerFlow.cpp.

{
    int nvar = 2 * numPQ + numPV;
 
    std::vector<std::vector<double>> J(nvar, std::vector<double>(nvar, 0.0));
 
    int n = m_numberOfBuses;
 
    // Precompute magnitudes and angles
    std::vector<double> V(n);
    std::vector<double> T(n);
 
    for (int i = 0; i < n; i++)
    {
        V[i] = std::abs(voltage[i]);
        T[i] = std::arg(voltage[i]);
    }
 
    // Compute currents
    std::vector<std::complex<double>> I(n);
 
    for (int i = 0; i < n; i++)
    {
        I[i] = 0;
        for (int k = 0; k < n; k++)
            I[i] += m_yBus[i][k] * voltage[k];
    }
 
    // Compute power injections
    std::vector<std::complex<double>> S(n);
 
    for (int i = 0; i < n; i++)
        S[i] = voltage[i] * std::conj(I[i]);
 
    int rowP = 0;
    int rowQ = numPV + numPQ;
 
    for (int i = 0; i < n; i++)
    {
        if (busType[i] == BUS_SLACK)
            continue;
 
        int colTheta = 0;
        int colV = numPV + numPQ;
 
        for (int j = 0; j < n; j++)
        {
            if (busType[j] == BUS_SLACK)
                continue;
 
            double G = m_yBus[i][j].real();
            double B = m_yBus[i][j].imag();
 
            double dtheta = T[i] - T[j];
 
            if (i == j)
            {
                double Pi = S[i].real();
                double Qi = S[i].imag();
 
                // J11
                J[rowP][colTheta] = -Qi - B * V[i] * V[i];
 
                // J12 only PQ
                if (busType[i] == BUS_PQ)
                    J[rowQ][colTheta] = Pi - G * V[i] * V[i];
            }
            else
            {
                // J11
                J[rowP][colTheta] = V[i] * V[j] * (G * sin(dtheta) - B * cos(dtheta));
 
                if (busType[i] == BUS_PQ)// J21                 
                    J[rowQ][colTheta] = -V[i] * V[j] * (G * cos(dtheta) + B * sin(dtheta));
            }
 
            colTheta++;
        }
 
        colTheta = 0;
 
        for (int j = 0; j < n; j++)
        {
            if (busType[j] != BUS_PQ)
                continue;
 
            double G = m_yBus[i][j].real();
            double B = m_yBus[i][j].imag();
 
            double dtheta = T[i] - T[j];
 
            if (i == j)
            {
                double Pi = S[i].real();
                double Qi = S[i].imag();
 
                // J12
                J[rowP][colV] = Pi / V[i] + G * V[i];
 
                if (busType[i] == BUS_PQ) // J22
                    J[rowQ][colV] = Qi / V[i] - B * V[i];
            }
            else
            {
                // J12
                J[rowP][colV] = V[i] * (G * cos(dtheta) + B * sin(dtheta));
 
                if (busType[i] == BUS_PQ) // J22
                    J[rowQ][colV] = V[i] * (G * sin(dtheta) - B * cos(dtheta));
            }
            colV++;
        }
        rowP++;
 
        if (busType[i] == BUS_PQ)
            rowQ++;
    }
 
    return J;
}

◆ CalculateMotorsReactivePower()

bool PowerFlow::CalculateMotorsReactivePower	(	std::vector< std::complex< double > >	voltage,
		std::vector< std::complex< double > > &	power
	)

protected

Definition at line 914 of file PowerFlow.cpp.

{
    for (unsigned int i = 0; i < m_indMotorList.size(); ++i) {
        IndMotor* motor = m_indMotorList[i];
        auto data = motor->GetElectricalData();
        if (motor->IsOnline() && data.calcQInPowerFlow) {
            double oldQ = data.qValue;
            if (!motor->CalculateReactivePower(std::abs(voltage[data.busNum]))) return false;
            double dQ = oldQ - motor->GetElectricalData().qValue;
            power[data.busNum] += std::complex<double>(0.0, dQ);
        }
    }
    return true;
}

◆ CheckReactiveLimits()

bool PowerFlow::CheckReactiveLimits	(	std::vector< BusType > &	busType,
		std::vector< ReactiveLimits > &	reactiveLimit,
		std::vector< std::complex< double > > &	power,
		std::vector< std::complex< double > >	loadPower
	)

protected

Definition at line 885 of file PowerFlow.cpp.

{
    bool limitReach = false;
    for (int i = 0; i < m_numberOfBuses; i++) {
        if (busType[i] == BUS_PV) {
            if (reactiveLimit[i].maxLimitType == RL_LIMITED) {
                if (power[i].imag() - loadPower[i].imag() > reactiveLimit[i].maxLimit) {
                    power[i] = std::complex<double>(power[i].real(), reactiveLimit[i].maxLimit + loadPower[i].imag());
                    busType[i] = BUS_PQ;
                    reactiveLimit[i].limitReached = RL_MAX_REACHED;
                    limitReach = true;
                }
            }
            if (reactiveLimit[i].minLimitType == RL_LIMITED) {
                if (power[i].imag() - loadPower[i].imag() < reactiveLimit[i].minLimit) {
                    power[i] = std::complex<double>(power[i].real(), reactiveLimit[i].minLimit + loadPower[i].imag());
                    busType[i] = BUS_PQ;
                    reactiveLimit[i].limitReached = RL_MIN_REACHED;
                    limitReach = true;
                }
            }
        }
    }
    return limitReach;
}

◆ GaussSeidel()

double PowerFlow::GaussSeidel	(	std::vector< BusType >	busType,
		std::vector< std::complex< double > > &	voltage,
		std::vector< std::complex< double > >	oldVoltage,
		std::vector< std::complex< double > > &	power,
		double	accFactor
	)

protected

Definition at line 657 of file PowerFlow.cpp.

{
    double error = 0.0;
 
    for (int i = 0; i < m_numberOfBuses; i++) {
        if (busType[i] == BUS_PQ) {
            std::complex<double> yeSum(0.0, 0.0);
            for (int k = 0; k < m_numberOfBuses; k++) {
                if (i != k) {
                    // Sum { Y[i,k] * E[k] } | k = 1->n; k diff i
                    yeSum += m_yBus[i][k] * voltage[k];
                }
            }
 
            // E[i] = (1/Y[i,i])*((P[i]-jQ[i])/E*[i] - Sum { Y[i,k] * E[k] (k diff i) })
            std::complex<double> newVolt = (1.0 / m_yBus[i][i]) * (std::conj(power[i]) / std::conj(voltage[i]) - yeSum);
 
            // Apply the acceleration factor.
            newVolt = std::complex<double>(accFactor * (newVolt.real() - voltage[i].real()) + voltage[i].real(),
                accFactor * (newVolt.imag() - voltage[i].imag()) + voltage[i].imag());
 
            voltage[i] = newVolt;
        }
        if (busType[i] == BUS_PV) {
            std::complex<double> yeSum(0.0, 0.0);
            for (int k = 0; k < m_numberOfBuses; k++) {
                if (i != k) {
                    // Sum { Y[i,k] * E[k] } | k = 1->n; k diff i
                    yeSum += m_yBus[i][k] * voltage[k];
                }
            }
            std::complex<double> yeSumT = yeSum + (m_yBus[i][i] * voltage[i]);
 
            // Q[i] = - Im( E*[i] * Sum { Y[i,k] * E[k] } )
            std::complex<double> qCalc = std::conj(voltage[i]) * yeSumT;
            power[i] = std::complex<double>(power[i].real(), -qCalc.imag());
 
            // E[i] = (1/Y[i,i])*((P[i]-jQ[i])/E*[i] - Sum { Y[i,k] * E[k] (k diff i) })
            std::complex<double> newVolt = (1.0 / m_yBus[i][i]) * (std::conj(power[i]) / std::conj(voltage[i]) - yeSum);
 
            // Apply the acceleration factor.
            newVolt = std::complex<double>(accFactor * (newVolt.real() - voltage[i].real()) + voltage[i].real(),
                accFactor * (newVolt.imag() - voltage[i].imag()) + voltage[i].imag());
 
            // Keep the same voltage magnitude.
            voltage[i] = std::complex<double>(std::abs(voltage[i]) * std::cos(std::arg(newVolt)),
                std::abs(voltage[i]) * std::sin(std::arg(newVolt)));
        }
 
        double busError = std::max(std::abs(voltage[i].real() - oldVoltage[i].real()),
            std::abs(voltage[i].imag() - oldVoltage[i].imag()));
 
        if (busError > error) error = busError;
    }
    return error;
}

◆ GetErrorMessage()

virtual wxString PowerFlow::GetErrorMessage ( )

inlinevirtual

Definition at line 67 of file PowerFlow.h.

67{ return m_errorMsg; }

◆ GetIterations()

virtual int PowerFlow::GetIterations ( )

inlinevirtual

Definition at line 68 of file PowerFlow.h.

68{ return m_iterations; }

◆ GetNumPVPQ()

void PowerFlow::GetNumPVPQ	(	std::vector< BusType >	busType,
		int &	numPQ,
		int &	numPV
	)

protected

Definition at line 645 of file PowerFlow.cpp.

{
    numPQ = 0;
    numPV = 0;
    for (auto it = busType.begin(), itEnd = busType.end(); it != itEnd; ++it) {
        if (*it == BUS_PQ)
            numPQ++;
        else if (*it == BUS_PV)
            numPV++;
    }
}

◆ HasInvalidValue()

bool PowerFlow::HasInvalidValue ( const std::vector< std::complex< double > > & voltage )

protected

Definition at line 338 of file PowerFlow.cpp.

{
    for (size_t i = 0; i < value.size(); i++)
    {
        if (!std::isfinite(value[i].real()) ||
            !std::isfinite(value[i].imag()))
        {
            return true;
        }
    }
    return false;
}

◆ InitPowerFlow()

bool PowerFlow::InitPowerFlow	(	std::vector< BusType > &	busType,
		std::vector< std::complex< double > > &	voltage,
		std::vector< std::complex< double > > &	power,
		std::vector< std::complex< double > > &	loadPower,
		std::vector< ReactiveLimits > &	reactiveLimit,
		double	systemPowerBase = `100e6`,
		double	initAngle = `0.0`
	)

virtual

Definition at line 23 of file PowerFlow.cpp.

{
    double radInitAngle = wxDegToRad(initAngle);
 
    // Calculate EMT Elements admittance to add to the Ybus.
    if (!CalculateEMTElementsAdmittance(systemPowerBase, m_errorMsg)) return false;
 
    // Calculate the Ybus.
    if (!GetYBus(m_yBus, systemPowerBase)) {
        m_errorMsg = _("No buses found on the system.");
        return false;
    }
 
    // Calculate EMT elements power for 1.0 p.u. voltage
    if (!CalculateEMTElementsPower(systemPowerBase, m_errorMsg, false)) return false;
 
    // Number of buses in the system.
    //m_numberOfBuses = static_cast<int>(m_busList.size());
    m_numberOfBuses = static_cast<int>(m_yBus.size());
 
    busType.clear();
    voltage.clear();
    power.clear();
    loadPower.clear();
    reactiveLimit.clear();
 
    reactiveLimit.resize(m_numberOfBuses);
 
    int busNumber = 0;
    Bus* slackBus = nullptr;
    for (auto itb = m_busList.begin(); itb != m_busList.end(); itb++) {
        Bus* bus = *itb;
        BusElectricalData data = bus->GetElectricalData();
        if (data.isConnected) {
            // Fill the bus type
            if (data.slackBus) {
                busType.push_back(BUS_SLACK);
                slackBus = bus;
            }
            // If the bus have controlled voltage, check if at least one synchronous machine is connected, then set the
            // bus type.
            else if (data.isVoltageControlled) {
                bool hasSyncMachine = false;
                // Synchronous generator
                for (auto itsg = m_syncGeneratorList.begin(); itsg != m_syncGeneratorList.end(); itsg++) {
                    SyncGenerator* syncGenerator = *itsg;
                    if (bus == syncGenerator->GetParentList()[0] && syncGenerator->IsOnline()) hasSyncMachine = true;
                }
                // Synchronous motor
                for (auto itsm = m_syncMotorList.begin(); itsm != m_syncMotorList.end(); itsm++) {
                    SyncMotor* syncMotor = *itsm;
                    if (bus == syncMotor->GetParentList()[0] && syncMotor->IsOnline()) hasSyncMachine = true;
                }
                if (hasSyncMachine)
                    busType.push_back(BUS_PV);
                else
                    busType.push_back(BUS_PQ);
            }
            else
                busType.push_back(BUS_PQ);
 
            // Fill the voltages array
            double v = 1.0;
            double t = 0.0;
            if (data.slackBus) {
                v = data.controlledVoltage;
                t = radInitAngle;
            }
            else if (busType[busNumber] == BUS_PV) {
                v = data.controlledVoltage;
                t = std::arg(data.voltage);
            }
            else {
                v = std::abs(data.voltage);
                if (v <= 0.1) v = 1.0; // Avoid very low voltage magnitude that can cause convergence problems.
                t = std::arg(data.voltage);
            }
            voltage.push_back(std::complex<double>(v * std::cos(t), v * std::sin(t)));
 
            //if (data.isVoltageControlled && busType[busNumber] != BUS_PQ) {
            //  voltage.push_back(std::complex<double>(data.controlledVoltage * std::cos(radInitAngle),
            //      data.controlledVoltage * std::sin(radInitAngle)));
            //}
            //else {
            //  voltage.push_back(std::complex<double>(std::cos(radInitAngle), std::sin(radInitAngle)));
            //}
 
            // Fill the power array
            power.push_back(std::complex<double>(0.0, 0.0));  // Initial value
            loadPower.push_back(std::complex<double>(0.0, 0.0));
 
            // Synchronous generator
            for (auto itsg = m_syncGeneratorList.begin(); itsg != m_syncGeneratorList.end(); itsg++) {
                SyncGenerator* syncGenerator = *itsg;
                if (syncGenerator->IsOnline()) {
                    if (bus == syncGenerator->GetParentList()[0]) {
                        SyncGeneratorElectricalData childData = syncGenerator->GetPUElectricalData(systemPowerBase);
                        power[busNumber] += std::complex<double>(childData.activePower, childData.reactivePower);
 
                        if (busType[busNumber] == BUS_PV) {
                            if (childData.haveMaxReactive && reactiveLimit[busNumber].maxLimitType != RL_UNLIMITED_SOURCE) {
                                reactiveLimit[busNumber].maxLimitType = RL_LIMITED;
                                reactiveLimit[busNumber].maxLimit += childData.maxReactive;
                            }
                            else if (!childData.haveMaxReactive)
                                reactiveLimit[busNumber].maxLimitType = RL_UNLIMITED_SOURCE;
 
                            if (childData.haveMinReactive && reactiveLimit[busNumber].minLimitType != RL_UNLIMITED_SOURCE) {
                                reactiveLimit[busNumber].minLimitType = RL_LIMITED;
                                reactiveLimit[busNumber].minLimit += childData.minReactive;
                            }
                            else if (!childData.haveMinReactive)
                                reactiveLimit[busNumber].minLimitType = RL_UNLIMITED_SOURCE;
                        }
                    }
                }
            }
            // Synchronous motor
            for (auto itsm = m_syncMotorList.begin(); itsm != m_syncMotorList.end(); itsm++) {
                SyncMotor* syncMotor = *itsm;
                if (syncMotor->IsOnline()) {
                    if (bus == syncMotor->GetParentList()[0]) {
                        SyncMotorElectricalData childData = syncMotor->GetPUElectricalData(systemPowerBase);
                        power[busNumber] += std::complex<double>(-childData.activePower, childData.reactivePower);
                        loadPower[busNumber] += std::complex<double>(-childData.activePower, 0.0);
 
                        if (busType[busNumber] == BUS_PV) {
                            if (childData.haveMaxReactive && reactiveLimit[busNumber].maxLimitType != RL_UNLIMITED_SOURCE) {
                                reactiveLimit[busNumber].maxLimitType = RL_LIMITED;
                                reactiveLimit[busNumber].maxLimit += childData.maxReactive;
                            }
                            else if (!childData.haveMaxReactive)
                                reactiveLimit[busNumber].maxLimitType = RL_UNLIMITED_SOURCE;
 
                            if (childData.haveMinReactive && reactiveLimit[busNumber].minLimitType != RL_UNLIMITED_SOURCE) {
                                reactiveLimit[busNumber].minLimitType = RL_LIMITED;
                                reactiveLimit[busNumber].minLimit += childData.minReactive;
                            }
                            else if (!childData.haveMinReactive)
                                reactiveLimit[busNumber].minLimitType = RL_UNLIMITED_SOURCE;
                        }
                    }
                }
            }
            // Load
            for (auto itl = m_loadList.begin(); itl != m_loadList.end(); itl++) {
                Load* load = *itl;
                if (load->IsOnline()) {
                    if (bus == load->GetParentList()[0]) {
                        LoadElectricalData childData = load->GetPUElectricalData(systemPowerBase);
                        if (childData.loadType == CONST_POWER) {
                            power[busNumber] += std::complex<double>(-childData.activePower, -childData.reactivePower);
                            loadPower[busNumber] += std::complex<double>(-childData.activePower, -childData.reactivePower);
                        }
                    }
                }
            }
 
            // Induction motor
            for (auto itim = m_indMotorList.begin(); itim != m_indMotorList.end(); itim++) {
                IndMotor* indMotor = *itim;
                if (indMotor->IsOnline()) {
                    if (bus == indMotor->GetParentList()[0]) {
                        IndMotorElectricalData childData = indMotor->GetPUElectricalData(systemPowerBase);
                        double reactivePower = childData.reactivePower;
 
                        if (childData.calcQInPowerFlow) {
                            indMotor->InitPowerFlowMotor(systemPowerBase, data.number);
                            if (!indMotor->CalculateReactivePower(std::abs(voltage[childData.busNum]))) {
                                m_errorMsg = _("It was not possible to solve the induction motors.");
                                return false;
                            }
                            reactivePower = indMotor->GetElectricalData().qValue;
                        }
 
                        power[busNumber] += std::complex<double>(-childData.activePower, -reactivePower);
                        loadPower[busNumber] += std::complex<double>(-childData.activePower, -reactivePower);
                    }
                }
            }
 
            // EMTElements
            for (EMTElement* emtElement : m_emtElementList) {
                if (emtElement->IsOnline() && !emtElement->GetParentList().empty()) {
                    if (bus == emtElement->GetParentList()[0]) {
                        EMTElementData childData = emtElement->GetEMTElementData();
                        power[busNumber] -= childData.power;
                        loadPower[busNumber] -= childData.power;
                    }
                }
            }
 
            busNumber++;
        }
    }
 
    // Check if have slack bus and if have generation on the slack bus
    bool haveSlackBus = false;
    bool slackBusHaveGeneration = false;
    for (unsigned int i = 0; i < busType.size(); i++) {
        if (busType[i] == BUS_SLACK) {
            for (auto itsg = m_syncGeneratorList.begin(); itsg != m_syncGeneratorList.end(); itsg++) {
                SyncGenerator* syncGenerator = *itsg;
                if (syncGenerator->IsOnline() && slackBus == syncGenerator->GetParentList()[0]) slackBusHaveGeneration = true;
            }
            haveSlackBus = true;
        }
    }
    if (!haveSlackBus) {
        m_errorMsg = _("There is no slack bus on the system.");
        return false;
    }
    if (!slackBusHaveGeneration) {
        m_errorMsg = _("The slack bus don't have generation.");
        return false;
    }
 
    m_tapAdjustmentsCount = 0;
    return true;
}

◆ NewtonRaphson()

void PowerFlow::NewtonRaphson	(	std::vector< BusType >	busType,
		std::vector< std::complex< double > > &	voltage,
		std::vector< std::complex< double > >	power,
		int	numPV,
		int	numPQ,
		std::vector< double >	dPdQ,
		double	inertia
	)

protected

Definition at line 718 of file PowerFlow.cpp.

{
    // Jacobian matrix
    std::vector<std::vector<double> > jacobMatrix = CalculateJacobianMatrix(voltage, power, busType, numPV, numPQ);
 
    // Apply inertia
    for (unsigned int i = 0; i < dPdQ.size(); ++i) { dPdQ[i] = inertia * dPdQ[i]; }
 
    // Calculate DeltaTheta DeltaV array
    std::vector<double> dTdV = GaussianElimination(jacobMatrix, dPdQ);
 
    // Update voltage array
    int indexDT = 0;
    int indexDV = numPQ + numPV;
    for (int i = 0; i < m_numberOfBuses; i++) {
        if (busType[i] != BUS_SLACK) {
            if (busType[i] == BUS_PV) {
                double newV = std::abs(voltage[i]);
                double newT = std::arg(voltage[i]) + dTdV[indexDT];
                voltage[i] = std::complex<double>(newV * std::cos(newT), newV * std::sin(newT));
                indexDT++;
            }
            else {
                //double newV = std::abs(voltage[i]) * (1.0 + dTdV[indexDV]);
                double newV = std::abs(voltage[i]) + dTdV[indexDV];
                double newT = std::arg(voltage[i]) + dTdV[indexDT];
                voltage[i] = std::complex<double>(newV * std::cos(newT), newV * std::sin(newT));
                indexDV++;
                indexDT++;
            }
        }
    }
}

◆ ResetVoltages()

void PowerFlow::ResetVoltages ( )

virtual

Definition at line 619 of file PowerFlow.cpp.

{
    for (auto* bus : m_busList) {
        BusElectricalData data = bus->GetElectricalData();
        if (bus->IsOnline()) {
            data.voltage = std::complex<double>(1.0, 0.0);
            if (data.isVoltageControlled) {
                data.voltage = std::complex<double>(data.controlledVoltage, 0.0);
            }
        }
        else
            data.voltage = std::complex<double>(0.0, 0.0);
        data.harmonicOrder.clear();
        data.harmonicVoltage.clear();
        data.thd = 0.0;
        bus->SetElectricalData(data);
    }
    for (auto* transf : m_transformerList) {
        auto data = transf->GetElectricalData();
        if (data.hasTapChanger && data.nominalTurnsRatio > 0.0) {
            data.turnsRatio = data.nominalTurnsRatio;
            transf->SetElectricaData(data);
        }
    }
}

◆ RunGaussNewton()

bool PowerFlow::RunGaussNewton	(	double	systemPowerBase = `100e6`,
		int	maxIteration = `5000`,
		double	error = `1e-6`,
		double	initAngle = `0.0`,
		double	accFactor = `1.0`,
		double	gaussTol = `1e-2`,
		double	inertia = `1.0`
	)

virtual

Definition at line 479 of file PowerFlow.cpp.

{
    std::vector<BusType> busType;                  // Bus type
    std::vector<std::complex<double> > voltage;    // Voltage of buses
    std::vector<std::complex<double> > power;      // Injected power
    std::vector<std::complex<double> > loadPower;  // Only the load power
    std::vector<ReactiveLimits> reactiveLimit;     // Limit of reactive power on PV buses
 
    if (!InitPowerFlow(busType, voltage, power, loadPower, reactiveLimit, systemPowerBase, initAngle)) return false;
 
    // Gauss-Seidel method
    std::vector<std::complex<double> > oldVoltage;  // Old voltage array.
    oldVoltage.resize(voltage.size());
 
    auto oldBusType = busType;
 
    int iteration = 0;  // Current itaration number.
 
    while (true) {
        // Reach the max number of iterations.
        if (iteration >= maxIteration) {
            m_errorMsg = _("The maximum number of iterations was reached.");
            return false;
        }
 
        // Calculate induction motor reactive power
        if (!CalculateMotorsReactivePower(voltage, power)) {
            m_errorMsg = _("It was not possible to solve the induction motors.");
            return false;
        }
 
        // Update the old voltage array to current iteration values.
        for (int i = 0; i < m_numberOfBuses; i++) oldVoltage[i] = voltage[i];
 
        double iterationError = GaussSeidel(busType, voltage, oldVoltage, power, accFactor);
 
        if (iterationError < gaussTol) break;
 
        iteration++;
    }
 
    // Newton-Raphson method
    int numPQ = 0;  // Number of PQ buses
    int numPV = 0;  // Number of PV buses
    GetNumPVPQ(busType, numPQ, numPV);
 
    // DeltaP and DeltaQ array
    std::vector<double> dPdQ;
    dPdQ.resize(numPV + 2 * numPQ, 0.0);
 
    while (true) {
        // Reach the max number of iterations.
        if (iteration >= maxIteration) {
            m_errorMsg = _("The maximum number of iterations was reached.");
            return false;
        }
 
        // Calculate induction motor reactive power
        if (!CalculateMotorsReactivePower(voltage, power)) {
            m_errorMsg = _("It was not possible to solve the induction motors.");
            return false;
        }
 
        // Calculate dPdQ array
 
        // Fill it with zeros
        std::fill(dPdQ.begin(), dPdQ.end(), 0.0);
 
        int indexDP = 0;
        int indexDQ = numPQ + numPV;
        for (int i = 0; i < m_numberOfBuses; i++) {
            if (busType[i] != BUS_SLACK) {
                for (int j = 0; j < m_numberOfBuses; j++) {
                    // PV ou PQ bus
                    std::complex<double> sInj = std::conj(m_yBus[i][j]) * voltage[i] * std::conj(voltage[j]);
                    dPdQ[indexDP] += sInj.real();
 
                    // PQ bus
                    if (busType[i] == BUS_PQ) dPdQ[indexDQ] += sInj.imag();
                }
 
                // PQ or PV bus
                dPdQ[indexDP] = power[i].real() - dPdQ[indexDP];
                indexDP++;
 
                // PQ bus
                if (busType[i] == BUS_PQ) {
                    dPdQ[indexDQ] = power[i].imag() - dPdQ[indexDQ];
                    indexDQ++;
                }
            }
        }
 
        // Calculate the iteration error
        double iterationError = 0.0;
        for (unsigned int i = 0; i < dPdQ.size(); ++i) {
            if (iterationError < std::abs(dPdQ[i])) iterationError = std::abs(dPdQ[i]);
        }
 
        // Check if the iteration error is less than tolerance, also check if any reactive limit was reached.
        // If any reactive limit was reached, change the bus type.
        if (iterationError < error) {
            double emtPowerError = CalculateEMTPowerError(voltage, power, systemPowerBase, m_errorMsg);
 
            bool qLimitReached = CheckReactiveLimits(busType, reactiveLimit, power, loadPower);
            bool tapAdjusted = AdjustTapChangers(voltage, systemPowerBase);
 
            if (!qLimitReached && !tapAdjusted && emtPowerError < error)
                break;
            else {
                GetNumPVPQ(busType, numPQ, numPV);
                dPdQ.clear();
                dPdQ.resize(numPV + 2 * numPQ, 0.0);
            }
        }
 
        NewtonRaphson(busType, voltage, power, numPV, numPQ, dPdQ, inertia);
 
        iteration++;
    }
    m_iterations = iteration;
 
    // Adjust the power array.
    for (int i = 0; i < m_numberOfBuses; i++) {
        std::complex<double> sBus = std::complex<double>(0.0, 0.0);
        for (int j = 0; j < m_numberOfBuses; j++) sBus += voltage[i] * std::conj(voltage[j]) * std::conj(m_yBus[i][j]);
        power[i] = sBus;
    }
 
    UpdateElementsPowerFlow(voltage, power, oldBusType, reactiveLimit, systemPowerBase);
 
    return true;
}

◆ RunGaussSeidel()

bool PowerFlow::RunGaussSeidel	(	double	systemPowerBase = `100e6`,
		int	maxIteration = `5000`,
		double	error = `1e-6`,
		double	initAngle = `0.0`,
		double	accFactor = `1.0`
	)

virtual

Definition at line 250 of file PowerFlow.cpp.

{
    std::vector<BusType> busType;                  // Bus type
    std::vector<std::complex<double> > voltage;    // Voltage of buses
    std::vector<std::complex<double> > power;      // Injected power
    std::vector<std::complex<double> > loadPower;  // Only the load power
    std::vector<ReactiveLimits> reactiveLimit;     // Limit of reactive power on PV buses
 
    if (!InitPowerFlow(busType, voltage, power, loadPower, reactiveLimit, systemPowerBase, initAngle)) return false;
 
    // Gauss-Seidel method
    std::vector<std::complex<double> > oldVoltage;  // Old voltage array.
    oldVoltage.resize(voltage.size());
 
    auto oldBusType = busType;
 
    int iteration = 0;  // Current itaration number.
    double emtPowerError = 1e3; // EMT Elements power error.
 
    while (true) {
        // Reach the max number of iterations.
        if (iteration >= maxIteration) {
            m_errorMsg = _("The maximum number of iterations was reached.");
            return false;
        }
 
        // Calculate induction motor reactive power
        if (!CalculateMotorsReactivePower(voltage, power)) {
            m_errorMsg = _("It was not possible to solve the induction motors.");
            return false;
        }
 
        // Update the old voltage array to current iteration values.
        for (int i = 0; i < m_numberOfBuses; i++) oldVoltage[i] = voltage[i];
 
        double iterationError = GaussSeidel(busType, voltage, oldVoltage, power, accFactor);
 
        if (HasInvalidValue(voltage)) {
            m_errorMsg = _("The power flow solution has invalid voltage values.");
            ResetVoltages();
            return false;
        }
        if (HasInvalidValue(power)) {
            m_errorMsg = _("The power flow solution has invalid power values.");
            ResetVoltages();
            return false;
        }
 
        if (iterationError < error) {
            // Calculate power error in EMT elements.
            if (!m_emtElementList.empty()) {
                double oldError = emtPowerError;
                emtPowerError = CalculateEMTPowerError(voltage, power, systemPowerBase, m_errorMsg);
                //wxMessageBox(wxString::Format(wxT("It %d, EMT Power Error: %e (base = %e)"), iteration, emtPowerError, error));
                if (abs(emtPowerError - oldError) < 1e-12) { // Without change in error the convergence is impossible
                    m_errorMsg = _("Impossible to reach a convergence with the current Electromagnetic Transient Elements.");
                    return false;
                }
            }
            else emtPowerError = 0.0;
 
            bool qLimitReached = CheckReactiveLimits(busType, reactiveLimit, power, loadPower);
            bool tapAdjusted = AdjustTapChangers(voltage, systemPowerBase);
 
            if (!qLimitReached && !tapAdjusted && emtPowerError < error) break;
        }
 
        iteration++;
    }
    m_iterations = iteration;
 
    // Adjust the power array.
    for (int i = 0; i < m_numberOfBuses; i++) {
        std::complex<double> sBus = std::complex<double>(0.0, 0.0);
        for (int j = 0; j < m_numberOfBuses; j++) sBus += voltage[i] * std::conj(voltage[j]) * std::conj(m_yBus[i][j]);
        power[i] = sBus;
    }
 
 
    UpdateElementsPowerFlow(voltage, power, oldBusType, reactiveLimit, systemPowerBase);
 
    return true;
}

◆ RunNewtonRaphson()

bool PowerFlow::RunNewtonRaphson	(	double	systemPowerBase = `100e6`,
		int	maxIteration = `5000`,
		double	error = `1e-6`,
		double	initAngle = `0.0`,
		double	inertia = `1.0`
	)

virtual

Definition at line 351 of file PowerFlow.cpp.

{
    std::vector<BusType> busType;                  // Bus type
    std::vector<std::complex<double> > voltage;    // Voltage of buses
    std::vector<std::complex<double> > power;      // Injected power
    std::vector<std::complex<double> > loadPower;  // Only the load power
    std::vector<ReactiveLimits> reactiveLimit;     // Limit of reactive power on PV buses
 
    if (!InitPowerFlow(busType, voltage, power, loadPower, reactiveLimit, systemPowerBase, initAngle)) return false;
    auto oldBusType = busType;
 
    // Newton-Raphson method
    int numPQ = 0;  // Number of PQ buses
    int numPV = 0;  // Number of PV buses
    GetNumPVPQ(busType, numPQ, numPV);
 
    // DeltaP and DeltaQ array
    std::vector<double> dPdQ;
    dPdQ.resize(numPV + 2 * numPQ, 0.0);
 
    int iteration = 0;  // Current iteration number.
    while (true) {
        // Reach the max number of iterations.
        if (iteration >= maxIteration) {
            m_errorMsg = _("The maximum number of iterations was reached.");
            return false;
        }
 
        // Calculate induction motor reactive power
        if (!CalculateMotorsReactivePower(voltage, power)) {
            m_errorMsg = _("It was not possible to solve the induction motors.");
            return false;
        }
 
        // Calculate dPdQ array
 
        // Fill it with zeros
        std::fill(dPdQ.begin(), dPdQ.end(), 0.0);
 
        int indexDP = 0;
        int indexDQ = numPQ + numPV;
        for (int i = 0; i < m_numberOfBuses; i++) {
            if (busType[i] != BUS_SLACK) {
                for (int j = 0; j < m_numberOfBuses; j++) {
                    // PV ou PQ bus
                    std::complex<double> sInj = std::conj(m_yBus[i][j]) * voltage[i] * std::conj(voltage[j]);
                    dPdQ[indexDP] += sInj.real();
 
                    // PQ bus
                    if (busType[i] == BUS_PQ) dPdQ[indexDQ] += sInj.imag();
                }
 
                // PQ or PV bus
                dPdQ[indexDP] = power[i].real() - dPdQ[indexDP];
                indexDP++;
 
                // PQ bus
                if (busType[i] == BUS_PQ) {
                    dPdQ[indexDQ] = power[i].imag() - dPdQ[indexDQ];
                    indexDQ++;
                }
            }
        }
 
        // Calculate the iteration error
        double iterationError = 0.0;
        for (unsigned int i = 0; i < dPdQ.size(); ++i) {
            if (iterationError < std::abs(dPdQ[i])) iterationError = std::abs(dPdQ[i]);
        }
 
        // Check if the iteration error is less than tolerance, also check if any reactive limit was reached.
        // If any reactive limit was reached, change the bus type.
        if (iterationError < error) {
            for (int i = 0; i < m_numberOfBuses; i++) {
                std::complex<double> sBus(0.0, 0.0);
                for (int j = 0; j < m_numberOfBuses; j++)
                    sBus += voltage[i] * std::conj(voltage[j]) * std::conj(m_yBus[i][j]);
                power[i] = sBus;
            }
 
            double emtPowerError = CalculateEMTPowerError(voltage, power, systemPowerBase, m_errorMsg);
 
            bool qLimitReached = CheckReactiveLimits(busType, reactiveLimit, power, loadPower);
            bool tapAdjusted = AdjustTapChangers(voltage, systemPowerBase);
 
            if (!qLimitReached && !tapAdjusted && emtPowerError < error)
                break;
            else {
                GetNumPVPQ(busType, numPQ, numPV);
                dPdQ.assign(numPV + 2 * numPQ, 0.0);
            }
        }
 
        NewtonRaphson(busType, voltage, power, numPV, numPQ, dPdQ, inertia);
 
        if (HasInvalidValue(voltage)) {
            m_errorMsg = _("The power flow solution has invalid voltage values.");
            ResetVoltages();
            return false;
        }
        if (HasInvalidValue(power)) {
            m_errorMsg = _("The power flow solution has invalid power values.");
            ResetVoltages();
            return false;
        }
 
        iteration++;
    }
    m_iterations = iteration;
 
 
 
    // Adjust the power array.
    for (int i = 0; i < m_numberOfBuses; i++) {
        std::complex<double> sBus = std::complex<double>(0.0, 0.0);
        for (int j = 0; j < m_numberOfBuses; j++) sBus += voltage[i] * std::conj(voltage[j]) * std::conj(m_yBus[i][j]);
        power[i] = sBus;
    }
 
    UpdateElementsPowerFlow(voltage, power, oldBusType, reactiveLimit, systemPowerBase);
 
    return true;
}

Member Data Documentation

◆ m_errorMsg

wxString PowerFlow::m_errorMsg = ""

protected

Definition at line 111 of file PowerFlow.h.

◆ m_iterations

int PowerFlow::m_iterations = 0

protected

Definition at line 113 of file PowerFlow.h.

◆ m_numberOfBuses

int PowerFlow::m_numberOfBuses = 0

protected

Definition at line 112 of file PowerFlow.h.

◆ m_tapAdjustmentsCount

int PowerFlow::m_tapAdjustmentsCount = 0

protected

Definition at line 114 of file PowerFlow.h.

◆ m_yBus

std::vector<std::vector<std::complex<double> > > PowerFlow::m_yBus

protected

Definition at line 110 of file PowerFlow.h.

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

Project/simulation/PowerFlow.h
Project/simulation/PowerFlow.cpp

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ PowerFlow() [1/2]

◆ PowerFlow() [2/2]

◆ ~PowerFlow()

Member Function Documentation

◆ AdjustTapChangers()

◆ CalculateJacobianMatrix()

◆ CalculateMotorsReactivePower()

◆ CheckReactiveLimits()

◆ GaussSeidel()

◆ GetErrorMessage()

◆ GetIterations()

◆ GetNumPVPQ()

◆ HasInvalidValue()

◆ InitPowerFlow()

◆ NewtonRaphson()

◆ ResetVoltages()

◆ RunGaussNewton()

◆ RunGaussSeidel()

◆ RunNewtonRaphson()

Member Data Documentation

◆ m_errorMsg

◆ m_iterations

◆ m_numberOfBuses

◆ m_tapAdjustmentsCount

◆ m_yBus