function to write out csv results

energy_demand/assumptions.py

@@ -0,0 +1,38 @@
+""" This file contains all assumptions of the energy demand model"""
+# pylint: disable=I0011,C0321,C0301,C0103, C0325
+
+def load_assumptions():
+    """All assumptions
+
+    Returns
+    -------
+    data : dict
+        dict with assumptions
+
+    Notes
+    -----
+
+    """
+    assumptions_dict = {}
+
+
+
+    # ------------------------------------------------------------------------
+    # Residential model
+    # ------------------------------------------------------------------------
+
+    # Building stock related
+    change_floor_area_pp = -0.1        # Assumption of change in floor area up to end_year ASSUMPTION
+
+
+    #assump_dwtype_distr = {'semi_detached': 26.0, 'terraced': 28.3, 'flat': 20.3, 'detached': 16.6, 'bungalow': 8.8}    # Assumption of distribution of dwelling types in end_year ASSUMPTION
+
+
+
+
+
+
+    # Add to dictionary
+    assumptions_dict['change_floor_area_pp'] = change_floor_area_pp
+
+    return assumptions_dict

energy_demand/building_stock_functions.py

@@ -81,6 +81,7 @@ def get_hlc(dw_type, age):
 
 class BuildingStockRegion(object):
     """Class of the building stock in a region"""
+    # TODO: Include old and new stock
 
     def __init__(self, region_ID, dwelling_list):
         """Returns a new building stock region object.
@@ -123,3 +124,63 @@ def get_sum_scenario_driver_lighting(self):
             sum_driver += dwelling.scenario_driver_lighting()
         return sum_driver
 
+
+def get_floor_area_pp(reg_floor_area, reg_pop, global_variables, assump_final_diff_floor_area_pp):
+    """ Calculates future floor area per person depending on
+    assumptions on final change and base year data
+
+    Parameters
+    ----------
+    reg_floor_area : dict
+        Floor area base year for all region
+
+    reg_pop : dict
+        Population of base year for all region
+
+    global_variables : dict
+        Contains all global simulation variables
+        
+    assump_final_diff_floor_area_pp : float
+        Assumption of change in floor area up to end of simulation
+
+    Returns
+    -------
+    data_floor_area_pp : dict
+        Contains all values for floor area per person for every year
+
+    Linear change of floor area
+    # todo: check with simulation period
+    """
+
+    # initialisation
+    data_floor_area_pp = {}
+    sim_period = range(global_variables['base_year'], global_variables['end_year'] + 1, 1) #base year, current year, iteration step
+    base_year = global_variables['base_year']
+
+    # Iterate regions
+    for reg_id in reg_pop:
+        sim_years = {}
+        floor_area_pp_by = reg_floor_area[reg_id] / reg_pop[reg_id] # Floor area per person of base year
+
+        for y in sim_period:
+            sim_year = y - global_variables['base_year']
+
+            if y == base_year:
+                sim_years[y] = floor_area_pp_by # base year value
+            else:
+                # Change up to current year
+                diff_cy = sim_year * (((1 + assump_final_diff_floor_area_pp) - 1) / (len(sim_period)-1)) # substract from sim_period 1 because of base year
+
+                # Floor area of simulation year
+                floor_ara_pp_sim_year = floor_area_pp_by * (1 + diff_cy)
+
+                sim_years[y] = floor_ara_pp_sim_year
+
+        # Values for every simulation year
+        data_floor_area_pp[reg_id] = sim_years
+
+    return data_floor_area_pp
+
+def get_dwtype_dist():
+
+    return

energy_demand/building_stock_generator.py

@@ -6,13 +6,17 @@
 # pylint: disable=I0011,C0321,C0301,C0103, C0325
 
 
-def virtual_building_stock(data):
+def virtual_building_stock(data, assumptions, data_ext):
     """Creates a virtual building stock based on base year data and assumptions
 
     Parameters
     ----------
     data : dict
-        Base data
+        Base data (data loaded)
+    assumptions : dict
+        All assumptions
+    data_ext : dict
+        Data provided externally from simulation
 
     Returns
     -------
@@ -25,11 +29,14 @@ def virtual_building_stock(data):
     Notes
     -----
     The header row is always skipped.
