PyPSA link delay — power that arrives later than it left¶

description: >-
  PyPSA's delayed link: power withdrawn at one snapshot arrives at a later one,
  so a shipment is the input shifted along time and derated by the link's
  efficiency. Two links serve the same demand — one takes two snapshots to
  arrive, one arrives at once — and the first snapshots, which nothing has
  reached yet, are served by the expensive unit standing beside the load.
  Optimum 4311.111111111111, 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
  link:
    description: controllable connections, each joining two buses
    dtype: str

relations:
  gen_bus:
    description: the bus a generator sits on
    key: generator
    values: bus
  link_from:
    description: the bus a link leaves
    key: link
    values: bus
  link_to:
    description: the bus a link arrives at
    key: link
    values: bus

parameters:
  p_nom:
    description: installed capacity of a generator
    dims: [generator]
  marginal_cost:
    description: cost of one unit of output
    dims: [generator]
  link_p_nom:
    description: most a link may take in during one snapshot
    dims: [link]
  efficiency:
    description: share of what entered a link that arrives at the other end
    dims: [link]
  delay:
    description: how many snapshots a link takes to deliver what it took in
    dims: [link]
    dtype: int
  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
  g:
    description: what a link takes in during a snapshot, at the bus it leaves
    dims: [snapshot, link]
    bounds:
      lower: 0
      upper: link_p_nom

constraints:
  nodal_balance:
    description: >-
      what is generated at a bus, plus what arrives over the links — the input
      of `delay` snapshots ago, derated — less what the links took in there,
      meets the load. `edge=0` is what a non-cyclic delay means: a snapshot
      earlier than a link's delay receives nothing over it, there being no such
      snapshot to have taken anything in.
    dims: [snapshot, bus]
    expression: >-
      sum(p, by=gen_bus, over=generator, into=bus)
      + sum(shift(g, along=snapshot, offset=delay, edge=0) * efficiency, by=link_to, over=link, into=bus)
      - sum(g, by=link_from, over=link, into=bus)
      == load

objective:
  sense: minimize
  description: what the fleet costs to run; moving power costs nothing but time and losses
  expression: sum(p * marginal_cost)

# sources: parameter name -> frame or parquet path
with sps.solve('examples/ports/pypsa_link_delay.yaml', sources) as solution:
    solution.objective  # 4311.111111111111
    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``.

    Both links are given a ``delay`` — 2 for ``ship`` and 0 for ``wire`` — so the
    column is read rather than a constant applied to everything, and neither
    link is extendable: a delay is about *when* energy arrives, and a capacity
    decision would give a mismatch a second thing to be about.
    """
    n = pypsa.Network()
    n.set_snapshots(tables['snapshot']['snapshot'])
    n.add('Bus', tables['bus']['bus'])

    generators: pd.DataFrame = tables['generator'].set_index('generator')
    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'],
    )

    links: pd.DataFrame = tables['link'].set_index('link')
    n.add(
        'Link',
        links.index,
        bus0=links['link_from'],
        bus1=links['link_to'],
        p_nom=tables['link_p_nom'].set_index('link')['value'],
        efficiency=tables['efficiency'].set_index('link')['value'],
        delay=tables['delay'].set_index('link')['value'],
        cyclic_delay=False,
    )

    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