integration of typeday and tsam

- typeday code is implemented according to the code of Daniel Zinsmeister from tum-ens#282
- the time series aggregation module from Kotzur, L., Markewitz, P., Robinius, M., & Stolten, D. (2018) is integrated into the urbs model primarily within the typeperiod module

Author: bereba

run_transdist.py

@@ -10,6 +10,7 @@
 import matplotlib.pyplot as plt
 from urbs.runfunctions import *
 
+
 input_files = 'Transmission_Level.xlsx'  # for single year file name, for intertemporal folder name
 input_dir = 'Input'
 input_path = os.path.join(input_dir, input_files)
@@ -39,34 +40,39 @@
 solver = 'gurobi'
 
 # simulation timesteps
-(offset, length) = (0,120)  # time step selection
+(offset, length) = (0,336)  # time step selection
 timesteps = range(offset, offset+length+1)
 dt = 1  # length of each time step (unit: hours)
 
+# input data for tsam method
+noTypicalPeriods = 4
+hoursPerPeriod = 168
+
 # detailed reporting commodity/sites
 report_tuples = [
      (2021, 'Bayern', 'Elec'),
      (2021, 'Hessen', 'Elec'),
-     (2021, 'node0_A1_Bayern', 'Elec'),
-     (2021, 'node1_A1_Bayern', 'Elec'),
-     (2021, 'node2_A1_Bayern', 'Elec'),
-     (2021, 'node3_A1_Bayern', 'Elec'),
-     (2021, 'node4_A1_Bayern', 'Elec'),
-     (2021, 'node5_A1_Bayern', 'Elec'),
-     (2021, 'node6_A1_Bayern', 'Elec'),
-     (2021, 'node7_A1_Bayern', 'Elec'),
-     (2021, 'node8_A1_Bayern', 'Elec'),
-     (2021, 'node9_A1_Bayern', 'Elec'),
-    (2021, 'node0_A1_Bayern', 'Elec-Reactive'),
-    (2021, 'node1_A1_Bayern', 'Elec-Reactive'),
-    (2021, 'node2_A1_Bayern', 'Elec-Reactive'),
-    (2021, 'node3_A1_Bayern', 'Elec-Reactive'),
-    (2021, 'node4_A1_Bayern', 'Elec-Reactive'),
-    (2021, 'node5_A1_Bayern', 'Elec-Reactive'),
-    (2021, 'node6_A1_Bayern', 'Elec-Reactive'),
-    (2021, 'node7_A1_Bayern', 'Elec-Reactive'),
-    (2021, 'node8_A1_Bayern', 'Elec-Reactive'),
-    (2021, 'node9_A1_Bayern', 'Elec-Reactive')
+    #  (2021, 'node0_A1_Bayern', 'Elec'),
+    #  (2021, 'node1_A1_Bayern', 'Elec'),
+    #  (2021, 'node2_A1_Bayern', 'Elec'),
+    #  (2021, 'node3_A1_Bayern', 'Elec'),
+    #  (2021, 'node4_A1_Bayern', 'Elec'),
+    #  (2021, 'node5_A1_Bayern', 'Elec'),
+    #  (2021, 'node6_A1_Bayern', 'Elec'),
+    #  (2021, 'node7_A1_Bayern', 'Elec'),
+    #  (2021, 'node8_A1_Bayern', 'Elec'),
+    #  (2021, 'node9_A1_Bayern', 'Elec'),
+    # (2021, 'node0_A1_Bayern', 'Elec-Reactive'),
+    # (2021, 'node1_A1_Bayern', 'Elec-Reactive'),
+    # (2021, 'node2_A1_Bayern', 'Elec-Reactive'),
+    # (2021, 'node3_A1_Bayern', 'Elec-Reactive'),
+    # (2021, 'node4_A1_Bayern', 'Elec-Reactive'),
+    # (2021, 'node5_A1_Bayern', 'Elec-Reactive'),
+    # (2021, 'node6_A1_Bayern', 'Elec-Reactive'),
+    # (2021, 'node7_A1_Bayern', 'Elec-Reactive'),
+    # (2021, 'node8_A1_Bayern', 'Elec-Reactive'),
+    # (2021, 'node9_A1_Bayern', 'Elec-Reactive')
+
     # ('Baden-Württemberg', 'Elec'),
     # ('Bavaria', 'Elec'),
     # ('Berlin', 'Elec'),
@@ -92,9 +98,10 @@
 
 # optional: define names for sites in report_tuples
 report_sites_name = {
-  ('Bayern','Hessen','node0_A1_Bayern','node1_A1_Bayern','node2_A1_Bayern',
-   'node3_A1_Bayern','node4_A1_Bayern','node5_A1_Bayern','node6_A1_Bayern',
-   'node7_A1_Bayern','node8_A1_Bayern','node9_A1_Bayern'):'Germany'
+  ('Bayern','Hessen'):'Germany'#
+   #,'node0_A1_Bayern','node1_A1_Bayern','node2_A1_Bayern',
+   #'node3_A1_Bayern','node4_A1_Bayern','node5_A1_Bayern','node6_A1_Bayern',
+   #'node7_A1_Bayern','node8_A1_Bayern','node9_A1_Bayern'):'Germany'
   # ('Baden-Württemberg', 'Bavaria', 'Berlin',
   # 'Brandenburg', 'Bremen', 'Hamburg', 'Hesse', 'Lower Saxony',
   # 'Mecklenburg-Vorpommern', 'North Rhine-Westphalia',
@@ -165,5 +172,7 @@
                              plot_sites_name=plot_sites_name,
                              plot_periods=plot_periods,
                              report_tuples=report_tuples,
-                             report_sites_name=report_sites_name)
+                             report_sites_name=report_sites_name,
+                             noTypicalPeriods=noTypicalPeriods,
+                             hoursPerPeriod=hoursPerPeriod)
 

