NewtonRaphson Class Reference

Newton-Raphson power flow solver implementing the ISolver interface. More...

#include <NewtonRaphson.H>

Inheritance diagram for NewtonRaphson:

Collaboration diagram for NewtonRaphson:

Public Member Functions
bool	solve (SolverContext &ctx) override
	Run the Newton-Raphson solver using the given context.
const char *	name () const override
	Human-readable solver name (e.g.
Public Member Functions inherited from ISolver
virtual	~ISolver ()=default

Static Public Member Functions
static bool	run (const Eigen::MatrixXd &G, const Eigen::MatrixXd &B, const Eigen::VectorXd &Ps, const Eigen::VectorXd &Qs, Eigen::VectorXd &V, Eigen::VectorXd &delta, int n_bus, int n_pq, const std::vector< int > &pq_bus_id, int maxIter=1024, double tolerance=1E-8, std::vector< std::pair< int, double > > *iterHistory=nullptr, ISolverObserver *observer=nullptr)
	Solves the power flow equations using the Newton-Raphson iterative method.

Detailed Description

Newton-Raphson power flow solver implementing the ISolver interface.

Takes G, B matrices, scheduled power, initial voltage/angle guesses, and bus classification. It modifies V and delta in-place.

Definition at line 96 of file NewtonRaphson.H.

Member Function Documentation

name()

const char * NewtonRaphson::name ( ) const

inlineoverridevirtual

Human-readable solver name (e.g.

for logging/output).

Implements ISolver.

Definition at line 105 of file NewtonRaphson.H.

{ return "Newton-Raphson"; }

run()

bool NewtonRaphson::run ( const Eigen::MatrixXd &  G, const Eigen::MatrixXd &  B, const Eigen::VectorXd &  Ps, const Eigen::VectorXd &  Qs, Eigen::VectorXd &  V, Eigen::VectorXd &  delta, int  n_bus, int  n_pq, const std::vector< int > &  pq_bus_id, int  maxIter = 1024, double  tolerance = 1E-8, std::vector< std::pair< int, double > > *  iterHistory = nullptr, ISolverObserver *  observer = nullptr  )

static

Solves the power flow equations using the Newton-Raphson iterative method.

Parameters

G	Conductance matrix (real part of $$ Y_{bus} $$).
B	Susceptance matrix (imaginary part of $$ Y_{bus} $$).
Ps	Scheduled active power injections (Pg - Pl) [p.u.].
Qs	Scheduled reactive power injections (Qg - Ql) [p.u.].
V	(in/out) Voltage magnitudes [p.u.].
delta	(in/out) Voltage angles [rad].
n_bus	Total number of buses.
n_pq	Number of PQ buses.
pq_bus_id	0-based indices of PQ buses.
maxIter	Maximum number of iterations (default: 1024).
tolerance	Convergence tolerance for power mismatches (default: $$ 1 \times 10^{-8} $$).
iterHistory	Optional pointer to store iteration number and error at each step.
observer	Optional injected progress/log observer (DIP); nullptr means silent (pure solve).

Returns

true if converged, false otherwise.

Definition at line 55 of file NewtonRaphson.C.

  {
    // Compute initial mismatch
    Eigen::VectorXd P(n_bus), Q(n_bus);
    Eigen::VectorXd mismatch = PowerMismatch::compute(Ps, Qs, G, B, V, delta, n_bus, pq_bus_id, P, Q);
 
    double error = mismatch.cwiseAbs().maxCoeff();
    int iter = 0;
 
    if (iterHistory) {
        iterHistory->clear();
        iterHistory->emplace_back(0, error);
    }
 
    while (error >= tolerance) {
        if (iter >= maxIter) {
            if (observer) observer->onFinished("Newton-Raphson", false, iter, maxIter, error, tolerance);
            return false;
        }
        iter++;
 
        // Build Jacobian
        Eigen::MatrixXd J = Jacobian::compute(V, delta, n_bus, n_pq, pq_bus_id, G, B, P, Q);
 
        // Solve J * correction = mismatch
        Eigen::VectorXd correction = J.colPivHouseholderQr().solve(mismatch);
 
        // Update delta for non-slack buses (indices 1..N-1)
        for (int i = 1; i < n_bus; ++i) {
            delta(i) += correction(i - 1);
        }
 
        // Update V for PQ buses only
        for (int k = 0; k < n_pq; ++k) {
            V(pq_bus_id[k]) += correction(n_bus - 1 + k);
        }
 
        // Recompute mismatch
        mismatch = PowerMismatch::compute(Ps, Qs, G, B, V, delta, n_bus, pq_bus_id, P, Q);
 
        error = mismatch.cwiseAbs().maxCoeff();
        if (iterHistory) iterHistory->emplace_back(iter, error);
        if (observer) observer->onIteration("Newton-Raphson", iter, maxIter, error, tolerance);
    }
 
    if (observer) observer->onFinished("Newton-Raphson", true, iter, maxIter, error, tolerance);
    return true;
}

References PowerMismatch::compute(), Jacobian::compute(), ISolverObserver::onFinished(), and ISolverObserver::onIteration().

Here is the call graph for this function:

Here is the caller graph for this function:

solve()

bool NewtonRaphson::solve ( SolverContext &  ctx )

overridevirtual

Run the Newton-Raphson solver using the given context.

Parameters

ctx	Solver context (in/out parameters; see SolverContext).

Returns

true if the algorithm converged within the specified number of iterations.

Implements ISolver.

Definition at line 37 of file NewtonRaphson.C.

                                            {
    return NewtonRaphson::run(
        *ctx.G,
        *ctx.B,
        *ctx.P,
        *ctx.Q,
        *ctx.V,
        *ctx.delta,
        ctx.N,
        ctx.n_pq,
        *ctx.pq_bus_id,
        ctx.maxIter,
        ctx.tolerance,
        ctx.iterHistory,
        ctx.observer
    );
}

References SolverContext::B, SolverContext::delta, SolverContext::G, SolverContext::iterHistory, SolverContext::maxIter, SolverContext::N, SolverContext::n_pq, SolverContext::observer, SolverContext::P, SolverContext::pq_bus_id, SolverContext::Q, run(), SolverContext::tolerance, and SolverContext::V.

Here is the call graph for this function:

---

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

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