Rung 5: global constraints — one row per limit type and sense¶
One rung of the PyPSA corpus: the file pypsa.yaml projected onto what this network builds, attached to that network, and held to what PyPSA solves it to.
✔ Verified against pypsa 1.3.0 — objective 10282.833333333332 on both sides; structure ≠
operational_limit3 vs 1+1+1 — one block per sense — ==, <=, >= — where PyPSA writes one row per labelled constraint whatever its sense;primary_energy3 vs 1+1+1 — one block per sense — ==, <=, >= — where PyPSA writes one row per labelled constraint whatever its sense; size ✔ 102 rows · ✔ 44 columns · ✔ 190 nonzeros; duals ✔ 102 rows, 2 negated; model for model: 23 blocks equal, 2 documented splits.
Rows and columns, PyPSA against specsolve, name for name
| row | PyPSA | specsolve |
|---|---|---|
Bus-nodal_balance |
8 | 8 |
Generator-fix-p-lower |
20 | 20 |
Generator-fix-p-upper |
20 | 20 |
Link-fix-p-lower |
4 | 4 |
Link-fix-p-upper |
4 | 4 |
StorageUnit-energy_balance |
4 | 4 |
StorageUnit-fix-p_dispatch-lower |
4 | 4 |
StorageUnit-fix-p_dispatch-upper |
4 | 4 |
StorageUnit-fix-p_store-lower |
4 | 4 |
StorageUnit-fix-p_store-upper |
4 | 4 |
StorageUnit-fix-state_of_charge-lower |
4 | 4 |
StorageUnit-fix-state_of_charge-upper |
4 | 4 |
Store-energy_balance |
4 | 4 |
Store-fix-e-lower |
4 | 4 |
Store-fix-e-upper |
4 | 4 |
operational_limit |
3 | ≠ 1+1+1 |
primary_energy |
3 | ≠ 1+1+1 |
| column | PyPSA | specsolve |
|---|---|---|
Generator-p |
20 | 20 |
Link-p |
4 | 4 |
StorageUnit-p_dispatch |
4 | 4 |
StorageUnit-p_store |
4 | 4 |
StorageUnit-state_of_charge |
4 | 4 |
Store-e |
4 | 4 |
Store-p |
4 | 4 |
The model¶
The same model, as math
The spec of the model a plain n.optimize() builds, 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 with \(\mathrm{Generator\_bus}: \mathcal{G} \to \mathcal{N},\ \mathrm{Link\_bus0}: \mathcal{L} \to \mathcal{N},\ \mathrm{Link\_output\_bus}: \mathcal{O} \to \mathcal{N},\ \mathrm{Load\_bus}: \mathcal{D} \to \mathcal{N},\ \mathrm{StorageUnit\_bus}: \mathcal{S} \to \mathcal{N},\ \mathrm{Store\_bus}: \mathcal{V} \to \mathcal{N}\) — 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},\ \mathrm{Link\_output\_link}: \mathcal{O} \to \mathcal{L}\) — 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},\ \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 |
| \(\mathcal{S}\) | index \(s\) — storage_unit with \(\mathrm{StorageUnit\_bus}: \mathcal{S} \to \mathcal{N}\) — storage units, dispatch and store behind one bus connection |
| \(\mathcal{V}\) | index \(v\) — store with \(\mathrm{Store\_bus}: \mathcal{V} \to \mathcal{N}\) — pure energy stores, each on one bus |
| \(\mathcal{B}\) | index \(b\) — global_constraint — PyPSA's GlobalConstraint rows, one label per declared limit |
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{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{d}^{f}\) | Link_output_delay over \(\mathcal{O}\) — snapshots a port's delivery lags its link's flow — PyPSA's delay, delay2, … read long, in snapshot_weightings.generators units, which the file states as whole snapshots; zero for a port that delivers at once |
| \(\mathrm{cyc}^{f}\) | Link_output_cyclic_delay over \(\mathcal{O}\) — whether a delayed port's flow wraps from the horizon's end — PyPSA's cyclic_delay, cyclic_delay2, …; where it does not, the flow still in transit at the first snapshots is lost |
| \(\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 |
| \(\mathrm{w}^{\mathrm{sto}}\) | snapshot_weightings_stores over \(\mathcal{T}\) — PyPSA's snapshot_weightings.stores — hours a snapshot stands for in a storage balance |
| \(\mathrm{w}^{\mathrm{gen}}\) | snapshot_weightings_generators over \(\mathcal{T}\) — PyPSA's snapshot_weightings.generators — hours a snapshot stands for in an energy total |
| \(\mathrm{h}^{\mathrm{nom}}\) | StorageUnit_p_nom over \(\mathcal{S}\) — nominal power |
| \(\mathrm{ext}^{h}\) | StorageUnit_p_nom_extendable over \(\mathcal{S}\) — whether the nominal power is a decision |
| \(\underline{\mathrm{h}}\) | StorageUnit_p_min_pu over \(\mathcal{T} \times \mathcal{S}\) — most storing, per unit of nominal power and negated |
| \(\overline{\mathrm{h}}\) | StorageUnit_p_max_pu over \(\mathcal{T} \times \mathcal{S}\) — most dispatch, per unit of nominal power |
| \(\mathrm{T}^{h}\) | StorageUnit_max_hours over \(\mathcal{S}\) — energy capacity, as hours of dispatch at nominal power |
| \(\eta^{-}\) | StorageUnit_efficiency_store over \(\mathcal{S}\) — share of the power drawn from the bus that becomes charge |
| \(\eta^{+}\) | StorageUnit_efficiency_dispatch over \(\mathcal{S}\) — share of the charge drawn down that reaches the bus |
| \(\rho\) | StorageUnit_retention over \(\mathcal{T} \times \mathcal{S}\) — share of charge kept over a snapshot — PyPSA's (1 - standing_loss) ** elapsed hours, data prep |
| \(\mathrm{soc}^{0}\) | StorageUnit_state_of_charge_initial over \(\mathcal{S}\) — charge held before the first snapshot |
| \(\mathrm{cyc}\) | StorageUnit_cyclic_state_of_charge over \(\mathcal{S}\) — whether the horizon closes on itself instead of opening on the initial charge |
| \(\mathrm{c}^{h}\) | StorageUnit_marginal_cost over \(\mathcal{T} \times \mathcal{S}\) — cost of one unit of dispatch |
| \(\mathrm{c}^{\mathrm{soc}}\) | StorageUnit_marginal_cost_storage over \(\mathcal{T} \times \mathcal{S}\) — cost of one unit of charge held over one snapshot |
| \(\mathrm{e}^{\mathrm{nom}}\) | Store_e_nom over \(\mathcal{V}\) — nominal energy capacity |
| \(\mathrm{ext}^{e}\) | Store_e_nom_extendable over \(\mathcal{V}\) — whether the nominal energy capacity is a decision |
| \(\underline{\mathrm{e}}\) | Store_e_min_pu over \(\mathcal{T} \times \mathcal{V}\) — least energy held, per unit of nominal capacity — negative for a store that may go short |
| \(\overline{\mathrm{e}}\) | Store_e_max_pu over \(\mathcal{T} \times \mathcal{V}\) — most energy held, per unit of nominal capacity |
| \(\rho^{e}\) | Store_retention over \(\mathcal{T} \times \mathcal{V}\) — share of energy kept over a snapshot — PyPSA's (1 - standing_loss) ** elapsed hours, data prep |
| \(\mathrm{e}^{0}\) | Store_e_initial over \(\mathcal{V}\) — energy held before the first snapshot |
| \(\mathrm{cyc}^{e}\) | Store_e_cyclic over \(\mathcal{V}\) — whether the horizon closes on itself instead of opening on the initial energy |
| \(\mathrm{c}^{q}\) | Store_marginal_cost over \(\mathcal{T} \times \mathcal{V}\) — cost of one unit of power delivered |
| \(\mathrm{c}^{e}\) | Store_marginal_cost_storage over \(\mathcal{T} \times \mathcal{V}\) — cost of one unit of energy held over one snapshot |
| \(\mathrm{type}\) | GlobalConstraint_type over \(\mathcal{B}\) — which formula the row takes — primary_energy, operational_limit, transmission_volume_expansion_limit, transmission_expansion_cost_limit or tech_capacity_expansion_limit |
| \(\mathrm{sense}\) | GlobalConstraint_sense over \(\mathcal{B}\) — which way the row binds — <=, >= or == |
| \(\mathrm{K}\) | GlobalConstraint_constant over \(\mathcal{B}\) — the constant the total is held against; what a variable cannot carry — an initial charge, a non-extendable build — is folded in here by data prep |
| \(\mathrm{last}\) | snapshot_is_last over \(\mathcal{T}\) — one at the horizon's last snapshot, zero elsewhere — data prep, how an expression reads a final level |
| \(\mathrm{a}\) | Generator_primary_energy_weight over \(\mathcal{B} \times \mathcal{G}\) — the constrained attribute per unit of energy at the bus — the carrier's co2_emissions over the generator's efficiency, data prep; a generator of an unweighted carrier has no row |
| \(\mathrm{a}^{h}\) | StorageUnit_primary_energy_weight over \(\mathcal{B} \times \mathcal{S}\) — the constrained attribute per unit of charge depleted — data prep; an unweighted unit has no row |
| \(\mathrm{a}^{e}\) | Store_primary_energy_weight over \(\mathcal{B} \times \mathcal{V}\) — the constrained attribute per unit of energy depleted — data prep; an unweighted store has no row |
| \(\mathrm{b}\) | Generator_operational_limit_weight over \(\mathcal{B} \times \mathcal{G}\) — one where the generator is in the row's set — data prep; one outside it has no row |
| \(\mathrm{b}^{h}\) | StorageUnit_operational_limit_weight over \(\mathcal{B} \times \mathcal{S}\) — one where the storage unit is in the row's set — data prep; one outside it has no row |
| \(\mathrm{b}^{e}\) | Store_operational_limit_weight over \(\mathcal{B} \times \mathcal{V}\) — one where the store is in the row's set — data prep; one outside it has no row |
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 |
| \(h^{+}\) | StorageUnit_p_dispatch over \(\mathcal{T} \times \mathcal{S}\) — StorageUnit-p_dispatch — power delivered to the bus |
| \(h^{-}\) | StorageUnit_p_store over \(\mathcal{T} \times \mathcal{S}\) — StorageUnit-p_store — power drawn from the bus into charge |
| \(\mathit{soc}\) | StorageUnit_state_of_charge over \(\mathcal{T} \times \mathcal{S}\) — StorageUnit-state_of_charge — energy held at the end of a snapshot |
| \(e\) | Store_e over \(\mathcal{T} \times \mathcal{V}\) — Store-e — energy held at the end of a snapshot |
| \(q\) | Store_p over \(\mathcal{T} \times \mathcal{V}\) — Store-p — power delivered to the bus; charging is negative |
Definitions¶
| Symbol | Meaning |
|---|---|
| \(\mathit{StorageUnit\_charge\_carried\_in}\) | StorageUnit_charge_carried_in over \(\mathcal{T} \times \mathcal{S}\) — the charge a unit opens a snapshot with — its last snapshot's less standing loss where it is cyclic, the given initial charge at the start of the horizon, which no standing loss has touched yet, and the previous snapshot's less standing loss otherwise |
| \(\mathit{Store\_energy\_carried\_in}\) | Store_energy_carried_in over \(\mathcal{T} \times \mathcal{V}\) — the energy a store opens a snapshot with — its last snapshot's less standing loss where it is cyclic, the given initial energy at the start of the horizon, which no standing loss has touched yet, and the previous snapshot's less standing loss otherwise |
| \(\mathit{Link\_output\_arrival}\) | Link_output_arrival over \(\mathcal{T} \times \mathcal{O}\) — what a link delivers to an output port at a snapshot — its flow after the port's efficiency, delayed by the port's delay; where the port is cyclic_delay the delayed flow wraps from the horizon's end, and where it is not the flow still in transit at the first snapshots is lost. A port that does not delay (delay zero) delivers its flow unshifted, cyclic or not |
| \(\mathit{primary\_energy}\) | primary_energy over \(\mathcal{B}\) — what a primary_energy row totals — weighted generator energy, less the charge left in weighted storage at the horizon's end; the initial charge it is compared against is folded into the row's constant |
| \(\mathit{operational\_limit}\) | operational_limit over \(\mathcal{B}\) — what an operational_limit row totals — the weighted energy its generators deliver, plus what its non-cyclic storage draws down; the initial charge it draws from is folded into the row's constant |
\(t \ominus k\) denotes cyclic translation: index \(t-k\) taken modulo the size of the dimension (roll). Plain \(t-k\) (shift) has no wraparound — terms translated past the edge are simply absent.
\(t \boxminus_{v} k\) denotes translation with \(v\) standing where index \(t-k\) leaves the dimension (shift(edge=v)), so the row at that boundary is built and carries \(v\) rather than being dropped.
\(\mathrm{pos}(t)\) denotes where index \(t\) sits along its dimension's own order — the order shift steps along, 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},\ g \in \mathcal{G}} p_{t,g} \cdot \mathrm{c}_{t,g} \cdot \mathrm{w}_{t} + \sum_{t \in \mathcal{T},\ l \in \mathcal{L}} f_{t,l} \cdot \mathrm{c}^{f}_{t,l} \cdot \mathrm{w}_{t} + \sum_{t \in \mathcal{T},\ s \in \mathcal{S}} h^{+}_{t,s} \cdot \mathrm{c}^{h}_{t,s} \cdot \mathrm{w}_{t} + \sum_{t \in \mathcal{T},\ s \in \mathcal{S}} \mathit{soc}_{t,s} \cdot \mathrm{c}^{\mathrm{soc}}_{t,s} \cdot \mathrm{w}_{t} + \sum_{t \in \mathcal{T},\ v \in \mathcal{V}} q_{t,v} \cdot \mathrm{c}^{q}_{t,v} \cdot \mathrm{w}_{t} + \sum_{t \in \mathcal{T},\ v \in \mathcal{V}} e_{t,v} \cdot \mathrm{c}^{e}_{t,v} \cdot \mathrm{w}_{t}
\]
Subject to¶
Generator_fix_p_lower
\[
p_{t,g} \ge \underline{\mathrm{p}}_{t,g} \cdot \mathrm{p}^{\mathrm{nom}}_{g} \qquad \forall\, t \in \mathcal{T},\ g \in \mathcal{G} \,:\, \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\, t \in \mathcal{T},\ g \in \mathcal{G} \,:\, \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\, t \in \mathcal{T},\ l \in \mathcal{L} \,:\, \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\, t \in \mathcal{T},\ l \in \mathcal{L} \,:\, \neg \mathrm{ext}^{f}_{l}
\]
StorageUnit_fix_p_dispatch_lower
\[
h^{+}_{t,s} \ge 0 \qquad \forall\, t \in \mathcal{T},\ s \in \mathcal{S} \,:\, \neg \mathrm{ext}^{h}_{s}
\]
StorageUnit_fix_p_dispatch_upper
\[
h^{+}_{t,s} \le \overline{\mathrm{h}}_{t,s} \cdot \mathrm{h}^{\mathrm{nom}}_{s} \qquad \forall\, t \in \mathcal{T},\ s \in \mathcal{S} \,:\, \neg \mathrm{ext}^{h}_{s}
\]
StorageUnit_fix_p_store_lower
\[
h^{-}_{t,s} \ge 0 \qquad \forall\, t \in \mathcal{T},\ s \in \mathcal{S} \,:\, \neg \mathrm{ext}^{h}_{s}
\]
StorageUnit_fix_p_store_upper
\[
h^{-}_{t,s} \le -\underline{\mathrm{h}}_{t,s} \cdot \mathrm{h}^{\mathrm{nom}}_{s} \qquad \forall\, t \in \mathcal{T},\ s \in \mathcal{S} \,:\, \neg \mathrm{ext}^{h}_{s}
\]
StorageUnit_fix_state_of_charge_lower
\[
\mathit{soc}_{t,s} \ge 0 \qquad \forall\, t \in \mathcal{T},\ s \in \mathcal{S} \,:\, \neg \mathrm{ext}^{h}_{s}
\]
StorageUnit_fix_state_of_charge_upper
\[
\mathit{soc}_{t,s} \le \mathrm{T}^{h}_{s} \cdot \mathrm{h}^{\mathrm{nom}}_{s} \qquad \forall\, t \in \mathcal{T},\ s \in \mathcal{S} \,:\, \neg \mathrm{ext}^{h}_{s}
\]
StorageUnit_energy_balance
\[
\mathit{soc}_{t,s} = \mathit{StorageUnit\_charge\_carried\_in}_{t,s} + \eta^{-}_{s} \cdot h^{-}_{t,s} \cdot \mathrm{w}^{\mathrm{sto}}_{t} - \frac{h^{+}_{t,s} \cdot \mathrm{w}^{\mathrm{sto}}_{t}}{\eta^{+}_{s}} \qquad \forall\, t \in \mathcal{T},\ s \in \mathcal{S}
\]
Store_fix_e_lower
\[
e_{t,v} \ge \underline{\mathrm{e}}_{t,v} \cdot \mathrm{e}^{\mathrm{nom}}_{v} \qquad \forall\, t \in \mathcal{T},\ v \in \mathcal{V} \,:\, \neg \mathrm{ext}^{e}_{v}
\]
Store_fix_e_upper
\[
e_{t,v} \le \overline{\mathrm{e}}_{t,v} \cdot \mathrm{e}^{\mathrm{nom}}_{v} \qquad \forall\, t \in \mathcal{T},\ v \in \mathcal{V} \,:\, \neg \mathrm{ext}^{e}_{v}
\]
Store_energy_balance
\[
e_{t,v} = \mathit{Store\_energy\_carried\_in}_{t,v} - q_{t,v} \cdot \mathrm{w}^{\mathrm{sto}}_{t} \qquad \forall\, t \in \mathcal{T},\ v \in \mathcal{V}
\]
GlobalConstraint_primary_energy_ub
\[
\mathit{primary\_energy}_{b} \le \mathrm{K}_{b} \qquad \forall\, b \in \mathcal{B} \,:\, \mathrm{type}_{b} = \text{'}\mathrm{primary\_energy}\text{'} \wedge \mathrm{sense}_{b} = \text{'}\mathrm{<=}\text{'}
\]
GlobalConstraint_primary_energy_lb
\[
\mathit{primary\_energy}_{b} \ge \mathrm{K}_{b} \qquad \forall\, b \in \mathcal{B} \,:\, \mathrm{type}_{b} = \text{'}\mathrm{primary\_energy}\text{'} \wedge \mathrm{sense}_{b} = \text{'}\mathrm{>=}\text{'}
\]
GlobalConstraint_primary_energy_eq
\[
\mathit{primary\_energy}_{b} = \mathrm{K}_{b} \qquad \forall\, b \in \mathcal{B} \,:\, \mathrm{type}_{b} = \text{'}\mathrm{primary\_energy}\text{'} \wedge \mathrm{sense}_{b} = \text{'}\mathrm{==}\text{'}
\]
GlobalConstraint_operational_limit_ub
\[
\mathit{operational\_limit}_{b} \le \mathrm{K}_{b} \qquad \forall\, b \in \mathcal{B} \,:\, \mathrm{type}_{b} = \text{'}\mathrm{operational\_limit}\text{'} \wedge \mathrm{sense}_{b} = \text{'}\mathrm{<=}\text{'}
\]
GlobalConstraint_operational_limit_lb
\[
\mathit{operational\_limit}_{b} \ge \mathrm{K}_{b} \qquad \forall\, b \in \mathcal{B} \,:\, \mathrm{type}_{b} = \text{'}\mathrm{operational\_limit}\text{'} \wedge \mathrm{sense}_{b} = \text{'}\mathrm{>=}\text{'}
\]
GlobalConstraint_operational_limit_eq
\[
\mathit{operational\_limit}_{b} = \mathrm{K}_{b} \qquad \forall\, b \in \mathcal{B} \,:\, \mathrm{type}_{b} = \text{'}\mathrm{operational\_limit}\text{'} \wedge \mathrm{sense}_{b} = \text{'}\mathrm{==}\text{'}
\]
Bus_nodal_balance
\[
\sum_{g \in \mathcal{G} \,:\, \mathrm{Generator\_bus}(g) = n} p_{t,g} + \sum_{s \in \mathcal{S} \,:\, \mathrm{StorageUnit\_bus}(s) = n} \left( h^{+}_{t,s} - h^{-}_{t,s} \right) + \sum_{v \in \mathcal{V} \,:\, \mathrm{Store\_bus}(v) = n} q_{t,v} - \left( \sum_{l \in \mathcal{L} \,:\, \mathrm{Link\_bus0}(l) = n} f_{t,l} \right) + \sum_{o \in \mathcal{O} \,:\, \mathrm{Link\_output\_bus}(o) = n} \mathit{Link\_output\_arrival}_{t,o} = \sum_{d \in \mathcal{D} \,:\, \mathrm{Load\_bus}(d) = n} \mathrm{load}_{t,d} \qquad \forall\, t \in \mathcal{T},\ n \in \mathcal{N}
\]
Definitions¶
StorageUnit_charge_carried_in
\[
\mathit{StorageUnit\_charge\_carried\_in}_{t,s} = \begin{cases} \rho_{t,s} \cdot \mathit{soc}_{t \ominus 1,s} & \text{if } \mathrm{cyc}_{s} \\ \mathrm{soc}^{0}_{s} & \text{if } \neg \mathrm{cyc}_{s} \wedge \mathrm{pos}(t) = 0 \\ \rho_{t,s} \cdot \mathit{soc}_{t - 1,s} & \text{otherwise} \end{cases} \qquad \forall\, t \in \mathcal{T},\ s \in \mathcal{S}
\]
Store_energy_carried_in
\[
\mathit{Store\_energy\_carried\_in}_{t,v} = \begin{cases} \rho^{e}_{t,v} \cdot e_{t \ominus 1,v} & \text{if } \mathrm{cyc}^{e}_{v} \\ \mathrm{e}^{0}_{v} & \text{if } \neg \mathrm{cyc}^{e}_{v} \wedge \mathrm{pos}(t) = 0 \\ \rho^{e}_{t,v} \cdot e_{t - 1,v} & \text{otherwise} \end{cases} \qquad \forall\, t \in \mathcal{T},\ v \in \mathcal{V}
\]
Link_output_arrival
\[
\mathit{Link\_output\_arrival}_{t,o} = \begin{cases} f_{t \ominus \mathrm{d}^{f},\mathrm{Link\_output\_link}(o)} \cdot \eta_{o} & \text{if } \mathrm{cyc}^{f}_{o} \\ f_{t \boxminus_{0} \mathrm{d}^{f},\mathrm{Link\_output\_link}(o)} \cdot \eta_{o} & \text{otherwise} \end{cases} \qquad \forall\, t \in \mathcal{T},\ o \in \mathcal{O}
\]
primary_energy
\[
\mathit{primary\_energy}_{b} = \sum_{g \in \mathcal{G}} \sum_{t \in \mathcal{T}} p_{t,g} \cdot \mathrm{w}^{\mathrm{gen}}_{t} \cdot \mathrm{a}_{b,g} - \left( \sum_{s \in \mathcal{S}} \sum_{t \in \mathcal{T}} \mathit{soc}_{t,s} \cdot \mathrm{last}_{t} \cdot \mathrm{a}^{h}_{b,s} \right) - \left( \sum_{v \in \mathcal{V}} \sum_{t \in \mathcal{T}} e_{t,v} \cdot \mathrm{last}_{t} \cdot \mathrm{a}^{e}_{b,v} \right) \qquad \forall\, b \in \mathcal{B}
\]
operational_limit
\[
\mathit{operational\_limit}_{b} = \sum_{g \in \mathcal{G}} \sum_{t \in \mathcal{T}} p_{t,g} \cdot \mathrm{w}^{\mathrm{gen}}_{t} \cdot \mathrm{b}_{b,g} - \left( \sum_{s \in \mathcal{S}} \sum_{t \in \mathcal{T}} \mathit{soc}_{t,s} \cdot \mathrm{last}_{t} \cdot \mathrm{b}^{h}_{b,s} \right) - \left( \sum_{v \in \mathcal{V}} \sum_{t \in \mathcal{T}} e_{t,v} \cdot \mathrm{last}_{t} \cdot \mathrm{b}^{e}_{b,v} \right) \qquad \forall\, b \in \mathcal{B}
\]
Variable domains¶
Generator_p
\[
p_{t,g} \in \mathbb{R} \qquad \forall\, t \in \mathcal{T},\ g \in \mathcal{G}
\]
Link_p
\[
f_{t,l} \in \mathbb{R} \qquad \forall\, t \in \mathcal{T},\ l \in \mathcal{L}
\]
StorageUnit_p_dispatch
\[
h^{+}_{t,s} \in \mathbb{R} \qquad \forall\, t \in \mathcal{T},\ s \in \mathcal{S}
\]
StorageUnit_p_store
\[
h^{-}_{t,s} \in \mathbb{R} \qquad \forall\, t \in \mathcal{T},\ s \in \mathcal{S}
\]
StorageUnit_state_of_charge
\[
\mathit{soc}_{t,s} \in \mathbb{R} \qquad \forall\, t \in \mathcal{T},\ s \in \mathcal{S}
\]
Store_e
\[
e_{t,v} \in \mathbb{R} \qquad \forall\, t \in \mathcal{T},\ v \in \mathcal{V}
\]
Store_p
\[
q_{t,v} \in \mathbb{R} \qquad \forall\, t \in \mathcal{T},\ v \in \mathcal{V}
\]
The spec, differential/pypsa/rungs/rung_05_global_constraints.yaml — the file projected onto what this rung builds:
description: The spec of the model a plain `n.optimize()` builds, 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'}
storage_unit: {description: 'storage units, dispatch and store behind one bus connection'}
store: {description: 'pure energy stores, each on one bus'}
global_constraint: {description: 'PyPSA''s `GlobalConstraint` rows, one label per declared limit'}
relations:
Generator_bus: {description: the bus a generator sits on, key: generator, values: bus}
Link_bus0: {description: the bus a link leaves, key: link, values: bus}
Link_output_link: {description: the link an output port belongs to, key: link_output, values: 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 relation, so the file states
any number of them', key: link_output, values: bus}
Load_bus: {description: the bus a load sits on, key: load, values: bus}
StorageUnit_bus: {description: the bus a storage unit sits on, key: storage_unit, values: bus}
Store_bus: {description: the bus a store sits on, key: store, values: 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
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_output_delay:
description: snapshots a port's delivery lags its link's flow — PyPSA's `delay`, `delay2`, … read
long, in `snapshot_weightings.generators` units, which the file states as whole snapshots; zero
for a port that delivers at once
dims: [link_output]
dtype: int
Link_output_cyclic_delay:
description: whether a delayed port's flow wraps from the horizon's end — PyPSA's `cyclic_delay`,
`cyclic_delay2`, …; where it does not, the flow still in transit at the first snapshots is lost
dims: [link_output]
dtype: bool
Link_marginal_cost:
description: cost of one unit of flow
dims: [snapshot, link]
Load_p_set:
description: demand
dims: [snapshot, load]
snapshot_weightings_stores:
description: PyPSA's `snapshot_weightings.stores` — hours a snapshot stands for in a storage balance
dims: [snapshot]
snapshot_weightings_generators:
description: PyPSA's `snapshot_weightings.generators` — hours a snapshot stands for in an energy total
dims: [snapshot]
StorageUnit_p_nom:
description: nominal power
dims: [storage_unit]
StorageUnit_p_nom_extendable:
description: whether the nominal power is a decision
dims: [storage_unit]
dtype: bool
StorageUnit_p_min_pu:
description: most storing, per unit of nominal power and negated
dims: [snapshot, storage_unit]
StorageUnit_p_max_pu:
description: most dispatch, per unit of nominal power
dims: [snapshot, storage_unit]
StorageUnit_max_hours:
description: energy capacity, as hours of dispatch at nominal power
dims: [storage_unit]
StorageUnit_efficiency_store:
description: share of the power drawn from the bus that becomes charge
dims: [storage_unit]
StorageUnit_efficiency_dispatch:
description: share of the charge drawn down that reaches the bus
dims: [storage_unit]
StorageUnit_retention:
description: share of charge kept over a snapshot — PyPSA's `(1 - standing_loss) ** elapsed hours`,
data prep
dims: [snapshot, storage_unit]
StorageUnit_state_of_charge_initial:
description: charge held before the first snapshot
dims: [storage_unit]
StorageUnit_cyclic_state_of_charge:
description: whether the horizon closes on itself instead of opening on the initial charge
dims: [storage_unit]
dtype: bool
StorageUnit_marginal_cost:
description: cost of one unit of dispatch
dims: [snapshot, storage_unit]
StorageUnit_marginal_cost_storage:
description: cost of one unit of charge held over one snapshot
dims: [snapshot, storage_unit]
Store_e_nom:
description: nominal energy capacity
dims: [store]
Store_e_nom_extendable:
description: whether the nominal energy capacity is a decision
dims: [store]
dtype: bool
Store_e_min_pu:
description: least energy held, per unit of nominal capacity — negative for a store that may go short
dims: [snapshot, store]
Store_e_max_pu:
description: most energy held, per unit of nominal capacity
dims: [snapshot, store]
Store_retention:
description: share of energy kept over a snapshot — PyPSA's `(1 - standing_loss) ** elapsed hours`,
data prep
dims: [snapshot, store]
Store_e_initial:
description: energy held before the first snapshot
dims: [store]
Store_e_cyclic:
description: whether the horizon closes on itself instead of opening on the initial energy
dims: [store]
dtype: bool
Store_marginal_cost:
description: cost of one unit of power delivered
dims: [snapshot, store]
Store_marginal_cost_storage:
description: cost of one unit of energy held over one snapshot
dims: [snapshot, store]
GlobalConstraint_type:
description: which formula the row takes — `primary_energy`, `operational_limit`, `transmission_volume_expansion_limit`,
`transmission_expansion_cost_limit` or `tech_capacity_expansion_limit`
dims: [global_constraint]
dtype: str
GlobalConstraint_sense:
description: which way the row binds — `<=`, `>=` or `==`
dims: [global_constraint]
dtype: str
GlobalConstraint_constant:
description: the constant the total is held against; what a variable cannot carry — an initial charge,
a non-extendable build — is folded in here by data prep
dims: [global_constraint]
snapshot_is_last:
description: one at the horizon's last snapshot, zero elsewhere — data prep, how an expression reads
a final level
dims: [snapshot]
dtype: int
Generator_primary_energy_weight:
description: the constrained attribute per unit of energy at the bus — the carrier's `co2_emissions`
over the generator's efficiency, data prep; a generator of an unweighted carrier has no row
dims: [global_constraint, generator]
StorageUnit_primary_energy_weight:
description: the constrained attribute per unit of charge depleted — data prep; an unweighted unit
has no row
dims: [global_constraint, storage_unit]
Store_primary_energy_weight:
description: the constrained attribute per unit of energy depleted — data prep; an unweighted store
has no row
dims: [global_constraint, store]
Generator_operational_limit_weight:
description: one where the generator is in the row's set — data prep; one outside it has no row
dims: [global_constraint, generator]
StorageUnit_operational_limit_weight:
description: one where the storage unit is in the row's set — data prep; one outside it has no row
dims: [global_constraint, storage_unit]
Store_operational_limit_weight:
description: one where the store is in the row's set — data prep; one outside it has no row
dims: [global_constraint, store]
variables:
Generator_p:
description: '`Generator-p` — output of a generator in a snapshot'
dims: [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'
dims: [snapshot, link]
StorageUnit_p_dispatch:
description: '`StorageUnit-p_dispatch` — power delivered to the bus'
dims: [snapshot, storage_unit]
StorageUnit_p_store:
description: '`StorageUnit-p_store` — power drawn from the bus into charge'
dims: [snapshot, storage_unit]
StorageUnit_state_of_charge:
description: '`StorageUnit-state_of_charge` — energy held at the end of a snapshot'
dims: [snapshot, storage_unit]
Store_e:
description: '`Store-e` — energy held at the end of a snapshot'
dims: [snapshot, store]
Store_p:
description: '`Store-p` — power delivered to the bus; charging is negative'
dims: [snapshot, store]
constraints:
Generator_fix_p_lower:
description: '`Generator-fix-p-lower` — a fixed generator outputs at least its minimum'
dims: [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'
dims: [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'
dims: [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'
dims: [snapshot, link]
where: not Link_p_nom_extendable
expression: Link_p <= Link_p_max_pu * Link_p_nom
StorageUnit_fix_p_dispatch_lower:
description: '`StorageUnit-fix-p_dispatch-lower` — dispatch is non-negative'
dims: [snapshot, storage_unit]
where: not StorageUnit_p_nom_extendable
expression: StorageUnit_p_dispatch >= 0
StorageUnit_fix_p_dispatch_upper:
description: '`StorageUnit-fix-p_dispatch-upper` — a fixed unit dispatches at most its nominal power'
dims: [snapshot, storage_unit]
where: not StorageUnit_p_nom_extendable
expression: StorageUnit_p_dispatch <= StorageUnit_p_max_pu * StorageUnit_p_nom
StorageUnit_fix_p_store_lower:
description: '`StorageUnit-fix-p_store-lower` — storing is non-negative'
dims: [snapshot, storage_unit]
where: not StorageUnit_p_nom_extendable
expression: StorageUnit_p_store >= 0
StorageUnit_fix_p_store_upper:
description: '`StorageUnit-fix-p_store-upper` — a fixed unit stores at most its nominal power, the
minimum-per-unit column carrying that cap negated'
dims: [snapshot, storage_unit]
where: not StorageUnit_p_nom_extendable
expression: StorageUnit_p_store <= -StorageUnit_p_min_pu * StorageUnit_p_nom
StorageUnit_fix_state_of_charge_lower:
description: '`StorageUnit-fix-state_of_charge-lower` — charge is non-negative'
dims: [snapshot, storage_unit]
where: not StorageUnit_p_nom_extendable
expression: StorageUnit_state_of_charge >= 0
StorageUnit_fix_state_of_charge_upper:
description: '`StorageUnit-fix-state_of_charge-upper` — a fixed unit holds at most its hours at nominal
power'
dims: [snapshot, storage_unit]
where: not StorageUnit_p_nom_extendable
expression: StorageUnit_state_of_charge <= StorageUnit_max_hours * StorageUnit_p_nom
StorageUnit_energy_balance:
description: '`StorageUnit-energy_balance` — the charge carried in, plus what is stored after its
efficiency, less what dispatch draws down before its own, plus inflow not spilled'
dims: [snapshot, storage_unit]
expression: StorageUnit_state_of_charge == StorageUnit_charge_carried_in + StorageUnit_efficiency_store
* StorageUnit_p_store * snapshot_weightings_stores - StorageUnit_p_dispatch * snapshot_weightings_stores
/ StorageUnit_efficiency_dispatch
Store_fix_e_lower:
description: '`Store-fix-e-lower` — a fixed store holds at least its floor'
dims: [snapshot, store]
where: not Store_e_nom_extendable
expression: Store_e >= Store_e_min_pu * Store_e_nom
Store_fix_e_upper:
description: '`Store-fix-e-upper` — a fixed store holds at most its nominal capacity'
dims: [snapshot, store]
where: not Store_e_nom_extendable
expression: Store_e <= Store_e_max_pu * Store_e_nom
Store_energy_balance:
description: '`Store-energy_balance` — the energy carried in, less what is delivered to the bus'
dims: [snapshot, store]
expression: Store_e == Store_energy_carried_in - Store_p * snapshot_weightings_stores
GlobalConstraint_primary_energy_ub:
description: '`primary_energy` — its total, at most its constant'
dims: [global_constraint]
where: GlobalConstraint_type == 'primary_energy' AND GlobalConstraint_sense == '<='
expression: primary_energy <= GlobalConstraint_constant
GlobalConstraint_primary_energy_lb:
description: '`primary_energy` — its total, at least its constant'
dims: [global_constraint]
where: GlobalConstraint_type == 'primary_energy' AND GlobalConstraint_sense == '>='
expression: primary_energy >= GlobalConstraint_constant
GlobalConstraint_primary_energy_eq:
description: '`primary_energy` — its total, at its constant'
dims: [global_constraint]
where: GlobalConstraint_type == 'primary_energy' AND GlobalConstraint_sense == '=='
expression: primary_energy == GlobalConstraint_constant
GlobalConstraint_operational_limit_ub:
description: '`operational_limit` — its total, at most its constant'
dims: [global_constraint]
where: GlobalConstraint_type == 'operational_limit' AND GlobalConstraint_sense == '<='
expression: operational_limit <= GlobalConstraint_constant
GlobalConstraint_operational_limit_lb:
description: '`operational_limit` — its total, at least its constant'
dims: [global_constraint]
where: GlobalConstraint_type == 'operational_limit' AND GlobalConstraint_sense == '>='
expression: operational_limit >= GlobalConstraint_constant
GlobalConstraint_operational_limit_eq:
description: '`operational_limit` — its total, at its constant'
dims: [global_constraint]
where: GlobalConstraint_type == 'operational_limit' AND GlobalConstraint_sense == '=='
expression: operational_limit == GlobalConstraint_constant
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 and any delay 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.'
dims: [snapshot, bus]
expression: sum(Generator_p, by=Generator_bus, over=generator, into=bus) + sum(StorageUnit_p_dispatch
- StorageUnit_p_store, by=StorageUnit_bus, over=storage_unit, into=bus) + sum(Store_p, by=Store_bus,
over=store, into=bus) - sum(Link_p, by=Link_bus0, over=link, into=bus) + sum(Link_output_arrival,
by=Link_output_bus, over=link_output, into=bus) == sum(Load_p_set, by=Load_bus, over=load, into=bus)
expressions:
StorageUnit_charge_carried_in:
description: the charge a unit opens a snapshot with — its last snapshot's less standing loss where
it is cyclic, the given initial charge at the start of the horizon, which no standing loss has touched
yet, and the previous snapshot's less standing loss otherwise
dims: [snapshot, storage_unit]
cases:
cyclic: {when: StorageUnit_cyclic_state_of_charge, expression: 'StorageUnit_retention * shift(StorageUnit_state_of_charge,
along=snapshot, offset=1, edge=''wrap'')'}
opening: {when: not StorageUnit_cyclic_state_of_charge AND position(snapshot) == 0, expression: StorageUnit_state_of_charge_initial}
otherwise: StorageUnit_retention * shift(StorageUnit_state_of_charge, along=snapshot, offset=1)
Store_energy_carried_in:
description: the energy a store opens a snapshot with — its last snapshot's less standing loss where
it is cyclic, the given initial energy at the start of the horizon, which no standing loss has touched
yet, and the previous snapshot's less standing loss otherwise
dims: [snapshot, store]
cases:
cyclic: {when: Store_e_cyclic, expression: 'Store_retention * shift(Store_e, along=snapshot, offset=1,
edge=''wrap'')'}
opening: {when: not Store_e_cyclic AND position(snapshot) == 0, expression: Store_e_initial}
otherwise: Store_retention * shift(Store_e, along=snapshot, offset=1)
Link_output_arrival:
description: what a link delivers to an output port at a snapshot — its flow after the port's efficiency,
delayed by the port's `delay`; where the port is `cyclic_delay` the delayed flow wraps from the
horizon's end, and where it is not the flow still in transit at the first snapshots is lost. A port
that does not delay (`delay` zero) delivers its flow unshifted, cyclic or not
dims: [snapshot, link_output]
cases:
wrapping: {when: Link_output_cyclic_delay, expression: 'shift(at(Link_p, by=Link_output_link, over=link,
into=link_output) * Link_efficiency, along=snapshot, offset=Link_output_delay, edge=''wrap'')'}
otherwise: shift(at(Link_p, by=Link_output_link, over=link, into=link_output) * Link_efficiency, along=snapshot,
offset=Link_output_delay, edge=0)
primary_energy: {description: 'what a `primary_energy` row totals — weighted generator energy, less
the charge left in weighted storage at the horizon''s end; the initial charge it is compared against
is folded into the row''s constant', expression: 'sum(sum(Generator_p * snapshot_weightings_generators
* Generator_primary_energy_weight, over=snapshot), over=generator) - sum(sum(StorageUnit_state_of_charge
* snapshot_is_last * StorageUnit_primary_energy_weight, over=snapshot), over=storage_unit) - sum(sum(Store_e
* snapshot_is_last * Store_primary_energy_weight, over=snapshot), over=store)'}
operational_limit: {description: 'what an `operational_limit` row totals — the weighted energy its generators
deliver, plus what its non-cyclic storage draws down; the initial charge it draws from is folded
into the row''s constant', expression: 'sum(sum(Generator_p * snapshot_weightings_generators * Generator_operational_limit_weight,
over=snapshot), over=generator) - sum(sum(StorageUnit_state_of_charge * snapshot_is_last * StorageUnit_operational_limit_weight,
over=snapshot), over=storage_unit) - sum(sum(Store_e * snapshot_is_last * Store_operational_limit_weight,
over=snapshot), over=store)'}
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(StorageUnit_p_dispatch * StorageUnit_marginal_cost
* snapshot_weightings_objective) + sum(StorageUnit_state_of_charge * StorageUnit_marginal_cost_storage
* snapshot_weightings_objective) + sum(Store_p * Store_marginal_cost * snapshot_weightings_objective)
+ sum(Store_e * Store_marginal_cost_storage * snapshot_weightings_objective)}
The prep — every table the spec declares, from the network — and the solve:
from differential.pypsa.prep import relation, static, varying, weighting
def _emissions(n: pypsa.Network, gc: pd.Series) -> pd.Series:
"""The nonzero values of the carrier attribute a `primary_energy` row weighs."""
values = n.carriers[gc['carrier_attribute']]
return values[values != 0]
def _gc_constants(n: pypsa.Network) -> pd.DataFrame:
"""Each row's constant, net of the initial charge PyPSA folds into its side of the row.
A `primary_energy` or `operational_limit` row counts what its non-cyclic
storage draws down, so PyPSA adds the initial charge as a constant on the
variable side; the file keeps the variables and moves it here.
"""
rows = []
for label, gc in n.global_constraints.iterrows():
constant = float(gc['constant'])
if gc['type'] == 'primary_energy':
emissions = _emissions(n, gc)
sus = n.storage_units
member = sus['carrier'].isin(emissions.index) & ~sus['cyclic_state_of_charge']
constant -= float(
(sus.loc[member, 'carrier'].map(emissions) * sus.loc[member, 'state_of_charge_initial']).sum()
)
stores = n.stores
member = stores['carrier'].isin(emissions.index) & ~stores['e_cyclic']
constant -= float((stores.loc[member, 'carrier'].map(emissions) * stores.loc[member, 'e_initial']).sum())
if gc['type'] == 'operational_limit':
sus = n.storage_units
member = (sus['carrier'] == gc['carrier_attribute']) & ~sus['cyclic_state_of_charge']
constant -= float(sus.loc[member, 'state_of_charge_initial'].sum())
stores = n.stores
member = (stores['carrier'] == gc['carrier_attribute']) & ~stores['e_cyclic']
constant -= float(stores.loc[member, 'e_initial'].sum())
rows.append({'global_constraint': str(label), 'value': constant})
return pd.DataFrame(rows, columns=['global_constraint', 'value']).astype({'value': float})
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)
# `efficiency`, `delay` and `cyclic_delay` are PyPSA's unsuffixed attributes: port 1
# spells them bare and every port after it takes the number
efficiencies = links.get(f'efficiency{suffix}', pd.Series(1.0, index=links.index)).astype(float)
delays = links.get(f'delay{suffix}', pd.Series(0, index=links.index)).fillna(0).astype(int)
cyclic = links.get(f'cyclic_delay{suffix}', pd.Series(False, index=links.index)).fillna(False).astype(bool)
frame = pd.DataFrame(
keyed(links.index, 'link')
| {
'bus': buses.to_numpy(),
'value': efficiencies.to_numpy(),
'delay': delays.to_numpy(),
'cyclic_delay': cyclic.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 _per_port(n: pypsa.Network, column: str, as_name: str | None = None) -> pd.DataFrame:
"""One column of the long port table keyed by ``link_output`` — what a port names, or what it carries.
*as_name* is what the file calls it: a relation keeps its target dimension's
own name, and every parameter over the ports lands under ``value``.
"""
ports = _link_ports(n)
keys = [key for key in ('scenario', 'link_output') if key in ports.columns]
return ports[[*keys, column]].rename(columns={column: as_name or column})
def _retention(n: pypsa.Network, component: str, dim: str) -> pd.DataFrame:
losses = n.static(component)['standing_loss']
hours = n.snapshot_weightings['stores'].to_numpy()
dense = pd.DataFrame({name: (1.0 - loss) ** hours for name, loss in losses.items()}, index=timesteps(n))
table = dense.melt(ignore_index=False, var_name=dim).reset_index(names='snapshot')
return table.astype({dim: str, 'value': float})
def _weights(gcs: pd.DataFrame, components: pd.DataFrame, dim: str, value) -> pd.DataFrame:
"""One row per (global constraint, member): *value* returns the weight, or 0/None outside the row's set."""
rows = [
{'global_constraint': str(label), dim: str(name), 'value': float(v)}
for label, gc in gcs.iterrows()
for name, component in components.iterrows()
if (v := value(gc, component))
]
return pd.DataFrame(rows, columns=['global_constraint', dim, 'value']).astype({'value': float})
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),
'storage_unit': pl.Series('storage_unit', list(names(storage_units.index).astype(str)), dtype=pl.String),
'store': pl.Series('store', list(names(stores.index).astype(str)), dtype=pl.String),
'global_constraint': pl.Series(
'global_constraint', list(names(n.global_constraints.index).astype(str)), dtype=pl.String
),
**scenarios(n),
**periods(n),
**carriers(n),
'Generator_bus': relation(n, 'Generator', 'bus'),
'Link_bus0': relation(n, 'Link', 'bus0'),
'Link_output_link': _per_port(n, 'link'),
'Link_output_bus': _per_port(n, 'bus'),
'Load_bus': relation(n, 'Load', 'bus'),
'StorageUnit_bus': relation(n, 'StorageUnit', 'bus'),
'Store_bus': relation(n, 'Store', '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'),
'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_output_delay': _per_port(n, 'delay', 'value'),
'Link_output_cyclic_delay': _per_port(n, 'cyclic_delay', 'value'),
'Link_marginal_cost': varying(n, 'Link', 'marginal_cost'),
'Load_p_set': varying(n, 'Load', 'p_set'),
'snapshot_weightings_stores': weighting(n, 'stores'),
'snapshot_weightings_generators': weighting(n, 'generators'),
'StorageUnit_p_nom': static(n, 'StorageUnit', 'p_nom'),
'StorageUnit_p_nom_extendable': static(n, 'StorageUnit', 'p_nom_extendable'),
'StorageUnit_p_min_pu': varying(n, 'StorageUnit', 'p_min_pu'),
'StorageUnit_p_max_pu': varying(n, 'StorageUnit', 'p_max_pu'),
'StorageUnit_max_hours': static(n, 'StorageUnit', 'max_hours'),
'StorageUnit_efficiency_store': static(n, 'StorageUnit', 'efficiency_store'),
'StorageUnit_efficiency_dispatch': static(n, 'StorageUnit', 'efficiency_dispatch'),
'StorageUnit_retention': _retention(n, 'StorageUnit', 'storage_unit'),
'StorageUnit_state_of_charge_initial': static(n, 'StorageUnit', 'state_of_charge_initial'),
'StorageUnit_cyclic_state_of_charge': static(n, 'StorageUnit', 'cyclic_state_of_charge'),
'StorageUnit_marginal_cost': varying(n, 'StorageUnit', 'marginal_cost'),
'StorageUnit_marginal_cost_storage': varying(n, 'StorageUnit', 'marginal_cost_storage'),
'Store_e_nom': static(n, 'Store', 'e_nom'),
'Store_e_nom_extendable': static(n, 'Store', 'e_nom_extendable'),
'Store_e_min_pu': varying(n, 'Store', 'e_min_pu'),
'Store_e_max_pu': varying(n, 'Store', 'e_max_pu'),
'Store_retention': _retention(n, 'Store', 'store'),
'Store_e_initial': static(n, 'Store', 'e_initial'),
'Store_e_cyclic': static(n, 'Store', 'e_cyclic'),
'Store_marginal_cost': varying(n, 'Store', 'marginal_cost'),
'Store_marginal_cost_storage': varying(n, 'Store', 'marginal_cost_storage'),
'GlobalConstraint_type': static(n, 'GlobalConstraint', 'type').astype({'value': str}),
'GlobalConstraint_sense': static(n, 'GlobalConstraint', 'sense').astype({'value': str}),
'GlobalConstraint_constant': _gc_constants(n),
'snapshot_is_last': pd.DataFrame(
{
'snapshot': timesteps(n),
'value': [0] * (len(n.snapshots) - 1) + [1] if len(n.snapshots) else [],
}
),
'Generator_primary_energy_weight': _weights(
primary, generators, 'generator', lambda gc, g: _emissions(n, gc).get(g['carrier'], 0.0) / g['efficiency']
),
'StorageUnit_primary_energy_weight': _weights(
primary,
storage_units,
'storage_unit',
lambda gc, s: 0.0 if s['cyclic_state_of_charge'] else _emissions(n, gc).get(s['carrier'], 0.0),
),
'Store_primary_energy_weight': _weights(
primary, stores, 'store', lambda gc, s: 0.0 if s['e_cyclic'] else _emissions(n, gc).get(s['carrier'], 0.0)
),
'Generator_operational_limit_weight': _weights(
operational, generators, 'generator', lambda gc, g: float(g['carrier'] == gc['carrier_attribute'])
),
'StorageUnit_operational_limit_weight': _weights(
operational,
storage_units,
'storage_unit',
lambda gc, s: float(s['carrier'] == gc['carrier_attribute'] and not s['cyclic_state_of_charge']),
),
'Store_operational_limit_weight': _weights(
operational,
stores,
'store',
lambda gc, s: float(s['carrier'] == gc['carrier_attribute'] and not s['e_cyclic']),
),
}
with sps.solve('differential/pypsa/rungs/rung_05_global_constraints.yaml', sources) as solution:
solution.objective # 10282.833333333332
The network, rung_05_global_constraints.py in the corpus — the spine plus what this rung adds:
"""Rung 5: global constraints — one row per limit type and sense."""
from __future__ import annotations
import spine
def build():
"""The spine plus this rung's additions, as a ``pypsa.Network``."""
n = spine.build()
n.add('Carrier', 'coalc', co2_emissions=0.9)
n.add('Carrier', 'gasc', co2_emissions=0.4)
n.add('Carrier', 'windc')
n.add('Generator', 'coal5', bus='north', carrier='coalc', p_nom=60, marginal_cost=9, efficiency=0.35)
n.add('Generator', 'gas5', bus='north', carrier='gasc', p_nom=60, marginal_cost=25, efficiency=0.5)
n.add('Generator', 'wind5', bus='north', carrier='windc', p_nom=60, marginal_cost=40)
n.add('Load', 'extra5', bus='north', p_set=50)
n.add('StorageUnit', 'res5', bus='north', carrier='gasc', p_nom=20, max_hours=4, state_of_charge_initial=30)
n.add('Store', 'tank5', bus='north', carrier='coalc', e_nom=40, e_initial=25)
n.add(
'GlobalConstraint',
'co2_cap',
type='primary_energy',
carrier_attribute='co2_emissions',
sense='<=',
constant=150,
)
n.add(
'GlobalConstraint',
'co2_floor',
type='primary_energy',
carrier_attribute='co2_emissions',
sense='>=',
constant=20,
)
n.add(
'GlobalConstraint',
'co2_exact',
type='primary_energy',
carrier_attribute='co2_emissions',
sense='==',
constant=120,
)
n.add('GlobalConstraint', 'op_wind', type='operational_limit', carrier_attribute='windc', sense='==', constant=30)
n.add('GlobalConstraint', 'op_coal', type='operational_limit', carrier_attribute='coalc', sense='<=', constant=200)
n.add('GlobalConstraint', 'op_gas', type='operational_limit', carrier_attribute='gasc', sense='>=', constant=10)
return n
The data¶
The tables this rung is the first to declare (7), as the prep produced them:
Generator_operational_limit_weight.csv
Generator_primary_energy_weight.csv
global_constraint,generator,value
co2_cap,coal5,2.571428571429
co2_cap,gas5,0.8
co2_exact,coal5,2.571428571429
co2_exact,gas5,0.8
co2_floor,coal5,2.571428571429
co2_floor,gas5,0.8
StorageUnit_operational_limit_weight.csv
StorageUnit_primary_energy_weight.csv
Store_operational_limit_weight.csv
Store_primary_energy_weight.csv
snapshot_is_last.csv