Admittance Class Reference

Computes the complex bus admittance matrix ($$ Y_{bus} $$). More...

#include <Admittance.H>

Static Public Member Functions
static Eigen::MatrixXcd	build (const BusData &busData, const BranchData &branchData, ISolverObserver *observer=nullptr)
	Computes the complex bus admittance matrix ($$ Y_{bus} $$).

Detailed Description

Computes the complex bus admittance matrix ($$ Y_{bus} $$).

Definition at line 51 of file Admittance.H.

Member Function Documentation

build()

Eigen::MatrixXcd Admittance::build ( const BusData &  busData, const BranchData &  branchData, ISolverObserver *  observer = nullptr  )

static

Computes the complex bus admittance matrix ($$ Y_{bus} $$).

This builds the bus admittance matrix, which is essential in solving power flow equations in electrical networks. The admittance matrix is computed using the provided bus and branch data.

Parameters

busData	Data representing the buses in the network.
branchData	Data representing the branches (lines/transformers) in the network.
observer	Optional injected log observer (DIP); nullptr means silent.

Returns

Eigen::MatrixXcd The computed $$ Y_{bus} $$ matrix as a complex matrix.

Definition at line 34 of file Admittance.C.

                                                                                                                {
    int nLine = branchData.From.size();
    int N = std::max(branchData.From.maxCoeff(), branchData.To.maxCoeff());  // 1-based bus indexing
 
    Eigen::MatrixXcd Ybus = Eigen::MatrixXcd::Zero(N, N);  // Size N x N, 0-based indexing internally
 
    for (int k = 0; k < nLine; ++k) {
        int from = branchData.From(k) - 1;  // Convert to 0-based
        int to   = branchData.To(k) - 1;    // Convert to 0-based
 
        std::complex<double> Z(branchData.R(k), branchData.X(k));
        std::complex<double> Y = 1.0 / Z;
 
        std::complex<double> B(0.0, 0.5 * branchData.B(k));
 
        double a = branchData.tapRatio(k);
        if (a == 0.0) {
            a = 1.0;
        }
 
        // Off-diagonal
        Ybus(from, to) -= Y / a;
        Ybus(to, from) = Ybus(from, to);  // Symmetric
 
        // Diagonal
        Ybus(from, from) += Y / (a * a) + B;
        Ybus(to, to)     += Y + B;
    }
 
    // Add shunt admittances
    int nBuses = busData.ID.size();  // Should match Gs and Bs size
 
    for (int n = 0; n < nBuses; ++n) {
        int busIndex = busData.ID(n) - 1;  // Convert to 0-based
 
        if (busIndex < 0 || busIndex >= Ybus.rows()) {
            if (observer) {
                std::string msg = fmt::format("Warning: Bus ID {} out of bounds in Ybus", busIndex + 1);
                observer->onMessage("Admittance", msg.c_str());
            }
            continue;
        }
 
        std::complex<double> Y_shunt(busData.Gs(n), busData.Bs(n));
        Ybus(busIndex, busIndex) += Y_shunt;
    }
 
    return Ybus;
}

References BranchData::B, BusData::Bs, BranchData::From, BusData::Gs, BusData::ID, ISolverObserver::onMessage(), BranchData::R, BranchData::tapRatio, BranchData::To, and BranchData::X.

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/model/Admittance.H
• src/core/model/Admittance.C