def dummy_sectoral_load_profiles(local_paths, path_main):
"""Create dummy sectoral load profiles
Arguments
---------
local_paths : dict
Paths
path_main : str
Main path
"""
create_folders_to_file(
os.path.join(local_paths['ss_load_profile_txt'], "dumm"), "_processed_data")
paths = data_loader.load_paths(path_main)
dict_enduses, dict_sectors, _, _, _ = data_loader.load_fuels(paths)
for enduse in dict_enduses['service']:
for sector in dict_sectors['service']:
joint_string_name = str(sector) + "__" + str(enduse)
# Flat profiles
load_peak_shape_dh = np.full((24), 1)
shape_non_peak_y_dh = np.full((365, 24), 1/24)
shape_non_peak_yd = np.full((365), 1/365)
write_data.create_txt_shapes(
joint_string_name,
local_paths['ss_load_profile_txt'],
load_peak_shape_dh,
shape_non_peak_y_dh,
shape_non_peak_yd)
def run(main_path, local_data_path):
"""Function to run script
"""
print("..start script {}".format(os.path.basename(__file__)))
# Paths
base_data = data_loader.load_paths(main_path, local_data_path)
# Read in raw temperature data
temperature_data_raw = read_weather_data_raw(
base_data['paths']['folder_path_weater_data'])
# Clean raw temperature data
temperature_data = clean_weather_data_raw(
temperature_data_raw)
# Weather stations
weather_stations = read_weather_stations_raw(
base_data['paths']['folder_path_weater_stations'],
temperature_data.keys()
)
# Write out to csv files
write_weather_stations(
os.path.join(main_path, 'data', 'data_scripts', 'weather_data', 'weather_stations.csv'),
weather_stations)
write_weather_data(
os.path.join(main_path, 'data', 'data_scripts', 'weather_data', 'weather_data.csv'),
temperature_data)
print("..finished script {}".format(os.path.basename(__file__)))
return
def run():
"""Function to write out assumptions
"""
path_main = os.path.dirname(
os.path.abspath(__file__))[:-25] #Remove 'energy_demand'
data = data_loader.load_paths(path_main,
'Y:\01-Data_NISMOD\data_energy_demand')
data = data_loader.load_fuels(data)
data['assumptions'] = load_assumptions(data)
# Write out temperature assumptions
'''write_data.write_out_temp_assumptions(
os.path.join(data['paths']['path_assumptions_db'], "assumptions_climate_change_temp.csv"),
data['assumptions']['climate_change_temp_diff_month'])
# Write out sigmoid parameters
write_data.write_out_sim_param(
os.path.join(
path_main,
'data',
'data_scripts',
'assumptions_from_db',
'assumptions_sim_param.csv'),
data['sim_param']
)
'''
return
def dummy_sectoral_load_profiles(local_paths, path_main):
"""
"""
create_folders_to_file(os.path.join(local_paths['ss_load_profile_txt'], "dumm"), "_processed_data")
paths = data_loader.load_paths(path_main)
lu = lookup_tables.basic_lookups()
dict_enduses, dict_sectors, dict_fuels = data_loader.load_fuels(paths, lu)
for enduse in dict_enduses['ss_enduses']:
for sector in dict_sectors['ss_sectors']:
joint_string_name = str(sector) + "__" + str(enduse)
# Flat profiles
load_peak_shape_dh = np.full((24), 1)
shape_non_peak_y_dh = np.full((365, 24), 1/24)
shape_peak_yd_factor = 1.0
shape_non_peak_yd = np.full((365), 1/365)
write_data.create_txt_shapes(
joint_string_name,
local_paths['ss_load_profile_txt'],
load_peak_shape_dh,
shape_non_peak_y_dh,
shape_peak_yd_factor,
shape_non_peak_yd)
def post_install_setup_minimum(args):
"""If not all data are available, this scripts allows to
create dummy datas (temperature and service sector load profiles)
"""
path_config_file = args.config_file
config = data_loader.read_config_file(path_config_file)
path_local_data = config['PATHS']['path_local_data']
# ==========================================
# Post installation setup witout access to non publicy available data
# ==========================================
print(
"... running initialisation scripts with only publicly available data")
local_paths = data_loader.get_local_paths(path_config_file)
# Create folders to input data
raw_folder = os.path.join(path_local_data, '_raw_data')
basic_functions.create_folder(raw_folder)
basic_functions.create_folder(config['PATHS']['path_processed_data'])
basic_functions.create_folder(local_paths['path_post_installation_data'])
basic_functions.create_folder(local_paths['load_profiles'])
basic_functions.create_folder(local_paths['rs_load_profile_txt'])
basic_functions.create_folder(local_paths['ss_load_profile_txt'])
# Load data
data = {}
data['paths'] = data_loader.load_paths(path_config_file)
data['lookups'] = lookup_tables.basic_lookups()
data['enduses'], data['sectors'], data[
'fuels'], lookup_enduses, lookup_sector_enduses = data_loader.load_fuels(
data['paths'])
# Assumptions
data['assumptions'] = general_assumptions.Assumptions(
lookup_enduses=lookup_enduses,
lookup_sector_enduses=lookup_sector_enduses,
base_yr=2015,
weather_by=config['CONFIG']['user_defined_weather_by'],
simulation_end_yr=config['CONFIG']['user_defined_simulation_end_yr'],
paths=data['paths'],
enduses=data['enduses'],
sectors=data['sectors'])
# Read in residential submodel shapes
run(data['paths'], local_paths, config['CONFIG']['base_yr'])
# --------
# Dummy service sector load profiles
# --------
dummy_sectoral_load_profiles(local_paths, path_config_file)
print(
"Successfully finished post installation setup with open source data")
def test_assign_by_fuel_tech_p():
"""
"""
path_main = resource_filename(Requirement.parse("energy_demand"),
'config_data')
# Load data
data = {}
data['paths'] = data_loader.load_paths(path_main)
data['lookups'] = lookup_tables.basic_lookups()
data['enduses'], data['sectors'], data['fuels'] = data_loader.load_fuels(
data['paths'], data['lookups'])
data['local_paths'] = data_loader.load_local_paths(path_main)
#Load assumptions
base_yr = 2015
data['assumptions'] = non_param_assumptions.Assumptions(
base_yr=base_yr,
curr_yr=None,
simulated_yrs=None,
paths=data['paths'],
enduses=data['enduses'],
sectors=data['sectors'],
fueltypes=data['lookups']['fueltypes'],
fueltypes_nr=data['lookups']['fueltypes_nr'])
param_assumptions.load_param_assump(data['paths'], data['local_paths'],
data['assumptions'])
rs_fuel_tech_p_by, ss_fuel_tech_p_by, is_fuel_tech_p_by = assumptions_fuel_shares.assign_by_fuel_tech_p(
data['enduses'], data['sectors'], data['lookups']['fueltypes'],
data['lookups']['fueltypes_nr'])
def run(path_main, local_data_path):
"""Function to run script
"""
print("... start script {}".format(os.path.basename(__file__)))
# Execute assumptions file to write out assumptions
temperature_data = read_weather_data_script_data(
os.path.join(path_main, 'data', 'data_scripts', 'weather_data',
'weather_data.csv'))
data = data_loader.load_paths(path_main, local_data_path)
base_data = data_loader.load_fuels(data)
data['assumptions'] = assumptions.load_assumptions(data)
assumptions_temp_change = data['assumptions'][
'climate_change_temp_diff_month']
'''assumptions_temp_change = read_assumption(
os.path.join(
local_data_path,
'data',
'data_scripts',
'assumptions_from_db',
'assumptions_climate_change_temp.csv'
)
)
sim_param = s_shared_functions.read_assumption_sim_param(
os.path.join(
local_data_path,
'data',
'data_scripts',
'assumptions_from_db',
'assumptions_sim_param.csv'
)
)'''
sim_param = data['sim_param']
temp_climate_change = change_temp_climate_change(temperature_data,
assumptions_temp_change,
sim_param)
# Write out temp_climate_change
write_chanted_temp_data(
os.path.join(path_main, 'data', 'data_scripts', 'weather_data',
'weather_data_changed_climate.csv'), temp_climate_change)
print("... finished script {}".format(os.path.basename(__file__)))
return
def test_load_param_assump():
"""
"""
path_main = resource_filename(Requirement.parse("energy_demand"), "config_data")
# Load data
data = {}
data['paths'] = data_loader.load_paths(path_main)
data['lookups'] = lookup_tables.basic_lookups()
data['enduses'], data['sectors'], data['fuels'] = data_loader.load_fuels(data['paths'], data['lookups'])
sim_param_expected = {}
sim_param_expected['base_yr'] = 2015
# Dummy test
assert sim_param_expected['base_yr'] == 2015
return
def run(path_main, local_data_path):
"""Function run script
"""
print("... start script {}".format(os.path.basename(__file__)))
# Load data and assumptions
base_data = data_loader.load_paths(path_main, local_data_path)
base_data = data_loader.load_fuels(base_data)
base_data['assumptions'] = assumptions.load_assumptions(base_data)
base_data[
'weather_stations'], temperature_data = data_loader.load_data_temperatures(
os.path.join(base_data['paths']['path_scripts_data'],
'weather_data'))
base_data['temperature_data'] = {}
for weather_station, base_yr_temp in temperature_data.items():
base_data['temperature_data'][weather_station] = {2015: base_yr_temp}
# IMPROVE TODO: LOAD FLOOR AREA DATA
# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
base_data = data_loader.dummy_data_generation(base_data)
# <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
# Disaggregation
base_data = disaggregate_base_demand(base_data)
#Write to csv file disaggregated demand
write_disagg_fuel(
os.path.join(path_main, 'data', 'data_scripts', 'disaggregated',
'rs_fueldata_disagg.csv'),
base_data['rs_fueldata_disagg'])
write_disagg_fuel_sector(
os.path.join(path_main, 'data', 'data_scripts', 'disaggregated',
'ss_fueldata_disagg.csv'),
base_data['ss_fueldata_disagg'])
write_disagg_fuel_sector(
os.path.join(path_main, 'data', 'data_scripts', 'disaggregated',
'is_fueldata_disagg.csv'),
base_data['is_fueldata_disagg'])
write_disagg_fuel_ts(
os.path.join(path_main, 'data', 'data_scripts', 'disaggregated',
'ts_fueldata_disagg.csv'),
base_data['ts_fueldata_disagg'])
print("... finished script {}".format(os.path.basename(__file__)))
return
def test_load_non_param_assump():
"""
"""
path_main = resource_filename(Requirement.parse("energy_demand"), "config_data")
# Load data
data = {}
paths = data_loader.load_paths(path_main)
lu = lookup_tables.basic_lookups()
enduses, sectors, _ = data_loader.load_fuels(paths, lu)
non_param_assumptions.Assumptions(
base_yr=2015,
curr_yr=None,
simulated_yrs=None,
paths=paths,
enduses=enduses,
sectors=sectors,
fueltypes=lu['fueltypes'],
fueltypes_nr=lu['fueltypes_nr'])
print("...finished energy demand model simulation")
return _, model_run_object
if __name__ == "__main__":
"""
"""
print('Start HIRE')
instrument_profiler = True
# Paths
path_main = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..")
local_data_path = r'Y:\01-Data_NISMOD\data_energy_demand'
# Load data
base_data = data_loader.load_paths(path_main, local_data_path)
base_data = data_loader.load_fuels(base_data)
base_data = data_loader.load_data_tech_profiles(base_data)
base_data = data_loader.load_data_profiles(base_data)
base_data['assumptions'] = assumptions.load_assumptions(base_data)
base_data['weather_stations'], base_data['temperature_data'] = data_loader.load_data_temperatures(
os.path.join(base_data['paths']['path_scripts_data'], 'weather_data')
)
# >>>>>>>>>>>>>>>DUMMY DATA GENERATION
# Population
# GVA
# Floor Area
# ...
base_data = data_loader.dummy_data_generation(base_data)
# <<<<<<<<<<<<<<<<<< FINISHED DUMMY GENERATION DATA
def run(path_main, local_data_path):
"""Function run script
"""
print("... start script {}".format(os.path.basename(__file__)))
path_out = os.path.join(path_main, 'data', 'data_scripts')
# Load data and assumptions
base_data = data_loader.load_paths(path_main, local_data_path)
base_data = data_loader.load_fuels(base_data)
base_data['assumptions'] = assumptions.load_assumptions(base_data)
# Read in Services
rs_service_tech_by_p = read_data.read_service_data_service_tech_by_p(
os.path.join(base_data['paths']['path_scripts_data'], 'services',
'rs_service_tech_by_p.csv'))
ss_service_tech_by_p = read_data.read_service_data_service_tech_by_p(
os.path.join(base_data['paths']['path_scripts_data'], 'services',
'ss_service_tech_by_p.csv'))
is_service_tech_by_p = read_data.read_service_data_service_tech_by_p(
os.path.join(base_data['paths']['path_scripts_data'], 'services',
'is_service_tech_by_p.csv'))
rs_service_fueltype_by_p = read_data.read_service_fueltype_by_p(
os.path.join(base_data['paths']['path_scripts_data'], 'services',
'rs_service_fueltype_by_p.csv'))
ss_service_fueltype_by_p = read_data.read_service_fueltype_by_p(
os.path.join(base_data['paths']['path_scripts_data'], 'services',
'ss_service_fueltype_by_p.csv'))
is_service_fueltype_by_p = read_data.read_service_fueltype_by_p(
os.path.join(base_data['paths']['path_scripts_data'], 'services',
'is_service_fueltype_by_p.csv'))
# Calculate technologies with more, less and constant service based on service switch assumptions
rs_tech_increased_service, rs_tech_decreased_share, rs_tech_constant_share = get_tech_future_service(
rs_service_tech_by_p,
base_data['assumptions']['rs_share_service_tech_ey_p'])
ss_tech_increased_service, ss_tech_decreased_share, ss_tech_constant_share = get_tech_future_service(
ss_service_tech_by_p,
base_data['assumptions']['ss_share_service_tech_ey_p'])
is_tech_increased_service, is_tech_decreased_share, is_tech_constant_share = get_tech_future_service(
is_service_tech_by_p,
base_data['assumptions']['is_share_service_tech_ey_p'])
# Calculate sigmoid diffusion curves based on assumptions about fuel switches
# --Residential
rs_installed_tech, rs_sig_param_tech = get_sig_diffusion(
base_data, base_data['assumptions']['rs_service_switches'],
base_data['assumptions']['rs_fuel_switches'],
base_data['rs_all_enduses'], rs_tech_increased_service,
base_data['assumptions']['rs_share_service_tech_ey_p'],
base_data['assumptions']['rs_enduse_tech_maxL_by_p'],
rs_service_fueltype_by_p, rs_service_tech_by_p,
base_data['assumptions']['rs_fuel_tech_p_by'])
# --Service
ss_installed_tech, ss_sig_param_tech = get_sig_diffusion(
base_data, base_data['assumptions']['ss_service_switches'],
base_data['assumptions']['ss_fuel_switches'],
base_data['ss_all_enduses'], ss_tech_increased_service,
base_data['assumptions']['ss_share_service_tech_ey_p'],
base_data['assumptions']['ss_enduse_tech_maxL_by_p'],
ss_service_fueltype_by_p, ss_service_tech_by_p,
base_data['assumptions']['ss_fuel_tech_p_by'])
# --Industry
is_installed_tech, is_sig_param_tech = get_sig_diffusion(
base_data, base_data['assumptions']['is_service_switches'],
base_data['assumptions']['is_fuel_switches'],
base_data['is_all_enduses'], is_tech_increased_service,
base_data['assumptions']['is_share_service_tech_ey_p'],
base_data['assumptions']['is_enduse_tech_maxL_by_p'],
is_service_fueltype_by_p, is_service_tech_by_p,
base_data['assumptions']['is_fuel_tech_p_by'])
# Write out to csv
write_installed_tech(os.path.join(path_out, 'rs_installed_tech.csv'),
rs_installed_tech)
write_installed_tech(os.path.join(path_out, 'ss_installed_tech.csv'),
ss_installed_tech)
write_installed_tech(os.path.join(path_out, 'is_installed_tech.csv'),
is_installed_tech)
write_sig_param_tech(os.path.join(path_out, 'rs_sig_param_tech.csv'),
rs_sig_param_tech)
write_sig_param_tech(os.path.join(path_out, 'ss_sig_param_tech.csv'),
ss_sig_param_tech)
write_sig_param_tech(os.path.join(path_out, 'is_sig_param_tech.csv'),
is_sig_param_tech)
write_installed_tech(
os.path.join(path_out, 'rs_tech_increased_service.csv'),
rs_tech_increased_service)
write_installed_tech(
os.path.join(path_out, 'ss_tech_increased_service.csv'),
ss_tech_increased_service)
write_installed_tech(
os.path.join(path_out, 'is_tech_increased_service.csv'),
is_tech_increased_service)
write_installed_tech(os.path.join(path_out, 'rs_tech_decreased_share.csv'),
rs_tech_decreased_share)
write_installed_tech(os.path.join(path_out, 'ss_tech_decreased_share.csv'),
ss_tech_decreased_share)
write_installed_tech(os.path.join(path_out, 'is_tech_decreased_share.csv'),
is_tech_decreased_share)
write_installed_tech(os.path.join(path_out, 'rs_tech_constant_share.csv'),
rs_tech_constant_share)
write_installed_tech(os.path.join(path_out, 'ss_tech_constant_share.csv'),
ss_tech_constant_share)
write_installed_tech(os.path.join(path_out, 'is_tech_constant_share.csv'),
is_tech_constant_share)
print("... finished script {}".format(os.path.basename(__file__)))
return
def run(path_main, local_data_path):
"""Function to run script
"""
print("... start script {}".format(os.path.basename(__file__)))
path_out = os.path.join(path_main, 'data', 'data_scripts', 'services')
# Load data and assumptions
base_data = data_loader.load_paths(path_main, local_data_path)
base_data = data_loader.load_fuels(base_data)
base_data['assumptions'] = assumptions.load_assumptions(base_data)
# RESIDENTIAL: Convert base year fuel input assumptions to energy service
rs_service_tech_by_p, rs_service_fueltype_tech_by_p, rs_service_fueltype_by_p = get_service_fueltype_tech(
base_data['assumptions']['technology_list'],
base_data['assumptions']['hybrid_technologies'],
base_data['lu_fueltype'],
base_data['assumptions']['rs_fuel_tech_p_by'],
base_data['rs_fuel_raw_data_enduses'],
base_data['assumptions']['technologies']
)
# SERVICE: Convert base year fuel input assumptions to energy service
fuels_aggregated_across_sectors = ss_sum_fuel_enduse_sectors(
base_data['ss_fuel_raw_data_enduses'],
base_data['ss_all_enduses'],
base_data['nr_of_fueltypes'])
ss_service_tech_by_p, ss_service_fueltype_tech_by_p, ss_service_fueltype_by_p = get_service_fueltype_tech(
base_data['assumptions']['technology_list'],
base_data['assumptions']['hybrid_technologies'],
base_data['lu_fueltype'],
base_data['assumptions']['ss_fuel_tech_p_by'],
fuels_aggregated_across_sectors,
base_data['assumptions']['technologies']
)
# INDUSTRY
fuels_aggregated_across_sectors = ss_sum_fuel_enduse_sectors(
base_data['is_fuel_raw_data_enduses'],
base_data['is_all_enduses'],
base_data['nr_of_fueltypes'])
is_service_tech_by_p, is_service_fueltype_tech_by_p, is_service_fueltype_by_p = get_service_fueltype_tech(
base_data['assumptions']['technology_list'],
base_data['assumptions']['hybrid_technologies'],
base_data['lu_fueltype'],
base_data['assumptions']['is_fuel_tech_p_by'],
fuels_aggregated_across_sectors,
base_data['assumptions']['technologies']
)
# Write to csv files
write_service_tech_by_p(
os.path.join(path_out, 'rs_service_tech_by_p.csv'),
rs_service_tech_by_p)
write_service_tech_by_p(
os.path.join(path_out, 'ss_service_tech_by_p.csv'),
ss_service_tech_by_p)
write_service_tech_by_p(
os.path.join(path_out, 'is_service_tech_by_p.csv'),
is_service_tech_by_p)
write_service_fueltype_tech_by_p(
os.path.join(path_out, 'rs_service_fueltype_tech_by_p.csv'),
rs_service_fueltype_tech_by_p)
write_service_fueltype_tech_by_p(
os.path.join(path_out, 'ss_service_fueltype_tech_by_p.csv'),
ss_service_fueltype_tech_by_p)
write_service_fueltype_tech_by_p(
os.path.join(path_out, 'is_service_fueltype_tech_by_p.csv'),
is_service_fueltype_tech_by_p)
write_service_fueltype_by_p(
os.path.join(path_out, 'rs_service_fueltype_by_p.csv'),
rs_service_fueltype_by_p)
write_service_fueltype_by_p(
os.path.join(path_out, 'ss_service_fueltype_by_p.csv'),
ss_service_fueltype_by_p)
write_service_fueltype_by_p(
os.path.join(path_out, 'is_service_fueltype_by_p.csv'),
is_service_fueltype_by_p)
print("... finished script {}".format(os.path.basename(__file__)))
return
def post_install_setup(args):
"""Run this function after installing the energy_demand
model with smif and putting the data folder with all necessary
data into a local drive. This scripts only needs to be
executed once after the energy_demand model has been installed
Arguments
----------
args : object
Arguments defined in ``./cli/__init__.py``
"""
print("... start running initialisation scripts")
# Paths
path_main = resource_filename(Requirement.parse("energy_demand"), "config_data")
path_results = resource_filename(Requirement.parse("energy_demand"), "results")
local_data_path = args.local_data
# Initialise logger
logger_setup.set_up_logger(
os.path.join(local_data_path, "logging_post_install_setup.log"))
logging.info("... start local energy demand calculations")
# Load data
base_yr = 2015
data = {}
data['paths'] = data_loader.load_paths(path_main)
data['local_paths'] = data_loader.load_local_paths(local_data_path)
data['result_paths'] = data_loader.load_result_paths(path_results)
data['lookups'] = lookup_tables.basic_lookups()
data['enduses'], data['sectors'], data['fuels'] = data_loader.load_fuels(
data['paths'], data['lookups'])
# Assumptions
data['assumptions'] = non_param_assumptions.Assumptions(
base_yr=base_yr,
paths=data['paths'],
enduses=data['enduses'],
sectors=data['sectors'],
fueltypes=data['lookups']['fueltypes'],
fueltypes_nr=data['lookups']['fueltypes_nr'])
# Delete all previous data from previous model runs
basic_functions.del_previous_setup(data['local_paths']['data_processed'])
basic_functions.del_previous_setup(data['result_paths']['data_results'])
# Create folders and subfolder for data_processed
basic_functions.create_folder(data['local_paths']['data_processed'])
basic_functions.create_folder(data['local_paths']['path_post_installation_data'])
basic_functions.create_folder(data['local_paths']['dir_raw_weather_data'])
basic_functions.create_folder(data['local_paths']['dir_changed_weather_station_data'])
basic_functions.create_folder(data['local_paths']['load_profiles'])
basic_functions.create_folder(data['local_paths']['rs_load_profile_txt'])
basic_functions.create_folder(data['local_paths']['ss_load_profile_txt'])
basic_functions.create_folder(data['local_paths']['dir_disaggregated'])
print("... Read in temperature data from raw files")
s_raw_weather_data.run(
data['local_paths'])
print("... Read in service submodel load profiles")
s_ss_raw_shapes.run(
data['paths'],
data['local_paths'],
data['lookups'])
print("... Read in residential submodel load profiles")
s_rs_raw_shapes.run(
data['paths'],
data['local_paths'],
base_yr)
print("... successfully finished setup")
return
'mode_constrained'] = True # Whether model is run in constrained mode or not
data['criterias'][
'plot_HDD_chart'] = False # Wheather HDD chart is plotted or not
data['criterias'][
'virtual_building_stock_criteria'] = True # Wheater model uses a virtual dwelling stock or not
data['criterias'][
'spatial_exliclit_diffusion'] = True # Wheater spatially epxlicit diffusion or not
data['criterias'][
'write_to_txt'] = True # Wheater results are written to txt files
data['criterias'][
'beyond_supply_outputs'] = True # Wheater all results besides integraded smif run are calculated
data['criterias'][
'plot_tech_lp'] = True # Wheater all individual load profils are plotted
# Paths
data['paths'] = data_loader.load_paths(path_main)
data['local_paths'] = data_loader.load_local_paths(local_data_path)
result_path = os.path.dirname(__file__).split(
"energy_demand\\energy_demand")[0]
data['result_paths'] = data_loader.load_result_paths(
os.path.join(result_path, '_result_data'))
data['lookups'] = lookup_tables.basic_lookups()
data['enduses'], data['sectors'], data['fuels'] = data_loader.load_fuels(
data['paths'], data['lookups'])
# local scrap
data['regions'] = data_loader.load_LAC_geocodes_info(
os.path.join(local_data_path, '_raw_data',
'_quick_and_dirty_spatial_disaggregation',
def run(path_main, local_data_path):
"""Function to run script
"""
print("... start script {}".format(os.path.basename(__file__)))
base_data = data_loader.load_paths(path_main, local_data_path)
base_data = data_loader.load_fuels(base_data)
base_data['assumptions'] = assumptions.load_assumptions(base_data)
_, ss_sectors, ss_enduses = read_data.read_csv_base_data_service(
os.path.join(path_main, 'data', 'submodel_service',
'data_service_by_fuel_end_uses.csv'),
base_data['nr_of_fueltypes'])
# Iterate sectors and read in shape
for sector in ss_sectors:
# Match electricity shapes for every sector
if sector == 'community_arts_leisure':
sector_folder_path_elec = os.path.join(
base_data['paths']['folder_raw_carbon_trust'], "Community")
elif sector == 'education':
sector_folder_path_elec = os.path.join(
base_data['paths']['folder_raw_carbon_trust'], "Education")
elif sector == 'emergency_services':
sector_folder_path_elec = os.path.join(
base_data['paths']['folder_raw_carbon_trust'], "_all_elec")
elif sector == 'health':
sector_folder_path_elec = os.path.join(
base_data['paths']['folder_raw_carbon_trust'], "Health")
elif sector == 'hospitality':
sector_folder_path_elec = os.path.join(
base_data['paths']['folder_raw_carbon_trust'], "_all_elec")
elif sector == 'military':
sector_folder_path_elec = os.path.join(
base_data['paths']['folder_raw_carbon_trust'], "_all_elec")
elif sector == 'offices':
sector_folder_path_elec = os.path.join(
base_data['paths']['folder_raw_carbon_trust'], "Offices")
elif sector == 'retail':
sector_folder_path_elec = os.path.join(
base_data['paths']['folder_raw_carbon_trust'], "Retail")
elif sector == 'storage':
sector_folder_path_elec = os.path.join(
base_data['paths']['folder_raw_carbon_trust'], "_all_elec")
else:
sys.exit(
"Error: The sector {} could not be assigned".format(sector))
# ------------------------------------------------------
# Assign same shape across all enduse for service sector
# ------------------------------------------------------
for enduse in ss_enduses:
print("Enduse service: {} in sector '{}'".format(enduse, sector))
# Select shape depending on enduse
if enduse in [
'ss_water_heating', 'ss_space_heating', 'ss_other_gas'
]: #TODO
folder_path = os.path.join(
base_data['paths']['folder_raw_carbon_trust'], "_all_gas")
else:
if enduse == 'ss_other_electricity' or enduse == 'ss_cooling_and_ventilation':
folder_path = os.path.join(
base_data['paths']['folder_raw_carbon_trust'],
"_all_elec")
else:
folder_path = sector_folder_path_elec
# Read in shape from carbon trust metering trial dataset
shape_non_peak_y_dh, load_peak_shape_dh, shape_peak_yd_factor, shape_non_peak_yd = read_raw_carbon_trust_data(
folder_path)
# Write shapes to txt
joint_string_name = str(sector) + "__" + str(enduse)
s_shared_functions.create_txt_shapes(
joint_string_name,
os.path.join(path_main, 'data', 'data_scripts',
'load_profiles', 'ss_submodel'),
load_peak_shape_dh, shape_non_peak_y_dh, shape_peak_yd_factor,
shape_non_peak_yd)
# ---------------------
# Compare Jan and Jul
# ---------------------
#ss_read_data.compare_jan_jul(main_dict_dayyear_absolute)
print("... finished script {}".format(os.path.basename(__file__)))
return
def run(path_main, local_data_path):
"""Function to run script
"""
print("... start script {}".format(os.path.basename(__file__)))
# Paths
path_hes_load_profiles = os.path.join(
local_data_path,
r'01-hes_data\HES_base_appliances_eletricity_load_profiles.csv')
'''sim_param = s_shared_functions.read_assumption_sim_param(
os.path.join(
path_main, 'data', 'data_scripts', 'assumptions_from_db', 'assumptions_sim_param.csv'))
'''
data = data_loader.load_paths(path_main, local_data_path)
sim_param = data['assumptions']['sim_param']
path_rs_txt_shapes = os.path.join(path_main, 'data', 'data_scripts',
'load_profiles', 'rs_submodel')
path_rs_fuel_raw_data = os.path.join(
path_main, 'data', 'submodel_residential',
'data_residential_by_fuel_end_uses.csv')
hes_appliances_matching = {
'rs_cold': 0,
'rs_cooking': 1,
'rs_lighting': 2,
'rs_consumer_electronics': 3,
'rs_home_computing': 4,
'rs_wet': 5,
'rs_water_heating': 6,
'NOT_USED_unkown_1': 7,
'NOT_USED_unkown_2': 8,
'NOT_USED_unkown_3': 9,
'NOT_USED_showers': 10
}
# HES data -- Generate generic load profiles
# for all electricity appliances from HES data
hes_data, hes_y_peak, _ = read_hes_data(path_hes_load_profiles,
len(hes_appliances_matching))
# Assign read in raw data to the base year
year_raw_hes_values = assign_hes_data_to_year(len(hes_appliances_matching),
hes_data,
int(sim_param['base_yr']))
_, rs_enduses = read_data.read_csv_base_data_resid(path_rs_fuel_raw_data)
# Load shape for all enduses
for enduse in rs_enduses:
if enduse not in hes_appliances_matching:
print(
"Warning: The enduse {} is not defined in hes_appliances_matching"
.format(enduse))
else:
# Generate HES load shapes
shape_peak_dh, shape_non_peak_y_dh, shape_peak_yd_factor, shape_non_peak_yd = get_hes_load_shapes(
hes_appliances_matching, year_raw_hes_values, hes_y_peak,
enduse)
# Write txt files
s_shared_functions.create_txt_shapes(enduse, path_rs_txt_shapes,
shape_peak_dh,
shape_non_peak_y_dh,
shape_peak_yd_factor,
shape_non_peak_yd)
print("... finished script {}".format(os.path.basename(__file__)))
return
path_config = os.path.abspath(
os.path.join(os.path.dirname(__file__), '..', '..', '..', "config"))
path_main = os.path.abspath(
os.path.join(os.path.dirname(__file__), '..', "config_data"))
# Configuration paths
config = configparser.ConfigParser()
config.read(os.path.join(path_config, 'wrapperconfig.ini'))
# --------
# Other configuration
# --------
base_yr = 2015
sim_yrs = [2015, 2050]
paths = data_loader.load_paths(path_main)
data_path = os.path.normpath(config['PATHS']['path_local_data'])
local_paths = data_loader.get_local_paths(data_path)
data = {}
data['enduses'], data['sectors'], data['fuels'] = data_loader.load_fuels(paths)
assumptions = general_assumptions.Assumptions(base_yr=user_defined_base_yr,
curr_yr=2015,
sim_yrs=sim_yrs,
paths=paths,
enduses=data['enduses'],
sectors=data['sectors'])
def post_install_setup_minimum(args):
"""If not all data are available, this scripts allows to
create dummy datas (temperature and service sector load profiles)
Arguments
---------
path_local_data : str
Path to `energy_demand_data` folder
path_energy_demand : str
Path to energy demand python files
"""
path_energy_demand = resource_filename(Requirement.parse("energy_demand"), "config_data")
path_local_data = args.local_data
# ==========================================
# Post installation setup witout access to non publicy available data
# ==========================================
print("... running initialisation scripts with only publicly available data")
# Load paths
local_paths = data_loader.load_local_paths(path_local_data)
# Create folders to input data
raw_folder = os.path.join(path_local_data, '_raw_data')
processed_folder = os.path.join(path_local_data, '_processed_data')
basic_functions.create_folder(raw_folder)
basic_functions.create_folder(processed_folder)
basic_functions.create_folder(local_paths['path_post_installation_data'])
basic_functions.create_folder(local_paths['dir_raw_weather_data'])
basic_functions.create_folder(local_paths['dir_changed_weather_station_data'])
basic_functions.create_folder(local_paths['load_profiles'])
basic_functions.create_folder(local_paths['rs_load_profile_txt'])
basic_functions.create_folder(local_paths['ss_load_profile_txt'])
basic_functions.create_folder(local_paths['dir_disaggregated'])
# Load data
base_yr = 2015
data = {}
data['paths'] = data_loader.load_paths(path_energy_demand)
data['lookups'] = lookup_tables.basic_lookups()
data['enduses'], data['sectors'], data['fuels'] = data_loader.load_fuels(
data['paths'], data['lookups'])
# Assumptions
data['assumptions'] = non_param_assumptions.Assumptions(
base_yr=base_yr,
paths=data['paths'],
enduses=data['enduses'],
sectors=data['sectors'],
fueltypes=data['lookups']['fueltypes'],
fueltypes_nr=data['lookups']['fueltypes_nr'])
# Read in residential submodel shapes
run(data['paths'], local_paths, base_yr)
# ==========================================
# Create not publica available files
# ==========================================
# --------
# Generate dummy weather stations
# --------
dummy_raw_weather_station(local_paths)
# --------
# Generate dummy temperatures
# --------
dummy_raw_weather_data(local_paths)
# --------
# Dummy service sector load profiles
# --------
dummy_sectoral_load_profiles(local_paths, path_energy_demand)
print("Successfully finished post installation setup with open source data")