2d_constraints.gms

$ontext
This file is part of Backbone.

Backbone is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

Backbone is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with Backbone.  If not, see <http://www.gnu.org/licenses/>.
$offtext


* =============================================================================
* --- Constraint Equation Definitions -----------------------------------------
* =============================================================================

* --- Energy Balance ----------------------------------------------------------

q_balance(gn(grid, node), msft(m, s, f, t)) // Energy/power balance dynamics solved using implicit Euler discretization
    ${  not p_gn(grid, node, 'boundAll')
        } ..

    // The left side of the equation is the change in the state (will be zero if the node doesn't have a state)
    + p_gn(grid, node, 'energyStoredPerUnitOfState')${gn_state(grid, node)} // Unit conversion between v_state of a particular node and energy variables (defaults to 1, but can have node based values if e.g. v_state is in Kelvins and each node has a different heat storage capacity)
        * [
            + v_state(grid, node, s, f+df_central(f,t), t)                   // The difference between current
            - v_state(grid, node, s+ds_state(grid,node,s,t), f+df(f,t+dt(t)), t+dt(t))       // ... and previous state of the node
            ]

    =E=

    // The right side of the equation contains all the changes converted to energy terms
    + p_stepLength(m, f, t) // Multiply with the length of the timestep to convert power into energy
        * (
            // Self discharge out of the model boundaries
            - p_gn(grid, node, 'selfDischargeLoss')${ gn_state(grid, node) }
                * v_state(grid, node, s, f+df_central(f,t), t) // The current state of the node

            // Energy diffusion from this node to neighbouring nodes
            - sum(gnn_state(grid, node, to_node),
                + p_gnn(grid, node, to_node, 'diffCoeff')
                    * v_state(grid, node, s, f+df_central(f,t), t)
                ) // END sum(to_node)

            // Energy diffusion from neighbouring nodes to this node
            + sum(gnn_state(grid, from_node, node),
                + p_gnn(grid, from_node, node, 'diffCoeff')
                    * v_state(grid, from_node, s, f+df_central(f,t), t) // Incoming diffusion based on the state of the neighbouring node
                ) // END sum(from_node)

            // Controlled energy transfer, applies when the current node is on the left side of the connection
            - sum(gn2n_directional(grid, node, node_),
                + (1 - p_gnn(grid, node, node_, 'transferLoss')) // Reduce transfer losses
                    * v_transfer(grid, node, node_, s, f, t)
                + p_gnn(grid, node, node_, 'transferLoss') // Add transfer losses back if transfer is from this node to another node
                    * v_transferRightward(grid, node, node_, s, f, t)
                ) // END sum(node_)

            // Controlled energy transfer, applies when the current node is on the right side of the connection
            + sum(gn2n_directional(grid, node_, node),
                + v_transfer(grid, node_, node, s, f, t)
                - p_gnn(grid, node_, node, 'transferLoss') // Reduce transfer losses if transfer is from another node to this node
                    * v_transferRightward(grid, node_, node, s, f, t)
                ) // END sum(node_)

            // Interactions between the node and its units
            + sum(gnuft(grid, node, unit, f, t),
                + v_gen(grid, node, unit, s, f, t) // Unit energy generation and consumption
                )

            // Spilling energy out of the endogenous grids in the model
            - v_spill(grid, node, s, f, t)${node_spill(node)}

            // Power inflow and outflow timeseries to/from the node
            + ts_influx_(grid, node, f, t, s)   // Incoming (positive) and outgoing (negative) absolute value time series

            // Dummy generation variables, for feasibility purposes
            + vq_gen('increase', grid, node, s, f, t) // Note! When stateSlack is permitted, have to take caution with the penalties so that it will be used first
            - vq_gen('decrease', grid, node, s, f, t) // Note! When stateSlack is permitted, have to take caution with the penalties so that it will be used first
    ) // END * p_stepLength
;

* --- Reserve Demand ----------------------------------------------------------
// NOTE! Currently, there are multiple identical instances of the reserve balance equation being generated for each forecast branch even when the reserves are committed and identical between the forecasts.
// NOTE! This could be solved by formulating a new "ft_reserves" set to cover only the relevant forecast-time steps, but it would possibly make the reserves even more confusing.

q_resDemand(restypeDirectionGroup(restype, up_down, group), sft(s, f, t))
    ${  ord(t) < tSolveFirst + p_groupReserves(group, restype, 'reserve_length')
        and not [ restypeReleasedForRealization(restype)
                  and sft_realized(s, f, t)]
        } ..

    // Reserve provision by capable units on this group
    + sum(gnuft(grid, node, unit, f, t)${ gnGroup(grid, node, group)
                                          and gnuRescapable(restype, up_down, grid, node, unit)
                                          },
        + v_reserve(restype, up_down, grid, node, unit, s, f+df_reserves(grid, node, restype, f, t), t)
            * [ // Account for reliability of reserves
                + 1${sft_realized(s, f+df_reserves(grid, node, restype, f, t), t)} // reserveReliability limits the reliability of reserves locked ahead of time.
                + p_gnuReserves(grid, node, unit, restype, 'reserveReliability')${not sft_realized(s, f+df_reserves(grid, node, restype, f, t), t)}
                ] // END * v_reserve
        ) // END sum(gnuft)

    // Reserve provision from other reserve categories when they can be shared
    + sum((gnuft(grid, node, unit, f, t), restype_)${ gnGroup(grid, node, group)
                                                      and p_gnuRes2Res(grid, node, unit, restype_, up_down, restype)
                                                      },
        + v_reserve(restype_, up_down, grid, node, unit, s, f+df_reserves(grid, node, restype_, f, t), t)
            * p_gnuRes2Res(grid, node, unit, restype_, up_down, restype)
            * [ // Account for reliability of reserves
                + 1${sft_realized(s, f+df_reserves(grid, node, restype, f, t), t)} // reserveReliability limits the reliability of reserves locked ahead of time.
                + p_gnuReserves(grid, node, unit, restype, 'reserveReliability')${not sft_realized(s, f+df_reserves(grid, node, restype, f, t), t)}
                    * p_gnuReserves(grid, node, unit, restype_, 'reserveReliability')
                ] // END * v_reserve
        ) // END sum(gnuft)

    // Reserve provision to this group via transfer links
    + sum(gn2n_directional(grid, node_, node)${ gnGroup(grid, node, group)
                                                and not gnGroup(grid, node_, group)
                                                and restypeDirectionGridNodeNode(restype, up_down, grid, node_, node)
                                                },
        + (1 - p_gnn(grid, node_, node, 'transferLoss') )
            * v_resTransferRightward(restype, up_down, grid, node_, node, s, f+df_reserves(grid, node_, restype, f, t), t) // Reserves from another node - reduces the need for reserves in the node
        ) // END sum(gn2n_directional)
    + sum(gn2n_directional(grid, node, node_)${ gnGroup(grid, node, group)
                                                and not gnGroup(grid, node_, group)
                                                and restypeDirectionGridNodeNode(restype, up_down, grid, node_, node)
                                                },
        + (1 - p_gnn(grid, node, node_, 'transferLoss') )
            * v_resTransferLeftward(restype, up_down, grid, node, node_, s, f+df_reserves(grid, node_, restype, f, t), t) // Reserves from another node - reduces the need for reserves in the node
        ) // END sum(gn2n_directional)

    =G=

    // Demand for reserves
    + ts_reserveDemand(restype, up_down, group, f, t)${p_groupReserves(group, restype, 'use_time_series')}
    + p_groupReserves(group, restype, up_down)${not p_groupReserves(group, restype, 'use_time_series')}

    // Reserve demand increase because of units
    + sum(gnuft(grid, node, unit, f, t)${ gnGroup(grid, node, group)
                                          and p_gnuReserves(grid, node, unit, restype, 'reserve_increase_ratio') // Could be better to have 'reserve_increase_ratio' separately for up and down directions
                                          },
        + v_gen(grid, node, unit, s, f, t)
            * p_gnuReserves(grid, node, unit, restype, 'reserve_increase_ratio')
        ) // END sum(nuft)

    // Reserve provisions to other groups via transfer links
    + sum(gn2n_directional(grid, node, node_)${ gnGroup(grid, node, group)
                                                and not gnGroup(grid, node_, group)
                                                and restypeDirectionGridNodeNode(restype, up_down, grid, node, node_)
                                                },   // If trasferring reserves to another node, increase your own reserves by same amount
        + v_resTransferRightward(restype, up_down, grid, node, node_, s, f+df_reserves(grid, node, restype, f, t), t)
        ) // END sum(gn2n_directional)
    + sum(gn2n_directional(grid, node_, node)${ gnGroup(grid, node, group)
                                                and not gnGroup(grid, node_, group)
                                                and restypeDirectionGridNodeNode(restype, up_down, grid, node, node_)
                                                },   // If trasferring reserves to another node, increase your own reserves by same amount
        + v_resTransferLeftward(restype, up_down, grid, node_, node, s, f+df_reserves(grid, node, restype, f, t), t)
        ) // END sum(gn2n_directional)

    // Reserve demand feasibility dummy variables
    - vq_resDemand(restype, up_down, group, s, f+df_reservesGroup(group, restype, f, t), t)
    - vq_resMissing(restype, up_down, group, s, f+df_reservesGroup(group, restype, f, t), t)${ft_reservesFixed(group, restype, f+df_reservesGroup(group, restype, f, t), t)}
