PyPSA multi-period investment — an asset exists for the years it exists¶

description: >-
  PyPSA multi-period investment: a build year and a lifetime decide which
  periods an asset exists in, so a generator that has retired has no dispatch to
  choose, and capacity is paid for once per period it stands in — discounted by
  that period's weight. One unit retires between the two periods, one is built
  for the second, one lives through both.
  Optimum 85300.0, from PyPSA itself.

dimensions:
  snapshot:
    description: dispatch periods, each falling in one investment period
    dtype: int
  period:
    description: investment periods, the grouping capacity is decided and paid over
    dtype: int
  generator:
    description: generating units, each existing in some periods and not others
    dtype: str

relations:
  period_of:
    description: the investment period a snapshot falls in
    key: snapshot
    values: period

parameters:
  load:
    description: demand to be met
    dims: [snapshot]
  period_weight:
    description: >-
      what one period's costs are worth at the horizon's start — the discount
      that makes a 2040 decision comparable with a 2030 one
    dims: [period]
  opex:
    description: cost of one unit of output
    dims: [generator]
  capex:
    description: cost of holding one unit of capacity through one period
    dims: [generator]
  p_nom_max:
    description: most capacity a generator may build
    dims: [generator]
  activity:
    description: >-
      1 where a generator exists in a period and 0 where it does not — PyPSA
      derives this from a build year and a lifetime, and it decides both what may
      run and what is paid for
    dims: [period, generator]

variables:
  p:
    description: >-
      output of a generator in a snapshot, held at zero in the snapshots whose
      period the generator does not exist in
    dims: [snapshot, generator]
    bounds:
      lower: 0
  p_nom:
    description: capacity built at a generator
    dims: [generator]
    bounds:
      lower: 0
      upper: p_nom_max

constraints:
  within_capacity:
    description: >-
      a generator produces no more than the capacity built for it, and nothing at
      all in a period it does not exist in — the activity is read down onto the
      snapshot through the period relation
    dims: [snapshot, generator]
    expression: p <= p_nom * at(activity, by=period_of, over=period, into=snapshot)

  power_balance:
    description: what exists in this snapshot meets the load
    dims: [snapshot]
    expression: sum(p, over=generator) == load

objective:
  sense: minimize
  description: >-
    operating cost and capacity cost, each discounted by the weight of the
    period it falls in — capacity once per period the asset stands in, which is
    why an asset alive in both is paid for twice
  expression: >-
    sum(p * opex * at(period_weight, by=period_of, over=period, into=snapshot))
    + sum(p_nom * capex * activity * period_weight)

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

    The port's flat ``snapshot`` axis carries a relation into ``period``; PyPSA
    wants the same fact as a ``(period, timestep)`` MultiIndex, so the snapshots
    are paired with the period each falls in. ``investment_period_weightings``
    takes the port's ``period_weight`` as its ``objective`` column, and ``years``
    is 10 for both periods — set explicitly, because a default of 1 would make
    the decade an accident rather than a statement.
    """
    n = pypsa.Network()
    snapshots: pd.DataFrame = tables['snapshot']
    periods = list(tables['period']['period'])
    n.set_snapshots(pd.MultiIndex.from_arrays([snapshots['period_of'], snapshots['snapshot']]))
    n.investment_periods = periods
    n.investment_period_weightings['years'] = 10
    n.investment_period_weightings['objective'] = tables['period_weight'].set_index('period')['value']

    n.add('Bus', 'hub')
    generators: pd.DataFrame = tables['generator'].set_index('generator')
    n.add(
        'Generator',
        generators.index,
        bus='hub',
        p_nom_extendable=True,
        build_year=[LIFETIMES[g][0] for g in generators.index],
        lifetime=[LIFETIMES[g][1] for g in generators.index],
        p_nom_max=tables['p_nom_max'].set_index('generator')['value'],
        marginal_cost=tables['opex'].set_index('generator')['value'],
        capital_cost=tables['capex'].set_index('generator')['value'],
    )

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