+    # TODO: check base year run...
     """
     uniqueID = 100000      # Initialise
     reg_building_stock = {}
 
-    base_year = data['global_variables']['base_year']          # Base year
+    # Base year data
+    base_year = data['global_variables']['base_year']
+    reg_pop = data['reg_pop']
 
     dwtype_distr = data['dwtype_distr'][base_year]             # Distribution of dwelling types        2015.0: {'semi_detached': 26.0, 'terraced': 28.3, 'flat': 20.3, 'detached': 16.6, 'bungalow': 8.8}
     dwtype_age_distr = data['dwtype_age_distr'][base_year]     # Age distribution of dwelling types    {2015: {1918: 20.8, 1928: 36.3, 1949: 29.4, 1968: 8.0, 1995: 5.4}} # year, average_age, percent
@@ -38,20 +45,20 @@ def virtual_building_stock(data):
     dw_lu = data['dwtype_lu']
     global_variables = data['global_variables']
     reg_lu = data['reg_lu']                                    # Regions
-    reg_pop = data['reg_pop']
-    print(dwtype_distr)
-    print("---")
-    print(dwtype_age_distr)
-    print("---")
-    print(dwtype_floor_area)
-    print("-tt--")
-    print(reg_floor_area)
-    print("oo")
-    print(dw_lu)
+
+    # External data (current year)
+    reg_pop_cy = data_ext['population']
+
+
+    # ----- Building stock scenario assumptions
+    #assump_dwtype_distr = {'semi_detached': 26.0, 'terraced': 28.3, 'flat': 20.3, 'detached': 16.6, 'bungalow': 8.8}    # Assumption of distribution of dwelling types in end_year ASSUMPTION
+
+    data_floor_area_pp = bf.get_floor_area_pp(reg_floor_area, reg_pop_cy, global_variables, assumptions['change_floor_area_pp']) # Calculate floor area per person over simulation period
+    #dwt_dist = get_dwtype_dist(assumptions['assump_dwtype_distr']) # Calculate distribution of dwelling types over simulation period
 
     # Iterate regions
     for reg_id in reg_lu:
-        dw_stock_old, dw_stock_new = [], []      # Initialise
+        dw_stock_old, dw_stock_new = [], []          # Initialise
 
         # Read base year data
         floor_area_by = reg_floor_area[reg_id]       # Read in floor area
@@ -62,17 +69,17 @@ def virtual_building_stock(data):
 
         # --Scenario drivers
         # base year
-        pop_by = reg_pop[reg_id]                            # Read in population
+        pop_by = reg_pop[reg_id]                    # Read in population
         floor_area_pp_by = floor_area_by / pop_by           # Floor area per person [m2/person]
         floor_area_by_pd = floor_area_by / dw_nr            # Floor area per dwelling [m2/dwelling]
 
-        # current year
-        pop_cy = pop_by * 1.5                               ### #TODO: get new population
-        floor_area_pp_cy = floor_area_pp_by * 1.05          ### #TODO: get new floor_area_pp_by
-        floor_area_by_pd_cy = floor_area_by_pd * 0.1        ### #TODO:floor area per dwelling get new floor_area_by_pd (if not constant over time, cann't extrapolate for any year)
+        # Current year of simulation
+        pop_cy = reg_pop_cy[reg_id]                                              # Read in population for current year
+        floor_area_pp_cy = data_floor_area_pp[reg_id][global_variables['current_year']]     # Read in from simulated floor_area_pp dict for current year
+        floor_area_by_pd_cy = floor_area_by_pd                                              ### #TODO:floor area per dwelling get new floor_area_by_pd (if not constant over time, cann't extrapolate for any year)
 
         # Population
-        pop_new_dw = pop_cy - pop_by
+        #pop_new_dw = pop_cy - pop_by
 
         # Total new floor area
         tot_floor_area_cy = floor_area_pp_cy * pop_cy
@@ -86,12 +93,12 @@ def virtual_building_stock(data):
         print("total_nr_dw:       " + str(total_nr_dw))
 
         # ---- old buildings
-        _scrap_pop_old = 0
-        _scrap_floor_old = 0
-        _scrap_pop_new = 0
-        _scrap_floor_new = 0
+        _scrap_pop_old, _scrap_floor_old, _scrap_pop_new, _scrap_floor_new = 0, 0, 0, 0
+
+        # Do This for base yeare and simulation year!
+        # dwtype_age_distr['curr_year']
 
-        # Iterate dwelling types
+        # Iterate dwelling types (BASE YEAR Or NEW YEAR??)
         for dw in dw_lu:
             dw_type_id, dw_type_name = dw, dw_lu[dw]
             percent_dw_type = dwtype_distr[dw_type_name] / 100                      # Percentage of dwelling type
@@ -160,24 +167,14 @@ def virtual_building_stock(data):
         print("Floor area of current year:  " + str(tot_floor_area_cy))
 
         # Generate region and save it in dictionary
-        reg_building_stock[reg_id] = bf.BuildingStockRegion(reg_id, dw_stock_old + dw_stock_new)
+        reg_building_stock[reg_id] = bf.BuildingStockRegion(reg_id, dw_stock_old + dw_stock_new) # Add old and new buildings to stock
 
-    '''print("....")
-    for h in dw_stock_old:
-        print(h.__dict__)
-    print(".............")
-    for i in dw_stock_new:
-        print(i.__dict__)
-    '''
 
-    print(reg_building_stock)
-    print(reg_building_stock[0].get_sum_scenario_driver_water_heating())
-    print("oooo")
-    print(reg_building_stock[0].dwelling_list)
-    l = reg_building_stock[0].dwelling_list
+    #print(reg_building_stock[0].dwelling_list)
+    #l = reg_building_stock[0].dwelling_list
     for i in l:
         print(i.__dict__)
-    prnt("..")
+
 
     return dw_stock_old, dw_stock_new
 

energy_demand/main.py

@@ -26,6 +26,8 @@
 from datetime import date
 import energy_demand.main_functions as mf
 import building_stock_generator as bg
+import assumptions as assumpt
+
 from energy_demand import residential_model
 import numpy as np
 
@@ -52,17 +54,12 @@ def load_data():
     #path_main = '../data'
     path_main = r'C:/Users/cenv0553/GIT/NISMODII/data/' # Remove
 
-    # Global variables
-    #YEAR_SIMULATION = 2015                                                  # Provide year for which to run the simulation
-    #global_variables['base_year'] = 2015                                                      # [int] First year of the simulation period
-    #P2_YEAR_END = 2050                                                      # [int] Last year of the simulation period
-    #P3_SIM_PERIOD = range(P2_YEAR_END - global_variables['base_year'])                       # List with simulation years
-    #P0_YEAR_CURR = YEAR_SIMULATION - global_variables['base_year']                           # [int] Current year in current simulation
-    #global_variables = [P0_YEAR_CURR, global_variables['base_year'], P2_YEAR_END, P3_SIM_PERIOD]    # Store all parameters in one list
-    global_variables = {'base_year': 2015, 'current_year': 2015, 'end_year': 2050}
-
     # ------Read in all data from csv files-------------------
     data, path_dict = mf.read_data(path_main)
+
+
+    # Global variables
+    global_variables = {'base_year': 2015, 'current_year': 2015, 'end_year': 2050}
     data['global_variables'] = global_variables # add to data dict
 
     #print(isinstance(reg_floor_area[0], int))
@@ -128,18 +125,19 @@ def load_data():
 # ---------------------------------------------------------------
 # Run Model
 # ---------------------------------------------------------------
-def energy_demand_model(data, pop_data_external):
+def energy_demand_model(data, assumptions, data_ext):
     """Main function to run energy demand module
 
     This function is executed in the wrapper.
 
     Parameters
     ----------
     data : dict
