SkillAgentSearch skills...

ac-branch-pi-model

AC branch pi-model power flow equations (P/Q and |S|) with transformer tap ratio and phase shift, matching `acopf-math-model.md` and MATPOWER branch fields

Install / Use

npx skills add benchflow-ai/skillsbench --skill ac-branch-pi-model

Installs into whichever agent you are using.

About this skill
📄

SKILL.md

Installable skill definition

Quality Score

83/100

Supported Platforms

Universal

Tags

Our assessment of ac-branch-pi-model

ac-branch-pi-model scores 83/100 on our quality scale, 679th of 947 AI & Machine Learning skills we index.

Its SKILL.md is 4.2 KB long, well organised into 13 sections with 2 code examples: a solid amount of guidance for an agent.

With 1,813 GitHub stars, it is one of the more widely adopted skills in the catalogue.

Substance
26/30
Structure
18/20
Description
15/15
Adoption
14/20
Freshness
11/15

Maintenance, license and trust

  • The repository was last updated about 4 months ago. That is recent enough to be usable, but agent tooling moves fast, so check the instructions against your agent's current version.
  • Our last check on 2026-11-06 found the source still online.
  • It is released under the Apache-2.0 license, a permissive license that allows use, modification and commercial use with attribution.
  • Its trust signals score 98/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.

Safety scan

No issues found

Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.

AI review by kimi-k2.7-code on 2026-10-02. Automated pattern scan on 2026-10-02. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.

ac-branch-pi-model compared with similar skills

All 4 of these similar skills score higher than ac-branch-pi-model; compare them before choosing.

SkillScoreStarsUpdatedFormat
ac-branch-pi-model (this skill)by benchflow-ai831.8k4mo agoSKILL.md
claude-memby thedotmack100117.6ktodayCLAUDE.md
Understand-Anythingby Egonex-AI10092.8k1d agoCLAUDE.md
headroomby headroomlabs-ai10079.8ktodayCLAUDE.md
CowAgentby zhayujie10048.0ktodayCLAUDE.md

Frequently asked questions

How do I install ac-branch-pi-model?
Run npx skills add benchflow-ai/skillsbench --skill ac-branch-pi-model. The install tabs above show the steps for each supported agent.
Which AI agents does ac-branch-pi-model work with?
It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
Is ac-branch-pi-model safe to use?
Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is Apache-2.0-licensed and scores 98/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is ac-branch-pi-model still maintained?
The repository was last updated about 4 months ago. That is recent enough to be usable, but agent tooling moves fast, so check the instructions against your agent's current version.

name: ac-branch-pi-model description: "AC branch pi-model power flow equations (P/Q and |S|) with transformer tap ratio and phase shift, matching acopf-math-model.md and MATPOWER branch fields. Use when computing branch flows in either direction, aggregating bus injections for nodal balance, checking MVA (rateA) limits, computing branch loading %, or debugging sign/units issues in AC power flow."

AC Branch Pi-Model + Transformer Handling

Implement the exact branch power flow equations in acopf-math-model.md using MATPOWER branch data:

[F_BUS, T_BUS, BR_R, BR_X, BR_B, RATE_A, RATE_B, RATE_C, TAP, SHIFT, BR_STATUS, ANGMIN, ANGMAX]

Quick start

  • Use scripts/branch_flows.py to compute per-unit branch flows.
  • Treat the results as power leaving the “from” bus and power leaving the “to” bus (i.e., compute both directions explicitly).

Example:

import json
import numpy as np

from scripts.branch_flows import compute_branch_flows_pu, build_bus_id_to_idx

data = json.load(open("/root/network.json"))
baseMVA = float(data["baseMVA"])
buses = np.array(data["bus"], dtype=float)
branches = np.array(data["branch"], dtype=float)

bus_id_to_idx = build_bus_id_to_idx(buses)

Vm = buses[:, 7]  # initial guess VM
Va = np.deg2rad(buses[:, 8])  # initial guess VA

br = branches[0]
P_ij, Q_ij, P_ji, Q_ji = compute_branch_flows_pu(Vm, Va, br, bus_id_to_idx)