urbs/features/BuySellPrice.py

@@ -1,6 +1,7 @@
 import math
 import pyomo.core as pyomo
 from .modelhelper import commodity_subset
+from .typeperiod import get_stf
 
 
 def add_buy_sell_price(m):
@@ -9,10 +10,12 @@ def add_buy_sell_price(m):
     m.com_sell = pyomo.Set(
         within=m.com,
         initialize=commodity_subset(m.com_tuples, 'Sell'),
+        ordered=False,
         doc='Commodities that can be sold')
     m.com_buy = pyomo.Set(
         within=m.com,
         initialize=commodity_subset(m.com_tuples, 'Buy'),
+        ordered=False,
         doc='Commodities that can be purchased')
 
     # Variables
@@ -73,7 +76,7 @@ def res_sell_total_rule(m, stf, sit, com, com_type):
         total_consumption = 0
         for tm in m.tm:
             total_consumption += (
-                m.e_co_sell[tm, stf, sit, com, com_type] * m.typeday['weight_typeday'][(stf,tm)])
+                m.e_co_sell[tm, stf, sit, com, com_type] * m.typeperiod['weight_typeperiod'][(stf,tm)])
         total_consumption *= m.weight
         return (total_consumption <=
                 m.commodity_dict['max'][(stf, sit, com, com_type)])
@@ -99,7 +102,7 @@ def res_buy_total_rule(m, stf, sit, com, com_type):
         total_consumption = 0
         for tm in m.tm:
             total_consumption += (
-                m.e_co_buy[tm, stf, sit, com, com_type] * m.typeday['weight_typeday'][(stf,tm)])
+                m.e_co_buy[tm, stf, sit, com, com_type] * m.typeperiod['weight_typeperiod'][(stf,tm)])
         total_consumption *= m.weight
         return (total_consumption <=
                 m.commodity_dict['max'][(stf, sit, com, com_type)])
