openTEPES 4.18.3__py3-none-any.whl → 4.18.5__py3-none-any.whl

openTEPES/openTEPES_InputData.py

@@ -1,5 +1,5 @@
 """
-Open Generation, Storage, and Transmission Operation and Expansion Planning Model with RES and ESS (openTEPES) - March 17, 2025
+Open Generation, Storage, and Transmission Operation and Expansion Planning Model with RES and ESS (openTEPES) - June 20, 2025
 """
 
 import datetime
@@ -10,7 +10,6 @@ import pandas        as pd
 from   collections   import defaultdict
 from   pyomo.environ import DataPortal, Set, Param, Var, Binary, NonNegativeReals, NonNegativeIntegers, PositiveReals, PositiveIntegers, Reals, UnitInterval, Any
 
-
 def InputData(DirName, CaseName, mTEPES, pIndLogConsole):
     print('Input data                             ****')
 
@@ -47,6 +46,20 @@ def InputData(DirName, CaseName, mTEPES, pIndLogConsole):
     dfNodeLocation          = pd.read_csv(f'{_path}/oT_Data_NodeLocation_'          f'{CaseName}.csv', header=0, index_col=[0    ])
     dfNetwork               = pd.read_csv(f'{_path}/oT_Data_Network_'               f'{CaseName}.csv', header=0, index_col=[0,1,2])
 
+    try:
+        dfVariableTTCFrw    = pd.read_csv(f'{_path}/oT_Data_VariableTTCFrw_'        f'{CaseName}.csv', header=[0,1,2  ], index_col=[0,1,2])
+        dfVariableTTCBck    = pd.read_csv(f'{_path}/oT_Data_VariableTTCBck_'        f'{CaseName}.csv', header=[0,1,2  ], index_col=[0,1,2])
+        pIndVarTTC          = 1
+    except:
+        pIndVarTTC          = 0
+        print('**** No variable transmission line TTCs')
+    try:
+        dfVariablePTDF      = pd.read_csv(f'{_path}/oT_Data_VariablePTDF_'          f'{CaseName}.csv', header=[0,1,2,3], index_col=[0,1,2])
+        pIndPTDF            = 1
+    except:
+        pIndPTDF            = 0
+        print('**** No flow-based market coupling method')
+
     try:
         dfReservoir         = pd.read_csv(f'{_path}/oT_Data_Reservoir_'             f'{CaseName}.csv', header=0, index_col=[0    ])
         dfVariableMinVolume = pd.read_csv(f'{_path}/oT_Data_VariableMinVolume_'     f'{CaseName}.csv', header=0, index_col=[0,1,2])
@@ -76,34 +89,41 @@ def InputData(DirName, CaseName, mTEPES, pIndLogConsole):
         print('**** No heat energy carrier')
 
     # substitute NaN by 0
-    dfOption.fillna               (0  , inplace=True)
-    dfParameter.fillna            (0.0, inplace=True)
-    dfPeriod.fillna               (0.0, inplace=True)
-    dfScenario.fillna             (0.0, inplace=True)
-    dfStage.fillna                (0.0, inplace=True)
-    dfDuration.fillna             (0  , inplace=True)
-    dfReserveMargin.fillna        (0.0, inplace=True)
-    dfEmission.fillna             (math.inf , inplace=True)
-    dfRESEnergy.fillna            (0.0, inplace=True)
-    dfDemand.fillna               (0.0, inplace=True)
-    dfInertia.fillna              (0.0, inplace=True)
-    dfUpOperatingReserve.fillna   (0.0, inplace=True)
-    dfDwOperatingReserve.fillna   (0.0, inplace=True)
-    dfGeneration.fillna           (0.0, inplace=True)
-    dfVariableMinPower.fillna     (0.0, inplace=True)
-    dfVariableMaxPower.fillna     (0.0, inplace=True)
-    dfVariableMinCharge.fillna    (0.0, inplace=True)
-    dfVariableMaxCharge.fillna    (0.0, inplace=True)
-    dfVariableMinStorage.fillna   (0.0, inplace=True)
-    dfVariableMaxStorage.fillna   (0.0, inplace=True)
-    dfVariableMinEnergy.fillna    (0.0, inplace=True)
-    dfVariableMaxEnergy.fillna    (0.0, inplace=True)
-    dfVariableFuelCost.fillna     (0.0, inplace=True)
-    dfVariableEmissionCost.fillna (0.0, inplace=True)
-    dfEnergyInflows.fillna        (0.0, inplace=True)
-    dfEnergyOutflows.fillna       (0.0, inplace=True)
-    dfNodeLocation.fillna         (0.0, inplace=True)
-    dfNetwork.fillna              (0.0, inplace=True)
+    dfOption.fillna                   (0  , inplace=True)
+    dfParameter.fillna                (0.0, inplace=True)
+    dfPeriod.fillna                   (0.0, inplace=True)
+    dfScenario.fillna                 (0.0, inplace=True)
+    dfStage.fillna                    (0.0, inplace=True)
+    dfDuration.fillna                 (0  , inplace=True)
+    dfReserveMargin.fillna            (0.0, inplace=True)
+    dfEmission.fillna                 (math.inf , inplace=True)
+    dfRESEnergy.fillna                (0.0, inplace=True)
+    dfDemand.fillna                   (0.0, inplace=True)
+    dfInertia.fillna                  (0.0, inplace=True)
+    dfUpOperatingReserve.fillna       (0.0, inplace=True)
+    dfDwOperatingReserve.fillna       (0.0, inplace=True)
+    dfGeneration.fillna               ({"Efficiency":1.0}, inplace=True)
+    dfGeneration.fillna               (0.0, inplace=True)
+    dfVariableMinPower.fillna         (0.0, inplace=True)
+    dfVariableMaxPower.fillna         (0.0, inplace=True)
+    dfVariableMinCharge.fillna        (0.0, inplace=True)
+    dfVariableMaxCharge.fillna        (0.0, inplace=True)
+    dfVariableMinStorage.fillna       (0.0, inplace=True)
+    dfVariableMaxStorage.fillna       (0.0, inplace=True)
+    dfVariableMinEnergy.fillna        (0.0, inplace=True)
+    dfVariableMaxEnergy.fillna        (0.0, inplace=True)
+    dfVariableFuelCost.fillna         (0.0, inplace=True)
+    dfVariableEmissionCost.fillna     (0.0, inplace=True)
+    dfEnergyInflows.fillna            (0.0, inplace=True)
+    dfEnergyOutflows.fillna           (0.0, inplace=True)
+    dfNodeLocation.fillna             (0.0, inplace=True)
+    dfNetwork.fillna                  (0.0, inplace=True)
+
+    if pIndVarTTC == 1:
+        dfVariableTTCFrw.fillna   (0.0, inplace=True)
+        dfVariableTTCBck.fillna   (0.0, inplace=True)
+    if pIndPTDF == 1:
+        dfVariablePTDF.fillna     (0.0, inplace=True)
 
     if pIndHydroTopology == 1:
         dfReservoir.fillna        (0.0, inplace=True)
@@ -140,6 +160,11 @@ def InputData(DirName, CaseName, mTEPES, pIndLogConsole):
     dfEnergyInflows         = dfEnergyInflows.where       (dfEnergyInflows        > 0.0, 0.0)
     dfEnergyOutflows        = dfEnergyOutflows.where      (dfEnergyOutflows       > 0.0, 0.0)
 
+    if (dfGeneration["Efficiency"] == 0).any():
+        print("WARNING: Efficiency values of 0.0 are not valid. They have been changed to 1.0.")
+        print("If you want to disable charging, set 'MaximumCharge' to 0.0 or leave it empty.")
+    dfGeneration["Efficiency"] = dfGeneration["Efficiency"].where(dfGeneration["Efficiency"] != 0.0, 1.0)
+
     if pIndHydroTopology == 1:
         dfVariableMinVolume = dfVariableMinVolume.where   (dfVariableMinVolume    > 0.0, 0.0)
         dfVariableMaxVolume = dfVariableMaxVolume.where   (dfVariableMaxVolume    > 0.0, 0.0)
@@ -170,6 +195,12 @@ def InputData(DirName, CaseName, mTEPES, pIndLogConsole):
         print('Energy outflows                       \n', dfEnergyOutflows.describe      (), '\n')
         print('Electric network                      \n', dfNetwork.describe             (), '\n')
 
+        if pIndVarTTC == 1:
+            print('Variable TTC forward              \n', dfVariableTTCFrw.describe      (), '\n')
+            print('Variable TTC backward             \n', dfVariableTTCBck.describe      (), '\n')
+        if pIndPTDF == 1:
+            print('Variable PTDF                     \n', dfVariablePTDF.describe        (), '\n')
+
         if pIndHydroTopology == 1:
             print('Reservoir                         \n', dfReservoir.describe           (), '\n')
             print('Variable minimum reservoir volume \n', dfVariableMinVolume.describe   (), '\n')
@@ -268,40 +299,40 @@ def InputData(DirName, CaseName, mTEPES, pIndLogConsole):
         pass
 
     #%% parameters
