Rung 2: storage — a cyclic battery, an inflow reservoir with a set state of charge, and a store¶
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 4456.659315422355 on both sides; structure ≠
StorageUnit-energy_balance8 vs 3+4+1 — three blocks — carried, initial, cyclic — where PyPSA masks one row three ways;Store-energy_balance4 vs 3+1 — three blocks — carried, initial, cyclic — where PyPSA masks one row three ways; size ✔ 103 rows · ✔ 48 columns · ✔ 166 nonzeros; duals ✔ 103 rows, 2 negated; model for model: 25 blocks equal, 2 documented splits.
Rows and columns, PyPSA against lpspec, name for name
| row | PyPSA | lpspec |
|---|---|---|
Bus-nodal_balance |
8 | 8 |
Generator-fix-p-lower |
8 | 8 |
Generator-fix-p-upper |
8 | 8 |
Link-fix-p-lower |
4 | 4 |
Link-fix-p-upper |
4 | 4 |
StorageUnit-energy_balance |
8 | ≠ 3+4+1 |
StorageUnit-fix-p_dispatch-lower |
8 | 8 |
StorageUnit-fix-p_dispatch-upper |
8 | 8 |
StorageUnit-fix-p_store-lower |
8 | 8 |
StorageUnit-fix-p_store-upper |
8 | 8 |
StorageUnit-fix-state_of_charge-lower |
8 | 8 |
StorageUnit-fix-state_of_charge-upper |
8 | 8 |
StorageUnit-p_set |
1 | 1 |
StorageUnit-state_of_charge_set |
1 | 1 |
Store-e_set |
1 | 1 |
Store-energy_balance |
4 | ≠ 3+1 |
Store-fix-e-lower |
4 | 4 |
Store-fix-e-upper |
4 | 4 |
| column | PyPSA | lpspec |
|---|---|---|
Generator-p |
8 | 8 |
Link-p |
4 | 4 |
StorageUnit-p_dispatch |
8 | 8 |
StorageUnit-p_store |
8 | 8 |
StorageUnit-spill |
4 | 4 |
StorageUnit-state_of_charge |
8 | 8 |
Store-e |
4 | 4 |
Store-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 |
| \(\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 |
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{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{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{inflow}\) | StorageUnit_inflow over \(\mathcal{T} \times \mathcal{S}\) — energy arriving per hour, a river into a reservoir |
| \(\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{c}^{\mathrm{spill}}\) | StorageUnit_spill_cost over \(\mathcal{T} \times \mathcal{S}\) — cost of one unit of inflow passed on unused |
| \(\mathrm{h}^{\mathrm{set}}\) | StorageUnit_p_set over \(\mathcal{T} \times \mathcal{S}\) — a given net dispatch schedule; a unit without one has no row here |
| \(\mathrm{soc}^{\mathrm{set}}\) | StorageUnit_state_of_charge_set over \(\mathcal{T} \times \mathcal{S}\) — a given charge schedule; a unit without one has no row here |
| \(\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{e}^{\mathrm{set}}\) | Store_e_set over \(\mathcal{T} \times \mathcal{V}\) — a given energy schedule; a store without one has no row here |
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 |
| \(\mathit{spill}\) | StorageUnit_spill over \(\mathcal{T} \times \mathcal{S}\) — StorageUnit-spill — inflow passed on unused. Zero where there is no inflow, so the balance keeps its row there; the bounds are PyPSA's, on the variable rather than as rows |
| \(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 |
\(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.
\(\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 s \in \mathcal{S}} h^{+}_{t,s} \cdot \mathrm{c}^{h}_{t,s} \cdot \mathrm{w}_{t} + \sum_{t \in \mathcal{T},\enspace s \in \mathcal{S}} \mathit{soc}_{t,s} \cdot \mathrm{c}^{\mathrm{soc}}_{t,s} \cdot \mathrm{w}_{t} + \sum_{t \in \mathcal{T},\enspace s \in \mathcal{S}} \mathit{spill}_{t,s} \cdot \mathrm{c}^{\mathrm{spill}}_{t,s} \cdot \mathrm{w}_{t} + \sum_{t \in \mathcal{T},\enspace v \in \mathcal{V}} q_{t,v} \cdot \mathrm{c}^{q}_{t,v} \cdot \mathrm{w}_{t} + \sum_{t \in \mathcal{T},\enspace 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\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}\]
StorageUnit_fix_p_dispatch_lower
\[h^{+}_{t,s} \ge 0 \qquad \forall\thinspace t \in \mathcal{T},\enspace s \in \mathcal{S} \thinspace:\thinspace \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\thinspace t \in \mathcal{T},\enspace s \in \mathcal{S} \thinspace:\thinspace \neg \mathrm{ext}^{h}_{s}\]
StorageUnit_fix_p_store_lower
\[h^{-}_{t,s} \ge 0 \qquad \forall\thinspace t \in \mathcal{T},\enspace s \in \mathcal{S} \thinspace:\thinspace \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\thinspace t \in \mathcal{T},\enspace s \in \mathcal{S} \thinspace:\thinspace \neg \mathrm{ext}^{h}_{s}\]
StorageUnit_fix_state_of_charge_lower
\[\mathit{soc}_{t,s} \ge 0 \qquad \forall\thinspace t \in \mathcal{T},\enspace s \in \mathcal{S} \thinspace:\thinspace \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\thinspace t \in \mathcal{T},\enspace s \in \mathcal{S} \thinspace:\thinspace \neg \mathrm{ext}^{h}_{s}\]
StorageUnit_energy_balance
\[\mathit{soc}_{t,s} = \rho_{t,s} \cdot \mathit{soc}_{t - 1,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}} + \left( \mathrm{inflow}_{t,s} - \mathit{spill}_{t,s} \right) \cdot \mathrm{w}^{\mathrm{sto}}_{t} \qquad \forall\thinspace t \in \mathcal{T},\enspace s \in \mathcal{S} \thinspace:\thinspace \neg \mathrm{cyc}_{s}\]
StorageUnit_energy_balance_initial
\[\mathit{soc}_{t,s} = \mathrm{soc}^{0}_{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}} + \left( \mathrm{inflow}_{t,s} - \mathit{spill}_{t,s} \right) \cdot \mathrm{w}^{\mathrm{sto}}_{t} \qquad \forall\thinspace t \in \mathcal{T},\enspace s \in \mathcal{S} \thinspace:\thinspace \neg \mathrm{cyc}_{s} \wedge \mathrm{pos}(t) = 0\]
StorageUnit_energy_balance_cyclic
\[\mathit{soc}_{t,s} = \rho_{t,s} \cdot \mathit{soc}_{t \ominus 1,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}} + \left( \mathrm{inflow}_{t,s} - \mathit{spill}_{t,s} \right) \cdot \mathrm{w}^{\mathrm{sto}}_{t} \qquad \forall\thinspace t \in \mathcal{T},\enspace s \in \mathcal{S} \thinspace:\thinspace \mathrm{cyc}_{s}\]
Store_fix_e_lower
\[e_{t,v} \ge \underline{\mathrm{e}}_{t,v} \cdot \mathrm{e}^{\mathrm{nom}}_{v} \qquad \forall\thinspace t \in \mathcal{T},\enspace v \in \mathcal{V} \thinspace:\thinspace \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\thinspace t \in \mathcal{T},\enspace v \in \mathcal{V} \thinspace:\thinspace \neg \mathrm{ext}^{e}_{v}\]
Store_energy_balance
\[e_{t,v} = \rho^{e}_{t,v} \cdot e_{t - 1,v} - q_{t,v} \cdot \mathrm{w}^{\mathrm{sto}}_{t} \qquad \forall\thinspace t \in \mathcal{T},\enspace v \in \mathcal{V} \thinspace:\thinspace \neg \mathrm{cyc}^{e}_{v}\]
Store_energy_balance_initial
\[e_{t,v} = \mathrm{e}^{0}_{v} - q_{t,v} \cdot \mathrm{w}^{\mathrm{sto}}_{t} \qquad \forall\thinspace t \in \mathcal{T},\enspace v \in \mathcal{V} \thinspace:\thinspace \neg \mathrm{cyc}^{e}_{v} \wedge \mathrm{pos}(t) = 0\]
StorageUnit_p_set
\[h^{+}_{t,s} - h^{-}_{t,s} = \mathrm{h}^{\mathrm{set}}_{t,s} \qquad \forall\thinspace t \in \mathcal{T},\enspace s \in \mathcal{S} \thinspace:\thinspace \mathrm{h}^{\mathrm{set}}_{t,s} \text{ is defined}\]
StorageUnit_state_of_charge_set
\[\mathit{soc}_{t,s} = \mathrm{soc}^{\mathrm{set}}_{t,s} \qquad \forall\thinspace t \in \mathcal{T},\enspace s \in \mathcal{S} \thinspace:\thinspace \mathrm{soc}^{\mathrm{set}}_{t,s} \text{ is defined}\]
Store_e_set
\[e_{t,v} = \mathrm{e}^{\mathrm{set}}_{t,v} \qquad \forall\thinspace t \in \mathcal{T},\enspace v \in \mathcal{V} \thinspace:\thinspace \mathrm{e}^{\mathrm{set}}_{t,v} \text{ is defined}\]
Bus_nodal_balance
\[\sum_{g \in \mathcal{G} \thinspace:\thinspace \mathrm{Generator\_bus}(g) = n} p_{t,g} + \sum_{s \in \mathcal{S} \thinspace:\thinspace \mathrm{StorageUnit\_bus}(s) = n} \left( h^{+}_{t,s} - h^{-}_{t,s} \right) + \sum_{v \in \mathcal{V} \thinspace:\thinspace \mathrm{Store\_bus}(v) = n} q_{t,v} - \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}\]
StorageUnit_p_dispatch
\[h^{+}_{t,s} \in \mathbb{R} \qquad \forall\thinspace t \in \mathcal{T},\enspace s \in \mathcal{S}\]
StorageUnit_p_store
\[h^{-}_{t,s} \in \mathbb{R} \qquad \forall\thinspace t \in \mathcal{T},\enspace s \in \mathcal{S}\]
StorageUnit_state_of_charge
\[\mathit{soc}_{t,s} \in \mathbb{R} \qquad \forall\thinspace t \in \mathcal{T},\enspace s \in \mathcal{S}\]
StorageUnit_spill
\[0 \le \mathit{spill}_{t,s} \le \mathrm{inflow}_{t,s} \qquad \forall\thinspace t \in \mathcal{T},\enspace s \in \mathcal{S} \thinspace:\thinspace \mathrm{inflow}_{t,s} > 0\]
Store_e
\[e_{t,v} \in \mathbb{R} \qquad \forall\thinspace t \in \mathcal{T},\enspace v \in \mathcal{V}\]
Store_p
\[q_{t,v} \in \mathbb{R} \qquad \forall\thinspace t \in \mathcal{T},\enspace v \in \mathcal{V}\]
The model, differential/pypsa/rungs/rung_02_storage.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'}
storage_unit: {description: 'storage units, dispatch and store behind one bus connection'}
store: {description: 'pure energy stores, 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}
StorageUnit_bus: {description: the bus a storage unit sits on, over: storage_unit, into: bus}
Store_bus: {description: the bus a store sits on, over: store, 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
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]
snapshot_weightings_stores:
description: PyPSA's `snapshot_weightings.stores` — hours a snapshot stands for in a storage balance
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_inflow:
description: energy arriving per hour, a river into a reservoir
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]
StorageUnit_spill_cost:
description: cost of one unit of inflow passed on unused
dims: [snapshot, storage_unit]
StorageUnit_p_set:
description: a given net dispatch schedule; a unit without one has no row here
dims: [snapshot, storage_unit]
StorageUnit_state_of_charge_set:
description: a given charge schedule; a unit without one has no row here
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]
Store_e_set:
description: a given energy schedule; a store without one has no row here
dims: [snapshot, store]
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]
StorageUnit_p_dispatch:
description: '`StorageUnit-p_dispatch` — power delivered to the bus'
foreach: [snapshot, storage_unit]
StorageUnit_p_store:
description: '`StorageUnit-p_store` — power drawn from the bus into charge'
foreach: [snapshot, storage_unit]
StorageUnit_state_of_charge:
description: '`StorageUnit-state_of_charge` — energy held at the end of a snapshot'
foreach: [snapshot, storage_unit]
StorageUnit_spill:
description: '`StorageUnit-spill` — inflow passed on unused. Zero where there is no inflow, so the
balance keeps its row there; the bounds are PyPSA''s, on the variable rather than as rows'
foreach: [snapshot, storage_unit]
where: StorageUnit_inflow > 0
absence: zero
bounds: {lower: 0, upper: StorageUnit_inflow}
Store_e:
description: '`Store-e` — energy held at the end of a snapshot'
foreach: [snapshot, store]
Store_p:
description: '`Store-p` — power delivered to the bus; charging is negative'
foreach: [snapshot, store]
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
StorageUnit_fix_p_dispatch_lower:
description: '`StorageUnit-fix-p_dispatch-lower` — dispatch is non-negative'
foreach: [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'
foreach: [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'
foreach: [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'
foreach: [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'
foreach: [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'
foreach: [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` — charge carried over less standing loss, plus what is
stored after its efficiency, less what dispatch draws down before its own, plus inflow not spilled.
The translated term vacates the first snapshot, so this block builds every row but that one; the
initial block below is the boundary'
foreach: [snapshot, storage_unit]
where: not StorageUnit_cyclic_state_of_charge
expression: StorageUnit_state_of_charge == StorageUnit_retention * shift(StorageUnit_state_of_charge,
over=snapshot, offset=1) + StorageUnit_efficiency_store * StorageUnit_p_store * snapshot_weightings_stores
- StorageUnit_p_dispatch * snapshot_weightings_stores / StorageUnit_efficiency_dispatch + (StorageUnit_inflow
- StorageUnit_spill) * snapshot_weightings_stores
StorageUnit_energy_balance_initial:
description: '`StorageUnit-energy_balance` — the first snapshot opens on the given initial charge,
which no standing loss has touched yet'
foreach: [snapshot, storage_unit]
where: not StorageUnit_cyclic_state_of_charge AND position(snapshot) == 0
expression: StorageUnit_state_of_charge == StorageUnit_state_of_charge_initial + StorageUnit_efficiency_store
* StorageUnit_p_store * snapshot_weightings_stores - StorageUnit_p_dispatch * snapshot_weightings_stores
/ StorageUnit_efficiency_dispatch + (StorageUnit_inflow - StorageUnit_spill) * snapshot_weightings_stores
StorageUnit_energy_balance_cyclic:
description: '`StorageUnit-energy_balance` — a cyclic unit''s first snapshot carries over from its
last'
foreach: [snapshot, storage_unit]
where: StorageUnit_cyclic_state_of_charge
expression: StorageUnit_state_of_charge == StorageUnit_retention * shift(StorageUnit_state_of_charge,
over=snapshot, offset=1, edge='wrap') + StorageUnit_efficiency_store * StorageUnit_p_store * snapshot_weightings_stores
- StorageUnit_p_dispatch * snapshot_weightings_stores / StorageUnit_efficiency_dispatch + (StorageUnit_inflow
- StorageUnit_spill) * snapshot_weightings_stores
Store_fix_e_lower:
description: '`Store-fix-e-lower` — a fixed store holds at least its floor'
foreach: [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'
foreach: [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` — energy carried over less standing loss, less what is delivered
to the bus. The translated term vacates the first snapshot; the initial block below is the boundary'
foreach: [snapshot, store]
where: not Store_e_cyclic
expression: Store_e == Store_retention * shift(Store_e, over=snapshot, offset=1) - Store_p * snapshot_weightings_stores
Store_energy_balance_initial:
description: '`Store-energy_balance` — the first snapshot opens on the given initial energy, which
no standing loss has touched yet'
foreach: [snapshot, store]
where: not Store_e_cyclic AND position(snapshot) == 0
expression: Store_e == Store_e_initial - Store_p * snapshot_weightings_stores
StorageUnit_p_set:
description: '`StorageUnit-p_set` — net dispatch pinned to the given schedule, wherever one is given'
foreach: [snapshot, storage_unit]
where: StorageUnit_p_set
expression: StorageUnit_p_dispatch - StorageUnit_p_store == StorageUnit_p_set
StorageUnit_state_of_charge_set:
description: '`StorageUnit-state_of_charge_set` — charge pinned to the given schedule, wherever one
is given'
foreach: [snapshot, storage_unit]
where: StorageUnit_state_of_charge_set
expression: StorageUnit_state_of_charge == StorageUnit_state_of_charge_set
Store_e_set:
description: '`Store-e_set` — energy pinned to the given schedule, wherever one is given'
foreach: [snapshot, store]
where: Store_e_set
expression: Store_e == Store_e_set
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(StorageUnit_p_dispatch - StorageUnit_p_store,
by=StorageUnit_bus) + sum(Store_p, by=Store_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(StorageUnit_p_dispatch * StorageUnit_marginal_cost
* snapshot_weightings_objective) + sum(StorageUnit_state_of_charge * StorageUnit_marginal_cost_storage
* snapshot_weightings_objective) + sum(StorageUnit_spill * StorageUnit_spill_cost * snapshot_weightings_objective)
+ sum(Store_p * Store_marginal_cost * snapshot_weightings_objective) + sum(Store_e * Store_marginal_cost_storage
* snapshot_weightings_objective)}
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 _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]]
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})
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),
'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'),
'StorageUnit_bus': lookup(n, 'StorageUnit', 'bus'),
'Store_bus': lookup(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_marginal_cost': varying(n, 'Link', 'marginal_cost'),
'Load_p_set': varying(n, 'Load', 'p_set'),
'snapshot_weightings_stores': weighting(n, 'stores'),
'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_inflow': varying(n, 'StorageUnit', 'inflow'),
'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'),
'StorageUnit_spill_cost': varying(n, 'StorageUnit', 'spill_cost'),
'StorageUnit_p_set': varying(n, 'StorageUnit', 'p_set').dropna(),
'StorageUnit_state_of_charge_set': varying(n, 'StorageUnit', 'state_of_charge_set').dropna(),
'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'),
'Store_e_set': varying(n, 'Store', 'e_set').dropna(),
}
with lps.solve('differential/pypsa/rungs/rung_02_storage.yaml', sources) as solution:
solution.objective # 4456.659315422355
The network, rung_02_storage.py in the corpus — the spine plus what this rung adds:
"""Rung 2: storage — a cyclic battery, an inflow reservoir with a set state of charge, and a store."""
from __future__ import annotations
from math import nan
import spine
def build():
"""The spine plus this rung's additions, as a ``pypsa.Network``."""
n = spine.build()
n.generators_t.marginal_cost['gas'] = [15, 15, 60, 60]
n.add(
'StorageUnit',
'battery',
bus='south',
p_nom=20,
max_hours=4,
efficiency_store=0.95,
efficiency_dispatch=0.9,
standing_loss=0.01,
cyclic_state_of_charge=True,
marginal_cost=0.5,
p_set=[0, nan, nan, nan],
)
n.add(
'StorageUnit',
'reservoir',
bus='south',
p_nom=10,
max_hours=2,
spill_cost=2,
state_of_charge_initial=5,
marginal_cost_storage=0.1,
inflow=[12, 12, 12, 12],
state_of_charge_set=[nan, nan, nan, 10],
)
n.add(
'Store',
'cavern',
bus='south',
e_nom=40,
e_initial=25,
standing_loss=0.005,
marginal_cost=0.2,
e_set=[nan, nan, nan, 20],
)
return n
The data¶
The tables this rung is the first to declare (31), as the binding produced them:
StorageUnit_bus.csv
StorageUnit_cyclic_state_of_charge.csv
StorageUnit_efficiency_dispatch.csv
StorageUnit_efficiency_store.csv
StorageUnit_inflow.csv
snapshot,storage_unit,value
2015-01-01T00:00:00.000000,battery,0.0
2015-01-01T00:00:00.000000,reservoir,12.0
2015-01-01T01:00:00.000000,battery,0.0
2015-01-01T01:00:00.000000,reservoir,12.0
2015-01-01T02:00:00.000000,battery,0.0
2015-01-01T02:00:00.000000,reservoir,12.0
2015-01-01T03:00:00.000000,battery,0.0
2015-01-01T03:00:00.000000,reservoir,12.0
StorageUnit_marginal_cost.csv
snapshot,storage_unit,value
2015-01-01T00:00:00.000000,battery,0.5
2015-01-01T00:00:00.000000,reservoir,0.0
2015-01-01T01:00:00.000000,battery,0.5
2015-01-01T01:00:00.000000,reservoir,0.0
2015-01-01T02:00:00.000000,battery,0.5
2015-01-01T02:00:00.000000,reservoir,0.0
2015-01-01T03:00:00.000000,battery,0.5
2015-01-01T03:00:00.000000,reservoir,0.0
StorageUnit_marginal_cost_storage.csv
snapshot,storage_unit,value
2015-01-01T00:00:00.000000,battery,0.0
2015-01-01T00:00:00.000000,reservoir,0.1
2015-01-01T01:00:00.000000,battery,0.0
2015-01-01T01:00:00.000000,reservoir,0.1
2015-01-01T02:00:00.000000,battery,0.0
2015-01-01T02:00:00.000000,reservoir,0.1
2015-01-01T03:00:00.000000,battery,0.0
2015-01-01T03:00:00.000000,reservoir,0.1
StorageUnit_max_hours.csv
StorageUnit_p_max_pu.csv
snapshot,storage_unit,value
2015-01-01T00:00:00.000000,battery,1.0
2015-01-01T00:00:00.000000,reservoir,1.0
2015-01-01T01:00:00.000000,battery,1.0
2015-01-01T01:00:00.000000,reservoir,1.0
2015-01-01T02:00:00.000000,battery,1.0
2015-01-01T02:00:00.000000,reservoir,1.0
2015-01-01T03:00:00.000000,battery,1.0
2015-01-01T03:00:00.000000,reservoir,1.0
StorageUnit_p_min_pu.csv
snapshot,storage_unit,value
2015-01-01T00:00:00.000000,battery,-1.0
2015-01-01T00:00:00.000000,reservoir,-1.0
2015-01-01T01:00:00.000000,battery,-1.0
2015-01-01T01:00:00.000000,reservoir,-1.0
2015-01-01T02:00:00.000000,battery,-1.0
2015-01-01T02:00:00.000000,reservoir,-1.0
2015-01-01T03:00:00.000000,battery,-1.0
2015-01-01T03:00:00.000000,reservoir,-1.0
StorageUnit_p_nom.csv
StorageUnit_p_nom_extendable.csv
StorageUnit_p_set.csv
StorageUnit_retention.csv
snapshot,storage_unit,value
2015-01-01T00:00:00.000000,battery,0.994987437107
2015-01-01T00:00:00.000000,reservoir,1.0
2015-01-01T01:00:00.000000,battery,0.9801
2015-01-01T01:00:00.000000,reservoir,1.0
2015-01-01T02:00:00.000000,battery,0.985037562736
2015-01-01T02:00:00.000000,reservoir,1.0
2015-01-01T03:00:00.000000,battery,0.975187187108
2015-01-01T03:00:00.000000,reservoir,1.0
StorageUnit_spill_cost.csv
snapshot,storage_unit,value
2015-01-01T00:00:00.000000,battery,0.0
2015-01-01T00:00:00.000000,reservoir,2.0
2015-01-01T01:00:00.000000,battery,0.0
2015-01-01T01:00:00.000000,reservoir,2.0
2015-01-01T02:00:00.000000,battery,0.0
2015-01-01T02:00:00.000000,reservoir,2.0
2015-01-01T03:00:00.000000,battery,0.0
2015-01-01T03:00:00.000000,reservoir,2.0
StorageUnit_state_of_charge_initial.csv
StorageUnit_state_of_charge_set.csv
Store_bus.csv
Store_e_cyclic.csv
Store_e_initial.csv
Store_e_max_pu.csv
snapshot,store,value
2015-01-01T00:00:00.000000,cavern,1.0
2015-01-01T01:00:00.000000,cavern,1.0
2015-01-01T02:00:00.000000,cavern,1.0
2015-01-01T03:00:00.000000,cavern,1.0
Store_e_min_pu.csv
snapshot,store,value
2015-01-01T00:00:00.000000,cavern,0.0
2015-01-01T01:00:00.000000,cavern,0.0
2015-01-01T02:00:00.000000,cavern,0.0
2015-01-01T03:00:00.000000,cavern,0.0
Store_e_nom.csv
Store_e_nom_extendable.csv
Store_e_set.csv
Store_marginal_cost.csv
snapshot,store,value
2015-01-01T00:00:00.000000,cavern,0.2
2015-01-01T01:00:00.000000,cavern,0.2
2015-01-01T02:00:00.000000,cavern,0.2
2015-01-01T03:00:00.000000,cavern,0.2
Store_marginal_cost_storage.csv
snapshot,store,value
2015-01-01T00:00:00.000000,cavern,0.0
2015-01-01T01:00:00.000000,cavern,0.0
2015-01-01T02:00:00.000000,cavern,0.0
2015-01-01T03:00:00.000000,cavern,0.0
Store_retention.csv
snapshot,store,value
2015-01-01T00:00:00.000000,cavern,0.997496867163
2015-01-01T01:00:00.000000,cavern,0.990025
2015-01-01T02:00:00.000000,cavern,0.992509382827
2015-01-01T03:00:00.000000,cavern,0.987546835913
snapshot_weightings_stores.csv
snapshot,value
2015-01-01T00:00:00.000000,0.5
2015-01-01T01:00:00.000000,2.0
2015-01-01T02:00:00.000000,1.5
2015-01-01T03:00:00.000000,2.5
storage_unit.csv
store.csv