Qlim Class Reference

Checks reactive power limits on PV buses after solver convergence. More...

#include <Qlim.H>

Static Public Member Functions
static bool	check (const Eigen::VectorXd &V, const Eigen::VectorXd &delta, Eigen::VectorXi &type_bus, const Eigen::MatrixXd &G, const Eigen::MatrixXd &B, BusData &busData, const std::vector< int > &pv_bus_id, int n_bus, ISolverObserver *observer=nullptr)
	Checks reactive power limits on PV buses after solver convergence.

Detailed Description

Checks reactive power limits on PV buses after solver convergence.

Definition at line 47 of file Qlim.H.

Member Function Documentation

check()

bool Qlim::check ( const Eigen::VectorXd &  V, const Eigen::VectorXd &  delta, Eigen::VectorXi &  type_bus, const Eigen::MatrixXd &  G, const Eigen::MatrixXd &  B, BusData &  busData, const std::vector< int > &  pv_bus_id, int  n_bus, ISolverObserver *  observer = nullptr  )

static

Checks reactive power limits on PV buses after solver convergence.

Computes the reactive power at each bus using converged voltages and angles, then checks if PV buses violate their $$ Q_{gmax} $$ or $$ Q_{gmin} $$ limits. Violating PV buses are converted to PQ type (type 3 in C++ convention).

Parameters

V	Converged voltage magnitudes [p.u.].
delta	Converged voltage angles [rad].
type_bus	(in/out) Bus type vector; PV buses that violate limits are set to PQ.
G	Conductance matrix.
B	Susceptance matrix.
busData	Bus data (for Ql, Qgmax, Qgmin).
pv_bus_id	0-based indices of PV buses (before any conversion).
n_bus	Total number of buses.
observer	Optional injected log observer (DIP); nullptr means silent.

Returns

true if any Q-limit was hit (solver must be re-run), false otherwise.

Definition at line 36 of file Qlim.C.

  {
    // Q-limits: zero means no limit, using +/-inf
    Eigen::VectorXd Qmax = busData.Qgmax;
    Eigen::VectorXd Qmin = busData.Qgmin;
 
    for (int i = 0; i < n_bus; ++i) {
        if (Qmax(i) == 0.0) Qmax(i) = std::numeric_limits<double>::infinity();
        if (Qmin(i) == 0.0) Qmin(i) = -std::numeric_limits<double>::infinity();
    }
 
    // Compute reactive power Q at each bus with converged V and delta
    Eigen::VectorXd Q = Eigen::VectorXd::Zero(n_bus);
    for (int i = 0; i < n_bus; ++i) {
        for (int j = 0; j < n_bus; ++j) {
            double dij = delta(i) - delta(j);
            Q(i) += V(i) * V(j) * (G(i, j) * std::sin(dij) - B(i, j) * std::cos(dij));
        }
    }
 
    // Qg = Q_calc + Ql (all in p.u.)
    Eigen::VectorXd Qg = Q + busData.Ql;
 
    // Check Q-limits only for PV buses
    bool qlim_hit = false;
 
    for (int idx : pv_bus_id) {
        if (Qg(idx) > Qmax(idx)) {
            type_bus(idx) = 3;  // PV to PQ
            busData.Qg(idx) = Qmax(idx);  // Fix Q at limit for next solver run
            qlim_hit = true;
            if (observer) {
                std::string msg = fmt::format("Q-limit (max) hit at bus {} : Qg = {:.4f} > Qmax = {:.4f}", idx + 1, Qg(idx), Qmax(idx));
                observer->onMessage("Qlim", msg.c_str());
            }
        } else if (Qg(idx) < Qmin(idx)) {
            type_bus(idx) = 3;  // PV to PQ
            busData.Qg(idx) = Qmin(idx);  // Fix Q at limit for next solver run
            qlim_hit = true;
            if (observer) {
                std::string msg = fmt::format("Q-limit (min) hit at bus {} : Qg = {:.4f} < Qmin = {:.4f}", idx + 1, Qg(idx), Qmin(idx));
                observer->onMessage("Qlim", msg.c_str());
            }
        }
    }
 
    if (!qlim_hit && observer) {
        observer->onMessage("Qlim", "Power flow converged without hitting Q-limits.");
    }
 
    return qlim_hit;
}

References ISolverObserver::onMessage(), BusData::Qg, BusData::Qgmax, BusData::Qgmin, and BusData::Ql.

Here is the call graph for this function:

Here is the caller graph for this function:

---

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

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