-    pIndBinGenInvest       = dfOption   ['IndBinGenInvest'    ].iloc[0].astype('int')                # Indicator of binary generation        expansion decisions, 0 continuous       - 1 binary - 2 no investment variables
-    pIndBinGenRetire       = dfOption   ['IndBinGenRetirement'].iloc[0].astype('int')                # Indicator of binary generation        retirement decisions,0 continuous       - 1 binary - 2 no retirement variables
-    pIndBinRsrInvest       = dfOption   ['IndBinRsrInvest'    ].iloc[0].astype('int')                # Indicator of binary reservoir         expansion decisions, 0 continuous       - 1 binary - 2 no investment variables
-    pIndBinNetElecInvest   = dfOption   ['IndBinNetInvest'    ].iloc[0].astype('int')                # Indicator of binary electric network  expansion decisions, 0 continuous       - 1 binary - 2 no investment variables
-    pIndBinNetH2Invest     = dfOption   ['IndBinNetH2Invest'  ].iloc[0].astype('int')                # Indicator of binary hydrogen pipeline expansion decisions, 0 continuous       - 1 binary - 2 no investment variables
-    pIndBinNetHeatInvest   = dfOption   ['IndBinNetHeatInvest'].iloc[0].astype('int')                # Indicator of binary heat     pipe     expansion decisions, 0 continuous       - 1 binary - 2 no investment variables
-    pIndBinGenOperat       = dfOption   ['IndBinGenOperat'    ].iloc[0].astype('int')                # Indicator of binary generation        operation decisions, 0 continuous       - 1 binary
-    pIndBinSingleNode      = dfOption   ['IndBinSingleNode'   ].iloc[0].astype('int')                # Indicator of single node although with electric network,   0 electric network - 1 single node
-    pIndBinGenRamps        = dfOption   ['IndBinGenRamps'     ].iloc[0].astype('int')                # Indicator of ramp constraints,                             0 no ramps         - 1 ramp constraints
-    pIndBinGenMinTime      = dfOption   ['IndBinGenMinTime'   ].iloc[0].astype('int')                # Indicator of minimum up/downtime constraints,              0 no min time      - 1 min time constraints
-    pIndBinLineCommit      = dfOption   ['IndBinLineCommit'   ].iloc[0].astype('int')                # Indicator of binary electric network switching decisions,  0 continuous       - 1 binary
-    pIndBinNetLosses       = dfOption   ['IndBinNetLosses'    ].iloc[0].astype('int')                # Indicator of        electric network losses,               0 lossless         - 1 ohmic losses
-    pENSCost               = dfParameter['ENSCost'            ].iloc[0] * 1e-3                       # cost of energy   not served               [MEUR/GWh]
-    pH2NSCost              = dfParameter['HNSCost'            ].iloc[0] * 1e-3                       # cost of hydrogen not served               [MEUR/tH2]
-    pHeatNSCost            = dfParameter['HTNSCost'           ].iloc[0] * 1e-3                       # cost of heat     not served               [MEUR/GWh]
-    pCO2Cost               = dfParameter['CO2Cost'            ].iloc[0]                              # cost of CO2 emission                      [EUR/tCO2]
-    pEconomicBaseYear      = dfParameter['EconomicBaseYear'   ].iloc[0]                              # economic base year                        [year]
-    pAnnualDiscRate        = dfParameter['AnnualDiscountRate' ].iloc[0]                              # annual discount rate                      [p.u.]
-    pUpReserveActivation   = dfParameter['UpReserveActivation'].iloc[0]                              # upward   reserve activation               [p.u.]
-    pDwReserveActivation   = dfParameter['DwReserveActivation'].iloc[0]                              # downward reserve activation               [p.u.]
-    pMinRatioDwUp          = dfParameter['MinRatioDwUp'       ].iloc[0]                              # minimum ratio down up operating reserves  [p.u.]
-    pMaxRatioDwUp          = dfParameter['MaxRatioDwUp'       ].iloc[0]                              # maximum ratio down up operating reserves  [p.u.]
-    pSBase                 = dfParameter['SBase'              ].iloc[0] * 1e-3                       # base power                                [GW]
-    pReferenceNode         = dfParameter['ReferenceNode'      ].iloc[0]                              # reference node
-    pTimeStep              = dfParameter['TimeStep'           ].iloc[0].astype('int')                # duration of the unit time step            [h]
-
-    pPeriodWeight          = dfPeriod       ['Weight'        ].astype('int')                         # weights of periods                        [p.u.]
-    pScenProb              = dfScenario     ['Probability'   ].astype('float64')                     # probabilities of scenarios                [p.u.]
-    pStageWeight           = dfStage        ['Weight'        ].astype('float64')                     # weights of stages
-    pDuration              = dfDuration     ['Duration'      ] * pTimeStep                           # duration of load levels                   [h]
-    pLevelToStage          = dfDuration     ['Stage'         ]                                       # load levels assignment to stages
-    pReserveMargin         = dfReserveMargin['ReserveMargin' ]                                       # minimum adequacy reserve margin           [p.u.]
-    pEmission              = dfEmission     ['CO2Emission'   ]                                       # maximum CO2 emission                      [MtCO2]
-    pRESEnergy             = dfRESEnergy    ['RESEnergy'     ]                                       # minimum RES energy                        [GWh]
+    pIndBinGenInvest      = dfOption   ['IndBinGenInvest'    ].iloc[0].astype('int')                 # Indicator of binary generation        expansion decisions, 0 continuous       - 1 binary - 2 no investment variables
+    pIndBinGenRetire      = dfOption   ['IndBinGenRetirement'].iloc[0].astype('int')                 # Indicator of binary generation        retirement decisions,0 continuous       - 1 binary - 2 no retirement variables
+    pIndBinRsrInvest      = dfOption   ['IndBinRsrInvest'    ].iloc[0].astype('int')                 # Indicator of binary reservoir         expansion decisions, 0 continuous       - 1 binary - 2 no investment variables
+    pIndBinNetElecInvest  = dfOption   ['IndBinNetInvest'    ].iloc[0].astype('int')                 # Indicator of binary electric network  expansion decisions, 0 continuous       - 1 binary - 2 no investment variables
+    pIndBinNetH2Invest    = dfOption   ['IndBinNetH2Invest'  ].iloc[0].astype('int')                 # Indicator of binary hydrogen pipeline expansion decisions, 0 continuous       - 1 binary - 2 no investment variables
+    pIndBinNetHeatInvest  = dfOption   ['IndBinNetHeatInvest'].iloc[0].astype('int')                 # Indicator of binary heat     pipe     expansion decisions, 0 continuous       - 1 binary - 2 no investment variables
+    pIndBinGenOperat      = dfOption   ['IndBinGenOperat'    ].iloc[0].astype('int')                 # Indicator of binary generation        operation decisions, 0 continuous       - 1 binary
+    pIndBinSingleNode     = dfOption   ['IndBinSingleNode'   ].iloc[0].astype('int')                 # Indicator of single node although with electric network,   0 electric network - 1 single node
+    pIndBinGenRamps       = dfOption   ['IndBinGenRamps'     ].iloc[0].astype('int')                 # Indicator of ramp constraints,                             0 no ramps         - 1 ramp constraints
+    pIndBinGenMinTime     = dfOption   ['IndBinGenMinTime'   ].iloc[0].astype('int')                 # Indicator of minimum up/downtime constraints,              0 no min time      - 1 min time constraints
+    pIndBinLineCommit     = dfOption   ['IndBinLineCommit'   ].iloc[0].astype('int')                 # Indicator of binary electric network switching decisions,  0 continuous       - 1 binary
+    pIndBinNetLosses      = dfOption   ['IndBinNetLosses'    ].iloc[0].astype('int')                 # Indicator of        electric network losses,               0 lossless         - 1 ohmic losses
+    pENSCost              = dfParameter['ENSCost'            ].iloc[0] * 1e-3                        # cost of energy   not served               [MEUR/GWh]
+    pH2NSCost             = dfParameter['HNSCost'            ].iloc[0] * 1e-3                        # cost of hydrogen not served               [MEUR/tH2]
+    pHeatNSCost           = dfParameter['HTNSCost'           ].iloc[0] * 1e-3                        # cost of heat     not served               [MEUR/GWh]
+    pCO2Cost              = dfParameter['CO2Cost'            ].iloc[0]                               # cost of CO2 emission                      [EUR/tCO2]
+    pEconomicBaseYear     = dfParameter['EconomicBaseYear'   ].iloc[0]                               # economic base year                        [year]
+    pAnnualDiscRate       = dfParameter['AnnualDiscountRate' ].iloc[0]                               # annual discount rate                      [p.u.]
+    pUpReserveActivation  = dfParameter['UpReserveActivation'].iloc[0]                               # upward   reserve activation               [p.u.]
+    pDwReserveActivation  = dfParameter['DwReserveActivation'].iloc[0]                               # downward reserve activation               [p.u.]
+    pMinRatioDwUp         = dfParameter['MinRatioDwUp'       ].iloc[0]                               # minimum ratio down up operating reserves  [p.u.]
+    pMaxRatioDwUp         = dfParameter['MaxRatioDwUp'       ].iloc[0]                               # maximum ratio down up operating reserves  [p.u.]
+    pSBase                = dfParameter['SBase'              ].iloc[0] * 1e-3                        # base power                                [GW]
+    pReferenceNode        = dfParameter['ReferenceNode'      ].iloc[0]                               # reference node
+    pTimeStep             = dfParameter['TimeStep'           ].iloc[0].astype('int')                 # duration of the unit time step            [h]
+
+    pPeriodWeight         = dfPeriod       ['Weight'        ].astype('int')                          # weights of periods                        [p.u.]
+    pScenProb             = dfScenario     ['Probability'   ].astype('float64')                      # probabilities of scenarios                [p.u.]
+    pStageWeight          = dfStage        ['Weight'        ].astype('float64')                      # weights of stages
+    pDuration             = dfDuration     ['Duration'      ] * pTimeStep                            # duration of load levels                   [h]
+    pLevelToStage         = dfDuration     ['Stage'         ]                                        # load levels assignment to stages
+    pReserveMargin        = dfReserveMargin['ReserveMargin' ]                                        # minimum adequacy reserve margin           [p.u.]
+    pEmission             = dfEmission     ['CO2Emission'   ]                                        # maximum CO2 emission                      [MtCO2]
+    pRESEnergy            = dfRESEnergy    ['RESEnergy'     ]                                        # minimum RES energy                        [GWh]
     pDemandElec           = dfDemand.reindex              (columns=mTEPES.nd, fill_value=0.0) * 1e-3 # electric demand                           [GW]
     pSystemInertia        = dfInertia.reindex             (columns=mTEPES.ar, fill_value=0.0)        # inertia                                   [s]
     pOperReserveUp        = dfUpOperatingReserve.reindex  (columns=mTEPES.ar, fill_value=0.0) * 1e-3 # upward   operating reserve                [GW]
@@ -320,20 +351,24 @@ def InputData(DirName, CaseName, mTEPES, pIndLogConsole):
     pEnergyInflows        = dfEnergyInflows.reindex       (columns=mTEPES.gg, fill_value=0.0) * 1e-3 # dynamic energy inflows                    [GW]
     pEnergyOutflows       = dfEnergyOutflows.reindex      (columns=mTEPES.gg, fill_value=0.0) * 1e-3 # dynamic energy outflows                   [GW]
 
+    if pIndVarTTC == 1:
+        pVariableTTCFrw = dfVariableTTCFrw * 1e-3                                                    # variable TTC forward                      [GW]
+        pVariableTTCBck = dfVariableTTCBck * 1e-3                                                    # variable TTC backward                     [GW]
+    if pIndPTDF == 1:
+        pVariablePTDF = dfVariablePTDF  # variable PTDF                             [p.u.]
+
     if pIndHydroTopology == 1:
         pVariableMinVolume = dfVariableMinVolume.reindex  (columns=mTEPES.rs, fill_value=0.0)        # dynamic variable minimum reservoir volume [hm3]
         pVariableMaxVolume = dfVariableMaxVolume.reindex  (columns=mTEPES.rs, fill_value=0.0)        # dynamic variable maximum reservoir volume [hm3]
         pHydroInflows      = dfHydroInflows.reindex       (columns=mTEPES.rs, fill_value=0.0)        # dynamic hydro inflows                     [m3/s]
         pHydroOutflows     = dfHydroOutflows.reindex      (columns=mTEPES.rs, fill_value=0.0)        # dynamic hydro outflows                    [m3/s]
 
-
-
     if pIndHydrogen == 1:
-        pDemandH2          = dfDemandHydrogen      [mTEPES.nd]                           # hydrogen demand                           [tH2/h]
+        pDemandH2          = dfDemandHydrogen      [mTEPES.nd]                                       # hydrogen demand                           [tH2/h]
 
     if pIndHeat == 1:
-        pReserveMarginHeat = dfReserveMarginHeat   ['ReserveMargin']                     # minimum adequacy reserve margin           [p.u.]
-        pDemandHeat        = dfDemandHeat          [mTEPES.nd] * 1e-3                    # heat     demand                           [GW]
+        pReserveMarginHeat = dfReserveMarginHeat   ['ReserveMargin']                                 # minimum adequacy reserve margin           [p.u.]
+        pDemandHeat        = dfDemandHeat          [mTEPES.nd] * 1e-3                                # heat     demand                           [GW]
 
     if pTimeStep > 1:
 
@@ -344,6 +379,7 @@ def InputData(DirName, CaseName, mTEPES, pIndLogConsole):
                 pDataFrame = pDataFrame.rolling(pTimeStep).mean()
                 pDataFrame.fillna(0.0, inplace=True)
             return pDataFrame
+
         # Apply the ProcessParameter function to each DataFrame
         pDemandElec            = ProcessParameter(pDemandElec,           pTimeStep)
         pSystemInertia         = ProcessParameter(pSystemInertia,        pTimeStep)
@@ -362,6 +398,12 @@ def InputData(DirName, CaseName, mTEPES, pIndLogConsole):
         pEnergyInflows         = ProcessParameter(pEnergyInflows,        pTimeStep)
         pEnergyOutflows        = ProcessParameter(pEnergyOutflows,       pTimeStep)
 
+        if pIndVarTTC == 1:
+            pVariableTTCFrw    = ProcessParameter(pVariableTTCFrw,       pTimeStep)
+            pVariableTTCBck    = ProcessParameter(pVariableTTCBck,       pTimeStep)
+        if pIndPTDF == 1:
+            pVariablePTDF      = ProcessParameter(pVariablePTDF,         pTimeStep)
+
         if pIndHydroTopology == 1:
             pVariableMinVolume = ProcessParameter(pVariableMinVolume,    pTimeStep)
             pVariableMaxVolume = ProcessParameter(pVariableMaxVolume,    pTimeStep)
@@ -374,7 +416,7 @@ def InputData(DirName, CaseName, mTEPES, pIndLogConsole):
         if pIndHeat == 1:
             pDemandHeat        = ProcessParameter(pDemandHeat,           pTimeStep)
 
-        # assign duration 0 to load levels not being considered, active load levels are at the end of every pTimeStep
+        # assign duration 0 to load levels not being considered; active load levels are at the end of every pTimeStep
         for n in range(pTimeStep-2,-1,-1):
             pDuration.iloc[[range(n,len(mTEPES.pp)*len(mTEPES.scc)*len(mTEPES.nn),pTimeStep)]] = 0
 
@@ -548,7 +590,7 @@ def InputData(DirName, CaseName, mTEPES, pIndLogConsole):
 
     #%% defining subsets: active load levels (n,n2), thermal units (t), RES units (r), ESS units (es), candidate gen units (gc), candidate ESS units (ec), all the electric lines (la), candidate electric lines (lc), candidate DC electric lines (cd), existing DC electric lines (cd), electric lines with losses (ll), reference node (rf), and reactive generating units (gq)
     mTEPES.p      = Set(doc='periods'                          , initialize=[pp     for pp   in mTEPES.pp  if pPeriodWeight       [pp] >  0.0 and sum(pDuration[pp,sc,n] for sc,n in mTEPES.scc*mTEPES.nn)])
-    mTEPES.sc     = Set(doc='scenarios'                        , initialize=[scc    for scc  in mTEPES.scc                                    ])
+    mTEPES.sc     = Set(doc='scenarios'                        , initialize=[scc    for scc  in mTEPES.scc                                   ])
     mTEPES.ps     = Set(doc='periods/scenarios'                , initialize=[(p,sc) for p,sc in mTEPES.p*mTEPES.sc if pScenProb [p,sc] >  0.0 and sum(pDuration[p,sc,n ] for    n in            mTEPES.nn)])
     mTEPES.st     = Set(doc='stages'                           , initialize=[stt    for stt  in mTEPES.stt if pStageWeight       [stt] >  0.0])
     mTEPES.n      = Set(doc='load levels'                      , initialize=[nn     for nn   in mTEPES.nn  if sum(pDuration  [p,sc,nn] for p,sc in mTEPES.ps) > 0])
@@ -612,6 +654,16 @@ def InputData(DirName, CaseName, mTEPES, pIndLogConsole):
         mTEPES.ha = Set(doc='all real  heat pipes'             , initialize=[])
         mTEPES.hc = Set(doc='candidate heat pipes'             , initialize=[])
 
+    pIndBinLinePTDF = pd.Series(index=mTEPES.la, data=0.0)                                     # indicate if the line has a PTDF or not
+    if pIndVarTTC == 1:
+        pVariableTTCFrw = pVariableTTCFrw.reindex(columns=mTEPES.la, fill_value=0.0)           # variable TTC forward  direction
+        pVariableTTCBck = pVariableTTCBck.reindex(columns=mTEPES.la, fill_value=0.0)           # variable TTC backward direction
+    if pIndPTDF == 1:
+        # get the level_3, level_4, and level_5 from multiindex of pVariablePTDF
+        PTDF_columns = pVariablePTDF.columns
+        PTDF_lines   = PTDF_columns.droplevel([3]).drop_duplicates()
+        pIndBinLinePTDF.loc[:] = pIndBinLinePTDF.index.isin(PTDF_lines).astype(float)
+
     # non-RES units, they can be committed and also contribute to the operating reserves
     mTEPES.nr = mTEPES.g - mTEPES.re
     # machines able to provide reactive power
@@ -630,10 +682,7 @@ def InputData(DirName, CaseName, mTEPES, pIndLogConsole):
     #%% inverse index load level to stage
     pStageToLevel = pLevelToStage.reset_index().set_index(['Period','Scenario','Stage'])['LoadLevel']
     #Filter only valid indices
-    pStageToLevel = pStageToLevel.loc[
-        pStageToLevel.index.isin([(p, s, st) for (p, s) in mTEPES.ps for st in mTEPES.st]) &
-        pStageToLevel.isin(mTEPES.n)
-        ]
+    pStageToLevel = pStageToLevel.loc[pStageToLevel.index.isin([(p,s,st) for (p,s) in mTEPES.ps for st in mTEPES.st]) & pStageToLevel.isin(mTEPES.n)]
     #Reorder the elements
     pStageToLevel = [(p,sc,st,n) for (p,sc,st),n in pStageToLevel.items()]
     mTEPES.s2n = Set(initialize=pStageToLevel, doc='Load level to stage')
