Qlim.C File Reference

Reactive power limit enforcement implementation. More...

#include <cmath>
#include <limits>
#include <vector>
#include "Qlim.H"
#include "Logger.H"
#include "Data.H"

Include dependency graph for Qlim.C:

Go to the source code of this file.

Functions
bool	checkQlimits (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)
	Checks reactive power limits on PV buses after solver convergence.

Detailed Description

Reactive power limit enforcement implementation.

Definition in file Qlim.C.

Function Documentation

checkQlimits()

bool checkQlimits	(	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
	)

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.

Returns

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

Definition at line 34 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;
            LOG_DEBUG("Q-limit (max) hit at bus {} : Qg = {:.4f} > Qmax = {:.4f}", idx + 1, Qg(idx), Qmax(idx));
        } 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;
            LOG_DEBUG("Q-limit (min) hit at bus {} : Qg = {:.4f} < Qmin = {:.4f}", idx + 1, Qg(idx), Qmin(idx));
        }
    }
 
    if (!qlim_hit) {
        LOG_DEBUG("Power flow converged without hitting Q-limits.");
    }
 
    return qlim_hit;
}

References LOG_DEBUG, BusData::Qg, BusData::Qgmax, BusData::Qgmin, and BusData::Ql.

Here is the caller graph for this function: