PyPSA LOPF — Kirchhoff's voltage law¶

description: >-
  PyPSA linear optimal power flow over passive AC lines under Kirchhoff's
  voltage law, rather than links whose flow is chosen. Optimum 17000.0, from
  PyPSA itself.

dimensions:
  snapshot:
    description: dispatch periods
    dtype: int
  bus:
    description: network nodes
    dtype: str
  generator:
    description: generating units, each sitting on one bus
    dtype: str
  line:
    description: passive AC lines, each joining two buses
    dtype: str
  cycle:
    description: one independent loop of the network
    dtype: str

relations:
  gen_bus:
    description: the bus a generator sits on
    key: generator
    values: bus
  line_from:
    description: the bus a line leaves
    key: line
    values: bus
  line_to:
    description: the bus a line arrives at
    key: line
    values: bus

parameters:
  p_nom:
    description: installed capacity of a generator
    dims: [generator]
  marginal_cost:
    description: cost of one unit of output
    dims: [generator]
  s_nom:
    description: most a line may carry towards its `line_to` bus
    dims: [line]
  neg_s_nom:
    description: most a line may carry the other way, negative by convention
    dims: [line]
  cycle_incidence:
    description: >-
      the cycle basis, as a sparse table of reactance times direction — a line
      may belong to several cycles, so this is a parameter over both dimensions
      rather than a coordinate, and rows are absent where a line is in no cycle
    dims: [cycle, line]
  load:
    description: demand at each bus in each snapshot
    dims: [snapshot, bus]

variables:
  p:
    description: output of a generator in a snapshot
    dims: [snapshot, generator]
    bounds:
      lower: 0
      upper: p_nom
  f:
    description: >-
      flow on a line, signed towards its `line_to` bus — not chosen, but whatever
      the voltage law leaves
    dims: [snapshot, line]
    bounds:
      lower: neg_s_nom
      upper: s_nom

constraints:
  nodal_balance:
    description: what is generated at a bus plus what arrives over the lines meets the load there
    dims: [snapshot, bus]
    expression: >-
      sum(p, by=gen_bus, over=generator, into=bus)
      + sum(f, by=line_to, over=line, into=bus)
      - sum(f, by=line_from, over=line, into=bus)
      == load

  kirchhoff_voltage_law:
    description: >-
      around each independent cycle the reactance-weighted flows sum to zero.
      The incidence table carries both which lines are in the cycle and which
      way round they run, so this is one equation rather than a case analysis
      over the topology — and a coordinate could not hold it, being
      single-valued per label.
    dims: [snapshot, cycle]
    expression: sum(f * cycle_incidence, over=line) == 0

objective:
  sense: minimize
  description: total cost of generation; the lines carry power for nothing
  expression: sum(p * marginal_cost)

# sources: parameter name -> frame or parquet path
with sps.solve('examples/ports/pypsa_kvl.yaml', sources) as solution:
    solution.objective  # 17000.0
    solution.dual('nodal_balance')

def build(tables: dict[str, pd.DataFrame]) -> pypsa.Network:
    """The port's tables as a PyPSA network, column for column.

    ``tables`` is the same mapping the specsolve call attaches as ``sources``.

    ``r=0`` keeps a line purely reactive: the linearised power flow is a
    function of ``x`` alone, and a resistance would only add losses the DC
    approximation does not model anyway.
    """
    n = pypsa.Network()
    n.set_snapshots(tables['snapshot']['snapshot'])
    n.add('Bus', tables['bus']['bus'])

    generators: pd.DataFrame = tables['generator'].set_index('generator')
    lines: pd.DataFrame = tables['line'].set_index('line')

    n.add(
        'Generator',
        generators.index,
        bus=generators['gen_bus'],
        p_nom=tables['p_nom'].set_index('generator')['value'],
        marginal_cost=tables['marginal_cost'].set_index('generator')['value'],
    )
    n.add(
        'Line',
        lines.index,
        bus0=lines['line_from'],
        bus1=lines['line_to'],
        x=tables['reactance'].set_index('line')['value'],
        r=0.0,
        s_nom=tables['s_nom'].set_index('line')['value'],
    )

    load: pd.DataFrame = tables['load'].pivot(index='snapshot', columns='bus', values='value')
    for bus in tables['bus']['bus']:
        n.add('Load', f'load_{bus}', bus=bus, p_set=load[bus])
    return n