@@ -653,7 +702,7 @@ def InputData(DirName, CaseName, mTEPES, pIndLogConsole):
         '''
                 Create mTEPES instrumental sets.
 
-                This function takes a mTEPES instance and adds instrumental sets which will be used later.
+                This function takes an mTEPES instance and adds instrumental sets which will be used later.
 
                 Parameters:
                     mTEPES: The instance of mTEPES.
@@ -704,10 +753,12 @@ def InputData(DirName, CaseName, mTEPES, pIndLogConsole):
         mTEPES.psnnd     = Set(initialize = [(p,sc,n,nd)       for p,sc,n,nd       in mTEPES.psn*mTEPES.nd                           ])
         mTEPES.psnar     = Set(initialize = [(p,sc,n,ar)       for p,sc,n,ar       in mTEPES.psn*mTEPES.ar                           ])
 
-        mTEPES.psnla     = Set(initialize = [(p,sc,n,ni,nf,cc) for p,sc,n,ni,nf,cc in mTEPES.psn*mTEPES.la if (p,ni,nf,cc) in mTEPES.pla])
-        mTEPES.psnle     = Set(initialize = [(p,sc,n,ni,nf,cc) for p,sc,n,ni,nf,cc in mTEPES.psn*mTEPES.le if (p,ni,nf,cc) in mTEPES.pla])
-        mTEPES.psnll     = Set(initialize = [(p,sc,n,ni,nf,cc) for p,sc,n,ni,nf,cc in mTEPES.psn*mTEPES.ll if (p,ni,nf,cc) in mTEPES.pll])
-        mTEPES.psnls     = Set(initialize = [(p,sc,n,ni,nf,cc) for p,sc,n,ni,nf,cc in mTEPES.psn*mTEPES.ls if (p,ni,nf,cc) in mTEPES.pla])
+        mTEPES.psnla     = Set(initialize = [(p,sc,n,ni,nf,cc) for p,sc,n,ni,nf,cc in mTEPES.psn*mTEPES.la  if (p,ni,nf,cc) in mTEPES.pla ])
+        mTEPES.psnle     = Set(initialize = [(p,sc,n,ni,nf,cc) for p,sc,n,ni,nf,cc in mTEPES.psn*mTEPES.le  if (p,ni,nf,cc) in mTEPES.pla ])
+        mTEPES.psnll     = Set(initialize = [(p,sc,n,ni,nf,cc) for p,sc,n,ni,nf,cc in mTEPES.psn*mTEPES.ll  if (p,ni,nf,cc) in mTEPES.pll ])
+        mTEPES.psnls     = Set(initialize = [(p,sc,n,ni,nf,cc) for p,sc,n,ni,nf,cc in mTEPES.psn*mTEPES.ls  if (p,ni,nf,cc) in mTEPES.pla ])
+
+        mTEPES.psnehc    = Set(initialize = [(p,sc,n,eh)       for p,sc,n,eh       in mTEPES.psneh          if pRatedMaxCharge[eh] > 0.0 ])
 
         if pIndHydroTopology == 1:
             mTEPES.prs   = Set(initialize = [(p,     rs)       for p,     rs       in mTEPES.p  *mTEPES.rs if pRsrPeriodIni[rs] <= p and pRsrPeriodFin[rs] >= p])
@@ -737,10 +788,13 @@ def InputData(DirName, CaseName, mTEPES, pIndLogConsole):
         else:
             mTEPES.phc   = Set(initialize = [])
 
+        if pIndPTDF == 1:
+            mTEPES.psnland = Set(initialize = [(p,sc,n,ni,nf,cc,nd) for p,sc,n,ni,nf,cc,nd in mTEPES.psnla*mTEPES.nd if (ni,nf,cc,nd) in pVariablePTDF.columns])
+
         # assigning a node to an area
         mTEPES.ndar = Set(initialize = [(nd,ar) for (nd,zn,ar) in mTEPES.ndzn*mTEPES.ar if (zn,ar) in mTEPES.znar])
 
-        # assigning a line to an area. Both nodes are in the same area. Cross-area lines not included
+        # assigning a line to an area. Both nodes are in the same area. Cross-area lines are not included
         mTEPES.laar = Set(initialize = [(ni,nf,cc,ar) for ni,nf,cc,ar in mTEPES.la*mTEPES.ar if (ni,ar) in mTEPES.ndar and (nf,ar) in mTEPES.ndar])
 
 
@@ -767,10 +821,31 @@ def InputData(DirName, CaseName, mTEPES, pIndLogConsole):
     pIndBinStorInvest         = pIndBinStorInvest.map    (idxDict)
     pIndBinLineInvest         = pIndBinLineInvest.map    (idxDict)
     pIndBinLineSwitch         = pIndBinLineSwitch.map    (idxDict)
-    pIndOperReserve           = pIndOperReserve.map      (idxDict)
+    # pIndOperReserve           = pIndOperReserve.map      (idxDict)
     pIndOutflowIncomp         = pIndOutflowIncomp.map    (idxDict)
     pMustRun                  = pMustRun.map             (idxDict)
 
+    # Operating reserves can be provided while generating or while consuming
+    # So there is need for two options to decide if the unit is able to provide them
+    # Due to backwards compatibility reasons instead of adding a new column to Data_Generation NoOperatingReserve column now accepts two inputs
+    # They are separated by "|", if only one input is detected, both parameters are set to whatever the input is
+
+    def split_and_map(val):
+        # Handle new format with double input. Detect if there is a | character
+        if isinstance(val, str) and '|' in val:
+            gen, cons = val.split('|', 1)
+            return pd.Series([idxDict.get(gen.strip(), 0), idxDict.get(cons.strip(), 0)])
+        else:
+        # If no | character is found, both options are set to the inputted value
+            mapped = idxDict.get(val, 0)
+            return pd.Series([mapped, mapped])
+
+    # Split the columns in pIndOperReserve and group them in Generation and Consumption tuples
+    pIndOperReserveGen, pIndOperReserveCon = zip(*pIndOperReserve.map(split_and_map))
+
+    pIndOperReserveGen = pd.Series(pIndOperReserveGen, index=pIndOperReserve.index)
+    pIndOperReserveCon = pd.Series(pIndOperReserveCon, index=pIndOperReserve.index)
+
     if pIndHydroTopology == 1:
         pIndBinRsrvInvest     = pIndBinRsrvInvest.map    (idxDict)
 
@@ -849,11 +924,42 @@ def InputData(DirName, CaseName, mTEPES, pIndLogConsole):
 
     Create_ESS_RES_Sets(mTEPES)
 
-    #%% inverse index generator to mutually exclusive generator
-    pExclusiveGenToGen = pGenToExclusiveGen.reset_index().set_index('MutuallyExclusive').set_axis(['Generator'], axis=1)[['Generator']]
-    pExclusiveGenToGen = pExclusiveGenToGen.loc[pExclusiveGenToGen['Generator'].isin(mTEPES.g)].reset_index().set_index(['MutuallyExclusive', 'Generator'])
+    # Create mutually exclusive groups
+    # Store in a group-generator dictionary all the relevant data
+    group_dict = {}
+    for generator, groups in pGenToExclusiveGen.items():
+        if groups != 0.0:
+            for group in str(groups).split('|'):
+                group_dict.setdefault(group, []).append(generator)
+
+    # These sets store all groups and the generators in them
+    mTEPES.ExclusiveGroups = Set(initialize=list(group_dict.keys()))
+    mTEPES.GeneratorsInExclusiveGroup = Set(mTEPES.ExclusiveGroups, initialize=group_dict)
+
+    # Create filtered dictionaries for Yearly and Hourly groups
+    group_dict_yearly = {}
+    group_dict_hourly = {}
+
+    for group, generators in group_dict.items():
+        if all(gen in mTEPES.gc for gen in generators):
+            group_dict_yearly[group] = generators
+        else:
+            group_dict_hourly[group] = generators
+
+    # The exclusive groups sets have all groups which are mutually exclusive in that time scope
+    # Generators in group sets are sets with the corresponding generators to a given group
+    mTEPES.ExclusiveGroupsYearly = Set(initialize=list(group_dict_yearly.keys()))
+    mTEPES.GeneratorsInYearlyGroup = Set(mTEPES.ExclusiveGroupsYearly, initialize=group_dict_yearly)
 
-    mTEPES.g2g = Set(doc='mutually exclusive generator to generator', initialize=[(gg,g) for gg,g in mTEPES.g*mTEPES.g if (gg,g) in pExclusiveGenToGen])
+    mTEPES.ExclusiveGroupsHourly = Set(initialize=list(group_dict_hourly.keys()))
+    mTEPES.GeneratorsInHourlyGroup = Set(mTEPES.ExclusiveGroupsHourly, initialize=group_dict_hourly)
+
+    # All exclusive generators (sorting to ensure deterministic behavior)
+    mTEPES.ExclusiveGenerators = Set(initialize=sorted(sum(group_dict.values(), [])))
+    # All yearly exclusive generators (sorting to ensure deterministic behavior)
+    mTEPES.ExclusiveGeneratorsYearly = Set(initialize=sorted(sum(group_dict_yearly.values(), [])))
+    # All hourly exclusive generators (sorting to ensure deterministic behavior)
+    mTEPES.ExclusiveGeneratorsHourly = Set(initialize=sorted(sum(group_dict_hourly.values(), [])))
 
     # minimum and maximum variable power, charge, and storage capacity
     pMinPowerElec  = pVariableMinPowerElec.replace(0.0, pRatedMinPowerElec)
@@ -1034,6 +1140,11 @@ def InputData(DirName, CaseName, mTEPES, pIndLogConsole):
         pDemandHeat      = pDemandHeat.loc          [mTEPES.psn  ]
         pDemandHeatAbs   = pDemandHeat.where(pDemandHeat > 0.0, 0.0)
 
+    if pIndPTDF == 1:
+        pVariableTTCFrw  = pVariableTTCFrw.loc      [mTEPES.psn]
+        pVariableTTCBck  = pVariableTTCBck.loc      [mTEPES.psn]
+        pVariablePTDF    = pVariablePTDF.loc        [mTEPES.psn]
+
     # separate positive and negative demands to avoid converting negative values to 0
     pDemandElecPos       = pDemandElec.where(pDemandElec >= 0.0, 0.0)
     pDemandElecNeg       = pDemandElec.where(pDemandElec <  0.0, 0.0)
@@ -1047,6 +1158,11 @@ def InputData(DirName, CaseName, mTEPES, pIndLogConsole):
     for ar,es in mTEPES.ar*mTEPES.es:
         if (ar,es) in mTEPES.a2g:
             e2a[ar].append(es)
+    r2a = defaultdict(list)
+    for ar,rs in mTEPES.ar*mTEPES.rs:
+        for h in mTEPES.h:
+            if (ar,h) in mTEPES.a2g and sum(1 for h in mTEPES.h if (rs,h) in mTEPES.r2h or (h,rs) in mTEPES.h2r or (rs,h) in mTEPES.r2p or (h,rs) in mTEPES.p2r) and rs not in r2a[ar]:
+                r2a[ar].append(rs)
     n2a = defaultdict(list)
     for ar,nr in mTEPES.ar*mTEPES.nr:
         if (ar,nr) in mTEPES.a2g:
@@ -1072,7 +1188,7 @@ def InputData(DirName, CaseName, mTEPES, pIndLogConsole):
         pOperReserveUp     [pOperReserveUp [[                 ar ]] <  pEpsilonElec] = 0.0
         pOperReserveDw     [pOperReserveDw [[                 ar ]] <  pEpsilonElec] = 0.0
 
-        if len(g2a[ar]):
+        if g2a[ar]:
             pMinPowerElec  [pMinPowerElec  [[g  for  g in g2a[ar]]] <  pEpsilonElec] = 0.0
             pMaxPowerElec  [pMaxPowerElec  [[g  for  g in g2a[ar]]] <  pEpsilonElec] = 0.0
             pMinCharge     [pMinCharge     [[es for es in e2a[ar]]] <  pEpsilonElec] = 0.0
@@ -1084,6 +1200,12 @@ def InputData(DirName, CaseName, mTEPES, pIndLogConsole):
             pMaxStorage    [pMaxStorage    [[es for es in e2a[ar]]] <  pEpsilonElec] = 0.0
             pIniInventory  [pIniInventory  [[es for es in e2a[ar]]] <  pEpsilonElec] = 0.0
 
+            if pIndHydroTopology == 1:
+                pMinVolume    [pMinVolume    [[rs for rs in r2a[ar]]] < pEpsilonElec] = 0.0
+                pMaxVolume    [pMaxVolume    [[rs for rs in r2a[ar]]] < pEpsilonElec] = 0.0
+                pHydroInflows [pHydroInflows [[rs for rs in r2a[ar]]] < pEpsilonElec] = 0.0
+                pHydroOutflows[pHydroOutflows[[rs for rs in r2a[ar]]] < pEpsilonElec] = 0.0
+
         # pInitialInventory.update(pd.Series([0.0 for es in e2a[ar] if pInitialInventory[es] < pEpsilonElec], index=[es for es in e2a[ar] if pInitialInventory[es] < pEpsilonElec], dtype='float64'))
 
         # merging positive and negative values of the demand
@@ -1103,25 +1225,25 @@ def InputData(DirName, CaseName, mTEPES, pIndLogConsole):
 
         pMaxCapacity       = pMaxPowerElec.where(pMaxPowerElec > pMaxCharge, pMaxCharge)
 
-        if len(g2a[ar]):
+        if g2a[ar]:
             pMaxPower2ndBlock [pMaxPower2ndBlock [[g for g in g2a[ar]]] < pEpsilonElec] = 0.0
             pMaxCharge2ndBlock[pMaxCharge2ndBlock[[g for g in g2a[ar]]] < pEpsilonElec] = 0.0
 
-        pLineNTCFrw.update(pd.Series([0.0 for ni,nf,cc in mTEPES.la if pLineNTCFrw[ni,nf,cc] < pEpsilonElec], index=[(ni,nf,cc) for ni,nf,cc in mTEPES.la if pLineNTCFrw[ni,nf,cc] < pEpsilonElec], dtype='float64'))
-        pLineNTCBck.update(pd.Series([0.0 for ni,nf,cc in mTEPES.la if pLineNTCBck[ni,nf,cc] < pEpsilonElec], index=[(ni,nf,cc) for ni,nf,cc in mTEPES.la if pLineNTCBck[ni,nf,cc] < pEpsilonElec], dtype='float64'))
+        pLineNTCFrw.update(pd.Series([0.0 for la in mTEPES.la if pLineNTCFrw[la] < pEpsilonElec], index=[la for la in mTEPES.la if pLineNTCFrw[la] < pEpsilonElec], dtype='float64'))
+        pLineNTCBck.update(pd.Series([0.0 for la in mTEPES.la if pLineNTCBck[la] < pEpsilonElec], index=[la for la in mTEPES.la if pLineNTCBck[la] < pEpsilonElec], dtype='float64'))
         pLineNTCMax = pLineNTCFrw.where(pLineNTCFrw > pLineNTCBck, pLineNTCBck)
 
         if pIndHydrogen == 1:
             pDemandH2[pDemandH2[[nd for nd in d2a[ar]]] < pEpsilonElec] = 0.0
-            pH2PipeNTCFrw.update(pd.Series([0.0 for ni,nf,cc in mTEPES.pa if pH2PipeNTCFrw[ni,nf,cc] < pEpsilonElec], index=[(ni,nf,cc) for ni,nf,cc in mTEPES.pa if pH2PipeNTCFrw[ni,nf,cc] < pEpsilonElec], dtype='float64'))
-            pH2PipeNTCBck.update(pd.Series([0.0 for ni,nf,cc in mTEPES.pa if pH2PipeNTCBck[ni,nf,cc] < pEpsilonElec], index=[(ni,nf,cc) for ni,nf,cc in mTEPES.pa if pH2PipeNTCBck[ni,nf,cc] < pEpsilonElec], dtype='float64'))
+            pH2PipeNTCFrw.update(pd.Series([0.0 for pa in mTEPES.pa if pH2PipeNTCFrw[pa] < pEpsilonElec], index=[pa for pa in mTEPES.pa if pH2PipeNTCFrw[pa] < pEpsilonElec], dtype='float64'))
+            pH2PipeNTCBck.update(pd.Series([0.0 for pa in mTEPES.pa if pH2PipeNTCBck[pa] < pEpsilonElec], index=[pa for pa in mTEPES.pa if pH2PipeNTCBck[pa] < pEpsilonElec], dtype='float64'))
 
         if pIndHeat == 1:
             pDemandHeatPeak[p,ar] = pDemandHeat.loc[p,:,:][[nd for nd in d2a[ar]]].sum(axis=1).max()
             pEpsilonHeat          = pDemandHeatPeak[p,ar]*1e-5
             pDemandHeat             [pDemandHeat    [[nd for nd in   d2a[ar]]] <  pEpsilonHeat] = 0.0
-            pHeatPipeNTCFrw.update(pd.Series([0.0 for ni,nf,cc in mTEPES.ha if pHeatPipeNTCFrw[ni,nf,cc] < pEpsilonHeat], index=[(ni,nf,cc) for ni,nf,cc in mTEPES.ha if pHeatPipeNTCFrw[ni,nf,cc] < pEpsilonHeat], dtype='float64'))
-            pHeatPipeNTCBck.update(pd.Series([0.0 for ni,nf,cc in mTEPES.ha if pHeatPipeNTCBck[ni,nf,cc] < pEpsilonHeat], index=[(ni,nf,cc) for ni,nf,cc in mTEPES.ha if pHeatPipeNTCBck[ni,nf,cc] < pEpsilonHeat], dtype='float64'))
+            pHeatPipeNTCFrw.update(pd.Series([0.0 for ha in mTEPES.ha if pHeatPipeNTCFrw[ha] < pEpsilonHeat], index=[ha for ha in mTEPES.ha if pHeatPipeNTCFrw[ha] < pEpsilonHeat], dtype='float64'))
+            pHeatPipeNTCBck.update(pd.Series([0.0 for ha in mTEPES.ha if pHeatPipeNTCBck[ha] < pEpsilonHeat], index=[ha for ha in mTEPES.ha if pHeatPipeNTCBck[ha] < pEpsilonHeat], dtype='float64'))
 
     # drop generators not g or es or eh or ch
     pMinPowerElec      = pMinPowerElec.loc     [:,mTEPES.g ]
@@ -1147,7 +1269,7 @@ def InputData(DirName, CaseName, mTEPES, pIndLogConsole):
     pMaxPower2ndBlock  = pMaxPower2ndBlock.where (pMaxPower2ndBlock  > pEpsilon, 0.0)
     pMaxCharge2ndBlock = pMaxCharge2ndBlock.where(pMaxCharge2ndBlock > pEpsilon, 0.0)
 
-    # computation of the power to heat ratio of the CHP units
+    # computation of the power-to-heat ratio of the CHP units
     # heat ratio of boiler units is fixed to 1.0
     pPower2HeatRatio   = pd.Series([1.0 if ch in mTEPES.bo else (pRatedMaxPowerElec[ch]-pRatedMinPowerElec[ch])/(pRatedMaxPowerHeat[ch]-pRatedMinPowerHeat[ch]) for ch in mTEPES.ch], index=mTEPES.ch)
     pMinPowerHeat      = pd.DataFrame([[pMinPowerElec     [ch][p,sc,n]/pPower2HeatRatio[ch] for ch in mTEPES.ch] for p,sc,n in mTEPES.psn], index=mTEPES.psn, columns=mTEPES.ch)
@@ -1206,6 +1328,17 @@ def InputData(DirName, CaseName, mTEPES, pIndLogConsole):
     pNetUpInvest             = pNetUpInvest.loc     [mTEPES.lc]
     pLineLossFactor          = pLineLossFactor.loc  [mTEPES.ll]
 
+    pMaxNTCFrw = pd.DataFrame([[pLineNTCFrw[la] for la in mTEPES.la] for p,sc,n in mTEPES.psn], index=mTEPES.psn, columns=mTEPES.la)
+    pMaxNTCBck = pd.DataFrame([[pLineNTCBck[la] for la in mTEPES.la] for p,sc,n in mTEPES.psn], index=mTEPES.psn, columns=mTEPES.la)
+    if pIndVarTTC == 1:
+        pMaxNTCFrw = pVariableTTCFrw.replace(0.0, pLineNTCFrw / dfNetwork['SecurityFactor']) * dfNetwork['SecurityFactor'].loc[dfNetwork.index.isin(set(mTEPES.la))]
+        pMaxNTCBck = pVariableTTCBck.replace(0.0, pLineNTCBck / dfNetwork['SecurityFactor']) * dfNetwork['SecurityFactor'].loc[dfNetwork.index.isin(set(mTEPES.la))]
+    pMaxNTCMax = pMaxNTCFrw.where(pMaxNTCFrw > pMaxNTCBck, pMaxNTCBck)
+
+    pMaxNTCBck                  = pMaxNTCBck.loc             [:,mTEPES.la]
+    pMaxNTCFrw                  = pMaxNTCFrw.loc             [:,mTEPES.la]
+    pMaxNTCMax                  = pMaxNTCFrw.loc             [:,mTEPES.la]
+
     if pIndHydroTopology == 1:
         # drop generators not h
         pProductionFunctionHydro = pProductionFunctionHydro.loc[mTEPES.h ]
@@ -1310,6 +1443,16 @@ def InputData(DirName, CaseName, mTEPES, pIndLogConsole):
     pOperReserveUp     = filter_rows(pOperReserveUp    , mTEPES.psnar)
     pOperReserveDw     = filter_rows(pOperReserveDw    , mTEPES.psnar)
 
+    pMaxNTCBck         = filter_rows(pMaxNTCBck        , mTEPES.psnla)
+    pMaxNTCFrw         = filter_rows(pMaxNTCFrw        , mTEPES.psnla)
+    pMaxNTCMax         = filter_rows(pMaxNTCMax        , mTEPES.psnla)
+
+    if pIndPTDF == 1:
+        pPTDF = pVariablePTDF.stack(level=list(range(pVariablePTDF.columns.nlevels)), future_stack=True)
+        pPTDF.index.set_names(['Period', 'Scenario', 'LoadLevel', 'InitialNode', 'FinalNode', 'Circuit', 'Node'], inplace=True)
+        # filter rows to keep the same as mTEPES.psnland
+        pPTDF = pPTDF[pPTDF.index.isin(mTEPES.psnland)]
+
     # %% parameters
     mTEPES.pIndBinGenInvest      = Param(initialize=pIndBinGenInvest    , within=NonNegativeIntegers, doc='Indicator of binary generation       investment decisions', mutable=True)
     mTEPES.pIndBinGenRetire      = Param(initialize=pIndBinGenRetire    , within=NonNegativeIntegers, doc='Indicator of binary generation       retirement decisions', mutable=True)
@@ -1326,19 +1469,20 @@ def InputData(DirName, CaseName, mTEPES, pIndLogConsole):
     mTEPES.pIndHydroTopology     = Param(initialize=pIndHydroTopology   , within=Binary,              doc='Indicator of reservoir and hydropower topology'                         )
     mTEPES.pIndHydrogen          = Param(initialize=pIndHydrogen        , within=Binary,              doc='Indicator of hydrogen demand and pipeline network'                      )
     mTEPES.pIndHeat              = Param(initialize=pIndHeat            , within=Binary,              doc='Indicator of heat     demand and pipe     network'                      )
-
-    mTEPES.pENSCost              = Param(initialize=pENSCost            , within=NonNegativeReals,    doc='ENS cost'                                          )
-    mTEPES.pH2NSCost             = Param(initialize=pH2NSCost           , within=NonNegativeReals,    doc='HNS cost'                                          )
-    mTEPES.pHeatNSCost           = Param(initialize=pHeatNSCost         , within=NonNegativeReals,    doc='HTNS cost'                                         )
-    mTEPES.pCO2Cost              = Param(initialize=pCO2Cost            , within=NonNegativeReals,    doc='CO2 emission cost'                                 )
-    mTEPES.pAnnualDiscRate       = Param(initialize=pAnnualDiscRate     , within=UnitInterval,        doc='Annual discount rate'                              )
-    mTEPES.pUpReserveActivation  = Param(initialize=pUpReserveActivation, within=UnitInterval,        doc='Proportion of upward   reserve activation'         )
-    mTEPES.pDwReserveActivation  = Param(initialize=pDwReserveActivation, within=UnitInterval,        doc='Proportion of downward reserve activation'         )
-    mTEPES.pMinRatioDwUp         = Param(initialize=pMinRatioDwUp       , within=UnitInterval,        doc='Minimum ration between upward and downward reserve')
-    mTEPES.pMaxRatioDwUp         = Param(initialize=pMaxRatioDwUp       , within=UnitInterval,        doc='Maximum ration between upward and downward reserve')
-    mTEPES.pSBase                = Param(initialize=pSBase              , within=PositiveReals,       doc='Base power'                                        )
-    mTEPES.pTimeStep             = Param(initialize=pTimeStep           , within=PositiveIntegers,    doc='Unitary time step'                                 )
-    mTEPES.pEconomicBaseYear     = Param(initialize=pEconomicBaseYear   , within=PositiveIntegers,    doc='Base year'                                         )
+    mTEPES.pIndPTDF              = Param(initialize=pIndPTDF            , within=Binary,              doc='Indicator of using or not the Flow-based method'                        )
+
+    mTEPES.pENSCost              = Param(initialize=pENSCost            , within=NonNegativeReals,    doc='ENS cost'                                           )
+    mTEPES.pH2NSCost             = Param(initialize=pH2NSCost           , within=NonNegativeReals,    doc='HNS cost'                                           )
+    mTEPES.pHeatNSCost           = Param(initialize=pHeatNSCost         , within=NonNegativeReals,    doc='HTNS cost'                                          )
+    mTEPES.pCO2Cost              = Param(initialize=pCO2Cost            , within=NonNegativeReals,    doc='CO2 emission cost'                                  )
+    mTEPES.pAnnualDiscRate       = Param(initialize=pAnnualDiscRate     , within=UnitInterval,        doc='Annual discount rate'                               )
+    mTEPES.pUpReserveActivation  = Param(initialize=pUpReserveActivation, within=UnitInterval,        doc='Proportion of upward   reserve activation'          )
+    mTEPES.pDwReserveActivation  = Param(initialize=pDwReserveActivation, within=UnitInterval,        doc='Proportion of downward reserve activation'          )
+    mTEPES.pMinRatioDwUp         = Param(initialize=pMinRatioDwUp       , within=UnitInterval,        doc='Minimum ratio downward to upward operating reserves')
+    mTEPES.pMaxRatioDwUp         = Param(initialize=pMaxRatioDwUp       , within=UnitInterval,        doc='Maximum ratio downward to upward operating reserves')
+    mTEPES.pSBase                = Param(initialize=pSBase              , within=PositiveReals,       doc='Base power'                                         )
+    mTEPES.pTimeStep             = Param(initialize=pTimeStep           , within=PositiveIntegers,    doc='Unitary time step'                                  )
+    mTEPES.pEconomicBaseYear     = Param(initialize=pEconomicBaseYear   , within=PositiveIntegers,    doc='Base year'                                          )
 
     mTEPES.pReserveMargin        = Param(mTEPES.par,   initialize=pReserveMargin.to_dict()            , within=NonNegativeReals,    doc='Adequacy reserve margin'                             )
     mTEPES.pEmission             = Param(mTEPES.par,   initialize=pEmission.to_dict()                 , within=NonNegativeReals,    doc='Maximum CO2 emission'                                )
@@ -1399,7 +1543,8 @@ def InputData(DirName, CaseName, mTEPES, pIndLogConsole):
     mTEPES.pIndBinUnitRetire     = Param(mTEPES.gd,    initialize=pIndBinUnitRetire.to_dict()         , within=Binary          ,    doc='Binary retirement decision'                          )
     mTEPES.pIndBinUnitCommit     = Param(mTEPES.nr,    initialize=pIndBinUnitCommit.to_dict()         , within=Binary          ,    doc='Binary commitment decision'                          )
     mTEPES.pIndBinStorInvest     = Param(mTEPES.ec,    initialize=pIndBinStorInvest.to_dict()         , within=Binary          ,    doc='Storage linked to generation investment'             )
-    mTEPES.pIndOperReserve       = Param(mTEPES.gg,    initialize=pIndOperReserve.to_dict()           , within=Binary          ,    doc='Indicator of operating reserve'                      )
+    mTEPES.pIndOperReserveGen    = Param(mTEPES.gg,    initialize=pIndOperReserveGen.to_dict()        , within=Binary          ,    doc='Indicator of operating reserve when generating power')
+    mTEPES.pIndOperReserveCon    = Param(mTEPES.gg,    initialize=pIndOperReserveCon.to_dict()        , within=Binary          ,    doc='Indicator of operating reserve when consuming power' )
     mTEPES.pIndOutflowIncomp     = Param(mTEPES.gg,    initialize=pIndOutflowIncomp.to_dict()         , within=Binary          ,    doc='Indicator of outflow incompatibility with charging'  )
     mTEPES.pEfficiency           = Param(mTEPES.eh,    initialize=pEfficiency.to_dict()               , within=UnitInterval    ,    doc='Round-trip efficiency'                               )
     mTEPES.pStorageTimeStep      = Param(mTEPES.es,    initialize=pStorageTimeStep.to_dict()          , within=PositiveIntegers,    doc='ESS Storage cycle'                                   )
@@ -1427,8 +1572,10 @@ def InputData(DirName, CaseName, mTEPES, pIndLogConsole):
         mTEPES.pProductionFunctionHeat     = Param(mTEPES.hp,    initialize=pProductionFunctionHeat.to_dict()    , within=NonNegativeReals, doc='Production function of an CHP plant'      )
         mTEPES.pProductionFunctionH2ToHeat = Param(mTEPES.hh,    initialize=pProductionFunctionH2ToHeat.to_dict(), within=NonNegativeReals, doc='Production function of an boiler using H2')
 
-    if pIndHydroTopology == 1:
+    if pIndPTDF == 1:
+        mTEPES.pPTDF                       = Param(mTEPES.psnland, initialize=pPTDF.to_dict()                    , within=Reals           , doc='Power transfer distribution factor'       )
 
+    if pIndHydroTopology == 1:
         pHydroInflows  = filter_rows(pHydroInflows , mTEPES.psnrs)
         pHydroOutflows = filter_rows(pHydroOutflows, mTEPES.psnrs)
         pMaxOutflows   = filter_rows(pMaxOutflows  , mTEPES.psnrs)
@@ -1502,6 +1649,10 @@ def InputData(DirName, CaseName, mTEPES, pIndLogConsole):
     mTEPES.pAngMax           = Param(mTEPES.la,    initialize=pAngMax.to_dict()          , within=           Reals,    doc='Maximum phase angle difference',                       mutable=True)
     mTEPES.pNetLoInvest      = Param(mTEPES.lc,    initialize=pNetLoInvest.to_dict()     , within=NonNegativeReals,    doc='Lower bound of the electric line investment decision', mutable=True)
     mTEPES.pNetUpInvest      = Param(mTEPES.lc,    initialize=pNetUpInvest.to_dict()     , within=NonNegativeReals,    doc='Upper bound of the electric line investment decision', mutable=True)
+    mTEPES.pIndBinLinePTDF   = Param(mTEPES.la,    initialize=pIndBinLinePTDF.to_dict()  , within=Binary          ,    doc='Binary indicator of line with'                                     )
+    mTEPES.pMaxNTCFrw        = Param(mTEPES.psnla, initialize=pMaxNTCFrw.to_dict()       , within=           Reals,    doc='Maximum NTC forward capacity'                                      )
+    mTEPES.pMaxNTCBck        = Param(mTEPES.psnla, initialize=pMaxNTCBck.to_dict()       , within=           Reals,    doc='Maximum NTC backward capacity'                                     )
+    mTEPES.pMaxNTCMax        = Param(mTEPES.psnla, initialize=pMaxNTCMax.to_dict()       , within=           Reals,    doc='Maximum NTC capacity'                                              )
 
     if pIndHydrogen == 1:
         mTEPES.pH2PipeLength       = Param(mTEPES.pn,  initialize=pH2PipeLength.to_dict()      , within=NonNegativeReals,    doc='Hydrogen pipeline length',                        mutable=True)
@@ -1599,7 +1750,7 @@ def SettingUpVariables(OptModel, mTEPES):
         '''
         Create all mTEPES variables.
 