@@ -130,7 +133,7 @@ def search_sell_buy_tuple(m, stf, sit_in, pro_in, coin):
     Returns:
         a process
     """
-    pro_output_tuples = [x for x in list(m.pro_output_tuples.value) if x[1] == sit_in] #todo: typeday fragen
+    pro_output_tuples = [x for x in list(m.pro_output_tuples.value) if x[1] == sit_in]
     pro_input_tuples = [x for x in list(m.pro_input_tuples.value) if x[1] == sit_in]
     # search the output commodities for the "buy" process
     # buy_out = (stf, site, output_commodity)
@@ -174,15 +177,15 @@ def revenue_costs(m):
     try:
         return -sum(
             m.e_co_sell[(tm,) + c] *
-            m.buy_sell_price_dict[c[2]][(c[0], tm)] * m.weight *  m.typeday['weight_typeday'][(m.stf[1],tm)] *
+            m.buy_sell_price_dict[c[2]][(c[0], tm)] * m.weight *  m.typeperiod['weight_typeperiod'][(get_stf(m),tm)] *
             m.commodity_dict['price'][c] *
             m.commodity_dict['cost_factor'][c]
             for tm in m.tm
             for c in sell_tuples)
     except KeyError:
         return -sum(
             m.e_co_sell[(tm,) + c] *
-            m.buy_sell_price_dict[c[2], ][(c[0], tm)] * m.weight *  m.typeday['weight_typeday'][(m.stf[1],tm)] *
+            m.buy_sell_price_dict[c[2], ][(c[0], tm)] * m.weight *  m.typeperiod['weight_typeperiod'][(get_stf(m),tm)] *
             m.commodity_dict['price'][c] *
             m.commodity_dict['cost_factor'][c]
             for tm in m.tm
@@ -194,15 +197,15 @@ def purchase_costs(m):
     try:
         return sum(
             m.e_co_buy[(tm,) + c] *
-            m.buy_sell_price_dict[c[2]][(c[0], tm)] * m.weight *  m.typeday['weight_typeday'][(m.stf[1],tm)] *
+            m.buy_sell_price_dict[c[2]][(c[0], tm)] * m.weight *  m.typeperiod['weight_typeperiod'][(get_stf(m),tm)] *
             m.commodity_dict['price'][c] *
             m.commodity_dict['cost_factor'][c]
             for tm in m.tm
             for c in buy_tuples)
     except KeyError:
         return sum(
             m.e_co_buy[(tm,) + c] *
-            m.buy_sell_price_dict[c[2], ][(c[0], tm)] * m.weight *  m.typeday['weight_typeday'][(m.stf[1],tm)] *
+            m.buy_sell_price_dict[c[2], ][(c[0], tm)] * m.weight *  m.typeperiod['weight_typeperiod'][(get_stf(m),tm)] *
             m.commodity_dict['price'][c] *
             m.commodity_dict['cost_factor'][c]
             for tm in m.tm

urbs/features/TypeDay.py

@@ -13,6 +13,5 @@
 from .BuySellPrice import add_buy_sell_price, bsp_surplus, revenue_costs, \
                           purchase_costs
 from .AdvancedProcesses import add_advanced_processes
-from .TypeDay import add_typeday
-
-#todo: muss ich hier trandisthelper auch ergänzen?
+from .typeperiod import *
+from .transdisthelper import *

urbs/features/__init__.py

@@ -182,8 +182,8 @@ def op_pro_tuples(pro_tuple, m):
                     1 <= stf + m.process_dict['depreciation'][
                                               (stf, sit, pro)]):
                     op_pro.append((sit, pro, stf, stf_later))
-            elif ((stf_later + sorted_stf[index_helper + 1]) / 2 <= stf + m.process_dict['depreciation'][(stf, sit, pro)]
-                  and stf <= stf_later): #todo: typeday fragen
+            elif ((stf_later + sorted_stf[index_helper+1]) / 2 <= stf + m.process_dict['depreciation'][(stf, sit, pro)]
+                  and stf <= stf_later):
                 op_pro.append((sit, pro, stf, stf_later))
             else:
                 pass
@@ -211,6 +211,6 @@ def inst_pro_tuples(m):
                     inst_pro.append((sit, pro, stf_later))
             elif (stf_later + sorted_stf[index_helper + 1]) / 2 <= (min(m.stf)
                                                                     + m.process_dict['lifetime'][(stf, sit, pro)]):
-                inst_pro.append((sit, pro, stf_later)) #todo: typeday fragen
+                inst_pro.append((sit, pro, stf_later))
 
     return inst_pro

urbs/features/modelhelper.py

@@ -1,5 +1,6 @@
 import math
 import pyomo.core as pyomo
+from .typeperiod import get_stf
 
 
 def add_storage(m):
@@ -10,6 +11,7 @@ def add_storage(m):
         indexlist.add(tuple(key)[2])
     m.sto = pyomo.Set(
         initialize=indexlist,
+        ordered=False,
         doc='Set of storage technologies')
 
     # storage tuples
@@ -331,11 +333,11 @@ def storage_cost(m, cost_type):
                    m.storage_dict['cost_factor'][s]
                    for s in m.sto_tuples)
     elif cost_type == 'Variable':
-        return sum(m.e_sto_con[(tm,) + s] * m.weight * m.typeday['weight_typeday'][(m.stf[1],tm)] *
+        return sum(m.e_sto_con[(tm,) + s] * m.weight * m.typeperiod['weight_typeperiod'][(get_stf(m),tm)] *
                    m.storage_dict['var-cost-c'][s] *
                    m.storage_dict['cost_factor'][s] +
                    (m.e_sto_in[(tm,) + s] + m.e_sto_out[(tm,) + s]) *
-                   m.weight * m.typeday['weight_typeday'][(m.stf[1],tm)] * m.storage_dict['var-cost-p'][s] *
+                   m.weight * m.typeperiod['weight_typeperiod'][(get_stf(m),tm)] * m.storage_dict['var-cost-p'][s] *
                    m.storage_dict['cost_factor'][s]
                    for tm in m.tm
                    for s in m.sto_tuples)

urbs/features/storage.py

@@ -1,4 +1,4 @@
-from .identify import *
+from urbs.identify import *
 import copy
 import math
 

urbs/transdisthelper.py urbs/features/transdisthelper.pyurbs/transdisthelper.py renamed to urbs/features/transdisthelper.py

@@ -1,6 +1,8 @@
 import math
+from .typeperiod import get_stf
 import pyomo.core as pyomo
 
+
 def e_tra_domain_rule1(m, tm, stf, sin, sout, tra, com):
     # assigning e_tra_in and e_tra_out variable domains for transport and DCPF
     if (stf, sin, sout, tra, com) in m.tra_tuples_dc:
@@ -44,6 +46,7 @@ def add_transmission(m):
         indexlist.add(tuple(key)[3])
     m.tra = pyomo.Set(
         initialize=indexlist,
+        ordered=False,
         doc='Set of transmission technologies')
 
     # transmission tuples
@@ -144,6 +147,7 @@ def add_transmission_dc(m):
         indexlist.add(tuple(key)[3])
     m.tra = pyomo.Set(
         initialize=indexlist,
+        ordered=False,
         doc='Set of transmission technologies')
 
     # Transport and DCPF transmission tuples
@@ -301,6 +305,7 @@ def add_transmission_ac(m):
         indexlist.add(tuple(key)[3])
     m.tra = pyomo.Set(
         initialize=indexlist,
+        ordered=False,
         doc='Set of transmission technologies')
 
     # Transport and DCPF transmission tuples
@@ -621,29 +626,29 @@ def transmission_cost(m, cost_type):
                    for t in m.tra_tuples)
     elif cost_type == 'Variable':
         if m.mode['dcpf']:
-            return sum(m.e_tra_in[(tm,) + t] * m.weight * m.typeday['weight_typeday'][(m.stf[1],tm)] *
+            return sum(m.e_tra_in[(tm,) + t] * m.weight * m.typeperiod['weight_typeperiod'][(get_stf(m),tm)] *
                        m.transmission_dict['var-cost'][t] *
                        m.transmission_dict['cost_factor'][t]
                        for tm in m.tm
                        for t in m.tra_tuples_tp) + \
-                   sum(m.e_tra_abs[(tm,) + t] * m.weight * m.typeday['weight_typeday'][(m.stf[1],tm)] *
+                   sum(m.e_tra_abs[(tm,) + t] * m.weight * m.typeperiod['weight_typeperiod'][(get_stf(m),tm)] *
                        m.transmission_dict['var-cost'][t] *
                        m.transmission_dict['cost_factor'][t]
                        for tm in m.tm
                        for t in m.tra_tuples_dc)
         if m.mode['acpf']:
-            return sum(m.e_tra_in[(tm,) + t] * m.weight * m.typeday['weight_typeday'][(m.stf[1],tm)] *
+            return sum(m.e_tra_in[(tm,) + t] * m.weight * m.typeperiod['weight_typeperiod'][(get_stf(m),tm)] *
                        m.transmission_dict['var-cost'][t] *
                        m.transmission_dict['cost_factor'][t]
                        for tm in m.tm
                        for t in m.tra_tuples_tp) + \
-                   sum(m.e_tra_abs[(tm,) + t] * m.weight * m.typeday['weight_typeday'][(m.stf[1],tm)] *
+                   sum(m.e_tra_abs[(tm,) + t] * m.weight * m.typeperiod['weight_typeperiod'][(get_stf(m),tm)] *
                        m.transmission_dict['var-cost'][t] *
                        m.transmission_dict['cost_factor'][t]
                        for tm in m.tm
                        for t in m.tra_tuples_ac_dc)
         else:
-            return sum(m.e_tra_in[(tm,) + t] * m.weight * m.typeday['weight_typeday'][(m.stf[1],tm)] *
+            return sum(m.e_tra_in[(tm,) + t] * m.weight * m.typeperiod['weight_typeperiod'][(get_stf(m),tm)] *
                        m.transmission_dict['var-cost'][t] *
                        m.transmission_dict['cost_factor'][t]
                        for tm in m.tm