;

* --- N-1 Reserve Demand ----------------------------------------------------------
// NOTE! Currently, there are multiple identical instances of the reserve balance equation being generated for each forecast branch even when the reserves are committed and identical between the forecasts.
// NOTE! This could be solved by formulating a new "ft_reserves" set to cover only the relevant forecast-time steps, but it would possibly make the reserves even more confusing.

q_resDemandLargestInfeedUnit(restypeDirectionGroup(restype, 'up', group), unit_fail(unit_), sft(s, f, t))
    ${  ord(t) < tSolveFirst + p_groupReserves(group, restype, 'reserve_length')
        and not [ restypeReleasedForRealization(restype)
            and ft_realized(f, t)
            ]
        and sum(gnGroup(grid, node, group), p_gnuReserves(grid, node, unit_, restype, 'portion_of_infeed_to_reserve'))
        and uft(unit_, f, t) // only active units
        and sum(gnGroup(grid, node, group), gnu_output(grid, node, unit_)) // only units with output capacity 'inside the group'
        } ..

    // Reserve provision by capable units on this group excluding the failing one
    + sum(gnuft(grid, node, unit, f, t)${ gnGroup(grid, node, group)
                                          and gnuRescapable(restype, 'up', grid, node, unit)
                                          and (ord(unit_) ne ord(unit))
                                          },
        + v_reserve(restype, 'up', grid, node, unit, s, f+df_reserves(grid, node, restype, f, t), t)
            * [ // Account for reliability of reserves
                + 1${sft_realized(s, f+df_reserves(grid, node, restype, f, t), t)} // reserveReliability limits the reliability of reserves locked ahead of time.
                + p_gnuReserves(grid, node, unit, restype, 'reserveReliability')${not sft_realized(s, f+df_reserves(grid, node, restype, f, t), t)}
                ] // END * v_reserve
        ) // END sum(nuft)

    // Reserve provision from other reserve categories when they can be shared
    + sum((gnuft(grid, node, unit, f, t), restype_)${ gnGroup(grid, node, group)
                                                      and p_gnuRes2Res(grid, node, unit, restype_, 'up', restype)
                                                      and (ord(unit_) ne ord(unit))
                                                      },
        + v_reserve(restype_, 'up', grid, node, unit, s, f+df_reserves(grid, node, restype_, f, t), t)
            * p_gnuRes2Res(grid, node, unit, restype_, 'up', restype)
            * [ // Account for reliability of reserves
                + 1${sft_realized(s, f+df_reserves(grid, node, restype, f, t), t)} // reserveReliability limits the reliability of reserves locked ahead of time.
                + p_gnuReserves(grid, node, unit, restype, 'reserveReliability')${not sft_realized(s, f+df_reserves(grid, node, restype, f, t), t)}
                    * p_gnuReserves(grid, node, unit, restype_, 'reserveReliability')
                ] // END * v_reserve
        ) // END sum(nuft)

    // Reserve provision to this group via transfer links
    + sum(gn2n_directional(grid, node_, node)${ gnGroup(grid, node, group)
                                                and not gnGroup(grid, node_, group)
                                                and restypeDirectionGridNodeNode(restype, 'up', grid, node_, node)
                                                },
        + (1 - p_gnn(grid, node_, node, 'transferLoss') )
            * v_resTransferRightward(restype, 'up', grid, node_, node, s, f+df_reserves(grid, node_, restype, f, t), t) // Reserves from another node - reduces the need for reserves in the node
        ) // END sum(gn2n_directional)
    + sum(gn2n_directional(grid, node, node_)${ gnGroup(grid, node, group)
                                                and not gnGroup(grid, node_, group)
                                                and restypeDirectionGridNodeNode(restype, 'up', grid, node_, node)
                                                },
        + (1 - p_gnn(grid, node, node_, 'transferLoss') )
            * v_resTransferLeftward(restype, 'up', grid, node, node_, s, f+df_reserves(grid, node_, restype, f, t), t) // Reserves from another node - reduces the need for reserves in the node
        ) // END sum(gn2n_directional)

    =G=

    // Demand for reserves due to a large unit that could fail
    + sum(gnGroup(grid, node, group),
        + v_gen(grid, node, unit_, s, f, t)
            * p_gnuReserves(grid, node, unit_, restype, 'portion_of_infeed_to_reserve')
        ) // END sum(gnGroup)

    // Reserve provisions to other groups via transfer links
    + sum(gn2n_directional(grid, node, node_)${ gnGroup(grid, node, group)
                                                and not gnGroup(grid, node_, group)
                                                and restypeDirectionGridNodeNode(restype, 'up', grid, node, node_)
                                                },   // If trasferring reserves to another node, increase your own reserves by same amount
        + v_resTransferRightward(restype, 'up', grid, node, node_, s, f+df_reserves(grid, node, restype, f, t), t)
        ) // END sum(gn2n_directional)
    + sum(gn2n_directional(grid, node_, node)${ gnGroup(grid, node, group)
                                                and not gnGroup(grid, node_, group)
                                                and restypeDirectionGridNodeNode(restype, 'up', grid, node, node_)
                                                },   // If trasferring reserves to another node, increase your own reserves by same amount
        + v_resTransferLeftward(restype, 'up', grid, node_, node, s, f+df_reserves(grid, node, restype, f, t), t)
        ) // END sum(gn2n_directional)

    // Reserve demand feasibility dummy variables
    - vq_resDemand(restype, 'up', group, s, f+df_reservesGroup(group, restype, f, t), t)
    - vq_resMissing(restype, 'up', group, s, f+df_reservesGroup(group, restype, f, t), t)${ft_reservesFixed(group, restype, f+df_reservesGroup(group, restype, f, t), t)}
