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")