-        This function takes a mTEPES instance with all parameters and sets created and adds variables to it.
+        This function takes an mTEPES instance with all parameters and sets created and adds variables to it.
 
         Parameters:
             mTEPES: The instance of mTEPES.
@@ -1608,126 +1759,137 @@ def SettingUpVariables(OptModel, mTEPES):
             None: Variables are added directly to the mTEPES object.
         '''
         #%% variables
-        OptModel.vTotalSCost               = Var(                       within=NonNegativeReals,                doc='total system                         cost      [MEUR]')
-        OptModel.vTotalICost               = Var(                       within=NonNegativeReals,                doc='total system investment              cost      [MEUR]')
-        OptModel.vTotalFCost               = Var(mTEPES.p,     within=NonNegativeReals,                 doc='total system fixed                   cost      [MEUR]')
-        OptModel.vTotalGCost               = Var(mTEPES.psn,   within=NonNegativeReals,                 doc='total variable generation  operation cost      [MEUR]')
-        OptModel.vTotalCCost               = Var(mTEPES.psn,   within=NonNegativeReals,                 doc='total variable consumption operation cost      [MEUR]')
-        OptModel.vTotalECost               = Var(mTEPES.psn,   within=NonNegativeReals,                 doc='total system emission                cost      [MEUR]')
-        OptModel.vTotalRCost               = Var(mTEPES.psn,   within=NonNegativeReals,                 doc='total system reliability             cost      [MEUR]')
-        OptModel.vTotalNCost               = Var(mTEPES.psn,   within=NonNegativeReals,                 doc='total network loss penalty operation cost      [MEUR]')
-        OptModel.vTotalEmissionArea        = Var(mTEPES.psnar, within=NonNegativeReals,                 doc='total   area emission                         [MtCO2]')
-        OptModel.vTotalECostArea           = Var(mTEPES.psnar, within=NonNegativeReals,                 doc='total   area emission                cost      [MEUR]')
-        OptModel.vTotalRESEnergyArea       = Var(mTEPES.psnar, within=NonNegativeReals,                 doc='        RES energy                              [GWh]')
-
-        OptModel.vTotalOutput              = Var(mTEPES.psng , within=NonNegativeReals,                 doc='total output of the unit                         [GW]')
-        OptModel.vOutput2ndBlock           = Var(mTEPES.psnnr, within=NonNegativeReals,                 doc='second block of the unit                         [GW]')
-        OptModel.vReserveUp                = Var(mTEPES.psnnr, within=NonNegativeReals,                 doc='upward   operating reserve                       [GW]')
-        OptModel.vReserveDown              = Var(mTEPES.psnnr, within=NonNegativeReals,                 doc='downward operating reserve                       [GW]')
-        OptModel.vEnergyInflows            = Var(mTEPES.psnec, within=NonNegativeReals,                 doc='unscheduled inflows  of candidate ESS units      [GW]')
-        OptModel.vEnergyOutflows           = Var(mTEPES.psnes, within=NonNegativeReals,                 doc='scheduled   outflows of all       ESS units      [GW]')
-        OptModel.vESSInventory             = Var(mTEPES.psnes, within=NonNegativeReals,                 doc='ESS inventory                                   [GWh]')
-        OptModel.vESSSpillage              = Var(mTEPES.psnes, within=NonNegativeReals,                 doc='ESS spillage                                    [GWh]')
-        OptModel.vIniInventory             = Var(mTEPES.psnec, within=NonNegativeReals,                 doc='initial inventory for ESS candidate             [GWh]')
-
-        OptModel.vESSTotalCharge           = Var(mTEPES.psneh, within=NonNegativeReals,                 doc='ESS total charge power                           [GW]')
-        OptModel.vCharge2ndBlock           = Var(mTEPES.psneh, within=NonNegativeReals,                 doc='ESS       charge power                           [GW]')
-        OptModel.vESSReserveUp             = Var(mTEPES.psneh, within=NonNegativeReals,                 doc='ESS upward   operating reserve                   [GW]')
-        OptModel.vESSReserveDown           = Var(mTEPES.psneh, within=NonNegativeReals,                 doc='ESS downward operating reserve                   [GW]')
-        OptModel.vENS                      = Var(mTEPES.psnnd, within=NonNegativeReals,                 doc='energy not served in node                        [GW]')
+        OptModel.vTotalSCost               = Var(                       within=NonNegativeReals, doc='total system                         cost      [MEUR]')
+        OptModel.vTotalICost               = Var(                       within=NonNegativeReals, doc='total system investment              cost      [MEUR]')
+        OptModel.vTotalFCost               = Var(mTEPES.p,     within=NonNegativeReals, doc='total system fixed                   cost      [MEUR]')
+        OptModel.vTotalGCost               = Var(mTEPES.psn,   within=NonNegativeReals, doc='total variable generation  operation cost      [MEUR]')
+        OptModel.vTotalCCost               = Var(mTEPES.psn,   within=NonNegativeReals, doc='total variable consumption operation cost      [MEUR]')
+        OptModel.vTotalECost               = Var(mTEPES.psn,   within=NonNegativeReals, doc='total system emission                cost      [MEUR]')
+        OptModel.vTotalRCost               = Var(mTEPES.psn,   within=NonNegativeReals, doc='total system reliability             cost      [MEUR]')
+        OptModel.vTotalNCost               = Var(mTEPES.psn,   within=NonNegativeReals, doc='total network loss penalty operation cost      [MEUR]')
+        OptModel.vTotalEmissionArea        = Var(mTEPES.psnar, within=NonNegativeReals, doc='total   area emission                         [MtCO2]')
+        OptModel.vTotalECostArea           = Var(mTEPES.psnar, within=NonNegativeReals, doc='total   area emission                cost      [MEUR]')
+        OptModel.vTotalRESEnergyArea       = Var(mTEPES.psnar, within=NonNegativeReals, doc='        RES energy                              [GWh]')
+
+        OptModel.vTotalOutput              = Var(mTEPES.psng , within=NonNegativeReals, doc='total output of the unit                         [GW]')
+        OptModel.vOutput2ndBlock           = Var(mTEPES.psnnr, within=NonNegativeReals, doc='second block of the unit                         [GW]')
+        OptModel.vReserveUp                = Var(mTEPES.psnnr, within=NonNegativeReals, doc='upward   operating reserve                       [GW]')
+        OptModel.vReserveDown              = Var(mTEPES.psnnr, within=NonNegativeReals, doc='downward operating reserve                       [GW]')
+        OptModel.vEnergyInflows            = Var(mTEPES.psnec, within=NonNegativeReals, doc='unscheduled inflows  of candidate ESS units      [GW]')
+        OptModel.vEnergyOutflows           = Var(mTEPES.psnes, within=NonNegativeReals, doc='scheduled   outflows of all       ESS units      [GW]')
+        OptModel.vESSInventory             = Var(mTEPES.psnes, within=NonNegativeReals, doc='ESS inventory                                   [GWh]')
+        OptModel.vESSSpillage              = Var(mTEPES.psnes, within=NonNegativeReals, doc='ESS spillage                                    [GWh]')
+        OptModel.vIniInventory             = Var(mTEPES.psnec, within=NonNegativeReals, doc='initial inventory for ESS candidate             [GWh]')
+
+        OptModel.vESSTotalCharge           = Var(mTEPES.psneh, within=NonNegativeReals, doc='ESS total charge power                           [GW]')
+        OptModel.vCharge2ndBlock           = Var(mTEPES.psneh, within=NonNegativeReals, doc='ESS       charge power                           [GW]')
+        OptModel.vESSReserveUp             = Var(mTEPES.psneh, within=NonNegativeReals, doc='ESS upward   operating reserve                   [GW]')
+        OptModel.vESSReserveDown           = Var(mTEPES.psneh, within=NonNegativeReals, doc='ESS downward operating reserve                   [GW]')
+        OptModel.vENS                      = Var(mTEPES.psnnd, within=NonNegativeReals, doc='energy not served in node                        [GW]')
 
         if mTEPES.pIndHydroTopology == 1:
-            OptModel.vHydroInflows         = Var(mTEPES.psnrc, within=NonNegativeReals,                 doc='unscheduled inflows  of candidate hydro units  [m3/s]')
-            OptModel.vHydroOutflows        = Var(mTEPES.psnrs, within=NonNegativeReals,                 doc='scheduled   outflows of all       hydro units  [m3/s]')
-            OptModel.vReservoirVolume      = Var(mTEPES.psnrs, within=NonNegativeReals,                 doc='Reservoir volume                                [hm3]')
-            OptModel.vReservoirSpillage    = Var(mTEPES.psnrs, within=NonNegativeReals,                 doc='Reservoir spillage                              [hm3]')
+            OptModel.vHydroInflows         = Var(mTEPES.psnrc, within=NonNegativeReals, doc='unscheduled inflows  of candidate hydro units  [m3/s]')
+            OptModel.vHydroOutflows        = Var(mTEPES.psnrs, within=NonNegativeReals, doc='scheduled   outflows of all       hydro units  [m3/s]')
+            OptModel.vReservoirVolume      = Var(mTEPES.psnrs, within=NonNegativeReals, doc='Reservoir volume                                [hm3]')
+            OptModel.vReservoirSpillage    = Var(mTEPES.psnrs, within=NonNegativeReals, doc='Reservoir spillage                              [hm3]')
 
         if mTEPES.pIndHeat == 1:
-            OptModel.vTotalOutputHeat      = Var(mTEPES.psng , within=NonNegativeReals,                 doc='total heat output of the boiler unit             [GW]')
+            OptModel.vTotalOutputHeat      = Var(mTEPES.psng , within=NonNegativeReals, doc='total heat output of the boiler unit             [GW]')
             [OptModel.vTotalOutputHeat[p,sc,n,ch].setub(mTEPES.pMaxPowerHeat[p,sc,n,ch]) for p,sc,n,ch in mTEPES.psnch]
             [OptModel.vTotalOutputHeat[p,sc,n,ch].setlb(mTEPES.pMinPowerHeat[p,sc,n,ch]) for p,sc,n,ch in mTEPES.psnch]
             # only boilers are forced to produce at their minimum heat power. CHPs are not forced to produce at their minimum heat power, they are committed or not to produce electricity
 
         if mTEPES.pIndBinGenInvest() != 1:
-            OptModel.vGenerationInvest     = Var(mTEPES.peb,   within=UnitInterval,                     doc='generation       investment decision exists in a year [0,1]')
-            OptModel.vGenerationInvPer     = Var(mTEPES.peb,   within=UnitInterval,                     doc='generation       investment decision done   in a year [0,1]')
+            OptModel.vGenerationInvest     = Var(mTEPES.peb,   within=UnitInterval,     doc='generation       investment decision exists in a year [0,1]')
+            OptModel.vGenerationInvPer     = Var(mTEPES.peb,   within=UnitInterval,     doc='generation       investment decision done   in a year [0,1]')
         else:
-            OptModel.vGenerationInvest     = Var(mTEPES.peb,   within=Binary,                           doc='generation       investment decision exists in a year {0,1}')
-            OptModel.vGenerationInvPer     = Var(mTEPES.peb,   within=Binary,                           doc='generation       investment decision done   in a year {0,1}')
+            OptModel.vGenerationInvest     = Var(mTEPES.peb,   within=Binary,           doc='generation       investment decision exists in a year {0,1}')
+            OptModel.vGenerationInvPer     = Var(mTEPES.peb,   within=Binary,           doc='generation       investment decision done   in a year {0,1}')
 
         if mTEPES.pIndBinGenRetire() != 1:
-            OptModel.vGenerationRetire     = Var(mTEPES.pgd,   within=UnitInterval,                     doc='generation       retirement decision exists in a year [0,1]')
-            OptModel.vGenerationRetPer     = Var(mTEPES.pgd,   within=UnitInterval,                     doc='generation       retirement decision exists in a year [0,1]')
+            OptModel.vGenerationRetire     = Var(mTEPES.pgd,   within=UnitInterval,     doc='generation       retirement decision exists in a year [0,1]')
+            OptModel.vGenerationRetPer     = Var(mTEPES.pgd,   within=UnitInterval,     doc='generation       retirement decision exists in a year [0,1]')
         else:
-            OptModel.vGenerationRetire     = Var(mTEPES.pgd,   within=Binary,                           doc='generation       retirement decision exists in a year {0,1}')
-            OptModel.vGenerationRetPer     = Var(mTEPES.pgd,   within=Binary,                           doc='generation       retirement decision exists in a year {0,1}')
+            OptModel.vGenerationRetire     = Var(mTEPES.pgd,   within=Binary,           doc='generation       retirement decision exists in a year {0,1}')
+            OptModel.vGenerationRetPer     = Var(mTEPES.pgd,   within=Binary,           doc='generation       retirement decision exists in a year {0,1}')
 
         if mTEPES.pIndBinNetElecInvest() != 1:
-            OptModel.vNetworkInvest        = Var(mTEPES.plc,   within=UnitInterval,                     doc='electric network investment decision exists in a year [0,1]')
-            OptModel.vNetworkInvPer        = Var(mTEPES.plc,   within=UnitInterval,                     doc='electric network investment decision exists in a year [0,1]')
+            OptModel.vNetworkInvest        = Var(mTEPES.plc,   within=UnitInterval,     doc='electric network investment decision exists in a year [0,1]')
+            OptModel.vNetworkInvPer        = Var(mTEPES.plc,   within=UnitInterval,     doc='electric network investment decision exists in a year [0,1]')
         else:
-            OptModel.vNetworkInvest        = Var(mTEPES.plc,   within=Binary,                           doc='electric network investment decision exists in a year {0,1}')
-            OptModel.vNetworkInvPer        = Var(mTEPES.plc,   within=Binary,                           doc='electric network investment decision exists in a year {0,1}')
+            OptModel.vNetworkInvest        = Var(mTEPES.plc,   within=Binary,           doc='electric network investment decision exists in a year {0,1}')
+            OptModel.vNetworkInvPer        = Var(mTEPES.plc,   within=Binary,           doc='electric network investment decision exists in a year {0,1}')
 
         if mTEPES.pIndHydroTopology == 1:
             if mTEPES.pIndBinRsrInvest() != 1:
-                OptModel.vReservoirInvest  = Var(mTEPES.prc,   within=UnitInterval,                     doc='reservoir        investment decision exists in a year [0,1]')
-                OptModel.vReservoirInvPer  = Var(mTEPES.prc,   within=UnitInterval,                     doc='reservoir        investment decision exists in a year [0,1]')
+                OptModel.vReservoirInvest  = Var(mTEPES.prc,   within=UnitInterval,     doc='reservoir        investment decision exists in a year [0,1]')
+                OptModel.vReservoirInvPer  = Var(mTEPES.prc,   within=UnitInterval,     doc='reservoir        investment decision exists in a year [0,1]')
             else:
-                OptModel.vReservoirInvest  = Var(mTEPES.prc,   within=Binary,                           doc='reservoir        investment decision exists in a year {0,1}')
-                OptModel.vReservoirInvPer  = Var(mTEPES.prc,   within=Binary,                           doc='reservoir        investment decision exists in a year {0,1}')
+                OptModel.vReservoirInvest  = Var(mTEPES.prc,   within=Binary,           doc='reservoir        investment decision exists in a year {0,1}')
+                OptModel.vReservoirInvPer  = Var(mTEPES.prc,   within=Binary,           doc='reservoir        investment decision exists in a year {0,1}')
 
         if mTEPES.pIndHydrogen == 1:
             if mTEPES.pIndBinNetH2Invest() != 1:
-                OptModel.vH2PipeInvest     = Var(mTEPES.ppc,   within=UnitInterval,                     doc='hydrogen network investment decision exists in a year [0,1]')
-                OptModel.vH2PipeInvPer     = Var(mTEPES.ppc,   within=UnitInterval,                     doc='hydrogen network investment decision exists in a year [0,1]')
+                OptModel.vH2PipeInvest     = Var(mTEPES.ppc,   within=UnitInterval,     doc='hydrogen network investment decision exists in a year [0,1]')
+                OptModel.vH2PipeInvPer     = Var(mTEPES.ppc,   within=UnitInterval,     doc='hydrogen network investment decision exists in a year [0,1]')
             else:
-                OptModel.vH2PipeInvest     = Var(mTEPES.ppc,   within=Binary,                           doc='hydrogen network investment decision exists in a year {0,1}')
-                OptModel.vH2PipeInvPer     = Var(mTEPES.ppc,   within=Binary,                           doc='hydrogen network investment decision exists in a year {0,1}')
+                OptModel.vH2PipeInvest     = Var(mTEPES.ppc,   within=Binary,           doc='hydrogen network investment decision exists in a year {0,1}')
+                OptModel.vH2PipeInvPer     = Var(mTEPES.ppc,   within=Binary,           doc='hydrogen network investment decision exists in a year {0,1}')
 
         if mTEPES.pIndHeat == 1:
             if mTEPES.pIndBinGenInvest() != 1:
-                OptModel.vGenerationInvestHeat = Var(mTEPES.pbc,   within=UnitInterval,                 doc='generation       investment decision exists in a year [0,1]')
-                OptModel.vGenerationInvPerHeat = Var(mTEPES.pbc,   within=UnitInterval,                 doc='generation       investment decision done   in a year [0,1]')
+                OptModel.vGenerationInvestHeat = Var(mTEPES.pbc,   within=UnitInterval, doc='generation       investment decision exists in a year [0,1]')
+                OptModel.vGenerationInvPerHeat = Var(mTEPES.pbc,   within=UnitInterval, doc='generation       investment decision done   in a year [0,1]')
             else:
-                OptModel.vGenerationInvestHeat = Var(mTEPES.pbc,   within=Binary,                       doc='generation       investment decision exists in a year {0,1}')
-                OptModel.vGenerationInvPerHeat = Var(mTEPES.pbc,   within=Binary,                       doc='generation       investment decision done   in a year {0,1}')
+                OptModel.vGenerationInvestHeat = Var(mTEPES.pbc,   within=Binary,       doc='generation       investment decision exists in a year {0,1}')
+                OptModel.vGenerationInvPerHeat = Var(mTEPES.pbc,   within=Binary,       doc='generation       investment decision done   in a year {0,1}')
             if mTEPES.pIndBinNetHeatInvest() != 1:
-                OptModel.vHeatPipeInvest       = Var(mTEPES.phc,   within=UnitInterval,                 doc='heat network investment decision exists in a year [0,1]'    )
-                OptModel.vHeatPipeInvPer       = Var(mTEPES.phc,   within=UnitInterval,                 doc='heat network investment decision exists in a year [0,1]'    )
+                OptModel.vHeatPipeInvest       = Var(mTEPES.phc,   within=UnitInterval, doc='heat network investment decision exists in a year [0,1]'    )
+                OptModel.vHeatPipeInvPer       = Var(mTEPES.phc,   within=UnitInterval, doc='heat network investment decision exists in a year [0,1]'    )
             else:
-                OptModel.vHeatPipeInvest       = Var(mTEPES.phc,   within=Binary,                       doc='heat network investment decision exists in a year {0,1}'    )
-                OptModel.vHeatPipeInvPer       = Var(mTEPES.phc,   within=Binary,                       doc='heat network investment decision exists in a year {0,1}'    )
+                OptModel.vHeatPipeInvest       = Var(mTEPES.phc,   within=Binary,       doc='heat network investment decision exists in a year {0,1}'    )
+                OptModel.vHeatPipeInvPer       = Var(mTEPES.phc,   within=Binary,       doc='heat network investment decision exists in a year {0,1}'    )
 
         if mTEPES.pIndBinGenOperat() == 0:
             OptModel.vCommitment           = Var(mTEPES.psnnr, within=UnitInterval,     initialize=0.0, doc='commitment         of the unit                        [0,1]')
             OptModel.vStartUp              = Var(mTEPES.psnnr, within=UnitInterval,     initialize=0.0, doc='startup            of the unit                        [0,1]')
             OptModel.vShutDown             = Var(mTEPES.psnnr, within=UnitInterval,     initialize=0.0, doc='shutdown           of the unit                        [0,1]')
-            OptModel.vMaxCommitment        = Var(mTEPES.psnr , within=UnitInterval,     initialize=0.0, doc='maximum commitment of the unit                        [0,1]')
             OptModel.vStableState          = Var(mTEPES.psnnr, within=UnitInterval,     initialize=0.0, doc='stable    state    of the unit                        [0,1]')
             OptModel.vRampUpState          = Var(mTEPES.psnnr, within=UnitInterval,     initialize=0.0, doc='ramp up   state    of the unit                        [0,1]')
             OptModel.vRampDwState          = Var(mTEPES.psnnr, within=UnitInterval,     initialize=0.0, doc='ramp down state    of the unit                        [0,1]')
+
+            OptModel.vMaxCommitmentYearly  = Var(mTEPES.psnr ,mTEPES.ExclusiveGroupsYearly, within=UnitInterval, initialize=0.0, doc='maximum commitment of the unit yearly [0,1]')
+            OptModel.vMaxCommitmentHourly  = Var(mTEPES.psnnr,mTEPES.ExclusiveGroupsHourly, within=UnitInterval, initialize=0.0, doc='maximum commitment of the unit hourly [0,1]')
+
+            if mTEPES.pIndHydroTopology == 1:
+                OptModel.vCommitmentCons   = Var(mTEPES.psnh,  within=UnitInterval,     doc='consumption commitment of the unit                    [0,1]')
+
         else:
             OptModel.vCommitment           = Var(mTEPES.psnnr, within=Binary,           initialize=0  , doc='commitment         of the unit                        {0,1}')
             OptModel.vStartUp              = Var(mTEPES.psnnr, within=Binary,           initialize=0  , doc='startup            of the unit                        {0,1}')
             OptModel.vShutDown             = Var(mTEPES.psnnr, within=Binary,           initialize=0  , doc='shutdown           of the unit                        {0,1}')
-            OptModel.vMaxCommitment        = Var(mTEPES.psnr , within=Binary,           initialize=0  , doc='maximum commitment of the unit                        {0,1}')
             OptModel.vStableState          = Var(mTEPES.psnnr, within=Binary,           initialize=0  , doc='stable    state    of the unit                        {0,1}')
             OptModel.vRampUpState          = Var(mTEPES.psnnr, within=Binary,           initialize=0  , doc='ramp up   state    of the unit                        {0,1}')
             OptModel.vRampDwState          = Var(mTEPES.psnnr, within=Binary,           initialize=0  , doc='ramp down state    of the unit                        {0,1}')
 
+            OptModel.vMaxCommitmentYearly  = Var(mTEPES.psnr ,mTEPES.ExclusiveGroupsYearly, within=Binary, initialize=0.0, doc='maximum commitment of the unit yearly [0,1]')
+            OptModel.vMaxCommitmentHourly  = Var(mTEPES.psnnr,mTEPES.ExclusiveGroupsHourly, within=Binary, initialize=0.0, doc='maximum commitment of the unit hourly [0,1]')
+            if mTEPES.pIndHydroTopology == 1:
+                OptModel.vCommitmentCons   = Var(mTEPES.psnh,  within=Binary,           doc='consumption commitment of the unit                    {0,1}')
+
+
         if mTEPES.pIndBinLineCommit() == 0:
-            OptModel.vLineCommit           = Var(mTEPES.psnla, within=UnitInterval,     initialize=0.0, doc='line switching      of the electric line              [0,1]')
+            OptModel.vLineCommit           = Var(mTEPES.psnla, within=UnitInterval,     doc='line switching      of the electric line              [0,1]')
         else:
-            OptModel.vLineCommit           = Var(mTEPES.psnla, within=Binary,           initialize=0  , doc='line switching      of the electric line              {0,1}')
+            OptModel.vLineCommit           = Var(mTEPES.psnla, within=Binary,           doc='line switching      of the electric line              {0,1}')
 
         if sum(mTEPES.pIndBinLineSwitch[:,:,:]):
             if mTEPES.pIndBinSingleNode() == 0 and mTEPES.pIndBinLineCommit() == 0:
-                OptModel.vLineOnState      = Var(mTEPES.psnla, within=UnitInterval,     initialize=0.0, doc='switching on  state of the electric line              [0,1]')
-                OptModel.vLineOffState     = Var(mTEPES.psnla, within=UnitInterval,     initialize=0.0, doc='switching off state of the electric line              [0,1]')
+                OptModel.vLineOnState      = Var(mTEPES.psnla, within=UnitInterval,     doc='switching on  state of the electric line              [0,1]')
+                OptModel.vLineOffState     = Var(mTEPES.psnla, within=UnitInterval,     doc='switching off state of the electric line              [0,1]')
             else:
-                OptModel.vLineOnState      = Var(mTEPES.psnla, within=Binary,           initialize=0  , doc='switching on  state of the electric line              {0,1}')
-                OptModel.vLineOffState     = Var(mTEPES.psnla, within=Binary,           initialize=0  , doc='switching off state of the electric line              {0,1}')
+                OptModel.vLineOnState      = Var(mTEPES.psnla, within=Binary,           doc='switching on  state of the electric line              {0,1}')
+                OptModel.vLineOffState     = Var(mTEPES.psnla, within=Binary,           doc='switching off state of the electric line              {0,1}')
 
     CreateVariables(mTEPES, mTEPES)
     # assign lower and upper bounds to variables
@@ -1735,7 +1897,7 @@ def SettingUpVariables(OptModel, mTEPES):
         '''
         Set upper/lower bounds.
 