;

* --- ROCOF Limit -- Units ----------------------------------------------------

q_rateOfChangeOfFrequencyUnit(group, unit_fail(unit_), sft(s, f, t))
    ${  p_groupPolicy(group, 'defaultFrequency')
        and p_groupPolicy(group, 'ROCOF')
        and uft(unit_, f, t) // only active units
        and sum(gnGroup(grid, node, group), gnu_output(grid, node, unit_)) // only units with output capacity 'inside the group'
        } ..

    // Kinetic/rotational energy in the system
    + p_groupPolicy(group, 'ROCOF')*2
        * [
            + sum(gnu_output(grid, node, unit)${   ord(unit) ne ord(unit_)
                                                   and gnGroup(grid, node, group)
                                                   and gnuft(grid, node, unit, f, t)
                                                   },
                + p_gnu(grid, node, unit, 'inertia')
                    * p_gnu(grid ,node, unit, 'unitSizeMVA')
                    * [
                        + v_online_LP(unit, s, f+df_central(f,t), t)
                            ${uft_onlineLP(unit, f, t)}
                        + v_online_MIP(unit, s, f+df_central(f,t), t)
                            ${uft_onlineMIP(unit, f, t)}
                        + v_gen(grid, node, unit, s, f, t)${not uft_online(unit, f, t)}
                            / p_gnu(grid, node, unit, 'unitSizeGen')
                        ] // * p_gnu
                ) // END sum(gnu_output)
            ] // END * p_groupPolicy

    =G=

    // Demand for kinetic/rotational energy due to a large unit that could fail
    + p_groupPolicy(group, 'defaultFrequency')
        * sum(gnu_output(grid, node, unit_)${   gnGroup(grid, node, group)
                                                },
            + v_gen(grid, node, unit_ , s, f, t)
            ) // END sum(gnu_output)
;

* --- ROCOF Limit -- Transfer Links -------------------------------------------

q_rateOfChangeOfFrequencyTransfer(group, gn2n(grid, node_, node_fail), sft(s, f, t))
    ${  p_groupPolicy(group, 'defaultFrequency')
        and p_groupPolicy(group, 'ROCOF')
        and gnGroup(grid, node_, group) // only interconnectors where one end is 'inside the group'
        and not gnGroup(grid, node_fail, group) // and the other end is 'outside the group'
        and [ p_gnn(grid, node_, node_fail, 'portion_of_transfer_to_reserve')
              or p_gnn(grid, node_fail, node_, 'portion_of_transfer_to_reserve')
              ]
        } ..

    // Kinetic/rotational energy in the system
    + p_groupPolicy(group, 'ROCOF')*2
        * [
            + sum(gnu_output(grid, node, unit)${   gnGroup(grid, node, group)
                                                   and gnuft(grid, node, unit, f, t)
                                                   },
                + p_gnu(grid, node, unit, 'inertia')
                    * p_gnu(grid ,node, unit, 'unitSizeMVA')
                    * [
                        + v_online_LP(unit, s, f+df_central(f,t), t)
                            ${uft_onlineLP(unit, f, t)}
                        + v_online_MIP(unit, s, f+df_central(f,t), t)
                            ${uft_onlineMIP(unit, f, t)}
                        + v_gen(grid, node, unit, s, f, t)${not uft_online(unit, f, t)}
                            / p_gnu(grid, node, unit, 'unitSizeGen')
                        ] // * p_gnu
                ) // END sum(gnu_output)
            ] // END * p_groupPolicy

    =G=

    // Demand for kinetic/rotational energy due to a large interconnector that could fail
    + p_groupPolicy(group, 'defaultFrequency')
        * [
            // Loss of import due to potential interconnector failures
            + p_gnn(grid, node_fail, node_, 'portion_of_transfer_to_reserve')
                * v_transferRightward(grid, node_fail, node_, s, f, t)${gn2n_directional(grid, node_fail, node_)}
                * (1 - p_gnn(grid, node_fail, node_, 'transferLoss') )
            + p_gnn(grid, node_, node_fail, 'portion_of_transfer_to_reserve')
                * v_transferLeftward(grid, node_, node_fail, s, f, t)${gn2n_directional(grid, node_, node_fail)}
                * (1 - p_gnn(grid, node_, node_fail, 'transferLoss') )
            // Loss of export due to potential interconnector failures
            + p_gnn(grid, node_fail, node_, 'portion_of_transfer_to_reserve')
                * v_transferLeftward(grid, node_fail, node_, s, f, t)${gn2n_directional(grid, node_fail, node_)}
            + p_gnn(grid, node_, node_fail, 'portion_of_transfer_to_reserve')
                * v_transferRightward(grid, node_, node_fail, s, f, t)${gn2n_directional(grid, node_, node_fail)}
            ] // END * p_groupPolicy
;

* --- N-1 Upward reserve demand due to a possibility that an interconnector that is transferring power to the node group fails -------------------------------------------------
// NOTE! Currently, there are multiple identical instances of the reserve balance equation being generated for each forecast branch even when the reserves are committed and identical between the forecasts.
// NOTE! This could be solved by formulating a new "ft_reserves" set to cover only the relevant forecast-time steps, but it would possibly make the reserves even more confusing.

