PowerMismatch.H File Reference

Power mismatch computation for Newton-Raphson power flow analysis. More...

#include <Eigen/Dense>
#include <vector>

Include dependency graph for PowerMismatch.H:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
Eigen::VectorXd	powerMismatch (const Eigen::VectorXd &Ps, const Eigen::VectorXd &Qs, const Eigen::MatrixXd &G, const Eigen::MatrixXd &B, const Eigen::VectorXd &V, const Eigen::VectorXd &delta, int n_bus, const std::vector< int > &pq_bus_id, Eigen::VectorXd &P, Eigen::VectorXd &Q)
	Computes the power mismatch vector for use in Newton-Raphson iterations.

Detailed Description

Power mismatch computation for Newton-Raphson power flow analysis.

Computes the active and reactive power at each bus and returns the mismatch vector $$ [\Delta P; \Delta Q] $$ used in iterative solvers.

Active power: $$ P_i = \sum_{j=1}^{n} |V_i||V_j|(G_{ij}\cos(\delta_i - \delta_j) + B_{ij}\sin(\delta_i - \delta_j)) $$

Reactive power: $$ Q_i = \sum_{j=1}^{n} |V_i||V_j|(G_{ij}\sin(\delta_i - \delta_j) - B_{ij}\cos(\delta_i - \delta_j)) $$

Definition in file PowerMismatch.H.

Function Documentation

powerMismatch()

Eigen::VectorXd powerMismatch	(	const Eigen::VectorXd &	Ps,
		const Eigen::VectorXd &	Qs,
		const Eigen::MatrixXd &	G,
		const Eigen::MatrixXd &	B,
		const Eigen::VectorXd &	V,
		const Eigen::VectorXd &	delta,
		int	n_bus,
		const std::vector< int > &	pq_bus_id,
		Eigen::VectorXd &	P,
		Eigen::VectorXd &	Q
	)

Computes the power mismatch vector for use in Newton-Raphson iterations.

The mismatch vector is composed of:

• $$ \Delta P $$ for all non-slack buses (buses 1..N-1, 0-indexed)
• $$ \Delta Q $$ for PQ buses only

Parameters

Ps	Scheduled active power injection (Pg - Pl) at each bus [p.u.].
Qs	Scheduled reactive power injection (Qg - Ql) at each bus [p.u.].
G	Conductance matrix (real part of $$ Y_{bus} $$).
B	Susceptance matrix (imaginary part of $$ Y_{bus} $$).
V	Voltage magnitudes at each bus [p.u.].
delta	Voltage angles at each bus [rad].
n_bus	Total number of buses.
pq_bus_id	0-based indices of PQ buses.
P	(output) Computed active power at each bus [p.u.].
Q	(output) Computed reactive power at each bus [p.u.].

Returns

Mismatch vector $$ [\Delta P_{2..N}; \Delta Q_{PQ}] $$.

Definition at line 30 of file PowerMismatch.C.

  {
    P = Eigen::VectorXd::Zero(n_bus);
    Q = Eigen::VectorXd::Zero(n_bus);
 
    // Compute P(i) and Q(i) at each bus
    for (int i = 0; i < n_bus; ++i) {
        for (int j = 0; j < n_bus; ++j) {
            double dij = delta(i) - delta(j);
            P(i) += V(i) * V(j) * (G(i, j) * std::cos(dij) + B(i, j) * std::sin(dij));
            Q(i) += V(i) * V(j) * (G(i, j) * std::sin(dij) - B(i, j) * std::cos(dij));
        }
    }
 
    // delta_P for all non-slack buses (bus index 1..N-1, 0-based)
    Eigen::VectorXd delta_P = Ps - P;
    Eigen::VectorXd delta_Q = Qs - Q;
 
    // Only keep delta_Q for PQ buses
    int n_pq = static_cast<int>(pq_bus_id.size());
    Eigen::VectorXd delta_Q_pq(n_pq);
    for (int k = 0; k < n_pq; ++k) {
        delta_Q_pq(k) = delta_Q(pq_bus_id[k]);
    }
 
    // Mismatch = [delta_P(2:end); delta_Q(pq)]
    // In 0-based: delta_P(1..N-1)
    Eigen::VectorXd mismatch(n_bus - 1 + n_pq);
    mismatch.head(n_bus - 1) = delta_P.tail(n_bus - 1);
    mismatch.tail(n_pq) = delta_Q_pq;
 
    return mismatch;
}

Here is the caller graph for this function: