PowerMismatch Class Reference

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

#include <PowerMismatch.H>

Static Public Member Functions
static Eigen::VectorXd	compute (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

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

Definition at line 45 of file PowerMismatch.H.

Member Function Documentation

compute()

Eigen::VectorXd PowerMismatch::compute ( 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  )

static

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:

---

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

• src/core/solvers/PowerMismatch.H
• src/core/solvers/PowerMismatch.C