q_resDemandLargestInfeedTransferUp(restypeDirectionGroup(restype, 'up', group), gn2n(grid, node_, node_fail), sft(s, f, t))
    ${  ord(t) < tSolveFirst + p_groupReserves(group, restype, 'reserve_length')
        and not [ restypeReleasedForRealization(restype)
                  and sft_realized(s, f, t)]
        and gn2n_directional(grid, node_, node_fail)
        and [ (gnGroup(grid, node_, group) and not gnGroup(grid, node_fail, group)) // only interconnectors where one end is 'inside the group'
              or (gnGroup(grid, node_fail, group) and not gnGroup(grid, node_, group)) // and the other end is 'outside the group'
              ]
        and [ p_gnn(grid, node_, node_fail, 'portion_of_transfer_to_reserve')
              or p_gnn(grid, node_fail, node_, 'portion_of_transfer_to_reserve')
              ]
        and p_groupReserves3D(group, restype, 'up', 'LossOfTrans')
        } ..

    // Reserve provision by capable units on this group
    + sum(gnuft(grid, node, unit, f, t)${ gnGroup(grid, node, group)
                                          and gnuRescapable(restype, 'up', grid, node, unit)
                                          },
        + v_reserve(restype, 'up', grid, node, unit, s, f+df_reserves(grid, node, restype, f, t), t)
            * [ // Account for reliability of reserves
                + 1${sft_realized(s, f+df_reserves(grid, node, restype, f, t), t)} // reserveReliability limits the reliability of reserves locked ahead of time.
                + p_gnuReserves(grid, node, unit, restype, 'reserveReliability')${not sft_realized(s, f+df_reserves(grid, node, restype, f, t), t)}
                ] // END * v_reserve
        ) // END sum(gnuft)

    // Reserve provision from other reserve categories when they can be shared
    + sum((gnuft(grid, node, unit, f, t), restype_)${ gnGroup(grid, node, group)
                                                      and p_gnuRes2Res(grid, node, unit, restype_, 'up', restype)
                                                      },
        + v_reserve(restype_, 'up', grid, node, unit, s, f+df_reserves(grid, node, restype_, f, t), t)
            * p_gnuRes2Res(grid, node, unit, restype_, 'up', restype)
            * [ // Account for reliability of reserves
                + 1${sft_realized(s, f+df_reserves(grid, node, restype, f, t), t)} // reserveReliability limits the reliability of reserves locked ahead of time.
                + p_gnuReserves(grid, node, unit, restype, 'reserveReliability')${not sft_realized(s, f+df_reserves(grid, node, restype, f, t), t)}
                    * p_gnuReserves(grid, node, unit, restype_, 'reserveReliability')
                ] // END * v_reserve
        ) // END sum(gnuft)

    // Reserve provision to this group via transfer links
    + sum(gn2n_directional(grid, from_node, to_node)${ gnGroup(grid, to_node, group)
                                                       and not gnGroup(grid, from_node, group)
                                                       and not (from_node(node_) and to_node(node_fail)) // excluding the failing link
                                                       and restypeDirectionGridNodeNode(restype, 'up', grid, from_node, to_node)
                                                       },
        + (1 - p_gnn(grid, from_node, to_node, 'transferLoss') )
            * v_resTransferRightward(restype, 'up', grid, from_node, to_node, s, f+df_reserves(grid, from_node, restype, f, t), t)
        ) // END sum(gn2n_directional)
    + sum(gn2n_directional(grid, to_node, from_node)${ gnGroup(grid, to_node, group)
                                                       and not gnGroup(grid, from_node, group)
                                                       and not (to_node(node_) and from_node(node_fail)) // excluding the failing link
                                                       and restypeDirectionGridNodeNode(restype, 'up', grid, from_node, to_node)
                                                       },
        + (1 - p_gnn(grid, to_node, from_node, 'transferLoss') )
            * v_resTransferLeftward(restype, 'up', grid, to_node, from_node, s, f+df_reserves(grid, from_node, restype, f, t), t)
        ) // END sum(gn2n_directional)

    =G=

    // Demand for upward reserve due to potential interconnector failures (sudden loss of import)
    + p_gnn(grid, node_, node_fail, 'portion_of_transfer_to_reserve')${gnGroup(grid, node_fail, group)}
        * v_transferRightward(grid, node_, node_fail, s, f, t) // multiply with efficiency?
    + p_gnn(grid, node_fail, node_, 'portion_of_transfer_to_reserve')${gnGroup(grid, node_, group)}
        * v_transferLeftward(grid, node_, node_fail, s, f, t) // multiply with efficiency?

    // Reserve provisions to other groups via transfer links
    + sum(gn2n_directional(grid, from_node, to_node)${ gnGroup(grid, from_node, group)
                                                       and not gnGroup(grid, to_node, group)
                                                       and not (from_node(node_) and to_node(node_fail)) // excluding the failing link
                                                       and restypeDirectionGridNodeNode(restype, 'up', grid, from_node, to_node)
                                                       },
          // Reserve transfers to other nodes increase the reserve need of the present node
        + v_resTransferRightward(restype, 'up', grid, from_node, to_node, s, f+df_reserves(grid, from_node, restype, f, t), t)
        ) // END sum(gn2n_directional)
    + sum(gn2n_directional(grid, to_node, from_node)${ gnGroup(grid, from_node, group)
                                                       and not gnGroup(grid, to_node, group)
                                                       and not (to_node(node_) and from_node(node_fail)) // excluding the failing link
                                                       and restypeDirectionGridNodeNode(restype, 'up', grid, from_node, to_node)
                                                       },
          // Reserve transfers to other nodes increase the reserve need of the present node
        + v_resTransferLeftward(restype, 'up', grid, to_node, from_node, s, f+df_reserves(grid, from_node, restype, f, t), t)
        ) // END sum(gn2n_directional)

    // Reserve demand feasibility dummy variables
    - vq_resDemand(restype, 'up', group, s, f+df_reservesGroup(group, restype, f, t), t)
    - vq_resMissing(restype, 'up', group, s, f+df_reservesGroup(group, restype, f, t), t)${ft_reservesFixed(group, restype, f+df_reservesGroup(group, restype, f, t), t)}
;

* --- N-1 Downward reserve demand due to a possibility that an interconnector that is transferring power from the node group fails -------------------------------------------------
// NOTE! Currently, there are multiple identical instances of the reserve balance equation being generated for each forecast branch even when the reserves are committed and identical between the forecasts.
// NOTE! This could be solved by formulating a new "ft_reserves" set to cover only the relevant forecast-time steps, but it would possibly make the reserves even more confusing.