-        This function takes a mTEPES instance and adds lower/upper bounds to variables which are limited by a parameter.
+        This function takes an mTEPES instance and adds lower/upper bounds to variables which are limited by a parameter.
 
         Parameters:
             mTEPES: The instance of mTEPES
@@ -1773,16 +1935,16 @@ def SettingUpVariables(OptModel, mTEPES):
     nFixedVariables = 0
     def RelaxBinaryInvestmentConditions(mTEPES, OptModel) -> int:
         '''
-        Relax binary investent variables.
+        Relax binary investment variables.
 
-        This function takes a mTEPES instance relaxes binary investment conditions and calculates the amount of variables fixed in the process.
+        This function takes an mTEPES instance, relaxes binary investment conditions and calculates the number of variables fixed in the process.
 
         Parameters:
             mTEPES: The instance of mTEPES.
             OptModel:
 
         Returns:
-            int: The amount of fixed variables.
+            int: The number of fixed variables.
         '''
 
         nFixedBinaries = 0
@@ -1844,9 +2006,20 @@ def SettingUpVariables(OptModel, mTEPES):
                 OptModel.vStartUp      [p,sc,n,nr].domain = UnitInterval
                 OptModel.vShutDown     [p,sc,n,nr].domain = UnitInterval
 
-        for p,sc,  nr in mTEPES.psnr:
-            if mTEPES.pIndBinUnitCommit[nr] == 0:
-                OptModel.vMaxCommitment[p,sc,  nr].domain = UnitInterval
+        for p,sc,nr,  group in mTEPES.psnr * mTEPES.ExclusiveGroups:
+            if mTEPES.pIndBinUnitCommit[nr] == 0 and nr in mTEPES.ExclusiveGeneratorsYearly:
+                OptModel.vMaxCommitmentYearly[p,sc,  nr,group].domain = UnitInterval
+        for p,sc,n,nr,group in mTEPES.psnnr * mTEPES.ExclusiveGroups:
+            if mTEPES.pIndBinUnitCommit[nr] == 0 and nr in mTEPES.ExclusiveGeneratorsHourly:
+                OptModel.vMaxCommitmentHourly[p,sc,n,nr,group].domain = UnitInterval
+        if mTEPES.pIndHydroTopology == 1:
+            for p,sc,n,h in mTEPES.psnh:
+                if mTEPES.pIndBinUnitCommit[h] == 0:
+                    OptModel.vCommitmentCons[p,sc,n,h].domain = UnitInterval
+                if mTEPES.pMaxCharge[p,sc,n,h] == 0:
+                    OptModel.vCommitmentCons[p,sc,n,h].fix(0)
+                    nFixedBinaries += 1
+
         return nFixedBinaries
 
     #Call the relaxing variables function and add its output to nFixedVariables
