PyPSA minimum up and down times — the rows that make commitment bite¶

description: >-
  PyPSA minimum up and down times: a unit that has started must stay on, and one
  that has stopped must stay off. Each window is a backward-looking sum whose
  length is a property of the generator, and the three units here carry
  different lengths. Optimum 32750.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]
  p_min_pu:
    description: share of capacity a committed unit must produce at least
    dims: [generator]
  marginal_cost:
    description: cost of one unit of output
    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]
  min_up_time:
    description: how many snapshots a unit must stay on once it has started
    dims: [generator]
    dtype: int
  min_down_time:
    description: how many snapshots a unit must stay off once it has stopped
    dims: [generator]
    dtype: int
  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, an uncommitted one at zero
    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:
    description: >-
      a unit whose status rises entering this snapshot pays for a start. Every
      unit begins the horizon off, which is the 0 the first snapshot reads where
      it has no predecessor
    dims: [snapshot, generator]
    expression: start_up - status + shift(status, along=snapshot, offset=1, edge=0) >= 0

  shut_down:
    description: >-
      a unit whose status falls entering this snapshot pays for a stop. There is
      no first-snapshot counterpart: a unit that begins off has nothing to stop,
      and the row PyPSA emits there holds for every value of both variables.
    dims: [snapshot, generator]
    expression: shut_down + status - shift(status, along=snapshot, offset=1) >= 0

  min_up_time:
    description: >-
      over the last `min_up_time` snapshots a unit may have started at most as
      often as it is running now — which is what stops it starting and stopping
      again inside its own window
    dims: [snapshot, generator]
    where: "snapshot > 0"
    expression: sum_back(start_up, along=snapshot, window=min_up_time) <= status

  min_down_time:
    description: >-
      the mirror: having stopped inside the window and running now cannot both
      be true
    dims: [snapshot, generator]
    where: "snapshot > 0"
    expression: status + sum_back(shut_down, along=snapshot, window=min_down_time) <= 1

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_min_up_down.yaml', sources) as solution:
    solution.objective  # 32750.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``.

    One bus and no network: a model that fails to match should implicate one
    feature, and here it is the window length. ``committable`` is what turns the
    status into a variable at all, and the two ``*_time_before`` values are set
    rather than defaulted for the reason in the module docstring.
    """
    n = pypsa.Network()
    n.set_snapshots(tables['snapshot']['snapshot'])
    n.add('Bus', 'hub')

    generators: pd.DataFrame = tables['generator'].set_index('generator')
    n.add(
        'Generator',
        generators.index,
        bus='hub',
        committable=True,
        up_time_before=0,
        down_time_before=0,
        p_nom=tables['p_nom'].set_index('generator')['value'],
        p_min_pu=tables['p_min_pu'].set_index('generator')['value'],
        marginal_cost=tables['marginal_cost'].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'],
        min_up_time=tables['min_up_time'].set_index('generator')['value'],
        min_down_time=tables['min_down_time'].set_index('generator')['value'],
    )

    n.add('Load', 'l', bus='hub', p_set=tables['load'].set_index('snapshot')['value'])
    return n