q_resDemandLargestInfeedTransferDown(restypeDirectionGroup(restype, 'down', group), gn2n(grid, node_, node_fail), sft(s, f, t))
    ${  ord(t) < tSolveFirst + p_groupReserves(group, restype, 'reserve_length')
        and not [ restypeReleasedForRealization(restype)
                  and sft_realized(s, f, t)]
        and gn2n_directional(grid, node_, node_fail)
        and [ (gnGroup(grid, node_, group) and not gnGroup(grid, node_fail, group)) // only interconnectors where one end is 'inside the group'
              or (gnGroup(grid, node_fail, group) and not gnGroup(grid, node_, group)) // and the other end is 'outside the group'
              ]
        and [ p_gnn(grid, node_, node_fail, 'portion_of_transfer_to_reserve')
              or p_gnn(grid, node_fail, node_, 'portion_of_transfer_to_reserve')
              ]
        and p_groupReserves3D(group, restype, 'down', 'LossOfTrans')
        } ..

    // Reserve provision by capable units on this group
    + sum(gnuft(grid, node, unit, f, t)${ gnGroup(grid, node, group)
                                          and gnuRescapable(restype, 'down', grid, node, unit)
                                          },
        + v_reserve(restype, 'down', grid, node, unit, s, f+df_reserves(grid, node, restype, f, t), t)
            * [ // Account for reliability of reserves
                + 1${sft_realized(s, f+df_reserves(grid, node, restype, f, t), t)} // reserveReliability limits the reliability of reserves locked ahead of time.
                + p_gnuReserves(grid, node, unit, restype, 'reserveReliability')${not sft_realized(s, f+df_reserves(grid, node, restype, f, t), t)}
                ] // END * v_reserve
        ) // END sum(gnuft)

    // Reserve provision from other reserve categories when they can be shared
    + sum((gnuft(grid, node, unit, f, t), restype_)${ gnGroup(grid, node, group)
                                                      and p_gnuRes2Res(grid, node, unit, restype_, 'down', restype)
                                                      },
        + v_reserve(restype_, 'down', grid, node, unit, s, f+df_reserves(grid, node, restype_, f, t), t)
            * p_gnuRes2Res(grid, node, unit, restype_, 'down', restype)
            * [ // Account for reliability of reserves
                + 1${sft_realized(s, f+df_reserves(grid, node, restype, f, t), t)} // reserveReliability limits the reliability of reserves locked ahead of time.
                + p_gnuReserves(grid, node, unit, restype, 'reserveReliability')${not sft_realized(s, f+df_reserves(grid, node, restype, f, t), t)}
                    * p_gnuReserves(grid, node, unit, restype_, 'reserveReliability')
                ] // END * v_reserve
        ) // END sum(gnuft)

    // Reserve provision to this group via transfer links
    + sum(gn2n_directional(grid, from_node, to_node)${ gnGroup(grid, to_node, group)
                                                       and not gnGroup(grid, from_node, group)
                                                       and not (from_node(node_) and to_node(node_fail)) // excluding the failing link
                                                       and restypeDirectionGridNodeNode(restype, 'down', grid, from_node, to_node)
                                                       },
        + (1 - p_gnn(grid, from_node, to_node, 'transferLoss') )
            * v_resTransferRightward(restype, 'down', grid, from_node, to_node, s, f+df_reserves(grid, from_node, restype, f, t), t)
        ) // END sum(gn2n_directional)
    + sum(gn2n_directional(grid, to_node, from_node)${ gnGroup(grid, to_node, group)
                                                       and not gnGroup(grid, from_node, group)
                                                       and not (to_node(node_) and from_node(node_fail)) // excluding the failing link
                                                       and restypeDirectionGridNodeNode(restype, 'down', grid, from_node, to_node)
                                                       },
        + (1 - p_gnn(grid, to_node, from_node, 'transferLoss') )
            * v_resTransferLeftward(restype, 'down', grid, to_node, from_node, s, f+df_reserves(grid, from_node, restype, f, t), t)
        ) // END sum(gn2n_directional)

    =G=

    // Demand for downward reserve due to potential interconnector failures (sudden loss of export)
    + p_gnn(grid, node_, node_fail, 'portion_of_transfer_to_reserve')${gnGroup(grid, node_, group)}
        * v_transferRightward(grid, node_, node_fail, s, f, t)
    + p_gnn(grid, node_fail, node_, 'portion_of_transfer_to_reserve')${gnGroup(grid, node_fail, group)}
        * v_transferLeftward(grid, node_, node_fail, s, f, t)

    // Reserve provisions to other groups via transfer links
    + sum(gn2n_directional(grid, from_node, to_node)${ gnGroup(grid, from_node, group)
                                                       and not gnGroup(grid, to_node, group)
                                                       and not (from_node(node_) and to_node(node_fail)) // excluding the failing link
                                                       and restypeDirectionGridNodeNode(restype, 'down', grid, from_node, to_node)
                                                       },
          // Reserve transfers to other nodes increase the reserve need of the present node
        + v_resTransferRightward(restype, 'down', grid, from_node, to_node, s, f+df_reserves(grid, from_node, restype, f, t), t)
        ) // END sum(gn2n_directional)
    + sum(gn2n_directional(grid, to_node, from_node)${ gnGroup(grid, from_node, group)
                                                       and not gnGroup(grid, to_node, group)
                                                       and not (to_node(node_) and from_node(node_fail)) // excluding the failing link
                                                       and restypeDirectionGridNodeNode(restype, 'down', grid, from_node, to_node)
                                                       },
          // Reserve transfers to other nodes increase the reserve need of the present node
        + v_resTransferLeftward(restype, 'down', grid, to_node, from_node, s, f+df_reserves(grid, from_node, restype, f, t), t)
        ) // END sum(gn2n_directional)

    // Reserve demand feasibility dummy variables
    - vq_resDemand(restype, 'down', group, s, f+df_reservesGroup(group, restype, f, t), t)
    - vq_resMissing(restype, 'down', group, s, f+df_reservesGroup(group, restype, f, t), t)${ft_reservesFixed(group, restype, f+df_reservesGroup(group, restype, f, t), t)}
;

* --- N-1 reserve demand due to a possibility that an interconnector that is transferring power to/from the node group fails -------------------------------------------------
// NOTE! Currently, there are multiple identical instances of the reserve balance equation being generated for each forecast branch even when the reserves are committed and identical between the forecasts.
// NOTE! This could be solved by formulating a new "ft_reserves" set to cover only the relevant forecast-time steps, but it would possibly make the reserves even more confusing.

q_resDemandLargestInfeedTransfer(restypeDirectionGroup(restype, up_down, group), gn2n(grid, node_left, node_right), sft(s, f, t))
    ${  ord(t) < tSolveFirst + p_groupReserves(group, restype, 'reserve_length')
        and not [ restypeReleasedForRealization(restype)
                  and sft_realized(s, f, t)]
        and gn2n_directional(grid, node_left, node_right)
        and [ (gnGroup(grid, node_left, group) and not gnGroup(grid, node_right, group)) // only interconnectors where one end is 'inside the group'
              or (gnGroup(grid, node_right, group) and not gnGroup(grid, node_left, group)) // and the other end is 'outside the group'
              ]
        and [ p_gnn(grid, node_left, node_right, 'portion_of_transfer_to_reserve')
              or p_gnn(grid, node_right, node_left, 'portion_of_transfer_to_reserve')
              ]
        and p_groupReserves3D(group, restype, up_down, 'LossOfTrans')
        } ..

    // Reserve provision by capable units on this group
    + sum(gnuft(grid, node, unit, f, t)${ gnGroup(grid, node, group)
                                          and gnuRescapable(restype, up_down, grid, node, unit)
                                          },
        + v_reserve(restype, up_down, grid, node, unit, s, f+df_reserves(grid, node, restype, f, t), t)
            * [ // Account for reliability of reserves
                + 1${sft_realized(s, f+df_reserves(grid, node, restype, f, t), t)} // reserveReliability limits the reliability of reserves locked ahead of time.
                + p_gnuReserves(grid, node, unit, restype, 'reserveReliability')${not sft_realized(s, f+df_reserves(grid, node, restype, f, t), t)}
                ] // END * v_reserve
        ) // END sum(gnuft)

    // Reserve provision from other reserve categories when they can be shared
    + sum((gnuft(grid, node, unit, f, t), restype_)${ gnGroup(grid, node, group)
                                                      and p_gnuRes2Res(grid, node, unit, restype_, up_down, restype)
                                                      },
        + v_reserve(restype_, up_down, grid, node, unit, s, f+df_reserves(grid, node, restype_, f, t), t)
            * p_gnuRes2Res(grid, node, unit, restype_, up_down, restype)
            * [ // Account for reliability of reserves
                + 1${sft_realized(s, f+df_reserves(grid, node, restype, f, t), t)} // reserveReliability limits the reliability of reserves locked ahead of time.
                + p_gnuReserves(grid, node, unit, restype, 'reserveReliability')${not sft_realized(s, f+df_reserves(grid, node, restype, f, t), t)}
                    * p_gnuReserves(grid, node, unit, restype_, 'reserveReliability')
                ] // END * v_reserve
        ) // END sum(gnuft)

    // Reserve provision to this group via transfer links
    + sum(gn2n_directional(grid, node_, node)${ gnGroup(grid, node, group)
                                                and not gnGroup(grid, node_, group)
                                                and not (sameas(node_, node_left) and sameas(node, node_right)) // excluding the failing link
                                                and restypeDirectionGridNodeNode(restype, up_down, grid, node_, node)
                                                },
        + (1 - p_gnn(grid, node_, node, 'transferLoss') )
            * v_resTransferRightward(restype, up_down, grid, node_, node, s, f+df_reserves(grid, node_, restype, f, t), t)
        ) // END sum(gn2n_directional)
    + sum(gn2n_directional(grid, node, node_)${ gnGroup(grid, node, group)
                                                and not gnGroup(grid, node_, group)
                                                and not (sameas(node, node_left) and sameas(node_, node_right)) // excluding the failing link
                                                and restypeDirectionGridNodeNode(restype, up_down, grid, node_, node)
                                                },
        + (1 - p_gnn(grid, node, node_, 'transferLoss') )
            * v_resTransferLeftward(restype, up_down, grid, node, node_, s, f+df_reserves(grid, node_, restype, f, t), t)
        ) // END sum(gn2n_directional)

    =G=

    // Demand for upward reserve due to potential interconnector failures (sudden loss of import)
    + [
        + p_gnn(grid, node_left, node_right, 'portion_of_transfer_to_reserve')${gnGroup(grid, node_right, group)}
            * v_transferRightward(grid, node_left, node_right, s, f, t) // multiply with efficiency?
        + p_gnn(grid, node_right, node_left, 'portion_of_transfer_to_reserve')${gnGroup(grid, node_left, group)}
            * v_transferLeftward(grid, node_left, node_right, s, f, t) // multiply with efficiency?
        ]${sameas(up_down, 'up')}
    // Demand for downward reserve due to potential interconnector failures (sudden loss of export)
    + [
        + p_gnn(grid, node_left, node_right, 'portion_of_transfer_to_reserve')${gnGroup(grid, node_left, group)}
            * v_transferRightward(grid, node_left, node_right, s, f, t)
        + p_gnn(grid, node_right, node_left, 'portion_of_transfer_to_reserve')${gnGroup(grid, node_right, group)}
            * v_transferLeftward(grid, node_left, node_right, s, f, t)
        ]${sameas(up_down, 'down')}

    // Reserve provisions to other groups via transfer links
    + sum(gn2n_directional(grid, node, node_)${ gnGroup(grid, node, group)
                                                and not gnGroup(grid, node_, group)
                                                and not (sameas(node, node_left) and sameas(node_, node_right)) // excluding the failing link
                                                and restypeDirectionGridNodeNode(restype, up_down, grid, node, node_)
                                                },
          // Reserve transfers to other nodes increase the reserve need of the present node
        + v_resTransferRightward(restype, up_down, grid, node, node_, s, f+df_reserves(grid, node, restype, f, t), t)
        ) // END sum(gn2n_directional)
    + sum(gn2n_directional(grid, node_, node)${ gnGroup(grid, node, group)
                                                and not gnGroup(grid, node_, group)
                                                and not (sameas(node_, node_left) and sameas(node, node_right)) // excluding the failing link
                                                and restypeDirectionGridNodeNode(restype, up_down, grid, node, node_)
                                                },
          // Reserve transfers to other nodes increase the reserve need of the present node
        + v_resTransferLeftward(restype, up_down, grid, node_, node, s, f+df_reserves(grid, node, restype, f, t), t)
        ) // END sum(gn2n_directional)

    // Reserve demand feasibility dummy variables
    - vq_resDemand(restype, up_down, group, s, f+df_reservesGroup(group, restype, f, t), t)
    - vq_resMissing(restype, up_down, group, s, f+df_reservesGroup(group, restype, f, t), t)${ft_reservesFixed(group, restype, f+df_reservesGroup(group, restype, f, t), t)}