-        A list containing all data not provided externally
-
-    pop_data_external : dict
-        Population data from wrapper
+        Contains all data not provided externally
+    assumptions : dict
+        Contains all assumptions
+    data_ext : dict
+        All data provided externally
 
     Returns
     -------
@@ -152,25 +150,26 @@ def energy_demand_model(data, pop_data_external):
 
     Notes
     -----
-
+    All messy now...needs cleaning
     """
     # Add external data to data dictionary
     # ----
 
-    # population data (scrap)
-    data_external = {}
-    data_external = mf.add_to_data(data_external, pop_data_external) # Convert to array, store in data
+    # Conert population data int array
+    data_ext = mf.add_to_data(data_ext, data_ext['population']) # Convert to array, store in data
 
     #print ("Energy Demand Model - Main funtion simulation parameter: " + str(global_variables))
 
 
-    # Build residential building stock
-    old_dwellings, new_dwellings = bg.virtual_building_stock(data)
+    # Build base year building stock
+
+    # Build virtual residential building stock
+    #old_dwellings, new_dwellings = bg.virtual_building_stock(data, assumptions, data_ext)
 
 
     # Run different sub-models (sector models)
     # -- Residential model
-    e_app_bd, g_hd_bd = residential_model.run(data['global_variables'], data['shape_app_elec'], data['reg_pop_array'], data_external['reg_pop_external_array'], data['timesteps_app_bd'], data['timesteps_hd_bd'])
+    e_app_bd, g_hd_bd = residential_model.run(data['global_variables'], data['shape_app_elec'], data['reg_pop_array'], data_ext['reg_pop_external_array'], data['timesteps_app_bd'], data['timesteps_hd_bd'])
     #print(e_app_bd[0][0])
 
     '''
@@ -201,6 +200,13 @@ def energy_demand_model(data, pop_data_external):
     # Write YAML File
     #mf.write_YAML(False, 'C:/Users/cenv0553/GIT/NISMODII/TESTYAML.yaml')
 
+    # ---
+    _, yaml_list = mf.timesteps_full_year()  # Create timesteps for full year (wrapper-timesteps)
+
+    mf.write_to_csv_will(result_dict, data['reg_lu'])
+    #rint("..")
+
+
     # Write function to also write out results
     print("FINAL Fueltype:  " + str(len(result_dict)))
     print("FINAL region:    " + str(len(result_dict[0])))
@@ -212,7 +218,10 @@ def energy_demand_model(data, pop_data_external):
 # Run
 if __name__ == "__main__":
     # New function to load data
-    pop_data = {'population': {0: 3000000, 1: 5300000, 2: 53000000}}
-    base_data = load_data()
-    energy_demand_model(base_data, pop_data["population"])
+    data_external = {'population': {0: 3000001, 1: 5300001, 2: 53000001}}
+
+    base_data = load_data()     # Get own data
+    assumptions = assumpt.load_assumptions() # Get all assumptions
+
+    energy_demand_model(base_data, assumptions, data_external)
     print("Finished everything")