PyPSA unit commitment¶

description: >-
  PyPSA unit commitment: which generators are on, not just how much they
  produce — a binary status per generator per snapshot, with start-up and
  shut-down charges. Optimum 24900.0, from PyPSA itself.

dimensions:
  snapshot:
    description: dispatch periods
    dtype: int
  generator:
    description: generating units, each either committed or off
    dtype: str

parameters:
  p_nom:
    description: installed capacity of a generator
    dims: [generator]
  marginal_cost:
    description: cost of one unit of output
    dims: [generator]
  p_min_pu:
    description: share of capacity a committed unit must produce at least
    dims: [generator]
  start_up_cost:
    description: what bringing a unit up costs, once per start
    dims: [generator]
  shut_down_cost:
    description: what taking a unit down costs, once per stop
    dims: [generator]
  load:
    description: demand to be met
    dims: [snapshot]

variables:
  p:
    description: output of a generator in a snapshot
    dims: [snapshot, generator]
    bounds:
      lower: 0
  status:
    description: is this unit committed in this snapshot?
    dims: [snapshot, generator]
    domain: binary
  start_up:
    description: does this unit come up entering this snapshot?
    dims: [snapshot, generator]
    domain: binary
  shut_down:
    description: does this unit go down entering this snapshot?
    dims: [snapshot, generator]
    domain: binary

constraints:
  power_balance:
    dims: [snapshot]
    expression: sum(p, over=generator) == load

  commitment_max:
    description: >-
      a committed unit runs at no more than its capacity and an uncommitted one
      is pinned to zero — capacity times status is a parameter against a
      variable, so the product stays degree 1
    dims: [snapshot, generator]
    expression: p - p_nom * status <= 0

  commitment_min:
    description: a committed unit runs at no less than its minimum, an uncommitted one at zero
    dims: [snapshot, generator]
    expression: p - p_min_pu * p_nom * status >= 0

  start_up_initial:
    description: >-
      the first snapshot has no predecessor, and PyPSA's default is that the
      unit was already up before the horizon — so the start-up row is slackened
      here and never binds
    dims: [snapshot, generator]
    where: "position(snapshot) == 0"
    expression: start_up - status >= -1

  start_up:
    description: >-
      a unit whose status rises entering this snapshot pays for a start. The
      start-up and shut-down variables are implied by these transitions, but
      PyPSA declares them binary rather than leaving it to the status, and the
      port matches that.
    dims: [snapshot, generator]
    expression: start_up - status + shift(status, along=snapshot, offset=1) >= 0

  shut_down_initial:
    description: >-
      the mirror of the start-up row, and not slackened: a unit that begins the
      horizon off is charged for the shut-down, which is PyPSA's asymmetry and
      worth 50 on this instance
    dims: [snapshot, generator]
    where: "position(snapshot) == 0"
    expression: shut_down + status >= 1

  shut_down:
    description: a unit whose status falls entering this snapshot pays for a stop
    dims: [snapshot, generator]
    expression: shut_down + status - shift(status, along=snapshot, offset=1) >= 0

objective:
  sense: minimize
  description: what the fleet costs to run, plus what its starts and stops cost
  expression: sum(p * marginal_cost) + sum(start_up * start_up_cost) + sum(shut_down * shut_down_cost)

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

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``.
    """
    n = pypsa.Network()
    n.set_snapshots(tables['snapshot']['snapshot'])
    n.add('Bus', 'bus')

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

    n.add(
        'Generator',
        generators.index,
        bus='bus',
        committable=True,
        p_nom=tables['p_nom'].set_index('generator')['value'],
        marginal_cost=tables['marginal_cost'].set_index('generator')['value'],
        p_min_pu=tables['p_min_pu'].set_index('generator')['value'],
        start_up_cost=tables['start_up_cost'].set_index('generator')['value'],
        shut_down_cost=tables['shut_down_cost'].set_index('generator')['value'],
    )

    load: pd.Series = tables['load'].set_index('snapshot')['value']
    n.add('Load', 'load', bus='bus', p_set=load)
    return n