dc-power-flow

DC power flow analysis for power systems. Use when computing power flows using DC approximation, building susceptance matrices, calculating line flows and lo...

Security Scan

The skill's code and instructions are consistent with its stated purpose (building susceptance matrices and computing DC line flows); it requires no credentials, no installs, and contains no network or privileged actions.

Purpose & Capability

Name/description (DC power flow, susceptance matrices, line flows) match the included SKILL.md and the single Python helper. The requested resources (none) are proportionate to the stated functionality.

Instruction Scope

SKILL.md provides domain-specific formulas, code snippets, and a single runtime step (run scripts/build_b_matrix.py). It only references local data structures and a local JSON input file; it does not instruct the agent to read unrelated files, call external endpoints, or access secrets.

Install Mechanism

No install spec; the skill is instruction-only with a small local Python script. Nothing is downloaded or written to disk by an installer step.

Credentials

No environment variables, credentials, or config paths are required. The code reads a local JSON network file passed as an argument, which is appropriate for the task.

Persistence & Privilege

always is false and the skill is user-invocable. There is no indication the skill modifies system or other-skill settings or requests permanent presence.

Assessment

This skill appears to do exactly what it says: compute susceptance matrices and DC line flows using a local JSON network file. Before using, inspect or run the included scripts in a safe environment and only provide trusted network JSON files (the script reads a local file given on the command line). No network calls or secret access are present, but standard runtime checks apply — validate input data (nonzero reactances, sensible RATE_A values) to avoid runtime errors or misleading results.

DC power flow is a linearized approximation of AC power flow, suitable for economic dispatch and contingency analysis.

DC Approximations

1. Lossless lines - Ignore resistance (R ≈ 0)
2. Flat voltage - All bus voltages = 1.0 pu
3. Small angles - sin(θ) ≈ θ, cos(θ) ≈ 1

Result: Power flow depends only on bus angles (θ) and line reactances (X).

Bus Number Mapping

Power system bus numbers may not be contiguous (e.g., case300 has non-sequential bus IDs). Always create a mapping from bus numbers to 0-indexed array positions:

# Create mapping: bus_number -> 0-indexed position
bus_num_to_idx = {int(buses[i, 0]): i for i in range(n_bus)}

# Use mapping for branch endpoints
f = bus_num_to_idx[int(br[0])]  # NOT br[0] - 1
t = bus_num_to_idx[int(br[1])]

Susceptance Matrix (B)

Build from branch reactances using bus number mapping:

# Run: scripts/build_b_matrix.py
# Or inline:
bus_num_to_idx = {int(buses[i, 0]): i for i in range(n_bus)}
B = np.zeros((n_bus, n_bus))

for br in branches:
    f = bus_num_to_idx[int(br[0])]  # Map bus number to index
    t = bus_num_to_idx[int(br[1])]
    x = br[3]  # Reactance
    if x != 0:
        b = 1.0 / x
        B[f, f] += b
        B[t, t] += b
        B[f, t] -= b
        B[t, f] -= b

Power Balance Equation

At each bus: Pg - Pd = B[i, :] @ θ

Where:

• Pg = generation at bus (pu)
• Pd = load at bus (pu)
• θ = vector of bus angles (radians)

Slack Bus

One bus must have θ = 0 as reference. Find slack bus (type=3):

slack_idx = None
for i in range(n_bus):
    if buses[i, 1] == 3:
        slack_idx = i
        break
constraints.append(theta[slack_idx] == 0)

Line Flow Calculation

Flow on branch from bus f to bus t (use bus number mapping):

f = bus_num_to_idx[int(br[0])]
t = bus_num_to_idx[int(br[1])]
b = 1.0 / br[3]  # Susceptance = 1/X
flow_pu = b * (theta[f] - theta[t])
flow_MW = flow_pu * baseMVA

Line Loading Percentage

loading_pct = abs(flow_MW) / rating_MW * 100

Where rating_MW = branch[5] (RATE_A column).

Branch Susceptances for Constraints

Store susceptances when building constraints:

branch_susceptances = []
for br in branches:
    x = br[3]
    b = 1.0 / x if x != 0 else 0
    branch_susceptances.append(b)

Line Flow Limits (for OPF)

Enforce thermal limits as linear constraints:

# |flow| <= rating  →  -rating <= flow <= rating
flow = b * (theta[f] - theta[t]) * baseMVA
constraints.append(flow <= rate)
constraints.append(flow >= -rate)