@@ -1856,7 +2029,7 @@ def SettingUpVariables(OptModel, mTEPES):
     def CreateFlowVariables(mTEPES,OptModel) -> int:
         #TODO use a more descriptive name for nFixedVariables
         '''
-                Create electricity, hydrogen and heat flow related variables.
+                Create electricity, hydrogen and heat-flow-related variables.
 
                 This function takes a mTEPES instance and adds the variables necessary to model power, hydrogen and heat flows in a network.
 
@@ -1865,7 +2038,7 @@ def SettingUpVariables(OptModel, mTEPES):
                     OptModel:
 
                 Returns:
-                    int: The amount of line commitment variables fixed
+                    int: The number of line commitment variables fixed
                 '''
         nFixedVariables = 0
         # existing lines are always committed if no switching decision is modeled
@@ -1882,12 +2055,15 @@ def SettingUpVariables(OptModel, mTEPES):
         OptModel.vFlowElec   = Var(mTEPES.psnla, within=Reals,            doc='electric flow    [GW]')
         OptModel.vTheta      = Var(mTEPES.psnnd, within=Reals,            doc='voltage angle   [rad]')
 
+        if mTEPES.pIndPTDF == 1:
+            OptModel.vNetPosition = Var(mTEPES.psnnd, within=Reals, doc='net position in node [GW]')
+
         [OptModel.vLineLosses[p,sc,n,ni,nf,cc].setub(0.5*mTEPES.pLineLossFactor[ni,nf,cc]*mTEPES.pLineNTCMax[ni,nf,cc]) for p,sc,n,ni,nf,cc in mTEPES.psnll]
         if mTEPES.pIndBinSingleNode() == 0:
