Struct BusDispatch 

pub struct BusDispatch {
    pub bus: usize,
    pub required: f64,
    pub attributed: f64,
    pub unattributed: f64,
    pub basis: KeyBasis,
    pub machines: Vec<MachineDispatch>,
}

One bus’s machines, and what they could account for.

Fields

bus: usize

The bus whose voltage these machines hold.

required: f64

What they jointly had to produce: the solved reactive injection at bus, less the part that is not theirs.

attributed: f64

What they could actually be given, once each one’s own limits were respected. Equal to required unless every machine is pinned.

unattributed: f64

required − attributed, and worth reading rather than ignoring.

A non-zero value means the machines holding this bus cannot account for the reactive power the solve put there — they are all at their limits and it is still not enough. That is not an arithmetic failure here; it means the solve placed the bus outside its machines’ joint capability, which happens because gridoxide bounds the wrong quantity.

ReactiveLimits compares Bus::q_min/q_max against the bus’s net injection, while the CGMES importer fills those fields from the machines’ own capability. Where a reactive load shares the bus, the machine has to cover it too, so the machine saturates before the net injection reaches the bound and the clamp fires late. pgm::PgmVoltageRegulator’s doc comment already names this as a deliberate simplification of the bus model; this field is the first thing that measures it.

Measured on RealGrid: of 416 regulated buses, 50 share their bus with another reactive injection and 6 come out unattributable, 0.044 p.u. in total. Small, real, and previously invisible.

basis: KeyBasis

What the shares were derived from.

machines: Vec<MachineDispatch>

Trait Implementations

impl Clone for BusDispatch

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BusDispatch

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for BusDispatch

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for BusDispatch