;

* --- Maximum Downward Capacity -----------------------------------------------

q_maxDownward(gnu(grid, node, unit), msft(m, s, f, t))
    ${  gnuft(grid, node, unit, f, t)
        and {
            [   ord(t) < tSolveFirst + smax(restype, p_gnReserves(grid, node, restype, 'reserve_length')) // Unit is either providing
                and sum(restype, gnuRescapable(restype, 'down', grid, node, unit)) // downward reserves
                ]
            // NOTE!!! Could be better to form a gnuft_reserves subset?
            or [ // the unit has an online variable
                uft_online(unit, f, t)
                and [
                    (unit_minLoad(unit) and p_gnu(grid, node, unit, 'unitSizeGen')) // generators with a min. load
                    or p_gnu(grid, node, unit, 'maxCons') // or consuming units with an online variable
                    ]
                ] // END or
            or [ // consuming units with investment possibility
                gnu_input(grid, node, unit)
                and [unit_investLP(unit) or unit_investMIP(unit)]
                ]
        }} ..

    // Energy generation/consumption
    + v_gen(grid, node, unit, s, f, t)

    // Considering output constraints (e.g. cV line)
    + sum(gngnu_constrainedOutputRatio(grid, node, grid_output, node_, unit),
        + p_gnu(grid_output, node_, unit, 'cV')
            * v_gen(grid_output, node_, unit, s, f, t)
        ) // END sum(gngnu_constrainedOutputRatio)

    // Downward reserve participation
    - sum(gnuRescapable(restype, 'down', grid, node, unit)${ ord(t) < tSolveFirst + p_gnReserves(grid, node, restype, 'reserve_length')
                                                             and not gnuOfflineRescapable(restype, grid, node, unit)
                                                             },
        + v_reserve(restype, 'down', grid, node, unit, s, f+df_reserves(grid, node, restype, f, t), t) // (v_reserve can be used only if the unit is capable of providing a particular reserve)
        ) // END sum(nuRescapable)

    =G= // Must be greater than minimum load or maximum consumption  (units with min-load and both generation and consumption are not allowed)

    // Generation units, greater than minload
    + p_gnu(grid, node, unit, 'unitSizeGen')
        * sum(suft(effGroup, unit, f, t), // Uses the minimum 'lb' for the current efficiency approximation
            + p_effGroupUnit(effGroup, unit, 'lb')${not ts_effGroupUnit(effGroup, unit, 'lb', f, t)}
            + ts_effGroupUnit(effGroup, unit, 'lb', f, t)
            ) // END sum(effGroup)
        * [ // Online variables should only be generated for units with restrictions
            + v_online_LP(unit, s, f+df_central(f,t), t)${uft_onlineLP(unit, f+df_central(f,t), t)} // LP online variant
            + v_online_MIP(unit, s, f+df_central(f,t), t)${uft_onlineMIP(unit, f+df_central(f,t), t)} // MIP online variant
            ] // END v_online

    // Units in run-up phase neet to keep up with the run-up rate
    + p_gnu(grid, node, unit, 'unitSizeGen')
        * sum(unitStarttype(unit, starttype)${uft_startupTrajectory(unit, f, t)},
            sum(runUpCounter(unit, counter)${t_active(t+dt_trajectory(counter))}, // Sum over the run-up intervals
                + [
                    + v_startup_LP(unit, starttype, s, f+df(f, t+dt_trajectory(counter)), t+dt_trajectory(counter))
                        ${ uft_onlineLP_withPrevious(unit, f+df(f, t+dt_trajectory(counter)), t+dt_trajectory(counter)) }
                    + v_startup_MIP(unit, starttype, s, f+df(f, t+dt_trajectory(counter)), t+dt_trajectory(counter))
                        ${ uft_onlineMIP_withPrevious(unit, f+df(f, t+dt_trajectory(counter)), t+dt_trajectory(counter)) }
                    ]
                    * p_uCounter_runUpMin(unit, counter)
                ) // END sum(runUpCounter)
            ) // END sum(unitStarttype)

    // Units in shutdown phase need to keep up with the shutdown rate
    + p_gnu(grid, node, unit, 'unitSizeGen')
        * sum(shutdownCounter(unit, counter)${t_active(t+dt_trajectory(counter)) and uft_shutdownTrajectory(unit, f, t)}, // Sum over the shutdown intervals
            + [
                + v_shutdown_LP(unit, s, f+df(f, t+dt_trajectory(counter)), t+dt_trajectory(counter))
                    ${ uft_onlineLP_withPrevious(unit, f+df(f, t+dt_trajectory(counter)), t+dt_trajectory(counter)) }
                + v_shutdown_MIP(unit, s, f+df(f, t+dt_trajectory(counter)), t+dt_trajectory(counter))
                    ${ uft_onlineMIP_withPrevious(unit, f+df(f, t+dt_trajectory(counter)), t+dt_trajectory(counter)) }
                ]
                * p_uCounter_shutdownMin(unit, counter)
            ) // END sum(shutdownCounter)

    // Consuming units, greater than maxCons
    // Available capacity restrictions
    - p_unit(unit, 'availability')
        * [
            // Capacity factors for flow units
            + sum(flowUnit(flow, unit),
                + ts_cf_(flow, node, f, t, s)
                ) // END sum(flow)
            + 1${not unit_flow(unit)}
            ] // END * p_unit(availability)
        * [
            // Online capacity restriction
            + p_gnu(grid, node, unit, 'maxCons')${not uft_online(unit, f, t)} // Use initial maximum if no online variables
            // !!! TEMPORARY SOLUTION !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
            + [
                + p_gnu(grid, node, unit, 'unitSizeCons')
                + p_gnu(grid, node, unit, 'maxCons')${not p_gnu(grid, node, unit, 'unitSizeCons') > 0}
                    / ( p_unit(unit, 'unitCount') + 1${not p_unit(unit, 'unitCount') > 0} )
                ]
            // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
                * [
                    // Capacity online
                    + v_online_LP(unit, s, f+df_central(f,t), t)${uft_onlineLP(unit, f, t)}
                    + v_online_MIP(unit, s, f+df_central(f,t), t)${uft_onlineMIP(unit, f, t)}

                    // Investments to additional non-online capacity
                    + sum(t_invest(t_)${    ord(t_)<=ord(t)
                                            and not uft_online(unit, f, t)
                                            },
                        + v_invest_LP(unit, t_)${unit_investLP(unit)} // NOTE! v_invest_LP also for consuming units is positive
                        + v_invest_MIP(unit, t_)${unit_investMIP(unit)} // NOTE! v_invest_MIP also for consuming units is positive
                        ) // END sum(t_invest)
                    ] // END * p_gnu(unitSizeCons)
            ] // END * p_unit(availability)