-            [OptModel.vFlowElec[p,sc,n,ni,nf,cc].setlb(-mTEPES.pLineNTCBck[ni,nf,cc]   ) for p,sc,n,ni,nf,cc in mTEPES.psnla]
-            [OptModel.vFlowElec[p,sc,n,ni,nf,cc].setub( mTEPES.pLineNTCFrw[ni,nf,cc]   ) for p,sc,n,ni,nf,cc in mTEPES.psnla]
-        [OptModel.vTheta       [p,sc,n,nd      ].setlb(-mTEPES.pMaxTheta  [p,sc,n,nd]()) for p,sc,n,nd       in mTEPES.psnnd]
-        [OptModel.vTheta       [p,sc,n,nd      ].setub( mTEPES.pMaxTheta  [p,sc,n,nd]()) for p,sc,n,nd       in mTEPES.psnnd]
+            [OptModel.vFlowElec[p,sc,n,ni,nf,cc].setlb(-mTEPES.pMaxNTCBck[p,sc,n,ni,nf,cc]   ) for p,sc,n,ni,nf,cc in mTEPES.psnla]
+            [OptModel.vFlowElec[p,sc,n,ni,nf,cc].setub( mTEPES.pMaxNTCFrw[p,sc,n,ni,nf,cc]   ) for p,sc,n,ni,nf,cc in mTEPES.psnla]
+        [OptModel.vTheta       [p,sc,n,nd      ].setlb(-mTEPES.pMaxTheta [p,sc,n,nd      ]() ) for p,sc,n,nd       in mTEPES.psnnd]
+        [OptModel.vTheta       [p,sc,n,nd      ].setub( mTEPES.pMaxTheta [p,sc,n,nd      ]() ) for p,sc,n,nd       in mTEPES.psnnd]
 
         if mTEPES.pIndHydrogen == 1:
             OptModel.vFlowH2 = Var(mTEPES.psnpa, within=Reals,            doc='pipeline flow               [tH2]')
@@ -1911,14 +2087,14 @@ def SettingUpVariables(OptModel, mTEPES):
         '''
             Fix commitment variables.
 
-            This function takes a mTEPES instance and fixes commitment related variables for must run units, ESS units and units with no minimum power.
+            This function takes an mTEPES instance and fixes commitment-related variables for must run units, ESS units and units with no minimum power.
 
             Parameters:
                 mTEPES: The instance of mTEPES.
                 OptModel:
 
             Returns:
-                int: The amount of commitment variables fixed.
+                int: The number of commitment variables fixed.
             '''
         nFixedVariables = 0
 
@@ -1930,32 +2106,31 @@ def SettingUpVariables(OptModel, mTEPES):
         nFixedVariables += sum(                1  for p,sc,n,g in mTEPES.psng if mTEPES.pMaxPowerElec[p,sc,n,g] == 0.0)
 
         for p,sc,n,nr in mTEPES.psnnr:
-            # must run units or units with no minimum power or ESS existing units are always committed and must produce at least their minimum output
+            # must run units or units with no minimum power, or ESS existing units are always committed and must produce at least their minimum output
             # not applicable to mutually exclusive units
-            if   len(mTEPES.g2g) == 0:
-                OptModel.vMaxCommitment     [p,sc,  nr].fix(1)
-                nFixedVariables += 1/len(mTEPES.n)
-                if (mTEPES.pMustRun[nr] == 1 or (mTEPES.pMinPowerElec[p,sc,n,nr] == 0.0 and mTEPES.pRatedConstantVarCost[nr] == 0.0) or nr in mTEPES.es) and nr not in mTEPES.ec:
+            if   len(mTEPES.ExclusiveGroups) == 0:
+                if (mTEPES.pMustRun[nr] == 1 or (mTEPES.pMinPowerElec[p,sc,n,nr] == 0.0 and mTEPES.pRatedConstantVarCost[nr] == 0.0) or nr in mTEPES.es ) and nr not in mTEPES.ec and nr not in mTEPES.h:
                     OptModel.vCommitment    [p,sc,n,nr].fix(1)
                     OptModel.vStartUp       [p,sc,n,nr].fix(0)
                     OptModel.vShutDown      [p,sc,n,nr].fix(0)
                     nFixedVariables += 3
-            elif len(mTEPES.g2g) >  0 and sum(1 for g in mTEPES.nr if (nr,g) in mTEPES.g2g or (g,nr) in mTEPES.g2g) == 0:
-                if (mTEPES.pMustRun[nr] == 1 or (mTEPES.pMinPowerElec[p,sc,n,nr] == 0.0 and mTEPES.pRatedConstantVarCost[nr] == 0.0) or nr in mTEPES.es) and nr not in mTEPES.ec:
+            # If there are mutually exclusive groups do not fix variables from ESS in mutually exclusive groups
+            elif len(mTEPES.ExclusiveGroups) >  0 and nr not in mTEPES.ExclusiveGenerators:
+                if (mTEPES.pMustRun[nr] == 1 or (mTEPES.pMinPowerElec[p,sc,n,nr] == 0.0 and mTEPES.pRatedConstantVarCost[nr] == 0.0) or nr in mTEPES.es) and nr not in mTEPES.ec and nr not in mTEPES.h:
                     OptModel.vCommitment    [p,sc,n,nr].fix(1)
                     OptModel.vStartUp       [p,sc,n,nr].fix(0)
                     OptModel.vShutDown      [p,sc,n,nr].fix(0)
-                    OptModel.vMaxCommitment [p,sc,  nr].fix(1)
-                    nFixedVariables += 3+1/len(mTEPES.n)
+                    nFixedVariables += 3
+
             # if min and max power coincide there are neither second block, nor operating reserve
-            if  mTEPES.pMaxPower2ndBlock[p,sc,n,nr] ==  0.0:
-                OptModel.vOutput2ndBlock[p,sc,n,nr].fix(0.0)
-                OptModel.vReserveUp     [p,sc,n,nr].fix(0.0)
-                OptModel.vReserveDown   [p,sc,n,nr].fix(0.0)
+            if  mTEPES.pMaxPower2ndBlock [p,sc,n,nr] ==  0.0:
+                OptModel.vOutput2ndBlock [p,sc,n,nr].fix(0.0)
+                OptModel.vReserveUp      [p,sc,n,nr].fix(0.0)
+                OptModel.vReserveDown    [p,sc,n,nr].fix(0.0)
                 nFixedVariables += 3
-            if  mTEPES.pIndOperReserve  [       nr] ==  1:
-                OptModel.vReserveUp     [p,sc,n,nr].fix(0.0)
-                OptModel.vReserveDown   [p,sc,n,nr].fix(0.0)
+            if  mTEPES.pIndOperReserveGen[       nr] ==  1:
+                OptModel.vReserveUp      [p,sc,n,nr].fix(0.0)
+                OptModel.vReserveDown    [p,sc,n,nr].fix(0.0)
                 nFixedVariables += 2
 
         # total energy inflows per storage
@@ -1981,7 +2156,7 @@ def SettingUpVariables(OptModel, mTEPES):
             if  mTEPES.pMaxCharge2ndBlock[p,sc,n,es] ==  0.0:
                 OptModel.vCharge2ndBlock [p,sc,n,es].fix(0.0)
                 nFixedVariables += 1
