Rung 7: commitment — committable units with up and down times and ramp limits at the transitions¶
One rung of the PyPSA corpus: the file pypsa.yaml projected onto what this network builds, bound to that network, and held to what PyPSA solves it to.
✔ Verified against pypsa 1.3.0 — objective 7775.0 on both sides; structure ≠
Generator-com-transition-shut-down8 vs 6+2 — two blocks — carried, initial — where PyPSA folds the pre-horizon status into the first snapshot's row;Generator-com-transition-start-up8 vs 6+2 — two blocks — carried, initial — where PyPSA folds the pre-horizon status into the first snapshot's row;Generator-p-ramp_limit_down7 vs 6+1 — two blocks — carried, initial — where PyPSA folds the pre-horizon status into the first snapshot's row;Generator-p-ramp_limit_up7 vs 6+1 — two blocks — carried, initial — where PyPSA folds the pre-horizon status into the first snapshot's row; size ✔ 116 rows · ✔ 44 columns · ✔ 237 nonzeros; duals — integer model, no duals; model for model: 16 blocks equal, 4 documented splits, 3 recorded deviations.
Rows and columns, PyPSA against lpspec, name for name
| row | PyPSA | lpspec |
|---|---|---|
Bus-nodal_balance |
8 | 8 |
Generator-com-down-time |
6 | 6 |
Generator-com-p-lower |
8 | 8 |
Generator-com-p-upper |
8 | 8 |
Generator-com-status-min_up_time_must_stay_up |
2 | 2 |
Generator-com-transition-shut-down |
8 | ≠ 6+2 |
Generator-com-transition-start-up |
8 | ≠ 6+2 |
Generator-com-up-time |
6 | 6 |
Generator-fix-p-lower |
8 | 8 |
Generator-fix-p-upper |
8 | 8 |
Generator-p-ramp_limit_down |
7 | ≠ 6+1 |
Generator-p-ramp_limit_up |
7 | ≠ 6+1 |
Generator-shut_down-p-fixed-upper |
8 | 8 |
Generator-start_up-p-fixed-upper |
8 | 8 |
Generator-status-p-fixed-upper |
8 | 8 |
Link-fix-p-lower |
4 | 4 |
Link-fix-p-upper |
4 | 4 |
| column | PyPSA | lpspec |
|---|---|---|
Generator-p |
16 | 16 |
Generator-shut_down |
8 | 8 |
Generator-start_up |
8 | 8 |
Generator-status |
8 | 8 |
Link-p |
4 | 4 |
The model¶
The same model, as math
The model a plain n.optimize() builds, stated in one file. Every declaration is named Component_attribute after the PyPSA statement it stands for, and each constraint's description opens with the linopy name PyPSA gives that row, so the two can be read side by side. PyPSA's regimes — extendable, committable — are data columns and become where: masks. Bounds are the explicit rows PyPSA writes, so their duals are row duals. Parameters no PyPSA table carries verbatim are computed in data prep and say so in their description.
Sets¶
| Symbol | Meaning |
|---|---|
| \(\mathcal{T}\) | index \(t\) — snapshot — dispatch periods |
| \(\mathcal{N}\) | index \(n\) — bus — network nodes |
| \(\mathcal{G}\) | index \(g\) — generator with \(\mathrm{Generator\_bus}: \mathcal{G} \to \mathcal{N}\) — generating units, each on one bus |
| \(\mathcal{L}\) | index \(l\) — link with \(\mathrm{Link\_bus0}: \mathcal{L} \to \mathcal{N}\) — controllable connections, each from one bus to the buses it delivers to |
| \(\mathcal{O}\) | index \(o\) — link_output with \(\mathrm{Link\_output\_link}: \mathcal{O} \to \mathcal{L},\enspace \mathrm{Link\_output\_bus}: \mathcal{O} \to \mathcal{N}\) — a link's output ports, one label per port a link declares — PyPSA's bus1, bus2, … columns read long, so a link of any number of output ports is one term in the balance, data prep |
| \(\mathcal{D}\) | index \(d\) — load with \(\mathrm{Load\_bus}: \mathcal{D} \to \mathcal{N}\) — demands, each on one bus |
Parameters¶
| Symbol | Meaning |
|---|---|
| \(\mathrm{w}\) | snapshot_weightings_objective over \(\mathcal{T}\) — PyPSA's snapshot_weightings.objective — hours a snapshot stands for in the cost |
| \(\mathrm{p}^{\mathrm{nom}}\) | Generator_p_nom over \(\mathcal{G}\) — nominal power |
| \(\mathrm{ext}\) | Generator_p_nom_extendable over \(\mathcal{G}\) — whether the nominal power is a decision |
| \(\underline{\mathrm{p}}\) | Generator_p_min_pu over \(\mathcal{T} \times \mathcal{G}\) — least output, per unit of nominal power |
| \(\overline{\mathrm{p}}\) | Generator_p_max_pu over \(\mathcal{T} \times \mathcal{G}\) — most output, per unit of nominal power — an availability profile |
| \(\mathrm{c}\) | Generator_marginal_cost over \(\mathcal{T} \times \mathcal{G}\) — cost of one unit of output |
| \(\mathrm{com}\) | Generator_committable over \(\mathcal{G}\) — whether output is gated by an on/off status decision |
| \(\mathrm{ru}\) | Generator_ramp_limit_up over \(\mathcal{G}\) — most a generator may raise its output between snapshots, per unit of nominal power; no value means no limit |
| \(\mathrm{rd}\) | Generator_ramp_limit_down over \(\mathcal{G}\) — most a generator may lower its output between snapshots, per unit of nominal power; no value means no limit |
| \(\mathrm{ru}^{\mathrm{up}}\) | Generator_ramp_limit_start_up over \(\mathcal{G}\) — most output in the snapshot a unit starts, per unit of nominal power |
| \(\mathrm{rd}^{\mathrm{dn}}\) | Generator_ramp_limit_shut_down over \(\mathcal{G}\) — most output in the snapshot before a unit stops, per unit of nominal power |
| \(\mathrm{UT}\) | Generator_min_up_time over \(\mathcal{G}\) — least snapshots a unit stays on once started |
| \(\mathrm{DT}\) | Generator_min_down_time over \(\mathcal{G}\) — least snapshots a unit stays off once stopped |
| \(\mathrm{u}^{0}\) | Generator_status_initial over \(\mathcal{G}\) — one where the unit was on before the first snapshot, zero where off — PyPSA's up_time_before > 0, data prep |
| \(\mathrm{hold}\) | Generator_must_stay_up over \(\mathcal{T} \times \mathcal{G}\) — true while the up time a unit brought into the horizon still binds — data prep, since position() compares against a literal rather than a parameter |
| \(\mathrm{c}^{\mathrm{up}}\) | Generator_start_up_cost over \(\mathcal{G}\) — cost of one start |
| \(\mathrm{c}^{\mathrm{dn}}\) | Generator_shut_down_cost over \(\mathcal{G}\) — cost of one stop |
| \(\mathrm{c}^{\mathrm{on}}\) | Generator_stand_by_cost over \(\mathcal{T} \times \mathcal{G}\) — cost of one snapshot spent on |
| \(\mathrm{p}^{\mathrm{mod}}\) | Generator_p_nom_mod over \(\mathcal{G}\) — the module size a build comes in whole numbers of; no value means the build is continuous |
| \(\mathrm{N}^{\mathrm{fix}}\) | Generator_modules_installed over \(\mathcal{G}\) — how many whole modules a committable build has in place: Generator_p_nom / Generator_p_nom_mod where a fixed build is modular, one where it is not, data prep. PyPSA refuses a fixed modular build whose nominal power is not a whole number of modules |
| \(\mathrm{f}^{\mathrm{nom}}\) | Link_p_nom over \(\mathcal{L}\) — nominal power |
| \(\mathrm{ext}^{f}\) | Link_p_nom_extendable over \(\mathcal{L}\) — whether the nominal power is a decision |
| \(\underline{\mathrm{f}}\) | Link_p_min_pu over \(\mathcal{T} \times \mathcal{L}\) — least flow, per unit of nominal power — negative for a link that carries both ways |
| \(\overline{\mathrm{f}}\) | Link_p_max_pu over \(\mathcal{T} \times \mathcal{L}\) — most flow, per unit of nominal power |
| \(\eta\) | Link_efficiency over \(\mathcal{O}\) — share of the flow that arrives at an output port, PyPSA's efficiency, efficiency2, … read long — negative where that port consumes rather than delivers |
| \(\mathrm{c}^{f}\) | Link_marginal_cost over \(\mathcal{T} \times \mathcal{L}\) — cost of one unit of flow |
| \(\mathrm{load}\) | Load_p_set over \(\mathcal{T} \times \mathcal{D}\) — demand |
Variables¶
| Symbol | Meaning |
|---|---|
| \(p\) | Generator_p over \(\mathcal{T} \times \mathcal{G}\) — Generator-p — output of a generator in a snapshot |
| \(f\) | Link_p over \(\mathcal{T} \times \mathcal{L}\) — Link-p — PyPSA's p0, the flow measured at the Link_bus0 end: a positive value withdraws there and injects at every bus the link's output ports deliver to |
| \(u\) | Generator_status over \(\mathcal{T} \times \mathcal{G}\) — Generator-status — how much of a committable unit is on: an integer the rows below cap at one, or at the module count where the build is modular |
| \(\mathit{up}\) | Generator_start_up over \(\mathcal{T} \times \mathcal{G}\) — Generator-start_up — how much of a committable unit turns on this snapshot, capped as the status is |
| \(\mathit{dn}\) | Generator_shut_down over \(\mathcal{T} \times \mathcal{G}\) — Generator-shut_down — how much of a committable unit turns off this snapshot, capped as the status is |
\(\mathrm{pos}(t)\) denotes where index \(t\) sits along its dimension's own order — the order shift walks, not the order labels sort in — counted from \(0\). The index itself stays the coordinate, so \(t\) compares against labels and \(\mathrm{pos}(t)\) against positions.
Objective¶
\[\min \sum_{t \in \mathcal{T},\enspace g \in \mathcal{G}} p_{t,g} \cdot \mathrm{c}_{t,g} \cdot \mathrm{w}_{t} + \sum_{t \in \mathcal{T},\enspace l \in \mathcal{L}} f_{t,l} \cdot \mathrm{c}^{f}_{t,l} \cdot \mathrm{w}_{t} + \sum_{t \in \mathcal{T},\enspace g \in \mathcal{G}} u_{t,g} \cdot \mathrm{c}^{\mathrm{on}}_{t,g} \cdot \mathrm{w}_{t} + \sum_{t \in \mathcal{T},\enspace g \in \mathcal{G}} \mathit{up}_{t,g} \cdot \mathrm{c}^{\mathrm{up}}_{g} + \sum_{t \in \mathcal{T},\enspace g \in \mathcal{G}} \mathit{dn}_{t,g} \cdot \mathrm{c}^{\mathrm{dn}}_{g}\]
Subject to¶
Generator_fix_p_lower
\[p_{t,g} \ge \underline{\mathrm{p}}_{t,g} \cdot \mathrm{p}^{\mathrm{nom}}_{g} \qquad \forall\thinspace t \in \mathcal{T},\enspace g \in \mathcal{G} \thinspace:\thinspace \neg \mathrm{ext}_{g} \wedge \neg \mathrm{com}_{g}\]
Generator_fix_p_upper
\[p_{t,g} \le \overline{\mathrm{p}}_{t,g} \cdot \mathrm{p}^{\mathrm{nom}}_{g} \qquad \forall\thinspace t \in \mathcal{T},\enspace g \in \mathcal{G} \thinspace:\thinspace \neg \mathrm{ext}_{g} \wedge \neg \mathrm{com}_{g}\]
Link_fix_p_lower
\[f_{t,l} \ge \underline{\mathrm{f}}_{t,l} \cdot \mathrm{f}^{\mathrm{nom}}_{l} \qquad \forall\thinspace t \in \mathcal{T},\enspace l \in \mathcal{L} \thinspace:\thinspace \neg \mathrm{ext}^{f}_{l}\]
Link_fix_p_upper
\[f_{t,l} \le \overline{\mathrm{f}}_{t,l} \cdot \mathrm{f}^{\mathrm{nom}}_{l} \qquad \forall\thinspace t \in \mathcal{T},\enspace l \in \mathcal{L} \thinspace:\thinspace \neg \mathrm{ext}^{f}_{l}\]
Generator_com_p_lower
\[p_{t,g} \ge \underline{\mathrm{p}}_{t,g} \cdot \mathrm{p}^{\mathrm{nom}}_{g} \cdot u_{t,g} \qquad \forall\thinspace t \in \mathcal{T},\enspace g \in \mathcal{G} \thinspace:\thinspace \mathrm{com}_{g} \wedge \neg \mathrm{ext}_{g}\]
Generator_com_p_upper
\[p_{t,g} \le \overline{\mathrm{p}}_{t,g} \cdot \mathrm{p}^{\mathrm{nom}}_{g} \cdot u_{t,g} \qquad \forall\thinspace t \in \mathcal{T},\enspace g \in \mathcal{G} \thinspace:\thinspace \mathrm{com}_{g} \wedge \neg \mathrm{ext}_{g}\]
Generator_com_transition_start_up
\[\mathit{up}_{t,g} \ge u_{t,g} - u_{t - 1,g} \qquad \forall\thinspace t \in \mathcal{T},\enspace g \in \mathcal{G} \thinspace:\thinspace \mathrm{com}_{g}\]
Generator_com_transition_start_up_initial
\[\mathit{up}_{t,g} \ge u_{t,g} - \mathrm{u}^{0}_{g} \qquad \forall\thinspace t \in \mathcal{T},\enspace g \in \mathcal{G} \thinspace:\thinspace \mathrm{com}_{g} \wedge \mathrm{pos}(t) = 0\]
Generator_com_transition_shut_down
\[\mathit{dn}_{t,g} \ge u_{t - 1,g} - u_{t,g} \qquad \forall\thinspace t \in \mathcal{T},\enspace g \in \mathcal{G} \thinspace:\thinspace \mathrm{com}_{g}\]
Generator_com_transition_shut_down_initial
\[\mathit{dn}_{t,g} \ge \mathrm{u}^{0}_{g} - u_{t,g} \qquad \forall\thinspace t \in \mathcal{T},\enspace g \in \mathcal{G} \thinspace:\thinspace \mathrm{com}_{g} \wedge \mathrm{pos}(t) = 0\]
Generator_com_up_time
\[\sum_{t' \in \mathcal{T} \thinspace:\thinspace 0 \le t - t' < \mathrm{UT}} \mathit{up}_{t',g} \le u_{t,g} \qquad \forall\thinspace t \in \mathcal{T},\enspace g \in \mathcal{G} \thinspace:\thinspace \mathrm{com}_{g} \wedge \mathrm{UT}_{g} > 0 \wedge \mathrm{pos}(t) > 0\]
Generator_com_down_time
\[\sum_{t' \in \mathcal{T} \thinspace:\thinspace 0 \le t - t' < \mathrm{DT}} \mathit{dn}_{t',g} \le 1 - u_{t,g} \qquad \forall\thinspace t \in \mathcal{T},\enspace g \in \mathcal{G} \thinspace:\thinspace \mathrm{com}_{g} \wedge \mathrm{DT}_{g} > 0 \wedge \mathrm{pos}(t) > 0\]
Generator_com_status_must_stay_up
\[u_{t,g} = 1 \qquad \forall\thinspace t \in \mathcal{T},\enspace g \in \mathcal{G} \thinspace:\thinspace \mathrm{com}_{g} \wedge \mathrm{hold}_{t,g}\]
Generator_p_ramp_limit_up_com
\[p_{t,g} - p_{t - 1,g} \le \mathrm{ru}_{g} \cdot \mathrm{p}^{\mathrm{nom}}_{g} \cdot u_{t - 1,g} + \mathrm{ru}^{\mathrm{up}}_{g} \cdot \mathrm{p}^{\mathrm{nom}}_{g} \cdot \left( u_{t,g} - u_{t - 1,g} \right) \qquad \forall\thinspace t \in \mathcal{T},\enspace g \in \mathcal{G} \thinspace:\thinspace \mathrm{com}_{g} \wedge \neg \mathrm{ext}_{g} \wedge \mathrm{ru}_{g} \text{ is defined}\]
Generator_p_ramp_limit_up_com_initial
\[p_{t,g} \le \mathrm{ru}_{g} \cdot \mathrm{p}^{\mathrm{nom}}_{g} \cdot \mathrm{u}^{0}_{g} + \mathrm{ru}^{\mathrm{up}}_{g} \cdot \mathrm{p}^{\mathrm{nom}}_{g} \cdot \left( u_{t,g} - \mathrm{u}^{0}_{g} \right) \qquad \forall\thinspace t \in \mathcal{T},\enspace g \in \mathcal{G} \thinspace:\thinspace \mathrm{com}_{g} \wedge \neg \mathrm{ext}_{g} \wedge \mathrm{ru}_{g} \text{ is defined} \wedge \mathrm{pos}(t) = 0 \wedge \mathrm{u}^{0}_{g} = 0\]
Generator_p_ramp_limit_down_com
\[p_{t - 1,g} - p_{t,g} \le \mathrm{rd}_{g} \cdot \mathrm{p}^{\mathrm{nom}}_{g} \cdot u_{t,g} + \mathrm{rd}^{\mathrm{dn}}_{g} \cdot \mathrm{p}^{\mathrm{nom}}_{g} \cdot \left( u_{t - 1,g} - u_{t,g} \right) \qquad \forall\thinspace t \in \mathcal{T},\enspace g \in \mathcal{G} \thinspace:\thinspace \mathrm{com}_{g} \wedge \neg \mathrm{ext}_{g} \wedge \mathrm{rd}_{g} \text{ is defined}\]
Generator_p_ramp_limit_down_com_initial
\[-p_{t,g} \le \mathrm{rd}_{g} \cdot \mathrm{p}^{\mathrm{nom}}_{g} \cdot u_{t,g} + \mathrm{rd}^{\mathrm{dn}}_{g} \cdot \mathrm{p}^{\mathrm{nom}}_{g} \cdot \left( \mathrm{u}^{0}_{g} - u_{t,g} \right) \qquad \forall\thinspace t \in \mathcal{T},\enspace g \in \mathcal{G} \thinspace:\thinspace \mathrm{com}_{g} \wedge \neg \mathrm{ext}_{g} \wedge \mathrm{rd}_{g} \text{ is defined} \wedge \mathrm{pos}(t) = 0 \wedge \mathrm{u}^{0}_{g} = 0\]
Generator_status_p_fixed_upper
\[u_{t,g} \le \mathrm{N}^{\mathrm{fix}}_{g} \qquad \forall\thinspace t \in \mathcal{T},\enspace g \in \mathcal{G} \thinspace:\thinspace \mathrm{com}_{g} \wedge \neg \left( \mathrm{ext}_{g} \wedge \mathrm{p}^{\mathrm{mod}}_{g} > 0 \right)\]
Generator_start_up_p_fixed_upper
\[\mathit{up}_{t,g} \le \mathrm{N}^{\mathrm{fix}}_{g} \qquad \forall\thinspace t \in \mathcal{T},\enspace g \in \mathcal{G} \thinspace:\thinspace \mathrm{com}_{g} \wedge \neg \left( \mathrm{ext}_{g} \wedge \mathrm{p}^{\mathrm{mod}}_{g} > 0 \right)\]
Generator_shut_down_p_fixed_upper
\[\mathit{dn}_{t,g} \le \mathrm{N}^{\mathrm{fix}}_{g} \qquad \forall\thinspace t \in \mathcal{T},\enspace g \in \mathcal{G} \thinspace:\thinspace \mathrm{com}_{g} \wedge \neg \left( \mathrm{ext}_{g} \wedge \mathrm{p}^{\mathrm{mod}}_{g} > 0 \right)\]
Bus_nodal_balance
\[\sum_{g \in \mathcal{G} \thinspace:\thinspace \mathrm{Generator\_bus}(g) = n} p_{t,g} - \left( \sum_{l \in \mathcal{L} \thinspace:\thinspace \mathrm{Link\_bus0}(l) = n} f_{t,l} \right) + \sum_{o \in \mathcal{O} \thinspace:\thinspace \mathrm{Link\_output\_bus}(o) = n} f_{t,\mathrm{Link\_output\_link}(o)} \cdot \eta_{o} = \sum_{d \in \mathcal{D} \thinspace:\thinspace \mathrm{Load\_bus}(d) = n} \mathrm{load}_{t,d} \qquad \forall\thinspace t \in \mathcal{T},\enspace n \in \mathcal{N}\]
Variable domains¶
Generator_p
\[p_{t,g} \in \mathbb{R} \qquad \forall\thinspace t \in \mathcal{T},\enspace g \in \mathcal{G}\]
Link_p
\[f_{t,l} \in \mathbb{R} \qquad \forall\thinspace t \in \mathcal{T},\enspace l \in \mathcal{L}\]
Generator_status
\[u_{t,g} \ge 0, u_{t,g} \in \mathbb{Z} \qquad \forall\thinspace t \in \mathcal{T},\enspace g \in \mathcal{G} \thinspace:\thinspace \mathrm{com}_{g}\]
Generator_start_up
\[\mathit{up}_{t,g} \ge 0, \mathit{up}_{t,g} \in \mathbb{Z} \qquad \forall\thinspace t \in \mathcal{T},\enspace g \in \mathcal{G} \thinspace:\thinspace \mathrm{com}_{g}\]
Generator_shut_down
\[\mathit{dn}_{t,g} \ge 0, \mathit{dn}_{t,g} \in \mathbb{Z} \qquad \forall\thinspace t \in \mathcal{T},\enspace g \in \mathcal{G} \thinspace:\thinspace \mathrm{com}_{g}\]
The model, differential/pypsa/rungs/rung_07_commitment.yaml — the file projected onto what this rung builds:
description: The model a plain `n.optimize()` builds, stated in one file. Every declaration is named `Component_attribute`
after the PyPSA statement it stands for, and each constraint's description opens with the linopy name
PyPSA gives that row, so the two can be read side by side. PyPSA's regimes — extendable, committable
— are data columns and become `where:` masks. Bounds are the explicit rows PyPSA writes, so their duals
are row duals. Parameters no PyPSA table carries verbatim are computed in data prep and say so in their
description.
dimensions:
snapshot: {description: dispatch periods, dtype: datetime}
bus: {description: network nodes}
generator: {description: 'generating units, each on one bus'}
link: {description: 'controllable connections, each from one bus to the buses it delivers to'}
link_output: {description: 'a link''s output ports, one label per port a link declares — PyPSA''s `bus1`,
`bus2`, … columns read long, so a link of any number of output ports is one term in the balance,
data prep'}
load: {description: 'demands, each on one bus'}
lookups:
Generator_bus: {description: the bus a generator sits on, over: generator, into: bus}
Link_bus0: {description: the bus a link leaves, over: link, into: bus}
Link_output_link: {description: the link an output port belongs to, over: link_output, into: link}
Link_output_bus: {description: 'the bus an output port delivers to — PyPSA''s `bus1`, `bus2`, … columns.
A link of three output ports is three labels here rather than a third lookup, so the file states
any number of them', over: link_output, into: bus}
Load_bus: {description: the bus a load sits on, over: load, into: bus}
parameters:
snapshot_weightings_objective:
description: PyPSA's `snapshot_weightings.objective` — hours a snapshot stands for in the cost
dims: [snapshot]
Generator_p_nom:
description: nominal power
dims: [generator]
Generator_p_nom_extendable:
description: whether the nominal power is a decision
dims: [generator]
dtype: bool
Generator_p_min_pu:
description: least output, per unit of nominal power
dims: [snapshot, generator]
Generator_p_max_pu:
description: most output, per unit of nominal power — an availability profile
dims: [snapshot, generator]
Generator_marginal_cost:
description: cost of one unit of output
dims: [snapshot, generator]
Generator_committable:
description: whether output is gated by an on/off status decision
dims: [generator]
dtype: bool
Generator_ramp_limit_up:
description: most a generator may raise its output between snapshots, per unit of nominal power; no
value means no limit
dims: [generator]
Generator_ramp_limit_down:
description: most a generator may lower its output between snapshots, per unit of nominal power; no
value means no limit
dims: [generator]
Generator_ramp_limit_start_up:
description: most output in the snapshot a unit starts, per unit of nominal power
dims: [generator]
Generator_ramp_limit_shut_down:
description: most output in the snapshot before a unit stops, per unit of nominal power
dims: [generator]
Generator_min_up_time:
description: least snapshots a unit stays on once started
dims: [generator]
dtype: int
Generator_min_down_time:
description: least snapshots a unit stays off once stopped
dims: [generator]
dtype: int
Generator_status_initial:
description: one where the unit was on before the first snapshot, zero where off — PyPSA's `up_time_before
> 0`, data prep
dims: [generator]
dtype: int
Generator_must_stay_up:
description: true while the up time a unit brought into the horizon still binds — data prep, since
`position()` compares against a literal rather than a parameter
dims: [snapshot, generator]
dtype: bool
Generator_start_up_cost:
description: cost of one start
dims: [generator]
Generator_shut_down_cost:
description: cost of one stop
dims: [generator]
Generator_stand_by_cost:
description: cost of one snapshot spent on
dims: [snapshot, generator]
Generator_p_nom_mod:
description: the module size a build comes in whole numbers of; no value means the build is continuous
dims: [generator]
Generator_modules_installed:
description: 'how many whole modules a committable build has in place: `Generator_p_nom / Generator_p_nom_mod`
where a fixed build is modular, one where it is not, data prep. PyPSA refuses a fixed modular build
whose nominal power is not a whole number of modules'
dims: [generator]
Link_p_nom:
description: nominal power
dims: [link]
Link_p_nom_extendable:
description: whether the nominal power is a decision
dims: [link]
dtype: bool
Link_p_min_pu:
description: least flow, per unit of nominal power — negative for a link that carries both ways
dims: [snapshot, link]
Link_p_max_pu:
description: most flow, per unit of nominal power
dims: [snapshot, link]
Link_efficiency:
description: share of the flow that arrives at an output port, PyPSA's `efficiency`, `efficiency2`,
… read long — negative where that port consumes rather than delivers
dims: [link_output]
Link_marginal_cost:
description: cost of one unit of flow
dims: [snapshot, link]
Load_p_set:
description: demand
dims: [snapshot, load]
variables:
Generator_p:
description: '`Generator-p` — output of a generator in a snapshot'
foreach: [snapshot, generator]
Link_p:
description: '`Link-p` — PyPSA''s `p0`, the flow measured at the `Link_bus0` end: a positive value
withdraws there and injects at every bus the link''s output ports deliver to'
foreach: [snapshot, link]
Generator_status:
description: '`Generator-status` — how much of a committable unit is on: an integer the rows below
cap at one, or at the module count where the build is modular'
foreach: [snapshot, generator]
where: Generator_committable
domain: integer
bounds: {lower: 0}
Generator_start_up:
description: '`Generator-start_up` — how much of a committable unit turns on this snapshot, capped
as the status is'
foreach: [snapshot, generator]
where: Generator_committable
domain: integer
bounds: {lower: 0}
Generator_shut_down:
description: '`Generator-shut_down` — how much of a committable unit turns off this snapshot, capped
as the status is'
foreach: [snapshot, generator]
where: Generator_committable
domain: integer
bounds: {lower: 0}
constraints:
Generator_fix_p_lower:
description: '`Generator-fix-p-lower` — a fixed generator outputs at least its minimum'
foreach: [snapshot, generator]
where: not Generator_p_nom_extendable AND not Generator_committable
expression: Generator_p >= Generator_p_min_pu * Generator_p_nom
Generator_fix_p_upper:
description: '`Generator-fix-p-upper` — a fixed generator outputs at most what is available'
foreach: [snapshot, generator]
where: not Generator_p_nom_extendable AND not Generator_committable
expression: Generator_p <= Generator_p_max_pu * Generator_p_nom
Link_fix_p_lower:
description: '`Link-fix-p-lower` — a fixed link carries at least its minimum, negative for the other
way'
foreach: [snapshot, link]
where: not Link_p_nom_extendable
expression: Link_p >= Link_p_min_pu * Link_p_nom
Link_fix_p_upper:
description: '`Link-fix-p-upper` — a fixed link carries at most its nominal power'
foreach: [snapshot, link]
where: not Link_p_nom_extendable
expression: Link_p <= Link_p_max_pu * Link_p_nom
Generator_com_p_lower:
description: '`Generator-com-p-lower` — a committed unit outputs at least its minimum; off, at least
nothing'
foreach: [snapshot, generator]
where: Generator_committable AND not Generator_p_nom_extendable
expression: Generator_p >= Generator_p_min_pu * Generator_p_nom * Generator_status
Generator_com_p_upper:
description: '`Generator-com-p-upper` — a committed unit outputs at most what is available; off, at
most nothing'
foreach: [snapshot, generator]
where: Generator_committable AND not Generator_p_nom_extendable
expression: Generator_p <= Generator_p_max_pu * Generator_p_nom * Generator_status
Generator_com_transition_start_up:
description: '`Generator-com-transition-start-up` — turning on is a start. The translated term vacates
the first snapshot; the initial block below compares it against the given status instead'
foreach: [snapshot, generator]
where: Generator_committable
expression: Generator_start_up >= Generator_status - shift(Generator_status, over=snapshot, offset=1)
Generator_com_transition_start_up_initial:
description: '`Generator-com-transition-start-up` — the first snapshot turns on against the status
the unit brought in'
foreach: [snapshot, generator]
where: Generator_committable AND position(snapshot) == 0
expression: Generator_start_up >= Generator_status - Generator_status_initial
Generator_com_transition_shut_down:
description: '`Generator-com-transition-shut-down` — turning off is a stop; the first snapshot is
the initial block''s'
foreach: [snapshot, generator]
where: Generator_committable
expression: Generator_shut_down >= shift(Generator_status, over=snapshot, offset=1) - Generator_status
Generator_com_transition_shut_down_initial:
description: '`Generator-com-transition-shut-down` — the first snapshot turns off against the status
the unit brought in'
foreach: [snapshot, generator]
where: Generator_committable AND position(snapshot) == 0
expression: Generator_shut_down >= Generator_status_initial - Generator_status
Generator_com_up_time:
description: '`Generator-com-up-time` — a unit started within its own minimum up time is still on.
The first snapshot''s share of the window is the brought-in up time''s, which the must-stay-up mask
carries'
foreach: [snapshot, generator]
where: Generator_committable AND Generator_min_up_time > 0 AND position(snapshot) > 0
expression: sum_back(Generator_start_up, over=snapshot, within=Generator_min_up_time) <= Generator_status
Generator_com_down_time:
description: '`Generator-com-down-time` — a unit stopped within its own minimum down time is still
off'
foreach: [snapshot, generator]
where: Generator_committable AND Generator_min_down_time > 0 AND position(snapshot) > 0
expression: sum_back(Generator_shut_down, over=snapshot, within=Generator_min_down_time) <= 1 - Generator_status
Generator_com_status_must_stay_up:
description: '`Generator-com-status-min_up_time_must_stay_up` — a unit still serving the up time it
brought in stays on'
foreach: [snapshot, generator]
where: Generator_committable AND Generator_must_stay_up
expression: Generator_status == 1
Generator_p_ramp_limit_up_com:
description: '`Generator-p-ramp_limit_up` — a committed unit raises output no faster than its limit
while it was already on, and no further than its start-up ramp in the snapshot it turns on'
foreach: [snapshot, generator]
where: Generator_committable AND not Generator_p_nom_extendable AND Generator_ramp_limit_up
expression: Generator_p - shift(Generator_p, over=snapshot, offset=1) <= Generator_ramp_limit_up *
Generator_p_nom * shift(Generator_status, over=snapshot, offset=1) + Generator_ramp_limit_start_up
* Generator_p_nom * (Generator_status - shift(Generator_status, over=snapshot, offset=1))
Generator_p_ramp_limit_up_com_initial:
description: '`Generator-p-ramp_limit_up` — a unit that was off ramps its first snapshot from an output
of nothing; one already on brought an unknown output, so it carries no row'
foreach: [snapshot, generator]
where: Generator_committable AND not Generator_p_nom_extendable AND Generator_ramp_limit_up AND position(snapshot)
== 0 AND Generator_status_initial == 0
expression: Generator_p <= Generator_ramp_limit_up * Generator_p_nom * Generator_status_initial +
Generator_ramp_limit_start_up * Generator_p_nom * (Generator_status - Generator_status_initial)
Generator_p_ramp_limit_down_com:
description: '`Generator-p-ramp_limit_down` — a committed unit lowers output no faster than its limit
while it stays on, and no further than its shut-down ramp in the snapshot it turns off'
foreach: [snapshot, generator]
where: Generator_committable AND not Generator_p_nom_extendable AND Generator_ramp_limit_down
expression: shift(Generator_p, over=snapshot, offset=1) - Generator_p <= Generator_ramp_limit_down
* Generator_p_nom * Generator_status + Generator_ramp_limit_shut_down * Generator_p_nom * (shift(Generator_status,
over=snapshot, offset=1) - Generator_status)
Generator_p_ramp_limit_down_com_initial:
description: '`Generator-p-ramp_limit_down` — a unit that was off ramps its first snapshot down from
an output of nothing; one already on carries no row'
foreach: [snapshot, generator]
where: Generator_committable AND not Generator_p_nom_extendable AND Generator_ramp_limit_down AND
position(snapshot) == 0 AND Generator_status_initial == 0
expression: -Generator_p <= Generator_ramp_limit_down * Generator_p_nom * Generator_status + Generator_ramp_limit_shut_down
* Generator_p_nom * (Generator_status_initial - Generator_status)
Generator_status_p_fixed_upper:
description: '`Generator-status-p-fixed-upper` — a status is at most the modules in place, an explicit
row as PyPSA writes it: one where the build is not modular, and the fixed build''s whole count of
modules where it is'
foreach: [snapshot, generator]
where: Generator_committable AND NOT (Generator_p_nom_extendable AND Generator_p_nom_mod > 0)
expression: Generator_status <= Generator_modules_installed
Generator_start_up_p_fixed_upper:
description: '`Generator-start_up-p-fixed-upper` — a start is at most the modules in place, an explicit
row as PyPSA writes it: one where the build is not modular, and the fixed build''s whole count of
modules where it is'
foreach: [snapshot, generator]
where: Generator_committable AND NOT (Generator_p_nom_extendable AND Generator_p_nom_mod > 0)
expression: Generator_start_up <= Generator_modules_installed
Generator_shut_down_p_fixed_upper:
description: '`Generator-shut_down-p-fixed-upper` — a stop is at most the modules in place, an explicit
row as PyPSA writes it: one where the build is not modular, and the fixed build''s whole count of
modules where it is'
foreach: [snapshot, generator]
where: Generator_committable AND NOT (Generator_p_nom_extendable AND Generator_p_nom_mod > 0)
expression: Generator_shut_down <= Generator_modules_installed
Bus_nodal_balance:
description: '`Bus-nodal_balance` — what is generated at a bus, storage dispatch and stores included,
less what the links take away, plus what arrives over them after losses at every port they deliver
to, meets the load there. A bus nothing is attached to has no row; PyPSA refuses one that carries
load, and this file does not yet.'
foreach: [snapshot, bus]
expression: sum(Generator_p, by=Generator_bus) - sum(Link_p, by=Link_bus0) + sum(at(Link_p, by=Link_output_link)
* Link_efficiency, by=Link_output_bus) == sum(Load_p_set, by=Load_bus)
objective: {sense: minimize, description: 'operating cost, each snapshot weighted by the hours it stands
for', expression: sum(Generator_p * Generator_marginal_cost * snapshot_weightings_objective) + sum(Link_p
* Link_marginal_cost * snapshot_weightings_objective) + sum(Generator_status * Generator_stand_by_cost
* snapshot_weightings_objective) + sum(Generator_start_up * Generator_start_up_cost) + sum(Generator_shut_down
* Generator_shut_down_cost)}
The binding — every table the model declares, from the network — and the solve:
from differential.pypsa.prep import lookup, static, varying, weighting
def _link_ports(n: pypsa.Network) -> pd.DataFrame:
"""A link's output ports read long — one row per port a link declares, carrying the link, the bus it delivers to and its efficiency.
PyPSA spells the ports across columns — ``bus1``/``efficiency``, ``bus2``/``efficiency2``, … — and a
link declares a port by naming a bus in one, so a link of any port count is as many rows here and
one term in the balance. The label is the link and the column the port came from.
"""
links = n.static('Link')
blank = pd.Series('', index=links.index, dtype=str)
frames = []
for port in ['1', *n.components.links.additional_ports]:
suffix = '' if port == '1' else port
buses = links.get(f'bus{port}', blank).astype(str)
efficiencies = links.get(f'efficiency{suffix}', pd.Series(1.0, index=links.index)).astype(float)
frame = pd.DataFrame(
keyed(links.index, 'link') | {'bus': buses.to_numpy(), 'value': efficiencies.to_numpy(), 'port': int(port)}
)
frames.append(frame[buses.to_numpy() != ''])
ports = pd.concat(frames, ignore_index=True).sort_values(['link', 'port'], kind='stable')
ports['link_output'] = ports['link'] + '_bus' + ports['port'].astype(str)
return ports.drop(columns='port').reset_index(drop=True)
def _modules_installed(n: pypsa.Network) -> pd.DataFrame:
"""The whole modules a build has standing — ``p_nom / p_nom_mod`` where a fixed build is modular, one where it is not.
PyPSA refuses a fixed modular build whose nominal power is not a whole number of modules, so the
division is exact and left unrounded: a fraction here is a network this prep should not have taken.
"""
generators = n.static('Generator')
modular = ~generators['p_nom_extendable'] & (generators.get('p_nom_mod', 0.0) > 0)
counts = generators['p_nom'].where(modular, 1.0) / generators.get('p_nom_mod', 1.0).where(modular, 1.0)
return pd.DataFrame(keyed(generators.index, 'generator') | {'value': counts.to_numpy()})
def _must_stay_up(n: pypsa.Network) -> pd.DataFrame:
"""True while the up time a unit brought into the horizon still binds."""
rows = []
for name, g in n.generators.iterrows():
if not g['committable'] or g['up_time_before'] <= 0:
continue
remaining = int(min(g['min_up_time'] - g['up_time_before'], len(n.snapshots)))
rows.extend({'snapshot': t, 'generator': str(name), 'value': True} for t in timesteps(n)[: max(remaining, 0)])
table = pd.DataFrame(rows, columns=['snapshot', 'generator', 'value'])
return table.astype({'value': bool})
def _per_port(n: pypsa.Network, column: str) -> pd.DataFrame:
"""One column of the long port table keyed by ``link_output`` — what each port names, or the efficiency it carries."""
ports = _link_ports(n)
keys = [key for key in ('scenario', 'link_output') if key in ports.columns]
return ports[[*keys, column]]
n = build() # the network from the PyPSA tab
sources = {
'snapshot': pl.Series('snapshot', list(timesteps(n)), dtype=pl.Datetime('us')),
'bus': pl.Series('bus', list(names(n.buses.index).astype(str)), dtype=pl.String),
'generator': pl.Series('generator', list(names(generators.index).astype(str)), dtype=pl.String),
'link': pl.Series('link', list(names(links.index).astype(str)), dtype=pl.String),
'link_output': pl.Series('link_output', list(pd.unique(_link_ports(n)['link_output'])), dtype=pl.String),
'load': pl.Series('load', list(names(loads.index).astype(str)), dtype=pl.String),
'Generator_bus': lookup(n, 'Generator', 'bus'),
'Link_bus0': lookup(n, 'Link', 'bus0'),
'Link_output_link': _per_port(n, 'link'),
'Link_output_bus': _per_port(n, 'bus'),
'Load_bus': lookup(n, 'Load', 'bus'),
'snapshot_weightings_objective': weighting(n, 'objective'),
'Generator_p_nom': static(n, 'Generator', 'p_nom'),
'Generator_p_nom_extendable': static(n, 'Generator', 'p_nom_extendable'),
'Generator_p_min_pu': varying(n, 'Generator', 'p_min_pu'),
'Generator_p_max_pu': varying(n, 'Generator', 'p_max_pu'),
'Generator_marginal_cost': varying(n, 'Generator', 'marginal_cost'),
'Generator_committable': static(n, 'Generator', 'committable'),
'Generator_ramp_limit_up': static(n, 'Generator', 'ramp_limit_up').dropna(),
'Generator_ramp_limit_down': static(n, 'Generator', 'ramp_limit_down').dropna(),
'Generator_ramp_limit_start_up': static(n, 'Generator', 'ramp_limit_start_up').fillna({'value': 1.0}),
'Generator_ramp_limit_shut_down': static(n, 'Generator', 'ramp_limit_shut_down').fillna({'value': 1.0}),
'Generator_min_up_time': static(n, 'Generator', 'min_up_time'),
'Generator_min_down_time': static(n, 'Generator', 'min_down_time'),
'Generator_status_initial': pd.DataFrame(
keyed(generators.index, 'generator')
| {
'value': (generators['up_time_before'] > 0).astype(int).to_numpy(),
}
),
'Generator_must_stay_up': _must_stay_up(n),
'Generator_start_up_cost': static(n, 'Generator', 'start_up_cost'),
'Generator_shut_down_cost': static(n, 'Generator', 'shut_down_cost'),
'Generator_stand_by_cost': varying(n, 'Generator', 'stand_by_cost'),
'Generator_p_nom_mod': static(n, 'Generator', 'p_nom_mod').query('value > 0'),
'Generator_modules_installed': _modules_installed(n),
'Link_p_nom': static(n, 'Link', 'p_nom'),
'Link_p_nom_extendable': static(n, 'Link', 'p_nom_extendable'),
'Link_p_min_pu': varying(n, 'Link', 'p_min_pu'),
'Link_p_max_pu': varying(n, 'Link', 'p_max_pu'),
'Link_efficiency': _per_port(n, 'value'),
'Link_marginal_cost': varying(n, 'Link', 'marginal_cost'),
'Load_p_set': varying(n, 'Load', 'p_set'),
}
with lps.solve('differential/pypsa/rungs/rung_07_commitment.yaml', sources) as solution:
solution.objective # 7775.0
The network, rung_07_commitment.py in the corpus — the spine plus what this rung adds:
"""Rung 7: commitment — committable units with up and down times and ramp limits at the transitions."""
from __future__ import annotations
import spine
def build():
"""The spine plus this rung's additions, as a ``pypsa.Network``."""
n = spine.build()
n.add(
'Generator',
'uc',
bus='north',
committable=True,
p_nom=50,
marginal_cost=5,
p_min_pu=0.4,
min_up_time=3,
min_down_time=2,
up_time_before=1,
ramp_limit_up=0.5,
ramp_limit_down=0.5,
ramp_limit_start_up=0.6,
ramp_limit_shut_down=0.6,
start_up_cost=100,
shut_down_cost=50,
stand_by_cost=5,
)
n.add(
'Generator',
'cold',
bus='south',
committable=True,
p_nom=30,
marginal_cost=60,
p_min_pu=0.3,
min_up_time=2,
min_down_time=1,
up_time_before=0,
ramp_limit_up=0.5,
ramp_limit_down=0.5,
start_up_cost=80,
)
n.add('Load', 'swing7', bus='north', p_set=[25, 45, 45, 10])
return n
The data¶
The tables this rung is the first to declare (10), as the binding produced them:
Generator_min_down_time.csv
Generator_min_up_time.csv
Generator_modules_installed.csv
Generator_must_stay_up.csv
Generator_ramp_limit_shut_down.csv
Generator_ramp_limit_start_up.csv
Generator_shut_down_cost.csv
Generator_stand_by_cost.csv
snapshot,generator,value
2015-01-01T00:00:00.000000,coal,0.0
2015-01-01T00:00:00.000000,cold,0.0
2015-01-01T00:00:00.000000,gas,0.0
2015-01-01T00:00:00.000000,uc,5.0
2015-01-01T01:00:00.000000,coal,0.0
2015-01-01T01:00:00.000000,cold,0.0
2015-01-01T01:00:00.000000,gas,0.0
2015-01-01T01:00:00.000000,uc,5.0
2015-01-01T02:00:00.000000,coal,0.0
2015-01-01T02:00:00.000000,cold,0.0
2015-01-01T02:00:00.000000,gas,0.0
2015-01-01T02:00:00.000000,uc,5.0
2015-01-01T03:00:00.000000,coal,0.0
2015-01-01T03:00:00.000000,cold,0.0
2015-01-01T03:00:00.000000,gas,0.0
2015-01-01T03:00:00.000000,uc,5.0
Generator_start_up_cost.csv
Generator_status_initial.csv