;

* --- Maximum Downward Capacity for Production/Consumption, Online Reserves and Offline Reserves ---

q_maxDownwardOfflineReserve(gnu(grid, node, unit), msft(m, s, f, t))
    ${  gnuft(grid, node, unit, f, t)
        and {
            [   ord(t) < tSolveFirst + smax(restype, p_gnReserves(grid, node, restype, 'reserve_length')) // Unit is providing
                and sum(restype, gnuRescapable(restype, 'down', grid, node, unit)) // downward reserves
                ]
        }

         and {  sum(restype, gnuOfflineRescapable(restype, grid, node, unit))}  // and it can provide some reserve products although being offline

}..

    // Energy generation/consumption
    + v_gen(grid, node, unit, s, f, t)

    // Considering output constraints (e.g. cV line)
    + sum(gngnu_constrainedOutputRatio(grid, node, grid_output, node_, unit),
        + p_gnu(grid_output, node_, unit, 'cV')
            * v_gen(grid_output, node_, unit, s, f, t)
        ) // END sum(gngnu_constrainedOutputRatio)

    // Downward reserve participation
    - sum(gnuRescapable(restype, 'down', grid, node, unit)${ord(t) < tSolveFirst + p_gnReserves(grid, node, restype, 'reserve_length')},
        + v_reserve(restype, 'down', grid, node, unit, s, f+df_reserves(grid, node, restype, f, t), t)
        ) // END sum(nuRescapable)

    =G= // Must be greater than maximum consumption

    // Consuming units
    // Available capacity restrictions
    - p_unit(unit, 'availability') // Consumption units are also restricted by their (available) capacity
        * [
            // Capacity factors for flow units
            + sum(flowUnit(flow, unit),
                + ts_cf_(flow, node, f, t, s)
                ) // END sum(flow)
            + 1${not unit_flow(unit)}
            ] // END * p_unit(availability)
        * [
            // Existing capacity
            + p_gnu(grid, node, unit, 'maxCons')
            // Investments to new capacity
            + [
                + p_gnu(grid, node, unit, 'unitSizeCons')
                ]
                * [
                    + sum(t_invest(t_)${    ord(t_)<=ord(t)
                                            },
                        + v_invest_LP(unit, t_)${unit_investLP(unit)}
                        + v_invest_MIP(unit, t_)${unit_investMIP(unit)}
                        ) // END sum(t_invest)
                    ] // END * p_gnu(unitSizeCons)
            ] // END * p_unit(availability)

;

* --- Maximum Upwards Capacity for Production/Consumption and Online Reserves ---

q_maxUpward(gnu(grid, node, unit), msft(m, s, f, t))
    ${  gnuft(grid, node, unit, f, t)
        and {
            [   ord(t) < tSolveFirst + smax(restype, p_gnReserves(grid, node, restype, 'reserve_length')) // Unit is either providing
                and sum(restype, gnuRescapable(restype, 'up', grid, node, unit)) // upward reserves
                ]
            or [
                uft_online(unit, f, t) // or the unit has an online variable
                and [
                    [unit_minLoad(unit) and p_gnu(grid, node, unit, 'unitSizeCons')] // consuming units with min_load
                    or [p_gnu(grid, node, unit, 'maxGen')]                          // generators with an online variable
                    ]
                ]
            or [
                gnu_output(grid, node, unit) // generators with investment possibility
                and (unit_investLP(unit) or unit_investMIP(unit))
                ]
             }
                 }..


    // Energy generation/consumption
    + v_gen(grid, node, unit, s, f, t)

    // Considering output constraints (e.g. cV line)
    + sum(gngnu_constrainedOutputRatio(grid, node, grid_output, node_, unit),
        + p_gnu(grid_output, node_, unit, 'cV')
            * v_gen(grid_output, node_, unit, s, f, t)
        ) // END sum(gngnu_constrainedOutputRatio)

    // Upwards reserve participation
    + sum(gnuRescapable(restype, 'up', grid, node, unit)${ ord(t) < tSolveFirst + p_gnReserves(grid, node, restype, 'reserve_length')
                                                           and not gnuOfflineRescapable(restype, grid, node, unit)
                                                           },
        + v_reserve(restype, 'up', grid, node, unit, s, f+df_reserves(grid, node, restype, f, t), t)
        ) // END sum(nuRescapable)

    =L= // must be less than available/online capacity

    // Consuming units
    - p_gnu(grid, node, unit, 'unitSizeCons')
        * sum(suft(effGroup, unit, f, t), // Uses the minimum 'lb' for the current efficiency approximation
            + p_effGroupUnit(effGroup, unit, 'lb')${not ts_effGroupUnit(effGroup, unit, 'lb', f, t)}
            + ts_effGroupUnit(effGroup, unit, 'lb', f, t)
            ) // END sum(effGroup)
        * [
            + v_online_LP(unit, s, f+df_central(f,t), t)${uft_onlineLP(unit, f, t)} // Consuming units are restricted by their min. load (consuming is negative)
            + v_online_MIP(unit, s, f+df_central(f,t), t)${uft_onlineMIP(unit, f, t)} // Consuming units are restricted by their min. load (consuming is negative)
            ] // END * p_gnu(unitSizeCons)

    // Generation units
    // Available capacity restrictions
    + p_unit(unit, 'availability') // Generation units are restricted by their (available) capacity
        * [
            // Capacity factor for flow units
            + sum(flowUnit(flow, unit),
                + ts_cf_(flow, node, f, t, s)
                ) // END sum(flow)
            + 1${not unit_flow(unit)}
            ] // END * p_unit(availability)
        * [
            // Online capacity restriction
            + p_gnu(grid, node, unit, 'maxGen')${not uft_online(unit, f, t)} // Use initial maxGen if no online variables
            + p_gnu(grid, node, unit, 'unitSizeGen')
                * [
                    // Capacity online
                    + v_online_LP(unit, s, f+df_central(f,t), t)${uft_onlineLP(unit, f ,t)}
                    + v_online_MIP(unit, s, f+df_central(f,t), t)${uft_onlineMIP(unit, f, t)}

                    // Investments to non-online capacity
                    + sum(t_invest(t_)${    ord(t_)<=ord(t)
                                            and not uft_online(unit, f ,t)
                                            },
                        + v_invest_LP(unit, t_)${unit_investLP(unit)}
                        + v_invest_MIP(unit, t_)${unit_investMIP(unit)}
                        ) // END sum(t_invest)
                    ] // END * p_gnu(unitSizeGen)
            ] // END * p_unit(availability)

    // Units in run-up phase neet to keep up with the run-up rate
    + p_gnu(grid, node, unit, 'unitSizeGen')
        * sum(unitStarttype(unit, starttype)${uft_startupTrajectory(unit, f, t)},
            sum(runUpCounter(unit, counter)${t_active(t+dt_trajectory(counter))}, // Sum over the run-up intervals
                + [
                    + v_startup_LP(unit, starttype, s, f+df(f, t+dt_trajectory(counter)), t+dt_trajectory(counter))
                        ${ uft_onlineLP_withPrevious(unit, f+df(f, t+dt_trajectory(counter)), t+dt_trajectory(counter)) }
                    + v_startup_MIP(unit, starttype, s, f+df(f, t+dt_trajectory(counter)), t+dt_trajectory(counter))
                        ${ uft_onlineMIP_withPrevious(unit, f+df(f, t+dt_trajectory(counter)), t+dt_trajectory(counter)) }
                    ]
                    * p_uCounter_runUpMax(unit, counter)
                ) // END sum(runUpCounter)
            ) // END sum(unitStarttype)

    // Units in shutdown phase need to keep up with the shutdown rate
    + p_gnu(grid, node, unit, 'unitSizeGen')
        * sum(shutdownCounter(unit, counter)${t_active(t+dt_trajectory(counter)) and uft_shutdownTrajectory(unit, f, t)}, // Sum over the shutdown intervals
            + [
                + v_shutdown_LP(unit, s, f+df(f, t+dt_trajectory(counter)), t+dt_trajectory(counter))
                    ${ uft_onlineLP_withPrevious(unit, f+df(f, t+dt_trajectory(counter)), t+dt_trajectory(counter)) }
                + v_shutdown_MIP(unit, s, f+df(f, t+dt_trajectory(counter)), t+dt_trajectory(counter))
                    ${ uft_onlineMIP_withPrevious(unit, f+df(f, t+dt_trajectory(counter)), t+dt_trajectory(counter)) }
                ]
                * p_uCounter_shutdownMax(unit, counter)
            ) // END sum(shutdownCounter)
