def thermal_networks_in_individual(locator, weather_features, DCN_barcode, DHN_barcode, district_heating_network, district_cooling_network, column_names_buildings_heating, column_names_buildings_cooling): # local variables ground_temp = weather_features.ground_temp # EVALUATE CASES TO CREATE A NETWORK OR NOT if district_heating_network: # network exists if not os.path.exists( locator.get_optimization_network_results_summary( 'DH', DHN_barcode)): total_demand = createTotalNtwCsv(DHN_barcode, locator, column_names_buildings_heating) num_total_buildings = len(column_names_buildings_heating) buildings_in_heating_network = total_demand.Name.values # Run the substation and distribution routines substation.substation_main_heating(locator, total_demand, buildings_in_heating_network, DHN_barcode=DHN_barcode) DH_network_summary_individual = summarize_network.network_main( locator, buildings_in_heating_network, ground_temp, num_total_buildings, "DH", DHN_barcode) else: DH_network_summary_individual = pd.read_csv( locator.get_optimization_network_results_summary( 'DH', DHN_barcode)) else: DH_network_summary_individual = None if district_cooling_network: # network exists if not os.path.exists( locator.get_optimization_network_results_summary( 'DC', DCN_barcode)): total_demand = createTotalNtwCsv(DCN_barcode, locator, column_names_buildings_cooling) num_total_buildings = len(column_names_buildings_cooling) buildings_in_cooling_network = total_demand.Name.values # Run the substation and distribution routines substation.substation_main_cooling(locator, total_demand, buildings_in_cooling_network, DCN_barcode=DCN_barcode) DC_network_summary_individual = summarize_network.network_main( locator, buildings_in_cooling_network, ground_temp, num_total_buildings, 'DC', DCN_barcode) else: DC_network_summary_individual = pd.read_csv( locator.get_optimization_network_results_summary( 'DC', DCN_barcode)) else: DC_network_summary_individual = None return DH_network_summary_individual, DC_network_summary_individual
def preproccessing(locator, total_demand, buildings_heating_demand, buildings_cooling_demand, weather_file, district_heating_network, district_cooling_network): """ This function aims at preprocessing all data for the optimization. :param locator: path to locator function :param total_demand: dataframe with total demand and names of all building in the area :param building_names: dataframe with names of all buildings in the area :param weather_file: path to wather file :type locator: class :type total_demand: list :type building_names: list :type weather_file: string :return: - extraCosts: extra pareto optimal costs due to electricity and process heat ( these are treated separately and not considered inside the optimization) - extraCO2: extra pareto optimal emissions due to electricity and process heat ( these are treated separately and not considered inside the optimization) - extraPrim: extra pareto optimal primary energy due to electricity and process heat ( these are treated separately and not considered inside the optimization) - solar_features: extraction of solar features form the results of the solar technologies calculation. :rtype: float, float, float, float """ # local variables network_depth_m = Z0 print("PRE-PROCESSING 1/2: weather properties") T_ambient = epwreader.epw_reader(weather_file)['drybulb_C'] ground_temp = calc_ground_temperature(locator, T_ambient, depth_m=network_depth_m) print("PRE-PROCESSING 2/2: thermal networks") # at first estimate a distribution with all the buildings connected if district_heating_network: num_tot_buildings = len(buildings_heating_demand) DHN_barcode = ''.join(str(1) for e in range(num_tot_buildings)) substation.substation_main_heating(locator, total_demand, buildings_heating_demand, DHN_barcode=DHN_barcode) summarize_network.network_main(locator, buildings_heating_demand, ground_temp, num_tot_buildings, "DH", DHN_barcode) # "_all" key for all buildings if district_cooling_network: num_tot_buildings = len(buildings_cooling_demand) DCN_barcode = ''.join(str(1) for e in range(num_tot_buildings)) substation.substation_main_cooling(locator, total_demand, buildings_cooling_demand, DCN_barcode=DCN_barcode) summarize_network.network_main(locator, buildings_cooling_demand, ground_temp, num_tot_buildings, "DC", DCN_barcode) # "_all" key for all buildings network_features = NetworkOptimizationFeatures(district_heating_network, district_cooling_network, locator) return network_features
def disconnected_buildings_heating_main(locator, total_demand, building_names, config, prices, lca): """ Computes the parameters for the operation of disconnected buildings output results in csv files. There is no optimization at this point. The different technologies are calculated and compared 1 to 1 to each technology. it is a classical combinatorial problem. :param locator: locator class :param building_names: list with names of buildings :type locator: class :type building_names: list :return: results of operation of buildings located in locator.get_optimization_decentralized_folder :rtype: Nonetype """ t0 = time.perf_counter() prop_geometry = Gdf.from_file(locator.get_zone_geometry()) geometry = pd.DataFrame({ 'Name': prop_geometry.Name, 'Area': prop_geometry.area }) geothermal_potential_data = dbf.dbf_to_dataframe( locator.get_building_supply()) geothermal_potential_data = pd.merge(geothermal_potential_data, geometry, on='Name') geothermal_potential_data['Area_geo'] = geothermal_potential_data['Area'] weather_path = locator.get_weather_file() weather_data = epwreader.epw_reader(weather_path)[[ 'year', 'drybulb_C', 'wetbulb_C', 'relhum_percent', 'windspd_ms', 'skytemp_C' ]] T_ground_K = calc_ground_temperature(locator, weather_data['drybulb_C'], depth_m=10) supply_systems = SupplySystemsDatabase(locator) # This will calculate the substation state if all buildings where connected(this is how we study this) substation.substation_main_heating(locator, total_demand, building_names) n = len(building_names) cea.utilities.parallel.vectorize(disconnected_heating_for_building, config.get_number_of_processes())( building_names, repeat(supply_systems, n), repeat(T_ground_K, n), repeat(geothermal_potential_data, n), repeat(lca, n), repeat(locator, n), repeat(prices, n)) print(time.perf_counter() - t0, "seconds process time for the Disconnected Building Routine \n")
def thermal_network_simplified(locator, config, network_name): # local variables network_type = config.thermal_network.network_type min_head_substation_kPa = config.thermal_network.min_head_substation thermal_transfer_unit_design_head_m = min_head_substation_kPa * 1000 / M_WATER_TO_PA coefficient_friction_hazen_williams = config.thermal_network.hw_friction_coefficient velocity_ms = config.thermal_network.peak_load_velocity fraction_equivalent_length = config.thermal_network.equivalent_length_factor peak_load_percentage = config.thermal_network.peak_load_percentage # GET INFORMATION ABOUT THE NETWORK edge_df, node_df = get_thermal_network_from_shapefile(locator, network_type, network_name) # GET INFORMATION ABOUT THE DEMAND OF BUILDINGS AND CONNECT TO THE NODE INFO # calculate substations for all buildings # local variables total_demand = pd.read_csv(locator.get_total_demand()) volume_flow_m3pers_building = pd.DataFrame() T_sup_K_building = pd.DataFrame() T_re_K_building = pd.DataFrame() Q_demand_kWh_building = pd.DataFrame() if network_type == "DH": buildings_name_with_heating = get_building_names_with_load(total_demand, load_name='QH_sys_MWhyr') buildings_name_with_space_heating = get_building_names_with_load(total_demand, load_name='Qhs_sys_MWhyr') DHN_barcode = "0" if (buildings_name_with_heating != [] and buildings_name_with_space_heating != []): building_names = [building for building in buildings_name_with_heating if building in node_df.Building.values] substation.substation_main_heating(locator, total_demand, building_names, DHN_barcode=DHN_barcode) else: raise Exception('problem here') for building_name in building_names: substation_results = pd.read_csv( locator.get_optimization_substations_results_file(building_name, "DH", DHN_barcode)) volume_flow_m3pers_building[building_name] = substation_results["mdot_DH_result_kgpers"] / P_WATER_KGPERM3 T_sup_K_building[building_name] = substation_results["T_supply_DH_result_K"] T_re_K_building[building_name] = np.where(substation_results["T_return_DH_result_K"] >273.15, substation_results["T_return_DH_result_K"], np.nan) Q_demand_kWh_building[building_name] = (substation_results["Q_heating_W"] + substation_results[ "Q_dhw_W"]) / 1000 if network_type == "DC": buildings_name_with_cooling = get_building_names_with_load(total_demand, load_name='QC_sys_MWhyr') DCN_barcode = "0" if buildings_name_with_cooling != []: building_names = [building for building in buildings_name_with_cooling if building in node_df.Building.values] substation.substation_main_cooling(locator, total_demand, building_names, DCN_barcode=DCN_barcode) else: raise Exception('problem here') for building_name in building_names: substation_results = pd.read_csv( locator.get_optimization_substations_results_file(building_name, "DC", DCN_barcode)) volume_flow_m3pers_building[building_name] = substation_results[ "mdot_space_cooling_data_center_and_refrigeration_result_kgpers"] / P_WATER_KGPERM3 T_sup_K_building[building_name] = substation_results[ "T_supply_DC_space_cooling_data_center_and_refrigeration_result_K"] T_re_K_building[building_name] = substation_results[ "T_return_DC_space_cooling_data_center_and_refrigeration_result_K"] Q_demand_kWh_building[building_name] = substation_results[ "Q_space_cooling_data_center_and_refrigeration_W"] / 1000 import cea.utilities with cea.utilities.pushd(locator.get_thermal_network_folder()): # Create a water network model wn = wntr.network.WaterNetworkModel() # add loads building_base_demand_m3s = {} for building in volume_flow_m3pers_building.keys(): building_base_demand_m3s[building] = volume_flow_m3pers_building[building].max() pattern_demand = (volume_flow_m3pers_building[building].values / building_base_demand_m3s[building]).tolist() wn.add_pattern(building, pattern_demand) # add nodes consumer_nodes = [] building_nodes_pairs = {} building_nodes_pairs_inversed = {} for node in node_df.iterrows(): if node[1]["Type"] == "CONSUMER": demand_pattern = node[1]['Building'] base_demand_m3s = building_base_demand_m3s[demand_pattern] consumer_nodes.append(node[0]) building_nodes_pairs[node[0]] = demand_pattern building_nodes_pairs_inversed[demand_pattern] = node[0] wn.add_junction(node[0], base_demand=base_demand_m3s, demand_pattern=demand_pattern, elevation=thermal_transfer_unit_design_head_m, coordinates=node[1]["coordinates"]) elif node[1]["Type"] == "PLANT": base_head = int(thermal_transfer_unit_design_head_m*1.2) start_node = node[0] name_node_plant = start_node wn.add_reservoir(start_node, base_head=base_head, coordinates=node[1]["coordinates"]) else: wn.add_junction(node[0], elevation=0, coordinates=node[1]["coordinates"]) # add pipes for edge in edge_df.iterrows(): length_m = edge[1]["length_m"] edge_name = edge[0] wn.add_pipe(edge_name, edge[1]["start node"], edge[1]["end node"], length=length_m * (1 + fraction_equivalent_length), roughness=coefficient_friction_hazen_williams, minor_loss=0.0, status='OPEN') # add options wn.options.time.duration = 8759 * 3600 # this indicates epanet to do one year simulation wn.options.time.hydraulic_timestep = 60 * 60 wn.options.time.pattern_timestep = 60 * 60 wn.options.solver.accuracy = 0.01 wn.options.solver.trials = 100 # 1st ITERATION GET MASS FLOWS AND CALCULATE DIAMETER sim = wntr.sim.EpanetSimulator(wn) results = sim.run_sim() max_volume_flow_rates_m3s = results.link['flowrate'].abs().max() pipe_names = max_volume_flow_rates_m3s.index.values pipe_catalog = pd.read_excel(locator.get_database_distribution_systems(), sheet_name='THERMAL_GRID') Pipe_DN, D_ext_m, D_int_m, D_ins_m = zip( *[calc_max_diameter(flow, pipe_catalog, velocity_ms=velocity_ms, peak_load_percentage=peak_load_percentage) for flow in max_volume_flow_rates_m3s]) pipe_dn = pd.Series(Pipe_DN, pipe_names) diameter_int_m = pd.Series(D_int_m, pipe_names) diameter_ext_m = pd.Series(D_ext_m, pipe_names) diameter_ins_m = pd.Series(D_ins_m, pipe_names) # 2nd ITERATION GET PRESSURE POINTS AND MASSFLOWS FOR SIZING PUMPING NEEDS - this could be for all the year # modify diameter and run simulations edge_df['Pipe_DN'] = pipe_dn edge_df['D_int_m'] = D_int_m for edge in edge_df.iterrows(): edge_name = edge[0] pipe = wn.get_link(edge_name) pipe.diameter = diameter_int_m[edge_name] sim = wntr.sim.EpanetSimulator(wn) results = sim.run_sim() # 3rd ITERATION GET FINAL UTILIZATION OF THE GRID (SUPPLY SIDE) # get accumulated head loss per hour unitary_head_ftperkft = results.link['headloss'].abs() unitary_head_mperm = unitary_head_ftperkft * FT_TO_M / (FT_TO_M * 1000) head_loss_m = unitary_head_mperm.copy() for column in head_loss_m.columns.values: length_m = edge_df.loc[column]['length_m'] head_loss_m[column] = head_loss_m[column] * length_m reservoir_head_loss_m = head_loss_m.sum(axis=1) + thermal_transfer_unit_design_head_m*1.2 # fixme: only one thermal_transfer_unit_design_head_m from one substation? # apply this pattern to the reservoir and get results base_head = reservoir_head_loss_m.max() pattern_head_m = (reservoir_head_loss_m.values / base_head).tolist() wn.add_pattern('reservoir', pattern_head_m) reservoir = wn.get_node(name_node_plant) reservoir.head_timeseries.base_value = int(base_head) reservoir.head_timeseries._pattern = 'reservoir' sim = wntr.sim.EpanetSimulator(wn) results = sim.run_sim() # POSTPROCESSING # $ POSTPROCESSING - PRESSURE/HEAD LOSSES PER PIPE PER HOUR OF THE YEAR # at the pipes unitary_head_loss_supply_network_ftperkft = results.link['headloss'].abs() linear_pressure_loss_Paperm = unitary_head_loss_supply_network_ftperkft * FT_WATER_TO_PA / (FT_TO_M * 1000) head_loss_supply_network_Pa = linear_pressure_loss_Paperm.copy() for column in head_loss_supply_network_Pa.columns.values: length_m = edge_df.loc[column]['length_m'] head_loss_supply_network_Pa[column] = head_loss_supply_network_Pa[column] * length_m head_loss_return_network_Pa = head_loss_supply_network_Pa.copy(0) # at the substations head_loss_substations_ft = results.node['head'][consumer_nodes].abs() head_loss_substations_Pa = head_loss_substations_ft * FT_WATER_TO_PA #POSTPORCESSING MASSFLOW RATES # MASS_FLOW_RATE (EDGES) flow_rate_supply_m3s = results.link['flowrate'].abs() massflow_supply_kgs = flow_rate_supply_m3s * P_WATER_KGPERM3 # $ POSTPROCESSING - PRESSURE LOSSES ACCUMULATED PER HOUR OF THE YEAR (TIMES 2 to account for return) accumulated_head_loss_supply_Pa = head_loss_supply_network_Pa.sum(axis=1) accumulated_head_loss_return_Pa = head_loss_return_network_Pa.sum(axis=1) accumulated_head_loss_substations_Pa = head_loss_substations_Pa.sum(axis=1) accumulated_head_loss_total_Pa = accumulated_head_loss_supply_Pa + accumulated_head_loss_return_Pa + accumulated_head_loss_substations_Pa # $ POSTPROCESSING - THERMAL LOSSES PER PIPE PER HOUR OF THE YEAR (SUPPLY) # calculate the thermal characteristics of the grid temperature_of_the_ground_K = calculate_ground_temperature(locator) thermal_coeffcient_WperKm = pd.Series( np.vectorize(calc_linear_thermal_loss_coefficient)(diameter_ext_m, diameter_int_m, diameter_ins_m), pipe_names) average_temperature_supply_K = T_sup_K_building.mean(axis=1) thermal_losses_supply_kWh = results.link['headloss'].copy() thermal_losses_supply_kWh.reset_index(inplace=True, drop=True) thermal_losses_supply_Wperm = thermal_losses_supply_kWh.copy() for pipe in pipe_names: length_m = edge_df.loc[pipe]['length_m'] massflow_kgs = massflow_supply_kgs[pipe] k_WperKm_pipe = thermal_coeffcient_WperKm[pipe] k_kWperK = k_WperKm_pipe * length_m / 1000 thermal_losses_supply_kWh[pipe] = np.vectorize(calc_thermal_loss_per_pipe)(average_temperature_supply_K.values, massflow_kgs.values, temperature_of_the_ground_K, k_kWperK, ) thermal_losses_supply_Wperm[pipe] = (thermal_losses_supply_kWh[pipe] / length_m) * 1000 # return pipes average_temperature_return_K = T_re_K_building.mean(axis=1) thermal_losses_return_kWh = results.link['headloss'].copy() thermal_losses_return_kWh.reset_index(inplace=True, drop=True) for pipe in pipe_names: length_m = edge_df.loc[pipe]['length_m'] massflow_kgs = massflow_supply_kgs[pipe] k_WperKm_pipe = thermal_coeffcient_WperKm[pipe] k_kWperK = k_WperKm_pipe * length_m / 1000 thermal_losses_return_kWh[pipe] = np.vectorize(calc_thermal_loss_per_pipe)(average_temperature_return_K.values, massflow_kgs.values, temperature_of_the_ground_K, k_kWperK, ) # WRITE TO DISK # LINEAR PRESSURE LOSSES (EDGES) linear_pressure_loss_Paperm.to_csv(locator.get_network_linear_pressure_drop_edges(network_type, network_name), index=False) # MASS_FLOW_RATE (EDGES) flow_rate_supply_m3s = results.link['flowrate'].abs() massflow_supply_kgs = flow_rate_supply_m3s * P_WATER_KGPERM3 massflow_supply_kgs.to_csv(locator.get_thermal_network_layout_massflow_edges_file(network_type, network_name), index=False) # VELOCITY (EDGES) velocity_edges_ms = results.link['velocity'].abs() velocity_edges_ms.to_csv(locator.get_thermal_network_velocity_edges_file(network_type, network_name), index=False) # PRESSURE LOSSES (NODES) pressure_at_nodes_ft = results.node['pressure'].abs() pressure_at_nodes_Pa = pressure_at_nodes_ft * FT_TO_M * M_WATER_TO_PA pressure_at_nodes_Pa.to_csv(locator.get_network_pressure_at_nodes(network_type, network_name), index=False) # MASS_FLOW_RATE (NODES) # $ POSTPROCESSING - MASSFLOWRATES PER NODE PER HOUR OF THE YEAR flow_rate_supply_nodes_m3s = results.node['demand'].abs() massflow_supply_nodes_kgs = flow_rate_supply_nodes_m3s * P_WATER_KGPERM3 massflow_supply_nodes_kgs.to_csv(locator.get_thermal_network_layout_massflow_nodes_file(network_type, network_name), index=False) # thermal demand per building (no losses in the network or substations) Q_demand_Wh_building = Q_demand_kWh_building * 1000 Q_demand_Wh_building.to_csv(locator.get_thermal_demand_csv_file(network_type, network_name), index=False) # pressure losses total # $ POSTPROCESSING - PUMPING NEEDS PER HOUR OF THE YEAR (TIMES 2 to account for return) flow_rate_substations_m3s = results.node['demand'][consumer_nodes].abs() head_loss_supply_kWperm = (linear_pressure_loss_Paperm * (flow_rate_supply_m3s * 3600)) / (3.6E6 * PUMP_ETA) head_loss_return_kWperm = head_loss_supply_kWperm.copy() pressure_loss_supply_edge_kW = (head_loss_supply_network_Pa * (flow_rate_supply_m3s * 3600)) / (3.6E6 * PUMP_ETA) head_loss_return_kW = pressure_loss_supply_edge_kW.copy() head_loss_substations_kW = (head_loss_substations_Pa * (flow_rate_substations_m3s * 3600)) / (3.6E6 * PUMP_ETA) accumulated_head_loss_supply_kW = pressure_loss_supply_edge_kW.sum(axis=1) accumulated_head_loss_return_kW = head_loss_return_kW.sum(axis=1) accumulated_head_loss_substations_kW = head_loss_substations_kW.sum(axis=1) accumulated_head_loss_total_kW = accumulated_head_loss_supply_kW + \ accumulated_head_loss_return_kW + \ accumulated_head_loss_substations_kW head_loss_system_Pa = pd.DataFrame({"pressure_loss_supply_Pa": accumulated_head_loss_supply_Pa, "pressure_loss_return_Pa": accumulated_head_loss_return_Pa, "pressure_loss_substations_Pa": accumulated_head_loss_substations_Pa, "pressure_loss_total_Pa": accumulated_head_loss_total_Pa}) head_loss_system_Pa.to_csv(locator.get_network_total_pressure_drop_file(network_type, network_name), index=False) # $ POSTPROCESSING - PLANT HEAT REQUIREMENT plant_load_kWh = thermal_losses_supply_kWh.sum(axis=1) * 2 + Q_demand_kWh_building.sum( axis=1) - accumulated_head_loss_total_kW.values plant_load_kWh.to_csv(locator.get_thermal_network_plant_heat_requirement_file(network_type, network_name), header=['thermal_load_kW'], index=False) # pressure losses per piping system pressure_loss_supply_edge_kW.to_csv( locator.get_thermal_network_pressure_losses_edges_file(network_type, network_name), index=False) # pressure losses per substation head_loss_substations_kW = head_loss_substations_kW.rename(columns=building_nodes_pairs) head_loss_substations_kW.to_csv(locator.get_thermal_network_substation_ploss_file(network_type, network_name), index=False) # pumping needs losses total pumping_energy_system_kWh = pd.DataFrame({"pressure_loss_supply_kW": accumulated_head_loss_supply_kW, "pressure_loss_return_kW": accumulated_head_loss_return_kW, "pressure_loss_substations_kW": accumulated_head_loss_substations_kW, "pressure_loss_total_kW": accumulated_head_loss_total_kW}) pumping_energy_system_kWh.to_csv( locator.get_network_energy_pumping_requirements_file(network_type, network_name), index=False) # pumping needs losses total temperatures_plant_C = pd.DataFrame({"temperature_supply_K": average_temperature_supply_K, "temperature_return_K": average_temperature_return_K}) temperatures_plant_C.to_csv(locator.get_network_temperature_plant(network_type, network_name), index=False) # thermal losses thermal_losses_supply_kWh.to_csv(locator.get_network_thermal_loss_edges_file(network_type, network_name), index=False) thermal_losses_supply_Wperm.to_csv(locator.get_network_linear_thermal_loss_edges_file(network_type, network_name), index=False) # thermal losses total accumulated_thermal_losses_supply_kWh = thermal_losses_supply_kWh.sum(axis=1) accumulated_thermal_losses_return_kWh = thermal_losses_return_kWh.sum(axis=1) accumulated_thermal_loss_total_kWh = accumulated_thermal_losses_supply_kWh + accumulated_thermal_losses_return_kWh thermal_losses_total_kWh = pd.DataFrame({"thermal_loss_supply_kW": accumulated_thermal_losses_supply_kWh, "thermal_loss_return_kW": accumulated_thermal_losses_return_kWh, "thermal_loss_total_kW": accumulated_thermal_loss_total_kWh}) thermal_losses_total_kWh.to_csv(locator.get_network_total_thermal_loss_file(network_type, network_name), index=False) # return average temperature of supply at the substations T_sup_K_nodes = T_sup_K_building.rename(columns=building_nodes_pairs_inversed) average_year = T_sup_K_nodes.mean(axis=1) for node in node_df.index.values: T_sup_K_nodes[node] = average_year T_sup_K_nodes.to_csv(locator.get_network_temperature_supply_nodes_file(network_type, network_name), index=False) # return average temperature of return at the substations T_return_K_nodes = T_re_K_building.rename(columns=building_nodes_pairs_inversed) average_year = T_return_K_nodes.mean(axis=1) for node in node_df.index.values: T_return_K_nodes[node] = average_year T_return_K_nodes.to_csv(locator.get_network_temperature_return_nodes_file(network_type, network_name), index=False) # summary of edges used for the calculation fields_edges = ['length_m', 'Pipe_DN', 'Type_mat', 'D_int_m'] edge_df[fields_edges].to_csv(locator.get_thermal_network_edge_list_file(network_type, network_name)) fields_nodes = ['Type', 'Building'] node_df[fields_nodes].to_csv(locator.get_thermal_network_node_types_csv_file(network_type, network_name)) # correct diameter of network and save to the shapefile from cea.utilities.dbf import dataframe_to_dbf, dbf_to_dataframe fields = ['length_m', 'Pipe_DN', 'Type_mat'] edge_df = edge_df[fields] edge_df['name'] = edge_df.index.values network_edges_df = dbf_to_dataframe( locator.get_network_layout_edges_shapefile(network_type, network_name).split('.shp')[0] + '.dbf') network_edges_df = network_edges_df.merge(edge_df, left_on='Name', right_on='name', suffixes=('_x', '')) network_edges_df = network_edges_df.drop(['Pipe_DN_x', 'Type_mat_x', 'name', 'length_m_x'], axis=1) dataframe_to_dbf(network_edges_df, locator.get_network_layout_edges_shapefile(network_type, network_name).split('.shp')[0] + '.dbf')
def preproccessing(locator, total_demand, buildings_heating_demand, buildings_cooling_demand, weather_file, district_heating_network, district_cooling_network): """ This function aims at preprocessing all data for the optimization. :param locator: path to locator function :param total_demand: dataframe with total demand and names of all building in the area :param building_names: dataframe with names of all buildings in the area :param weather_file: path to wather file :type locator: class :type total_demand: list :type building_names: list :type weather_file: string :return: - extraCosts: extra pareto optimal costs due to electricity and process heat ( these are treated separately and not considered inside the optimization) - extraCO2: extra pareto optimal emissions due to electricity and process heat ( these are treated separately and not considered inside the optimization) - extraPrim: extra pareto optimal primary energy due to electricity and process heat ( these are treated separately and not considered inside the optimization) - solar_features: extraction of solar features form the results of the solar technologies calculation. :rtype: float, float, float, float """ print("PRE-PROCESSING 0/4: initialize directory") shutil.rmtree(locator.get_optimization_master_results_folder()) shutil.rmtree(locator.get_optimization_network_results_folder()) shutil.rmtree(locator.get_optimization_slave_results_folder()) shutil.rmtree(locator.get_optimization_substations_folder()) print("PRE-PROCESSING 1/4: weather features") # at first estimate a distribution with all the buildings connected weather_features = WeatherFeatures(weather_file, locator) print("PRE-PROCESSING 2/4: conversion systems database") # at first estimate a distribution with all the buildings connected supply_systems = SupplySystemsDatabase(locator) print("PRE-PROCESSING 3/4: feedstocks systems database") # at first estimate a distribution with all the buildings connected prices = Prices(supply_systems) lca = LcaCalculations(supply_systems) print("PRE-PROCESSING 4/4: network features") # at first estimate a distribution with all the buildings connected if district_heating_network: num_tot_buildings = len(buildings_heating_demand) DHN_barcode = ''.join(str(1) for e in range(num_tot_buildings)) substation.substation_main_heating(locator, total_demand, buildings_heating_demand, DHN_barcode=DHN_barcode) summarize_network.network_main(locator, buildings_heating_demand, weather_features.ground_temp, num_tot_buildings, "DH", DHN_barcode) # "_all" key for all buildings if district_cooling_network: num_tot_buildings = len(buildings_cooling_demand) DCN_barcode = ''.join(str(1) for e in range(num_tot_buildings)) substation.substation_main_cooling(locator, total_demand, buildings_cooling_demand, DCN_barcode=DCN_barcode) summarize_network.network_main(locator, buildings_cooling_demand, weather_features.ground_temp, num_tot_buildings, "DC", DCN_barcode) # "_all" key for all buildings network_features = NetworkOptimizationFeatures(district_heating_network, district_cooling_network, locator) return weather_features, network_features, prices, lca
def extract_loads_individual(locator, DCN_barcode, DHN_barcode, district_heating_network, district_cooling_network, column_names_buildings_heating, column_names_buildings_cooling): # local variables weather_file = locator.get_weather_file() network_depth_m = Z0 T_ambient = epwreader.epw_reader(weather_file)['drybulb_C'] ground_temp = calc_ground_temperature(locator, T_ambient, depth_m=network_depth_m) # EVALUATE CASES TO CREATE A NETWORK OR NOT if district_heating_network: # network exists network_file_name_heating = "DH_Network_summary_result_" + hex( int(str(DHN_barcode), 2)) + ".csv" if not os.path.exists( locator.get_optimization_network_results_summary( 'DH', DHN_barcode)): total_demand = createTotalNtwCsv(DHN_barcode, locator, column_names_buildings_heating) num_total_buildings = len(column_names_buildings_heating) buildings_in_heating_network = total_demand.Name.values # Run the substation and distribution routines substation.substation_main_heating(locator, total_demand, buildings_in_heating_network, DHN_barcode=DHN_barcode) results = summarize_network.network_main( locator, buildings_in_heating_network, ground_temp, num_total_buildings, "DH", DHN_barcode) else: results = pd.read_csv( locator.get_optimization_network_results_summary( 'DH', DHN_barcode)) Q_DHNf_W = results['Q_DHNf_W'].values Q_heating_max_W = Q_DHNf_W.max() Qcdata_netw_total_kWh = results['Qcdata_netw_total_kWh'].values Q_wasteheat_datacentre_max_W = Qcdata_netw_total_kWh.max() else: Q_heating_max_W = 0.0 Q_wasteheat_datacentre_max_W = 0.0 network_file_name_heating = "" if district_cooling_network: # network exists network_file_name_cooling = "DC_Network_summary_result_" + hex( int(str(DCN_barcode), 2)) + ".csv" if not os.path.exists( locator.get_optimization_network_results_summary( 'DC', DCN_barcode)): total_demand = createTotalNtwCsv(DCN_barcode, locator, column_names_buildings_cooling) num_total_buildings = len(column_names_buildings_cooling) buildings_in_cooling_network = total_demand.Name.values # Run the substation and distribution routines substation.substation_main_cooling(locator, total_demand, buildings_in_cooling_network, DCN_barcode=DCN_barcode) results = summarize_network.network_main( locator, buildings_in_cooling_network, ground_temp, num_total_buildings, 'DC', DCN_barcode) else: results = pd.read_csv( locator.get_optimization_network_results_summary( 'DC', DCN_barcode)) # if heat recovery is ON, then only need to satisfy cooling load of space cooling and refrigeration Q_DCNf_W = results[ "Q_DCNf_space_cooling_data_center_and_refrigeration_W"].values Q_cooling_max_W = Q_DCNf_W.max() else: Q_cooling_max_W = 0.0 network_file_name_cooling = "" Q_heating_nom_W = Q_heating_max_W * (1 + Q_MARGIN_FOR_NETWORK) Q_cooling_nom_W = Q_cooling_max_W * (1 + Q_MARGIN_FOR_NETWORK) return Q_cooling_nom_W, Q_heating_nom_W, Q_wasteheat_datacentre_max_W, network_file_name_cooling, network_file_name_heating
def extract_loads_individual(locator, config, individual_with_name_dict, DCN_barcode, DHN_barcode, district_heating_network, district_cooling_network, column_names_buildings_heating, column_names_buildings_cooling): # local variables weather_file = locator.get_weather_file() network_depth_m = Z0 T_ambient = epwreader.epw_reader(weather_file)['drybulb_C'] ground_temp = calc_ground_temperature(locator, T_ambient, depth_m=network_depth_m) # EVALUATE CASES TO CREATE A NETWORK OR NOT if district_heating_network: # network exists if DHN_barcode.count("1") == len(column_names_buildings_heating): network_file_name_heating = "DH_Network_summary_result_" + hex( int(str(DHN_barcode), 2)) + ".csv" Q_DHNf_W = pd.read_csv( locator.get_optimization_network_results_summary( 'DH', DHN_barcode), usecols=["Q_DHNf_W"]).values Q_heating_max_W = Q_DHNf_W.max() elif DHN_barcode.count("1") == 0: # no network at all network_file_name_heating = "DH_Network_summary_result_" + hex( int(str(DHN_barcode), 2)) + ".csv" Q_heating_max_W = 0 else: network_file_name_heating = "DH_Network_summary_result_" + hex( int(str(DHN_barcode), 2)) + ".csv" if not os.path.exists( locator.get_optimization_network_results_summary( 'DH', DHN_barcode)): total_demand = createTotalNtwCsv( DHN_barcode, locator, column_names_buildings_heating) num_total_buildings = len(column_names_buildings_heating) buildings_in_heating_network = total_demand.Name.values # Run the substation and distribution routines substation.substation_main_heating( locator, total_demand, buildings_in_heating_network, DHN_barcode=DHN_barcode) summarize_network.network_main(locator, buildings_in_heating_network, ground_temp, num_total_buildings, "DH", DHN_barcode) Q_DHNf_W = pd.read_csv( locator.get_optimization_network_results_summary( 'DH', DHN_barcode), usecols=["Q_DHNf_W"]).values Q_heating_max_W = Q_DHNf_W.max() else: Q_heating_max_W = 0.0 network_file_name_heating = "" if district_cooling_network: # network exists if DCN_barcode.count("1") == len(column_names_buildings_cooling): network_file_name_cooling = "DC_Network_summary_result_" + hex( int(str(DCN_barcode), 2)) + ".csv" if individual_with_name_dict['HPServer'] == 1: # if heat recovery is ON, then only need to satisfy cooling load of space cooling and refrigeration Q_DCNf_W_no_server_demand = pd.read_csv( locator.get_optimization_network_results_summary( 'DC', DCN_barcode), usecols=["Q_DCNf_space_cooling_and_refrigeration_W" ]).values Q_DCNf_W_with_server_demand = pd.read_csv( locator.get_optimization_network_results_summary( 'DC', DCN_barcode), usecols=[ "Q_DCNf_space_cooling_data_center_and_refrigeration_W" ]).values Q_DCNf_W = Q_DCNf_W_no_server_demand + ( (Q_DCNf_W_with_server_demand - Q_DCNf_W_no_server_demand) * (individual_with_name_dict['HPShare'])) else: Q_DCNf_W = pd.read_csv( locator.get_optimization_network_results_summary( 'DC', DCN_barcode), usecols=[ "Q_DCNf_space_cooling_data_center_and_refrigeration_W" ]).values Q_cooling_max_W = Q_DCNf_W.max() elif DCN_barcode.count("1") == 0: network_file_name_cooling = "DC_Network_summary_result_" + hex( int(str(DCN_barcode), 2)) + ".csv" Q_cooling_max_W = 0.0 else: network_file_name_cooling = "DC_Network_summary_result_" + hex( int(str(DCN_barcode), 2)) + ".csv" if not os.path.exists( locator.get_optimization_network_results_summary( 'DC', DCN_barcode)): total_demand = createTotalNtwCsv( DCN_barcode, locator, column_names_buildings_cooling) num_total_buildings = len(column_names_buildings_cooling) buildings_in_cooling_network = total_demand.Name.values # Run the substation and distribution routines substation.substation_main_cooling( locator, total_demand, buildings_in_cooling_network, DCN_barcode=DCN_barcode) summarize_network.network_main(locator, buildings_in_cooling_network, ground_temp, num_total_buildings, 'DC', DCN_barcode) Q_DCNf_W_no_server_demand = pd.read_csv( locator.get_optimization_network_results_summary( 'DC', DCN_barcode), usecols=["Q_DCNf_space_cooling_and_refrigeration_W"]).values Q_DCNf_W_with_server_demand = pd.read_csv( locator.get_optimization_network_results_summary( 'DC', DCN_barcode), usecols=[ "Q_DCNf_space_cooling_data_center_and_refrigeration_W" ]).values # if heat recovery is ON, then only need to satisfy cooling load of space cooling and refrigeration if district_heating_network and individual_with_name_dict[ 'HPServer'] == 1: Q_DCNf_W = Q_DCNf_W_no_server_demand + ( (Q_DCNf_W_with_server_demand - Q_DCNf_W_no_server_demand) * (individual_with_name_dict['HPShare'])) else: Q_DCNf_W = Q_DCNf_W_with_server_demand Q_cooling_max_W = Q_DCNf_W.max() else: Q_cooling_max_W = 0.0 network_file_name_cooling = "" Q_heating_nom_W = Q_heating_max_W * (1 + Q_MARGIN_FOR_NETWORK) Q_cooling_nom_W = Q_cooling_max_W * (1 + Q_MARGIN_FOR_NETWORK) return Q_cooling_nom_W, Q_heating_nom_W, network_file_name_cooling, network_file_name_heating
def disconnected_buildings_heating_main(locator, total_demand, building_names, config, prices, lca): """ Computes the parameters for the operation of disconnected buildings output results in csv files. There is no optimization at this point. The different technologies are calculated and compared 1 to 1 to each technology. it is a classical combinatorial problem. :param locator: locator class :param building_names: list with names of buildings :type locator: class :type building_names: list :return: results of operation of buildings located in locator.get_optimization_decentralized_folder :rtype: Nonetype """ t0 = time.clock() prop_geometry = Gdf.from_file(locator.get_zone_geometry()) geometry = pd.DataFrame({'Name': prop_geometry.Name, 'Area': prop_geometry.area}) geothermal_potential_data = dbf.dbf_to_dataframe(locator.get_building_supply()) geothermal_potential_data = pd.merge(geothermal_potential_data, geometry, on='Name') geothermal_potential_data['Area_geo'] = geothermal_potential_data['Area'] weather_path = locator.get_weather_file() weather_data = epwreader.epw_reader(weather_path)[['year', 'drybulb_C', 'wetbulb_C', 'relhum_percent', 'windspd_ms', 'skytemp_C']] T_ground_K = calc_ground_temperature(locator, weather_data['drybulb_C'], depth_m=10) # This will calculate the substation state if all buildings where connected(this is how we study this) substation.substation_main_heating(locator, total_demand, building_names) for building_name in building_names: print('running for building %s') %(building_name) # run substation model to derive temperatures of the building substation_results = pd.read_csv(locator.get_optimization_substations_results_file(building_name, "DH", "")) q_load_Wh = np.vectorize(calc_new_load)(substation_results["mdot_DH_result_kgpers"], substation_results["T_supply_DH_result_K"], substation_results["T_return_DH_result_K"]) Qnom_W = q_load_Wh.max() # Create empty matrices Opex_a_var_USD = np.zeros((13, 7)) Capex_total_USD = np.zeros((13, 7)) Capex_a_USD = np.zeros((13, 7)) Opex_a_fixed_USD = np.zeros((13, 7)) Capex_opex_a_fixed_only_USD = np.zeros((13, 7)) Opex_a_USD = np.zeros((13, 7)) GHG_tonCO2 = np.zeros((13, 7)) PEN_MJoil = np.zeros((13, 7)) # indicate supply technologies for each configuration Opex_a_var_USD[0][0] = 1 # Boiler NG Opex_a_var_USD[1][1] = 1 # Boiler BG Opex_a_var_USD[2][2] = 1 # Fuel Cell resourcesRes = np.zeros((13, 4)) Q_Boiler_for_GHP_W = np.zeros((10, 1)) # Save peak capacity of GHP Backup Boilers GHP_el_size_W = np.zeros((10, 1)) # Save peak capacity of GHP # save supply system activation of all supply configurations heating_dispatch = {} # Supply with the Boiler / FC / GHP Tret_K = substation_results["T_return_DH_result_K"].values Tsup_K = substation_results["T_supply_DH_result_K"].values mdot_kgpers = substation_results["mdot_DH_result_kgpers"].values ## Start Hourly calculation print building_name, ' decentralized heating supply systems simulations...' Tret_K = np.where(Tret_K > 0.0, Tret_K, Tsup_K) ## 0: Boiler NG BoilerEff = np.vectorize(Boiler.calc_Cop_boiler)(q_load_Wh, Qnom_W, Tret_K) Qgas_to_Boiler_Wh = np.divide(q_load_Wh, BoilerEff, out=np.zeros_like(q_load_Wh), where=BoilerEff != 0.0) Boiler_Status = np.where(Qgas_to_Boiler_Wh > 0.0, 1, 0) # add costs Opex_a_var_USD[0][4] += sum(prices.NG_PRICE * Qgas_to_Boiler_Wh) # CHF GHG_tonCO2[0][5] += calc_emissions_Whyr_to_tonCO2yr(sum(Qgas_to_Boiler_Wh), lca.NG_TO_CO2_EQ) # ton CO2 PEN_MJoil[0][6] += calc_pen_Whyr_to_MJoilyr(sum(Qgas_to_Boiler_Wh), lca.NG_TO_OIL_EQ) # MJ-oil-eq # add activation resourcesRes[0][0] += sum(q_load_Wh) # q from NG heating_dispatch[0] = {'Q_Boiler_gen_directload_W': q_load_Wh, 'Boiler_Status': Boiler_Status, 'NG_Boiler_req_W': Qgas_to_Boiler_Wh, 'E_hs_ww_req_W': np.zeros(8760)} ## 1: Boiler BG # add costs Opex_a_var_USD[1][4] += sum(prices.BG_PRICE * Qgas_to_Boiler_Wh) # CHF GHG_tonCO2[1][5] += calc_emissions_Whyr_to_tonCO2yr(sum(Qgas_to_Boiler_Wh), lca.NG_TO_CO2_EQ) # ton CO2 PEN_MJoil[1][6] += calc_pen_Whyr_to_MJoilyr(sum(Qgas_to_Boiler_Wh), lca.NG_TO_OIL_EQ) # MJ-oil-eq # add activation resourcesRes[1][1] += sum(q_load_Wh) # q from BG heating_dispatch[1] = {'Q_Boiler_gen_directload_W': q_load_Wh, 'Boiler_Status': Boiler_Status, 'BG_Boiler_req_W': Qgas_to_Boiler_Wh, 'E_hs_ww_req_W': np.zeros(8760)} ## 2: Fuel Cell (FC_Effel, FC_Effth) = np.vectorize(FC.calc_eta_FC)(q_load_Wh, Qnom_W, 1, "B") Qgas_to_FC_Wh = q_load_Wh / (FC_Effth + FC_Effel) # FIXME: should be q_load_Wh/FC_Effth? el_from_FC_Wh = Qgas_to_FC_Wh * FC_Effel FC_Status = np.where(Qgas_to_FC_Wh > 0.0, 1, 0) # add variable costs, emissions and primary energy Opex_a_var_USD[2][4] += sum(prices.NG_PRICE * Qgas_to_FC_Wh - prices.ELEC_PRICE_EXPORT * el_from_FC_Wh) # CHF, extra electricity sold to grid GHG_tonCO2_from_FC = (0.0874 * Qgas_to_FC_Wh * 3600E-6 + 773 * 0.45 * el_from_FC_Wh * 1E-6 - lca.EL_TO_CO2_EQ * el_from_FC_Wh * 3600E-6) / 1E3 GHG_tonCO2[2][5] += sum(GHG_tonCO2_from_FC) # tonCO2 # Bloom box emissions within the FC: 773 lbs / MWh_el (and 1 lbs = 0.45 kg) # http://www.carbonlighthouse.com/2011/09/16/bloom-box/ PEN_MJoil_from_FC = 1.51 * Qgas_to_FC_Wh * 3600E-6 - lca.EL_TO_OIL_EQ * el_from_FC_Wh * 3600E-6 PEN_MJoil[2][6] += sum(PEN_MJoil_from_FC) # MJ-oil-eq # add activation resourcesRes[2][0] = sum(q_load_Wh) # q from NG resourcesRes[2][2] = sum(el_from_FC_Wh) # el for GHP # FIXME: el from FC heating_dispatch[2] = {'Q_Fuelcell_gen_directload_W': q_load_Wh, 'Fuelcell_Status': FC_Status, 'NG_FuelCell_req_W': Qgas_to_FC_Wh, 'E_Fuelcell_gen_export_W': el_from_FC_Wh, 'E_hs_ww_req_W': np.zeros(8760)} # 3-13: Boiler NG + GHP for i in range(10): # set nominal size for Boiler and GHP QnomBoiler_W = i / 10.0 * Qnom_W mdot_kgpers_Boiler = i / 10.0 * mdot_kgpers QnomGHP_W = Qnom_W - QnomBoiler_W # GHP operation Texit_GHP_nom_K = QnomGHP_W / (mdot_kgpers * HEAT_CAPACITY_OF_WATER_JPERKGK) + Tret_K el_GHP_Wh, q_load_NG_Boiler_Wh, \ qhot_missing_Wh, \ Texit_GHP_K, q_from_GHP_Wh = np.vectorize(calc_GHP_operation)(QnomGHP_W, T_ground_K, Texit_GHP_nom_K, Tret_K, Tsup_K, mdot_kgpers, q_load_Wh) GHP_el_size_W[i][0] = max(el_GHP_Wh) GHP_Status = np.where(q_from_GHP_Wh > 0.0, 1, 0) # GHP Backup Boiler operation if max(qhot_missing_Wh) > 0.0: print "GHP unable to cover the whole demand, boiler activated!" Qnom_GHP_Backup_Boiler_W = max(qhot_missing_Wh) BoilerEff = np.vectorize(Boiler.calc_Cop_boiler)(qhot_missing_Wh, Qnom_GHP_Backup_Boiler_W, Texit_GHP_K) Qgas_to_GHPBoiler_Wh = np.divide(qhot_missing_Wh, BoilerEff, out=np.zeros_like(qhot_missing_Wh), where=BoilerEff != 0.0) else: Qgas_to_GHPBoiler_Wh = np.zeros(q_load_Wh.shape[0]) Qnom_GHP_Backup_Boiler_W = 0.0 Q_Boiler_for_GHP_W[i][0] = Qnom_GHP_Backup_Boiler_W GHPbackupBoiler_Status = np.where(qhot_missing_Wh > 0.0, 1, 0) # NG Boiler operation BoilerEff = np.vectorize(Boiler.calc_Cop_boiler)(q_load_NG_Boiler_Wh, QnomBoiler_W, Texit_GHP_K) Qgas_to_Boiler_Wh = np.divide(q_load_NG_Boiler_Wh, BoilerEff, out=np.zeros_like(q_load_NG_Boiler_Wh), where=BoilerEff != 0.0) Boiler_Status = np.where(q_load_NG_Boiler_Wh > 0.0, 1, 0) # add costs # electricity el_total_Wh = el_GHP_Wh Opex_a_var_USD[3 + i][4] += sum(prices.ELEC_PRICE * el_total_Wh) # CHF GHG_tonCO2[3 + i][5] += calc_emissions_Whyr_to_tonCO2yr(sum(el_total_Wh), lca.EL_TO_CO2_EQ) # ton CO2 PEN_MJoil[3 + i][6] += calc_pen_Whyr_to_MJoilyr(sum(el_total_Wh), lca.EL_TO_OIL_EQ) # MJ-oil-eq # gas Q_gas_total_Wh = Qgas_to_GHPBoiler_Wh + Qgas_to_Boiler_Wh Opex_a_var_USD[3 + i][4] += sum(prices.NG_PRICE * Q_gas_total_Wh) # CHF GHG_tonCO2[3 + i][5] += calc_emissions_Whyr_to_tonCO2yr(sum(Q_gas_total_Wh), lca.NG_TO_CO2_EQ) # ton CO2 PEN_MJoil[3 + i][6] += calc_pen_Whyr_to_MJoilyr(sum(Q_gas_total_Wh), lca.NG_TO_OIL_EQ) # MJ-oil-eq # add activation resourcesRes[3 + i][0] = sum(qhot_missing_Wh + q_load_NG_Boiler_Wh) resourcesRes[3 + i][2] = sum(el_GHP_Wh) resourcesRes[3 + i][3] = sum(q_from_GHP_Wh) heating_dispatch[3 + i] = {'Q_GHP_gen_directload_W': q_from_GHP_Wh, 'Q_BackupBoiler_gen_directload_W': qhot_missing_Wh, 'Q_Boiler_gen_directload_W': q_load_NG_Boiler_Wh, 'GHP_Status': GHP_Status, 'BackupBoiler_Status': GHPbackupBoiler_Status, 'Boiler_Status': Boiler_Status, 'NG_BackupBoiler_req_Wh': Qgas_to_GHPBoiler_Wh, 'NG_Boiler_req_Wh': Qgas_to_Boiler_Wh, 'E_hs_ww_req_W': el_GHP_Wh} # Add all costs # 0: Boiler NG Capex_a_Boiler_USD, Opex_a_fixed_Boiler_USD, Capex_Boiler_USD = Boiler.calc_Cinv_boiler(Qnom_W, locator, config, 'BO1') Capex_total_USD[0][0] = Capex_Boiler_USD Capex_a_USD[0][0] = Capex_a_Boiler_USD Opex_a_fixed_USD[0][0] = Opex_a_fixed_Boiler_USD Capex_opex_a_fixed_only_USD[0][0] = Capex_a_Boiler_USD + Opex_a_fixed_Boiler_USD # TODO:variable price? # 1: Boiler BG Capex_total_USD[1][0] = Capex_Boiler_USD Capex_a_USD[1][0] = Capex_a_Boiler_USD Opex_a_fixed_USD[1][0] = Opex_a_fixed_Boiler_USD Capex_opex_a_fixed_only_USD[1][0] = Capex_a_Boiler_USD + Opex_a_fixed_Boiler_USD # TODO:variable price? # 2: Fuel Cell Capex_a_FC_USD, Opex_fixed_FC_USD, Capex_FC_USD = FC.calc_Cinv_FC(Qnom_W, locator, config) Capex_total_USD[2][0] = Capex_FC_USD Capex_a_USD[2][0] = Capex_a_FC_USD Opex_a_fixed_USD[2][0] = Opex_fixed_FC_USD Capex_opex_a_fixed_only_USD[2][0] = Capex_a_FC_USD + Opex_fixed_FC_USD # TODO:variable price? # 3-13: BOILER + GHP for i in range(10): Opex_a_var_USD[3 + i][0] = i / 10.0 # Boiler share Opex_a_var_USD[3 + i][3] = 1 - i / 10.0 # GHP share # Get boiler costs QnomBoiler_W = i / 10.0 * Qnom_W Capex_a_Boiler_USD, Opex_a_fixed_Boiler_USD, Capex_Boiler_USD = Boiler.calc_Cinv_boiler(QnomBoiler_W, locator, config, 'BO1') Capex_total_USD[3 + i][0] += Capex_Boiler_USD Capex_a_USD[3 + i][0] += Capex_a_Boiler_USD Opex_a_fixed_USD[3 + i][0] += Opex_a_fixed_Boiler_USD Capex_opex_a_fixed_only_USD[3 + i][ 0] += Capex_a_Boiler_USD + Opex_a_fixed_Boiler_USD # TODO:variable price? # Get back up boiler costs Qnom_Backup_Boiler_W = Q_Boiler_for_GHP_W[i][0] Capex_a_GHPBoiler_USD, Opex_a_fixed_GHPBoiler_USD, Capex_GHPBoiler_USD = Boiler.calc_Cinv_boiler( Qnom_Backup_Boiler_W, locator, config, 'BO1') Capex_total_USD[3 + i][0] += Capex_GHPBoiler_USD Capex_a_USD[3 + i][0] += Capex_a_GHPBoiler_USD Opex_a_fixed_USD[3 + i][0] += Opex_a_fixed_GHPBoiler_USD Capex_opex_a_fixed_only_USD[3 + i][ 0] += Capex_a_GHPBoiler_USD + Opex_a_fixed_GHPBoiler_USD # TODO:variable price? # Get ground source heat pump costs Capex_a_GHP_USD, Opex_a_fixed_GHP_USD, Capex_GHP_USD = HP.calc_Cinv_GHP(GHP_el_size_W[i][0], locator, config) Capex_total_USD[3 + i][0] += Capex_GHP_USD Capex_a_USD[3 + i][0] += Capex_a_GHP_USD Opex_a_fixed_USD[3 + i][0] += Opex_a_fixed_GHP_USD Capex_opex_a_fixed_only_USD[3 + i][0] += Capex_a_GHP_USD + Opex_a_fixed_GHP_USD # TODO:variable price? # Best configuration Best = np.zeros((13, 1)) indexBest = 0 TAC_USD = np.zeros((13, 2)) TotalCO2 = np.zeros((13, 2)) TotalPrim = np.zeros((13, 2)) for i in range(13): TAC_USD[i][0] = TotalCO2[i][0] = TotalPrim[i][0] = i Opex_a_USD[i][1] = Opex_a_fixed_USD[i][0] + + Opex_a_var_USD[i][4] TAC_USD[i][1] = Capex_opex_a_fixed_only_USD[i][0] + Opex_a_var_USD[i][4] TotalCO2[i][1] = GHG_tonCO2[i][5] TotalPrim[i][1] = PEN_MJoil[i][6] CostsS = TAC_USD[np.argsort(TAC_USD[:, 1])] CO2S = TotalCO2[np.argsort(TotalCO2[:, 1])] PrimS = TotalPrim[np.argsort(TotalPrim[:, 1])] el = len(CostsS) rank = 0 Bestfound = False optsearch = np.empty(el) optsearch.fill(3) indexBest = 0 geothermal_potential = geothermal_potential_data.set_index('Name') # Check the GHP area constraint for i in range(10): QGHP = (1 - i / 10.0) * Qnom_W areaAvail = geothermal_potential.ix[building_name, 'Area_geo'] Qallowed = np.ceil(areaAvail / GHP_A) * GHP_HMAX_SIZE # [W_th] if Qallowed < QGHP: optsearch[i + 3] += 1 Best[i + 3][0] = - 1 while not Bestfound and rank < el: optsearch[int(CostsS[rank][0])] -= 1 optsearch[int(CO2S[rank][0])] -= 1 optsearch[int(PrimS[rank][0])] -= 1 if np.count_nonzero(optsearch) != el: Bestfound = True indexBest = np.where(optsearch == 0)[0][0] rank += 1 # get the best option according to the ranking. Best[indexBest][0] = 1 # Save results in csv file performance_results = { "Nominal heating load": Qnom_W, "Capacity_BaseBoiler_NG_W": Qnom_W * Opex_a_var_USD[:, 0], "Capacity_FC_NG_W": Qnom_W * Opex_a_var_USD[:, 2], "Capacity_GS_HP_W": Qnom_W * Opex_a_var_USD[:, 3], "TAC_USD": TAC_USD[:, 1], "Capex_a_USD": Capex_a_USD[:, 0], "Capex_total_USD": Capex_total_USD[:, 0], "Opex_fixed_USD": Opex_a_fixed_USD[:, 0], "Opex_var_USD": Opex_a_var_USD[:, 4], "GHG_tonCO2": GHG_tonCO2[:, 5], "PEN_MJoil": PEN_MJoil[:, 6], "Best configuration": Best[:, 0]} results_to_csv = pd.DataFrame(performance_results) fName_result = locator.get_optimization_decentralized_folder_building_result_heating(building_name) results_to_csv.to_csv(fName_result, sep=',') # save activation for the best supply system configuration best_activation_df = pd.DataFrame.from_dict(heating_dispatch[indexBest]) # best_activation_df.to_csv( locator.get_optimization_decentralized_folder_building_result_heating_activation(building_name)) print time.clock() - t0, "seconds process time for the Disconnected Building Routine \n"