S_ij_MVA = (P_ij**2 + Q_ij**2) ** 0.5 * baseMVA
S_ji_MVA = (P_ji**2 + Q_ji**2) ** 0.5 * baseMVA
print(S_ij_MVA, S_ji_MVA)

Model details (match the task formulation)

Per-unit conventions

  • Work in per-unit internally.
  • Convert with baseMVA:
    • (P_{pu} = P_{MW} / baseMVA)
    • (Q_{pu} = Q_{MVAr} / baseMVA)
    • (|S|{MVA} = |S|{pu} \cdot baseMVA)

Transformer handling (MATPOWER TAP + SHIFT)

  • Use (T_{ij} = tap \cdot e^{j \cdot shift}).
  • Implementation shortcut (real tap + phase shift):
    • If abs(TAP) < 1e-12, treat tap = 1.0 (no transformer).
    • Convert SHIFT from degrees to radians.
    • Use the angle shift by modifying the angle difference:
      • (\delta_{ij} = \theta_i - \theta_j - shift)
      • (\delta_{ji} = \theta_j - \theta_i + shift)

Series admittance

Given BR_R = r, BR_X = x:

  • If r == 0 and x == 0, set g = 0, b = 0 (avoid divide-by-zero).
  • Else:
    • (y = 1/(r + jx) = g + jb)
    • (g = r/(r^2 + x^2))
    • (b = -x/(r^2 + x^2))

Line charging susceptance

  • BR_B is the total line charging susceptance (b_c) (per unit).
  • Each end gets (b_c/2) in the standard pi model.

Power flow equations (use these exactly)

Let:

  • (V_i = |V_i| e^{j\theta_i}), (V_j = |V_j| e^{j\theta_j})
  • tap is real, shift is radians
  • inv_t = 1/tap, inv_t2 = inv_t^2

Then the real/reactive power flow from i→j is:

  • (P_{ij} = g |V_i|^2 inv_t2 - |V_i||V_j| inv_t (g\cos\delta_{ij} + b\sin\delta_{ij}))
  • (Q_{ij} = -(b + b_c/2)|V_i|^2 inv_t2 - |V_i||V_j| inv_t (g\sin\delta_{ij} - b\cos\delta_{ij}))

And from j→i is:

  • (P_{ji} = g |V_j|^2 - |V_i||V_j| inv_t (g\cos\delta_{ji} + b\sin\delta_{ji}))
  • (Q_{ji} = -(b + b_c/2)|V_j|^2 - |V_i||V_j| inv_t (g\sin\delta_{ji} - b\cos\delta_{ji}))

Compute apparent power:

  • (|S_{ij}| = \sqrt{P_{ij}^2 + Q_{ij}^2})
  • (|S_{ji}| = \sqrt{P_{ji}^2 + Q_{ji}^2})

Common uses

Enforce MVA limits (rateA)

  • RATE_A is an MVA limit (may be 0 meaning “no limit”).
  • Enforce in both directions:
    • (|S_{ij}| \le RATE_A)
    • (|S_{ji}| \le RATE_A)

Compute branch loading %

For reporting “most loaded branches”:

  • loading_pct = 100 * max(|S_ij|, |S_ji|) / RATE_A if RATE_A > 0, else 0.

Aggregate bus injections for nodal balance

To build the branch flow sum for each bus (i):

  • Add (P_{ij}, Q_{ij}) to bus i
  • Add (P_{ji}, Q_{ji}) to bus j

This yields arrays P_out[i], Q_out[i] such that the nodal balance can be written as:

  • (P^g - P^d - G^s|V|^2 = P_{out})
  • (Q^g - Q^d + B^s|V|^2 = Q_{out})

Sanity checks (fast debug)

  • With SHIFT=0 and TAP=1, if (V_i = V_j) and (\theta_i=\theta_j), then (P_{ij}\approx 0) and (P_{ji}\approx 0) (lossless only if r=0).
  • For a pure transformer (r=x=0) you should not get meaningful flows; treat as g=b=0 (no series element).

Related Skills

View on GitHub
GitHub Stars1.8k
CategoryAI
Updated3mo ago
Forks368

Languages

PDDL

Trust signals

98/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

1 info