;

* --- Maximum Upwards Capacity for Production/Consumption, Online Reserves and Offline Reserves ---

q_maxUpwardOfflineReserve(gnu(grid, node, unit), msft(m, s, f, t))
    ${  gnuft(grid, node, unit, f, t)
        and {
            [   ord(t) < tSolveFirst + smax(restype, p_gnReserves(grid, node, restype, 'reserve_length')) // Unit is providing
                and sum(restype, gnuRescapable(restype, 'up', grid, node, unit)) // upward reserves
                ]
        }

         and {  sum(restype, gnuOfflineRescapable(restype, grid, node, unit))}  // and it can provide some reserve products although being offline

}..

    // Energy generation/consumption
    + v_gen(grid, node, unit, s, f, t)

    // Considering output constraints (e.g. cV line)
    + sum(gngnu_constrainedOutputRatio(grid, node, grid_output, node_, unit),
        + p_gnu(grid_output, node_, unit, 'cV')
            * v_gen(grid_output, node_, unit, s, f, t)
        ) // END sum(gngnu_constrainedOutputRatio)

    // Upwards reserve participation
    + sum(gnuRescapable(restype, 'up', grid, node, unit)${ord(t) < tSolveFirst + p_gnReserves(grid, node, restype, 'reserve_length')},
        + v_reserve(restype, 'up', grid, node, unit, s, f+df_reserves(grid, node, restype, f, t), t)
        ) // END sum(nuRescapable)

    =L= // must be less than available capacity

    // Generation units
    // Available capacity restrictions
    + p_unit(unit, 'availability') // Generation units are restricted by their (available) capacity
        * [
            // Capacity factor for flow units
            + sum(flowUnit(flow, unit),
                + ts_cf_(flow, node, f, t, s)
                ) // END sum(flow)
            + 1${not unit_flow(unit)}
            ] // END * p_unit(availability)
        * [
            // Capacity restriction
            + p_gnu(grid, node, unit, 'unitSizeGen')
                * [
                    // Existing capacity
                    + p_unit(unit, 'unitCount')

                    // Investments to new capacity
                    + sum(t_invest(t_)${    ord(t_)<=ord(t)
                                             },
                        + v_invest_LP(unit, t_)${unit_investLP(unit)}
                        + v_invest_MIP(unit, t_)${unit_investMIP(unit)}
                        ) // END sum(t_invest)
                    ] // END * p_gnu(unitSizeGen)
            ] // END * p_unit(availability)
;

* --- Reserve Provision of Units with Investments -----------------------------

q_reserveProvision(gnuRescapable(restypeDirectionGridNode(restype, up_down, grid, node), unit), sft(s, f, t))
    ${  ord(t) <= tSolveFirst + p_gnReserves(grid, node, restype, 'reserve_length')
        and gnuft(grid, node, unit, f, t)
        and (unit_investLP(unit) or unit_investMIP(unit))
        and not sum(restypeDirectionGridNodeGroup(restype, up_down, grid, node, group),
                    ft_reservesFixed(group, restype, f+df_reservesGroup(group, restype, f, t), t))
        } ..

    + v_reserve(restype, up_down, grid, node, unit, s, f+df_reserves(grid, node, restype, f, t), t)

    =L=

    + p_gnuReserves(grid, node, unit, restype, up_down)
        * [
            + [ p_gnu(grid, node, unit, 'maxGen') + p_gnu(grid, node, unit, 'maxCons') ]
            + sum(t_invest(t_)${ ord(t_)<=ord(t) },
                + v_invest_LP(unit, t_)${unit_investLP(unit)}
                    * p_gnu(grid, node, unit, 'unitSizeTot')
                + v_invest_MIP(unit, t_)${unit_investMIP(unit)}
                    * p_gnu(grid, node, unit, 'unitSizeTot')
                ) // END sum(t_)
            ]
        * p_unit(unit, 'availability') // Taking into account availability...
        * [
            // ... and capacity factor for flow units
            + sum(flowUnit(flow, unit),
                + ts_cf_(flow, node, f, t, s)
                ) // END sum(flow)
            + 1${not unit_flow(unit)}
            ] // How to consider reserveReliability in the case of investments when we typically only have "realized" time steps?
;

* --- Online Reserve Provision of Units with Online Variables -----------------

q_reserveProvisionOnline(gnuRescapable(restypeDirectionGridNode(restype, up_down, grid, node), unit), sft(s, f, t))
    ${  ord(t) <= tSolveFirst + p_gnReserves(grid, node, restype, 'reserve_length')