GaussSeidel Class Reference

Gauss-Seidel power flow solver implementing the ISolver interface. More...

#include <GaussSeidel.H>

Inheritance diagram for GaussSeidel:

Collaboration diagram for GaussSeidel:

Public Member Functions
bool	solve (SolverContext &ctx) override
	Run the Gauss-Seidel 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::MatrixXcd &Y, Eigen::VectorXd &V, Eigen::VectorXd &delta, const Eigen::VectorXi &type_bus, const Eigen::VectorXd &P, const Eigen::VectorXd &Q, int N, int maxIter=1024, double tolerance=1E-8, double omega=1.0, std::vector< std::pair< int, double > > *iterHistory=nullptr, ISolverObserver *observer=nullptr)
	Solves the power flow equations using the Gauss-Seidel iterative method.

Detailed Description

Gauss-Seidel power flow solver implementing the ISolver interface.

Pure solver: no Q-limit checking (handled by outer loop via checkQlimits). PV buses maintain their scheduled voltage magnitude; PQ buses are fully updated.

Definition at line 88 of file GaussSeidel.H.

Member Function Documentation

name()

const char * GaussSeidel::name ( ) const

inlineoverridevirtual

Human-readable solver name (e.g.

for logging/output).

Implements ISolver.

Definition at line 97 of file GaussSeidel.H.

{ return "Gauss-Seidel"; }

run()

bool GaussSeidel::run ( const Eigen::MatrixXcd &  Y, Eigen::VectorXd &  V, Eigen::VectorXd &  delta, const Eigen::VectorXi &  type_bus, const Eigen::VectorXd &  P, const Eigen::VectorXd &  Q, int  N, int  maxIter = 1024, double  tolerance = 1E-8, double  omega = 1.0, std::vector< std::pair< int, double > > *  iterHistory = nullptr, ISolverObserver *  observer = nullptr  )

static

Solves the power flow equations using the Gauss-Seidel iterative method.

Parameters

Y	The bus admittance matrix ($$ Y_{bus} $$).
V	(in/out) Voltage magnitudes [p.u.]. PV buses maintain scheduled value.
delta	(in/out) Voltage angles [rad].
type_bus	Bus type vector (1=Slack, 2=PV, 3=PQ).
P	Scheduled net active power injections [p.u.] ($$ P_g - P_l $$).
Q	Scheduled net reactive power injections [p.u.] ($$ Q_g - Q_l $$). Used only for PQ buses.
N	Total number of buses.
maxIter	Maximum number of iterations (default: 1024).
tolerance	Convergence tolerance for bus voltage updates (default: $$ 1 \times 10^{-8} $$).
omega	Relaxation parameter for the Successive Over-Relaxation (SOR) method (default: 1.0; SOR not applied).
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 the algorithm converged within the specified number of iterations, false otherwise.

Definition at line 50 of file GaussSeidel.C.

  {
    // Store scheduled voltage magnitudes for PV buses
    Eigen::VectorXd Vmag_sched = Vmag;
 
    // Initialize complex voltage vector
    Eigen::VectorXcd V(N);
    for (int i = 0; i < N; ++i)
        V(i) = std::polar(Vmag(i), delta(i));
 
    int iteration = 0;
    double error = std::numeric_limits<double>::infinity();
 
    if (omega <= 0.0 || omega >= 2.0) {
        if (observer) observer->onMessage("Gauss-Seidel", "Invalid input: Relaxation coefficient must be between 0 and 2. Setting Relaxation coefficient to 1.");
        omega = 1.0;
    }
 
    if (observer) {
        if (omega < 1.0) {
            observer->onMessage("Gauss-Seidel", "Under-relaxation enabled (omega < 1), this will slow down convergence.");
        } else if (omega == 1.0) {
            observer->onMessage("Gauss-Seidel", "Standard Gauss-Seidel enabled (omega = 1).");
        } else {
            observer->onMessage("Gauss-Seidel", "Over-relaxation enabled (omega > 1), this will accelerate convergence.");
        }
    }
 
    while (error >= tolerance && iteration < maxIter) {
        Eigen::VectorXcd dV = Eigen::VectorXcd::Zero(N);
 
        for (int n = 0; n < N; ++n) {
            if (type_bus(n) == 1) continue;  // Skip slack bus
 
            std::complex<double> In = Y.row(n) * V;
 
            if (type_bus(n) == 2) {  // PV Bus
                // Compute Q from current solution (no clamping)
                double Qn = -std::imag(std::conj(V(n)) * In);
 
                // GS update maintaining scheduled voltage magnitude
                std::complex<double> I_excl = In - Y(n, n) * V(n);
                std::complex<double> V_updated = ((P(n) - std::complex<double>(0, 1) * Qn) / std::conj(V(n)) - I_excl) / Y(n, n);
                std::complex<double> V_corrected = Vmag_sched(n) * V_updated / std::abs(V_updated);
                dV(n) = V_corrected - V(n);
                V(n) = V_corrected;
 
            } else if (type_bus(n) == 3) {  // PQ Bus
                std::complex<double> I_excl = In - Y(n, n) * V(n);
                std::complex<double> V_updated = ((P(n) - std::complex<double>(0, 1) * Q(n)) / std::conj(V(n)) - I_excl) / Y(n, n);
                std::complex<double> V_relaxed = V(n) + omega * (V_updated - V(n));
                dV(n) = V_relaxed - V(n);
                V(n) = V_relaxed;
            }
        }
 
        error = dV.norm();
        iteration++;
        if (iterHistory) iterHistory->emplace_back(iteration, error);
        if (observer) observer->onIteration("Gauss-Seidel", iteration, maxIter, error, tolerance);
    }
 
    if (iteration >= maxIter) {
        if (observer) observer->onFinished("Gauss-Seidel", false, iteration, maxIter, error, tolerance);
        return false;
    }
 
    // Extract converged V magnitudes and angles
    for (int i = 0; i < N; ++i) {
        Vmag(i) = std::abs(V(i));
        delta(i) = std::arg(V(i));
    }
 
    if (observer) observer->onFinished("Gauss-Seidel", true, iteration, maxIter, error, tolerance);
 
    return true;
}

References ISolverObserver::onFinished(), ISolverObserver::onIteration(), and ISolverObserver::onMessage().

Here is the call graph for this function:

Here is the caller graph for this function:

solve()

bool GaussSeidel::solve ( SolverContext &  ctx )

overridevirtual

Run the Gauss-Seidel 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 33 of file GaussSeidel.C.

                                          {
    return GaussSeidel::run(
        *ctx.Y,
        *ctx.V,
        *ctx.delta,
        *ctx.type_bus,
        *ctx.P,
        *ctx.Q,
        ctx.N,
        ctx.maxIter,
        ctx.tolerance,
        ctx.omega,
        ctx.iterHistory,
        ctx.observer
    );
}

References SolverContext::delta, SolverContext::iterHistory, SolverContext::maxIter, SolverContext::N, SolverContext::observer, SolverContext::omega, SolverContext::P, SolverContext::Q, run(), SolverContext::tolerance, SolverContext::type_bus, SolverContext::V, and SolverContext::Y.

Here is the call graph for this function:

---

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

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