-            if  mTEPES.pMaxCharge2ndBlock[p,sc,n,es] ==  0.0 or mTEPES.pIndOperReserve[es] == 1:
+            if  mTEPES.pMaxCharge2ndBlock[p,sc,n,es] ==  0.0 or mTEPES.pIndOperReserveCon[es] == 1:
                 OptModel.vESSReserveUp   [p,sc,n,es].fix(0.0)
                 OptModel.vESSReserveDown [p,sc,n,es].fix(0.0)
                 nFixedVariables += 2
@@ -1994,11 +2169,12 @@ def SettingUpVariables(OptModel, mTEPES):
                 # ESS with no charge capacity or not storage capacity can't charge
                 if  mTEPES.pMaxCharge        [p,sc,n,h ] ==  0.0:
                     OptModel.vESSTotalCharge [p,sc,n,h ].fix(0.0)
-                    nFixedVariables += 1
+                    OptModel.vCommitmentCons [p,sc,n,h ].fix(0.0)
+                    nFixedVariables += 2
                 if  mTEPES.pMaxCharge2ndBlock[p,sc,n,h ] ==  0.0:
                     OptModel.vCharge2ndBlock [p,sc,n,h ].fix(0.0)
                     nFixedVariables += 1
-                if  mTEPES.pMaxCharge2ndBlock[p,sc,n,h ] ==  0.0 or mTEPES.pIndOperReserve[h ] == 1:
+                if  mTEPES.pMaxCharge2ndBlock[p,sc,n,h ] ==  0.0 or mTEPES.pIndOperReserveCon[h ] == 1:
                     OptModel.vESSReserveUp   [p,sc,n,h ].fix(0.0)
                     OptModel.vESSReserveDown [p,sc,n,h ].fix(0.0)
                     nFixedVariables += 2
@@ -2006,7 +2182,7 @@ def SettingUpVariables(OptModel, mTEPES):
     nFixedGeneratorCommits = FixGeneratorsCommitment(mTEPES,mTEPES)
     nFixedVariables       += nFixedGeneratorCommits
     # thermal, ESS, and RES units ordered by increasing variable operation cost, excluding reactive generating units
-    if len(mTEPES.tq):
+    if mTEPES.tq:
         mTEPES.go = Set(initialize=[g for g in sorted(mTEPES.pRatedLinearVarCost, key=mTEPES.pRatedLinearVarCost.__getitem__) if g not in mTEPES.sq])
     else:
         if mTEPES.pIndHydroTopology == 1:
@@ -2026,29 +2202,29 @@ def SettingUpVariables(OptModel, mTEPES):
         mTEPES.st = Set(doc='stages',      initialize=[stt for stt in mTEPES.stt if st == stt and mTEPES.pStageWeight[stt] and sum(1 for (p,sc,st,nn) in mTEPES.s2n)])
         mTEPES.n  = Set(doc='load levels', initialize=[nn  for nn  in mTEPES.nn  if                                                      (p,sc,st,nn) in mTEPES.s2n ])
 
-        if len(mTEPES.n):
+        if mTEPES.n:
             # determine the first load level of each stage
             n1 = (p,sc,mTEPES.n.first())
             # commit the units of each area and their output at the first load level of each stage
             for ar in mTEPES.ar:
                 pSystemOutput = 0.0
                 for nr in mTEPES.nr:
-                    if nr in g2a[ar] and pSystemOutput < sum(mTEPES.pDemandElec[n1,nd] for nd in mTEPES.nd if (nd,ar) in mTEPES.ndar) and mTEPES.pMustRun[nr] == 1:
-                        mTEPES.pInitialOutput[n1,nr] = mTEPES.pMaxPowerElec[n1,nr]
+                    if nr in g2a[ar] and (p,nr) in mTEPES.pnr and pSystemOutput < sum(mTEPES.pDemandElec[n1,nd] for nd in mTEPES.nd if (nd,ar) in mTEPES.ndar) and mTEPES.pMustRun[nr] == 1:
+                        mTEPES.pInitialOutput[n1,nr] = mTEPES.pMaxPowerElec [n1,nr]
                         mTEPES.pInitialUC    [n1,nr] = 1
                         pSystemOutput               += mTEPES.pInitialOutput[n1,nr]()
 
-                # determine the initial committed units and their output at the first load level of each period, scenario, and stage
+                # determine the initially committed units and their output at the first load level of each period, scenario, and stage
                 for go in mTEPES.go:
-                    if go in g2a[ar] and pSystemOutput < sum(mTEPES.pDemandElec[n1,nd] for nd in mTEPES.nd if (nd,ar) in mTEPES.ndar) and mTEPES.pMustRun[go] == 0:
+                    if go in g2a[ar] and (p,go) in mTEPES.pg and pSystemOutput < sum(mTEPES.pDemandElec[n1,nd] for nd in mTEPES.nd if (nd,ar) in mTEPES.ndar) and mTEPES.pMustRun[go] == 0:
                         if go in mTEPES.re:
-                            mTEPES.pInitialOutput[n1,go] = mTEPES.pMaxPowerElec[n1,go]
+                            mTEPES.pInitialOutput[n1,go] = mTEPES.pMaxPowerElec [n1,go]
                         else:
-                            mTEPES.pInitialOutput[n1,go] = mTEPES.pMinPowerElec[n1,go]
+                            mTEPES.pInitialOutput[n1,go] = mTEPES.pMinPowerElec [n1,go]
                         mTEPES.pInitialUC[n1,go]         = 1
                         pSystemOutput                   += mTEPES.pInitialOutput[n1,go]()
 
-            # determine the initial committed lines
+            # determine the initially committed lines
             for la in mTEPES.la:
                 if la in mTEPES.lc:
                     mTEPES.pInitialSwitch[n1,la] = 0
@@ -2057,7 +2233,7 @@ def SettingUpVariables(OptModel, mTEPES):
 
             # fixing the ESS inventory at the last load level of the stage for every period and scenario if between storage limits
             for es in mTEPES.es:
-                if es not in mTEPES.ec:
+                if es not in mTEPES.ec and (p,es) in mTEPES.pes:
                     OptModel.vESSInventory[p,sc,mTEPES.n.last(),es].fix(mTEPES.pIniInventory[p,sc,mTEPES.n.last(),es])
 
             if mTEPES.pIndHydroTopology == 1:
@@ -2112,7 +2288,7 @@ def SettingUpVariables(OptModel, mTEPES):
             OptModel.vEnergyInflows     [p,sc,n,ec].fix (0.0)
             nFixedVariables += 1
 
-    # if no operating reserve is required no variables are needed
+    # if no operating reserve is required, no variables are needed
     for p,sc,n,ar,nr in mTEPES.psnar*mTEPES.nr:
         if (ar,nr) in mTEPES.a2g and (p,nr) in mTEPES.pnr:
             if mTEPES.pOperReserveUp    [p,sc,n,ar] ==  0.0:
@@ -2130,7 +2306,7 @@ def SettingUpVariables(OptModel, mTEPES):
                 OptModel.vESSReserveDown[p,sc,n,es].fix(0.0)
                 nFixedVariables += 1
 
-    # if there are no energy outflows no variable is needed
+    # if there are no energy outflows, no variable is needed
     for es in mTEPES.es:
         if sum(mTEPES.pEnergyOutflows[p,sc,n,es]() for p,sc,n in mTEPES.psn if (p,es) in mTEPES.pes) == 0.0:
             for p,sc,n in mTEPES.psn:
@@ -2138,6 +2314,15 @@ def SettingUpVariables(OptModel, mTEPES):
                     OptModel.vEnergyOutflows[p,sc,n,es].fix(0.0)
                     nFixedVariables += 1
 
+    if mTEPES.pIndHydroTopology == 1:
+        # if there are no hydro outflows, no variable is needed
+        for rs in mTEPES.rs:
+            if sum(mTEPES.pHydroOutflows[p,sc,n,rs]() for p,sc,n in mTEPES.psn if (p,rs) in mTEPES.prs) == 0.0:
+                for p,sc,n in mTEPES.psn:
+                    if (p,rs) in mTEPES.prs:
+                        OptModel.vHydroOutflows[p,sc,n,rs].fix(0.0)
+                        nFixedVariables += 1
+
     # fixing the voltage angle of the reference node for each scenario, period, and load level
     if mTEPES.pIndBinSingleNode() == 0:
         for p,sc,n in mTEPES.psn:
@@ -2168,14 +2353,14 @@ def SettingUpVariables(OptModel, mTEPES):
         '''
         Fix installations/retirements forbidden by period.
 
-        This function takes a mTEPES instance and fixes all installation and retirement variables to 0 if they are not allowed in the corresponding period.
+        This function takes an mTEPES instance and fixes all installation and retirement variables to 0 if they are not allowed in the corresponding period.
 
         Parameters:
             mTEPES: The instance of mTEPES.
             OptModel:
 
         Returns:
-            int: The amount of variables fixed.
+            int: The number of variables fixed.
         '''
         nFixedVariables = 0
         # do not install/retire power plants and lines if not allowed in this period
@@ -2273,7 +2458,7 @@ def SettingUpVariables(OptModel, mTEPES):
         if mTEPES.pIndHydroTopology == 1:
             for p,sc,n,rs in mTEPES.psnrs:
                 if rs not in mTEPES.rn and mTEPES.pRsrPeriodIni[rs] > p:
-                    OptModel.vEnergyOutflows        [p,sc,n,rs].fix(0.0)
+                    OptModel.vHydroOutflows         [p,sc,n,rs].fix(0.0)
                     OptModel.vReservoirVolume       [p,sc,n,rs].fix(0.0)
                     OptModel.vReservoirSpillage     [p,sc,n,rs].fix(0.0)
                     mTEPES.pIniVolume               [p,sc,n,rs] =   0.0
@@ -2295,18 +2480,18 @@ def SettingUpVariables(OptModel, mTEPES):
     [OptModel.vLineCommit  [p,sc,n,ni,nf,cc].fix(0  ) for p,sc,n,ni,nf,cc in mTEPES.psnla if (ni,nf,cc) not in mTEPES.lc and mTEPES.pElecNetPeriodIni [ni,nf,cc] > p]
     [OptModel.vLineOnState [p,sc,n,ni,nf,cc].fix(0  ) for p,sc,n,ni,nf,cc in mTEPES.psnla if (ni,nf,cc) not in mTEPES.lc and mTEPES.pElecNetPeriodIni [ni,nf,cc] > p]
     [OptModel.vLineOffState[p,sc,n,ni,nf,cc].fix(0  ) for p,sc,n,ni,nf,cc in mTEPES.psnla if (ni,nf,cc) not in mTEPES.lc and mTEPES.pElecNetPeriodIni [ni,nf,cc] > p]
-    nFixedVariables += sum(                        4  for p,sc,n,ni,nf,cc in mTEPES.psnla if (ni,nf,cc) not in mTEPES.lc and mTEPES.pElecNetPeriodIni [ni,nf,cc] > p)
+    nFixedVariables += sum(                      4    for p,sc,n,ni,nf,cc in mTEPES.psnla if (ni,nf,cc) not in mTEPES.lc and mTEPES.pElecNetPeriodIni [ni,nf,cc] > p)
 
     [OptModel.vLineLosses  [p,sc,n,ni,nf,cc].fix(0.0) for p,sc,n,ni,nf,cc in mTEPES.psnll if (ni,nf,cc) not in mTEPES.lc and mTEPES.pElecNetPeriodIni [ni,nf,cc] > p]
-    nFixedVariables += sum(                        1  for p,sc,n,ni,nf,cc in mTEPES.psnll if (ni,nf,cc) not in mTEPES.lc and mTEPES.pElecNetPeriodIni [ni,nf,cc] > p)
+    nFixedVariables += sum(                      1    for p,sc,n,ni,nf,cc in mTEPES.psnll if (ni,nf,cc) not in mTEPES.lc and mTEPES.pElecNetPeriodIni [ni,nf,cc] > p)
 
     if mTEPES.pIndHydrogen == 1:
-        [OptModel.vFlowH2  [p,sc,n,ni,nf,cc].fix(0.0) for p,sc,n,ni,nf,cc in mTEPES.psnpa if (ni,nf,cc) not in mTEPES.pc and mTEPES.pH2PipePeriodIni[ni,nf,cc] > p]
-        nFixedVariables += sum(                    4  for p,sc,n,ni,nf,cc in mTEPES.psnpa if (ni,nf,cc) not in mTEPES.pc and mTEPES.pH2PipePeriodIni[ni,nf,cc] > p)
+        [OptModel.vFlowH2  [p,sc,n,ni,nf,cc].fix(0.0) for p,sc,n,ni,nf,cc in mTEPES.psnpa if (ni,nf,cc) not in mTEPES.pc and mTEPES.pH2PipePeriodIni  [ni,nf,cc] > p]
+        nFixedVariables += sum(                  4    for p,sc,n,ni,nf,cc in mTEPES.psnpa if (ni,nf,cc) not in mTEPES.pc and mTEPES.pH2PipePeriodIni  [ni,nf,cc] > p)
 
     if mTEPES.pIndHeat == 1:
         [OptModel.vFlowHeat[p,sc,n,ni,nf,cc].fix(0.0) for p,sc,n,ni,nf,cc in mTEPES.psnha if (ni,nf,cc) not in mTEPES.hc and mTEPES.pHeatPipePeriodIni[ni,nf,cc] > p]
-        nFixedVariables += sum(                    4  for p,sc,n,ni,nf,cc in mTEPES.psnha if (ni,nf,cc) not in mTEPES.hc and mTEPES.pHeatPipePeriodIni[ni,nf,cc] > p)
+        nFixedVariables += sum(                  4    for p,sc,n,ni,nf,cc in mTEPES.psnha if (ni,nf,cc) not in mTEPES.hc and mTEPES.pHeatPipePeriodIni[ni,nf,cc] > p)
 
     # tolerance to consider 0 an investment decision
     pEpsilon = 1e-4
@@ -2314,7 +2499,7 @@ def SettingUpVariables(OptModel, mTEPES):
         '''
         Set small numbers to 0.
 
-        This function takes a mTEPES instance and sets values under a certain threshold to be 0.
+        This function takes an mTEPES instance and sets values under a certain threshold to be 0.
 
         Parameters:
             mTEPES: The instance of mTEPES.