def calc_electricity_performance_costs(locator, E_GRID_directload_W,
master_to_slave_vars):
# PV COSTS
Capacity_PV_district_scale_m2 = master_to_slave_vars.A_PV_m2
Capex_a_PV_USD, \
Opex_fixed_PV_USD, \
Capex_PV_USD, \
Capacity_PV_district_scale_W = pv.calc_Cinv_pv(Capacity_PV_district_scale_m2, locator)
capacity_installed = {
"Capacity_PV_el_district_scale_W": Capacity_PV_district_scale_W,
"Capacity_GRID_el_district_scale_W": E_GRID_directload_W.max(),
"Capacity_PV_el_district_scale_m2": Capacity_PV_district_scale_m2
}
performance_electricity_costs = {
"Capex_a_PV_district_scale_USD": Capex_a_PV_USD,
"Capex_a_GRID_district_scale_USD": 0.0,
# total_capex
"Capex_total_PV_district_scale_USD": Capex_PV_USD,
"Capex_total_GRID_district_scale_USD": 0.0,
# opex fixed costs
"Opex_fixed_PV_district_scale_USD": Opex_fixed_PV_USD,
"Opex_fixed_GRID_district_scale_USD": 0.0,
}
return performance_electricity_costs, capacity_installed
def calc_pv_costs(building, config, locator):
pv_installed_building = pd.read_csv(
locator.PV_results(building))[['E_PV_gen_kWh', 'Area_PV_m2']]
pv_installed_area = pv_installed_building['Area_PV_m2'].max()
pv_annual_production_kWh = pv_installed_building['E_PV_gen_kWh'].sum()
Capex_a_PV, Opex_a_fixed_PV = calc_Cinv_pv(pv_installed_area, locator,
config)
Opex_a_PV = calc_opex_PV(pv_annual_production_kWh,
pv_installed_area) + Opex_a_fixed_PV
return Capex_a_PV, Opex_a_PV, pv_installed_area
def calc_electricity_performance_costs(locator, master_to_slave_vars):
# PV COSTS
PV_installed_area_m2 = master_to_slave_vars.A_PV_m2 # kW
Capex_a_PV_USD, Opex_fixed_PV_USD, Capex_PV_USD = pv.calc_Cinv_pv(
PV_installed_area_m2, locator)
performance_electricity_costs = {
"Capex_a_PV_connected_USD": Capex_a_PV_USD,
"Capex_a_GRID_connected_USD": 0.0,
# total_capex
"Capex_total_PV_connected_USD": Capex_PV_USD,
"Capex_total_GRID_connected_USD": 0.0,
# opex fixed costs
"Opex_fixed_PV_connected_USD": Opex_fixed_PV_USD,
"Opex_fixed_GRID_connected_USD": 0.0,
}
return performance_electricity_costs
def preprocessing_cost_data(locator, data_raw, individual, generations,
data_address, config):
string_network = data_raw['network'].loc[individual].values[0]
total_demand = pd.read_csv(locator.get_total_demand())
building_names = total_demand.Name.values
individual_barcode_list = data_raw['individual_barcode'].loc[
individual].values[0]
# The current structure of CEA has the following columns saved, in future, this will be slightly changed and
# correspondingly these columns_of_saved_files needs to be changed
columns_of_saved_files = [
'CHP/Furnace', 'CHP/Furnace Share', 'Base Boiler', 'Base Boiler Share',
'Peak Boiler', 'Peak Boiler Share', 'Heating Lake',
'Heating Lake Share', 'Heating Sewage', 'Heating Sewage Share', 'GHP',
'GHP Share', 'Data Centre', 'Compressed Air', 'PV', 'PV Area Share',
'PVT', 'PVT Area Share', 'SC_ET', 'SC_ET Area Share', 'SC_FP',
'SC_FP Area Share', 'DHN Temperature', 'DHN unit configuration',
'Lake Cooling', 'Lake Cooling Share', 'VCC Cooling',
'VCC Cooling Share', 'Absorption Chiller', 'Absorption Chiller Share',
'Storage', 'Storage Share', 'DCN Temperature', 'DCN unit configuration'
]
for i in building_names: # DHN
columns_of_saved_files.append(str(i) + ' DHN')
for i in building_names: # DCN
columns_of_saved_files.append(str(i) + ' DCN')
df_current_individual = pd.DataFrame(
np.zeros(shape=(1, len(columns_of_saved_files))),
columns=columns_of_saved_files)
for i, ind in enumerate((columns_of_saved_files)):
df_current_individual[ind] = individual_barcode_list[i]
data_address = data_address[data_address['individual_list'] == individual]
generation_number = data_address['generation_number_address'].values[0]
individual_number = data_address['individual_number_address'].values[0]
# get data about the activation patterns of these buildings (main units)
if config.multi_criteria.network_type == 'DH':
building_demands_df = pd.read_csv(
locator.get_optimization_network_results_summary(
string_network)).set_index("DATE")
data_activation_path = os.path.join(
locator.get_optimization_slave_heating_activation_pattern(
individual_number, generation_number))
df_heating = pd.read_csv(data_activation_path).set_index("DATE")
data_activation_path = os.path.join(
locator.
get_optimization_slave_electricity_activation_pattern_heating(
individual_number, generation_number))
df_electricity = pd.read_csv(data_activation_path).set_index("DATE")
# get data about the activation patterns of these buildings (storage)
data_storage_path = os.path.join(
locator.get_optimization_slave_storage_operation_data(
individual_number, generation_number))
df_SO = pd.read_csv(data_storage_path).set_index("DATE")
# join into one database
data_processed = df_heating.join(df_electricity).join(df_SO).join(
building_demands_df)
elif config.multi_criteria.network_type == 'DC':
data_costs = pd.read_csv(
os.path.join(
locator.
get_optimization_slave_investment_cost_detailed_cooling(
individual_number, generation_number)))
data_cooling = pd.read_csv(
os.path.join(
locator.get_optimization_slave_cooling_activation_pattern(
individual_number, generation_number)))
data_electricity = pd.read_csv(
os.path.join(
locator.
get_optimization_slave_electricity_activation_pattern_cooling(
individual_number, generation_number)))
# Total CAPEX calculations
# Absorption Chiller
Absorption_chiller_cost_data = pd.read_excel(
locator.get_supply_systems(config.region),
sheetname="Absorption_chiller",
usecols=[
'type', 'code', 'cap_min', 'cap_max', 'a', 'b', 'c', 'd', 'e',
'IR_%', 'LT_yr', 'O&M_%'
])
Absorption_chiller_cost_data = Absorption_chiller_cost_data[
Absorption_chiller_cost_data['type'] == 'double']
max_ACH_chiller_size = max(
Absorption_chiller_cost_data['cap_max'].values)
Inv_IR = (Absorption_chiller_cost_data.iloc[0]['IR_%']) / 100
Inv_LT = Absorption_chiller_cost_data.iloc[0]['LT_yr']
Q_ACH_max_W = data_cooling['Q_from_ACH_W'].max()
Q_ACH_max_W = Q_ACH_max_W * (1 + SIZING_MARGIN)
number_of_ACH_chillers = max(
int(ceil(Q_ACH_max_W / max_ACH_chiller_size)), 1)
Q_nom_ACH_W = Q_ACH_max_W / number_of_ACH_chillers
Capex_a_ACH, Opex_fixed_ACH = calc_Cinv(Q_nom_ACH_W, locator, 'double',
config)
Capex_total_ACH = (Capex_a_ACH * ((1 + Inv_IR)**Inv_LT - 1) /
(Inv_IR) *
(1 + Inv_IR)**Inv_LT) * number_of_ACH_chillers
data_costs['Capex_total_ACH'] = Capex_total_ACH
data_costs['Opex_total_ACH'] = np.sum(
data_cooling['Opex_var_ACH']) + data_costs['Opex_fixed_ACH']
# VCC
VCC_cost_data = pd.read_excel(locator.get_supply_systems(
config.region),
sheetname="Chiller")
VCC_cost_data = VCC_cost_data[VCC_cost_data['code'] == 'CH3']
max_VCC_chiller_size = max(VCC_cost_data['cap_max'].values)
Inv_IR = (VCC_cost_data.iloc[0]['IR_%']) / 100
Inv_LT = VCC_cost_data.iloc[0]['LT_yr']
Q_VCC_max_W = data_cooling['Q_from_VCC_W'].max()
Q_VCC_max_W = Q_VCC_max_W * (1 + SIZING_MARGIN)
number_of_VCC_chillers = max(
int(ceil(Q_VCC_max_W / max_VCC_chiller_size)), 1)
Q_nom_VCC_W = Q_VCC_max_W / number_of_VCC_chillers
Capex_a_VCC, Opex_fixed_VCC = calc_Cinv_VCC(Q_nom_VCC_W, locator,
config, 'CH3')
Capex_total_VCC = (Capex_a_VCC * ((1 + Inv_IR)**Inv_LT - 1) /
(Inv_IR) *
(1 + Inv_IR)**Inv_LT) * number_of_VCC_chillers
data_costs['Capex_total_VCC'] = Capex_total_VCC
data_costs['Opex_total_VCC'] = np.sum(
data_cooling['Opex_var_VCC']) + data_costs['Opex_fixed_VCC']
# VCC Backup
Q_VCC_backup_max_W = data_cooling['Q_from_VCC_backup_W'].max()
Q_VCC_backup_max_W = Q_VCC_backup_max_W * (1 + SIZING_MARGIN)
number_of_VCC_backup_chillers = max(
int(ceil(Q_VCC_backup_max_W / max_VCC_chiller_size)), 1)
Q_nom_VCC_backup_W = Q_VCC_backup_max_W / number_of_VCC_backup_chillers
Capex_a_VCC_backup, Opex_fixed_VCC_backup = calc_Cinv_VCC(
Q_nom_VCC_backup_W, locator, config, 'CH3')
Capex_total_VCC_backup = (
Capex_a_VCC_backup * ((1 + Inv_IR)**Inv_LT - 1) / (Inv_IR) *
(1 + Inv_IR)**Inv_LT) * number_of_VCC_backup_chillers
data_costs['Capex_total_VCC_backup'] = Capex_total_VCC_backup
data_costs['Opex_total_VCC_backup'] = np.sum(
data_cooling['Opex_var_VCC_backup']
) + data_costs['Opex_fixed_VCC_backup']
# Storage Tank
storage_cost_data = pd.read_excel(locator.get_supply_systems(
config.region),
sheetname="TES")
storage_cost_data = storage_cost_data[storage_cost_data['code'] ==
'TES2']
Inv_IR = (storage_cost_data.iloc[0]['IR_%']) / 100
Inv_LT = storage_cost_data.iloc[0]['LT_yr']
Capex_a_storage_tank = data_costs['Capex_a_Tank'][0]
Capex_total_storage_tank = (Capex_a_storage_tank *
((1 + Inv_IR)**Inv_LT - 1) / (Inv_IR) *
(1 + Inv_IR)**Inv_LT)
data_costs['Capex_total_storage_tank'] = Capex_total_storage_tank
data_costs['Opex_total_storage_tank'] = np.sum(
data_cooling['Opex_var_VCC_backup']
) + data_costs['Opex_fixed_Tank']
# Cooling Tower
CT_cost_data = pd.read_excel(locator.get_supply_systems(config.region),
sheetname="CT")
CT_cost_data = CT_cost_data[CT_cost_data['code'] == 'CT1']
max_CT_size = max(CT_cost_data['cap_max'].values)
Inv_IR = (CT_cost_data.iloc[0]['IR_%']) / 100
Inv_LT = CT_cost_data.iloc[0]['LT_yr']
Qc_CT_max_W = data_cooling['Qc_CT_associated_with_all_chillers_W'].max(
)
number_of_CT = max(int(ceil(Qc_CT_max_W / max_CT_size)), 1)
Qnom_CT_W = Qc_CT_max_W / number_of_CT
Capex_a_CT, Opex_fixed_CT = calc_Cinv_CT(Qnom_CT_W, locator, config,
'CT1')
Capex_total_CT = (Capex_a_CT * ((1 + Inv_IR)**Inv_LT - 1) / (Inv_IR) *
(1 + Inv_IR)**Inv_LT) * number_of_CT
data_costs['Capex_total_CT'] = Capex_total_CT
data_costs['Opex_total_CT'] = np.sum(
data_cooling['Opex_var_CT']) + data_costs['Opex_fixed_CT']
# CCGT
CCGT_cost_data = pd.read_excel(locator.get_supply_systems(
config.region),
sheetname="CCGT")
technology_code = list(set(CCGT_cost_data['code']))
CCGT_cost_data = CCGT_cost_data[CCGT_cost_data['code'] ==
technology_code[0]]
Inv_IR = (CCGT_cost_data.iloc[0]['IR_%']) / 100
Inv_LT = CCGT_cost_data.iloc[0]['LT_yr']
Capex_a_CCGT = data_costs['Capex_a_CCGT'][0]
Capex_total_CCGT = (Capex_a_CCGT * ((1 + Inv_IR)**Inv_LT - 1) /
(Inv_IR) * (1 + Inv_IR)**Inv_LT)
data_costs['Capex_total_CCGT'] = Capex_total_CCGT
data_costs['Opex_total_CCGT'] = np.sum(
data_cooling['Opex_var_CCGT']) + data_costs['Opex_fixed_CCGT']
# pump
config.restricted_to = None # FIXME: remove this later
config.thermal_network.network_type = config.multi_criteria.network_type
config.thermal_network.network_names = []
network_features = network_opt.network_opt_main(config, locator)
DCN_barcode = ""
for name in building_names:
DCN_barcode += str(df_current_individual[name + ' DCN'][0])
if df_current_individual['Data Centre'][0] == 1:
df = pd.read_csv(
locator.get_optimization_network_data_folder(
"Network_summary_result_" + hex(int(str(DCN_barcode), 2)) +
".csv"),
usecols=[
"mdot_cool_space_cooling_and_refrigeration_netw_all_kgpers"
])
else:
df = pd.read_csv(
locator.get_optimization_network_data_folder(
"Network_summary_result_" + hex(int(str(DCN_barcode), 2)) +
".csv"),
usecols=[
"mdot_cool_space_cooling_data_center_and_refrigeration_netw_all_kgpers"
])
mdotA_kgpers = np.array(df)
mdotnMax_kgpers = np.amax(mdotA_kgpers)
deltaPmax = np.max((network_features.DeltaP_DCN) *
DCN_barcode.count("1") / len(DCN_barcode))
E_pumping_required_W = mdotnMax_kgpers * deltaPmax / DENSITY_OF_WATER_AT_60_DEGREES_KGPERM3
P_motor_tot_W = E_pumping_required_W / PUMP_ETA # electricty to run the motor
Pump_max_kW = 375.0
Pump_min_kW = 0.5
nPumps = int(np.ceil(P_motor_tot_W / 1000.0 / Pump_max_kW))
# if the nominal load (electric) > 375kW, a new pump is installed
Pump_Array_W = np.zeros((nPumps))
Pump_Remain_W = P_motor_tot_W
Capex_total_pumps = 0
Capex_a_total_pumps = 0
for pump_i in range(nPumps):
# calculate pump nominal capacity
Pump_Array_W[pump_i] = min(Pump_Remain_W, Pump_max_kW * 1000)
if Pump_Array_W[pump_i] < Pump_min_kW * 1000:
Pump_Array_W[pump_i] = Pump_min_kW * 1000
Pump_Remain_W -= Pump_Array_W[pump_i]
pump_cost_data = pd.read_excel(locator.get_supply_systems(
config.region),
sheetname="Pump")
pump_cost_data = pump_cost_data[pump_cost_data['code'] == 'PU1']
# if the Q_design is below the lowest capacity available for the technology, then it is replaced by the least
# capacity for the corresponding technology from the database
if Pump_Array_W[pump_i] < pump_cost_data.iloc[0]['cap_min']:
Pump_Array_W[pump_i] = pump_cost_data.iloc[0]['cap_min']
pump_cost_data = pump_cost_data[
(pump_cost_data['cap_min'] <= Pump_Array_W[pump_i])
& (pump_cost_data['cap_max'] > Pump_Array_W[pump_i])]
Inv_a = pump_cost_data.iloc[0]['a']
Inv_b = pump_cost_data.iloc[0]['b']
Inv_c = pump_cost_data.iloc[0]['c']
Inv_d = pump_cost_data.iloc[0]['d']
Inv_e = pump_cost_data.iloc[0]['e']
Inv_IR = (pump_cost_data.iloc[0]['IR_%']) / 100
Inv_LT = pump_cost_data.iloc[0]['LT_yr']
Inv_OM = pump_cost_data.iloc[0]['O&M_%'] / 100
InvC = Inv_a + Inv_b * (Pump_Array_W[pump_i])**Inv_c + (
Inv_d + Inv_e * Pump_Array_W[pump_i]) * log(
Pump_Array_W[pump_i])
Capex_total_pumps += InvC
Capex_a_total_pumps += InvC * (Inv_IR) * (1 + Inv_IR)**Inv_LT / (
(1 + Inv_IR)**Inv_LT - 1)
data_costs['Capex_total_pumps'] = Capex_total_pumps
data_costs['Opex_total_pumps'] = data_costs[
'Opex_fixed_pump'] + data_costs['Opex_fixed_pump']
# PV
pv_installed_area = data_electricity['Area_PV_m2'].max()
Capex_a_PV, Opex_fixed_PV = calc_Cinv_pv(pv_installed_area, locator,
config)
pv_annual_production_kWh = (data_electricity['E_PV_W'].sum()) / 1000
Opex_a_PV = calc_opex_PV(pv_annual_production_kWh, pv_installed_area)
PV_cost_data = pd.read_excel(locator.get_supply_systems(config.region),
sheetname="PV")
technology_code = list(set(PV_cost_data['code']))
PV_cost_data[PV_cost_data['code'] == technology_code[0]]
Inv_IR = (PV_cost_data.iloc[0]['IR_%']) / 100
Inv_LT = PV_cost_data.iloc[0]['LT_yr']
Capex_total_PV = (Capex_a_PV * ((1 + Inv_IR)**Inv_LT - 1) / (Inv_IR) *
(1 + Inv_IR)**Inv_LT)
data_costs['Capex_total_PV'] = Capex_total_PV
data_costs['Opex_total_PV'] = Opex_a_PV + Opex_fixed_PV
# Disconnected Buildings
Capex_total_disconnected = 0
Opex_total_disconnected = 0
Capex_a_total_disconnected = 0
for (index, building_name) in zip(DCN_barcode, building_names):
if index is '0':
df = pd.read_csv(
locator.
get_optimization_disconnected_folder_building_result_cooling(
building_name, configuration='AHU_ARU_SCU'))
dfBest = df[df["Best configuration"] == 1]
if dfBest['VCC to AHU_ARU_SCU Share'].iloc[
0] == 1: #FIXME: Check for other options
Inv_IR = (VCC_cost_data.iloc[0]['IR_%']) / 100
Inv_LT = VCC_cost_data.iloc[0]['LT_yr']
if dfBest['single effect ACH to AHU_ARU_SCU Share (FP)'].iloc[
0] == 1:
Inv_IR = (
Absorption_chiller_cost_data.iloc[0]['IR_%']) / 100
Inv_LT = Absorption_chiller_cost_data.iloc[0]['LT_yr']
Opex_total_disconnected += dfBest[
"Operation Costs [CHF]"].iloc[0]
Capex_a_total_disconnected += dfBest[
"Annualized Investment Costs [CHF]"].iloc[0]
Capex_total_disconnected += (
dfBest["Annualized Investment Costs [CHF]"].iloc[0] *
((1 + Inv_IR)**Inv_LT - 1) / (Inv_IR) *
(1 + Inv_IR)**Inv_LT)
data_costs[
'Capex_total_disconnected_Mio'] = Capex_total_disconnected / 1000000
data_costs[
'Opex_total_disconnected_Mio'] = Opex_total_disconnected / 1000000
data_costs[
'Capex_a_disconnected_Mio'] = Capex_a_total_disconnected / 1000000
data_costs['costs_Mio'] = data_raw['population']['costs_Mio'][
individual]
data_costs['emissions_kiloton'] = data_raw['population'][
'emissions_kiloton'][individual]
data_costs['prim_energy_TJ'] = data_raw['population'][
'prim_energy_TJ'][individual]
# Electricity Details/Renewable Share
total_electricity_demand_decentralized_W = np.zeros(8760)
DCN_barcode = ""
for name in building_names: # identifying the DCN code
DCN_barcode += str(
int(df_current_individual[name + ' DCN'].values[0]))
for i, name in zip(
DCN_barcode, building_names
): # adding the electricity demand from the decentralized buildings
if i is '0':
building_demand = pd.read_csv(
locator.get_demand_results_folder() + '//' + name + ".csv",
usecols=['E_sys_kWh'])
total_electricity_demand_decentralized_W += building_demand[
'E_sys_kWh'] * 1000
lca = lca_calculations(locator, config)
data_electricity_processed = electricity_import_and_exports(
generation_number, individual_number, locator, config)
data_costs['Network_electricity_demand_GW'] = (
data_electricity['E_total_req_W'].sum()) / 1000000000 # GW
data_costs['Decentralized_electricity_demand_GW'] = (
data_electricity_processed['E_decentralized_appliances_W'].sum()
) / 1000000000 # GW
data_costs['Total_electricity_demand_GW'] = (
data_electricity_processed['E_total_req_W'].sum()
) / 1000000000 # GW
renewable_share_electricity = (data_electricity_processed['E_PV_to_directload_W'].sum() +
data_electricity_processed['E_PV_to_grid_W'].sum()) * 100 / \
(data_costs['Total_electricity_demand_GW'] * 1000000000)
data_costs['renewable_share_electricity'] = renewable_share_electricity
data_costs['Electricity_Costs_Mio'] = (
(data_electricity_processed['E_from_grid_W'].sum() +
data_electricity_processed['E_total_to_grid_W_negative'].sum()) *
lca.ELEC_PRICE) / 1000000
data_costs['Capex_a_total_Mio'] = (Capex_a_ACH * number_of_ACH_chillers + Capex_a_VCC * number_of_VCC_chillers + \
Capex_a_VCC_backup * number_of_VCC_backup_chillers + Capex_a_CT * number_of_CT + Capex_a_storage_tank + \
Capex_a_total_pumps + Capex_a_CCGT + Capex_a_PV + Capex_a_total_disconnected) / 1000000
data_costs['Capex_a_ACH'] = Capex_a_ACH * number_of_ACH_chillers
data_costs['Capex_a_VCC'] = Capex_a_VCC * number_of_VCC_chillers
data_costs[
'Capex_a_VCC_backup'] = Capex_a_VCC_backup * number_of_VCC_backup_chillers
data_costs['Capex_a_CT'] = Capex_a_CT * number_of_CT
data_costs['Capex_a_storage_tank'] = Capex_a_storage_tank
data_costs['Capex_a_total_pumps'] = Capex_a_total_pumps
data_costs['Capex_a_CCGT'] = Capex_a_CCGT
data_costs['Capex_a_PV'] = Capex_a_PV
data_costs['Capex_total_Mio'] = (data_costs['Capex_total_ACH'] + data_costs['Capex_total_VCC'] + data_costs['Capex_total_VCC_backup'] + \
data_costs['Capex_total_storage_tank'] + data_costs['Capex_total_CT'] + data_costs['Capex_total_CCGT'] + \
data_costs['Capex_total_pumps'] + data_costs['Capex_total_PV'] + Capex_total_disconnected) / 1000000
data_costs['Opex_total_Mio'] = ((data_costs['Opex_total_ACH'] + data_costs['Opex_total_VCC'] + data_costs['Opex_total_VCC_backup'] + \
data_costs['Opex_total_storage_tank'] + data_costs['Opex_total_CT'] + data_costs['Opex_total_CCGT'] + \
data_costs['Opex_total_pumps'] + Opex_total_disconnected) / 1000000) + data_costs['Electricity_Costs_Mio']
data_costs['TAC_Mio'] = data_costs['Capex_a_total_Mio'] + data_costs[
'Opex_total_Mio']
return data_costs
def preprocessing_final_generation_data_cost_centralized(self, locator, data_raw, config, data_address):
total_demand = pd.read_csv(locator.get_total_demand())
building_names = total_demand.Name.values
df_all_generations = pd.read_csv(locator.get_optimization_all_individuals())
preprocessing_costs = pd.read_csv(locator.get_preprocessing_costs())
# The current structure of CEA has the following columns saved, in future, this will be slightly changed and
# correspondingly these columns_of_saved_files needs to be changed
columns_of_saved_files = ['CHP/Furnace', 'CHP/Furnace Share', 'Base Boiler',
'Base Boiler Share', 'Peak Boiler', 'Peak Boiler Share',
'Heating Lake', 'Heating Lake Share', 'Heating Sewage', 'Heating Sewage Share', 'GHP',
'GHP Share',
'Data Centre', 'Compressed Air', 'PV', 'PV Area Share', 'PVT', 'PVT Area Share', 'SC_ET',
'SC_ET Area Share', 'SC_FP', 'SC_FP Area Share', 'DHN Temperature', 'DHN unit configuration',
'Lake Cooling', 'Lake Cooling Share', 'VCC Cooling', 'VCC Cooling Share',
'Absorption Chiller', 'Absorption Chiller Share', 'Storage', 'Storage Share',
'DCN Temperature', 'DCN unit configuration']
for i in building_names: # DHN
columns_of_saved_files.append(str(i) + ' DHN')
for i in building_names: # DCN
columns_of_saved_files.append(str(i) + ' DCN')
individual_index = data_raw['individual_barcode'].index.values
if config.plots_optimization.network_type == 'DH':
data_activation_path = os.path.join(
locator.get_optimization_slave_investment_cost_detailed(1, 1))
df_heating_costs = pd.read_csv(data_activation_path)
column_names = df_heating_costs.columns.values
column_names = np.append(column_names, ['Opex_HP_Sewage', 'Opex_HP_Lake', 'Opex_GHP', 'Opex_CHP_BG',
'Opex_CHP_NG', 'Opex_Furnace_wet', 'Opex_Furnace_dry',
'Opex_BaseBoiler_BG', 'Opex_BaseBoiler_NG', 'Opex_PeakBoiler_BG',
'Opex_PeakBoiler_NG', 'Opex_BackupBoiler_BG', 'Opex_BackupBoiler_NG',
'Capex_SC', 'Capex_PVT', 'Capex_Boiler_backup', 'Capex_storage_HEX',
'Capex_furnace', 'Capex_Boiler', 'Capex_Boiler_peak', 'Capex_Lake', 'Capex_CHP',
'Capex_Sewage', 'Capex_pump', 'Opex_Total', 'Capex_Total', 'Capex_Boiler_Total',
'Opex_Boiler_Total', 'Opex_CHP_Total', 'Opex_Furnace_Total', 'Disconnected_costs',
'Capex_Decentralized', 'Opex_Decentralized', 'Capex_Centralized', 'Opex_Centralized', 'Electricity_Costs', 'Process_Heat_Costs'])
data_processed = pd.DataFrame(np.zeros([len(data_raw['individual_barcode']), len(column_names)]), columns=column_names)
elif config.plots_optimization.network_type == 'DC':
data_activation_path = os.path.join(
locator.get_optimization_slave_investment_cost_detailed_cooling(1, 1))
df_cooling_costs = pd.read_csv(data_activation_path)
column_names = df_cooling_costs.columns.values
column_names = np.append(column_names,
['Opex_var_ACH', 'Opex_var_CCGT', 'Opex_var_CT', 'Opex_var_Lake', 'Opex_var_VCC', 'Opex_var_PV',
'Opex_var_VCC_backup', 'Capex_ACH', 'Capex_CCGT', 'Capex_CT', 'Capex_Tank', 'Capex_VCC', 'Capex_a_PV',
'Capex_VCC_backup', 'Capex_a_pump', 'Opex_Total', 'Capex_Total', 'Opex_var_pumps', 'Disconnected_costs',
'Capex_Decentralized', 'Opex_Decentralized', 'Capex_Centralized', 'Opex_Centralized', 'Electricitycosts_for_appliances',
'Process_Heat_Costs', 'Electricitycosts_for_hotwater'])
data_processed = pd.DataFrame(np.zeros([len(data_raw['individual_barcode']), len(column_names)]), columns=column_names)
for individual_code in range(len(data_raw['individual_barcode'])):
individual_barcode_list = data_raw['individual_barcode'].loc[individual_index[individual_code]].values[0]
df_current_individual = pd.DataFrame(np.zeros(shape = (1, len(columns_of_saved_files))), columns=columns_of_saved_files)
for i, ind in enumerate((columns_of_saved_files)):
df_current_individual[ind] = individual_barcode_list[i]
data_address_individual = data_address[data_address['individual_list'] == individual_index[individual_code]]
generation_pointer = data_address_individual['generation_number_address'].values[0] # points to the correct file to be referenced from optimization folders
individual_pointer = data_address_individual['individual_number_address'].values[0]
if config.plots_optimization.network_type == 'DH':
data_activation_path = os.path.join(
locator.get_optimization_slave_investment_cost_detailed(individual_pointer, generation_pointer))
df_heating_costs = pd.read_csv(data_activation_path)
data_activation_path = os.path.join(
locator.get_optimization_slave_heating_activation_pattern(individual_pointer, generation_pointer))
df_heating = pd.read_csv(data_activation_path).set_index("DATE")
for column_name in df_heating_costs.columns.values:
data_processed.loc[individual_code][column_name] = df_heating_costs[column_name].values
data_processed.loc[individual_code]['Opex_HP_Sewage'] = np.sum(df_heating['Opex_var_HP_Sewage'])
data_processed.loc[individual_code]['Opex_HP_Lake'] = np.sum(df_heating['Opex_var_HP_Lake'])
data_processed.loc[individual_code]['Opex_GHP'] = np.sum(df_heating['Opex_var_GHP'])
data_processed.loc[individual_code]['Opex_CHP_BG'] = np.sum(df_heating['Opex_var_CHP_BG'])
data_processed.loc[individual_code]['Opex_CHP_NG'] = np.sum(df_heating['Opex_var_CHP_NG'])
data_processed.loc[individual_code]['Opex_Furnace_wet'] = np.sum(df_heating['Opex_var_Furnace_wet'])
data_processed.loc[individual_code]['Opex_Furnace_dry'] = np.sum(df_heating['Opex_var_Furnace_dry'])
data_processed.loc[individual_code]['Opex_BaseBoiler_BG'] = np.sum(df_heating['Opex_var_BaseBoiler_BG'])
data_processed.loc[individual_code]['Opex_BaseBoiler_NG'] = np.sum(df_heating['Opex_var_BaseBoiler_NG'])
data_processed.loc[individual_code]['Opex_PeakBoiler_BG'] = np.sum(df_heating['Opex_var_PeakBoiler_BG'])
data_processed.loc[individual_code]['Opex_PeakBoiler_NG'] = np.sum(df_heating['Opex_var_PeakBoiler_NG'])
data_processed.loc[individual_code]['Opex_BackupBoiler_BG'] = np.sum(df_heating['Opex_var_BackupBoiler_BG'])
data_processed.loc[individual_code]['Opex_BackupBoiler_NG'] = np.sum(df_heating['Opex_var_BackupBoiler_NG'])
data_processed.loc[individual_code]['Capex_SC'] = data_processed.loc[individual_code]['Capex_a_SC'] + data_processed.loc[individual_code]['Opex_fixed_SC']
data_processed.loc[individual_code]['Capex_PVT'] = data_processed.loc[individual_code]['Capex_a_PVT'] + data_processed.loc[individual_code]['Opex_fixed_PVT']
data_processed.loc[individual_code]['Capex_Boiler_backup'] = data_processed.loc[individual_code]['Capex_a_Boiler_backup']+ data_processed.loc[individual_code]['Opex_fixed_Boiler_backup']
data_processed.loc[individual_code]['Capex_storage_HEX'] = data_processed.loc[individual_code]['Capex_a_storage_HEX'] + data_processed.loc[individual_code]['Opex_fixed_storage_HEX']
data_processed.loc[individual_code]['Capex_furnace'] = data_processed.loc[individual_code]['Capex_a_furnace']+ data_processed.loc[individual_code]['Opex_fixed_furnace']
data_processed.loc[individual_code]['Capex_Boiler'] = data_processed.loc[individual_code]['Capex_a_Boiler'] + data_processed.loc[individual_code]['Opex_fixed_Boiler']
data_processed.loc[individual_code]['Capex_Boiler_peak'] = data_processed.loc[individual_code]['Capex_a_Boiler_peak']+ data_processed.loc[individual_code]['Opex_fixed_Boiler_peak']
data_processed.loc[individual_code]['Capex_Lake'] = data_processed.loc[individual_code]['Capex_a_Lake']+ data_processed.loc[individual_code]['Opex_fixed_Lake']
data_processed.loc[individual_code]['Capex_Sewage'] = data_processed.loc[individual_code]['Capex_a_Sewage'] + data_processed.loc[individual_code]['Opex_fixed_Boiler']
data_processed.loc[individual_code]['Capex_pump'] = data_processed.loc[individual_code]['Capex_a_pump'] + data_processed.loc[individual_code]['Opex_fixed_pump']
data_processed.loc[individual_code]['Capex_CHP'] = data_processed.loc[individual_code]['Capex_a_CHP'] + data_processed.loc[individual_code]['Opex_fixed_CHP']
data_processed.loc[individual_code]['Disconnected_costs'] = df_heating_costs['CostDiscBuild']
data_processed.loc[individual_code]['Capex_Boiler_Total'] = data_processed.loc[individual_code]['Capex_Boiler'] + \
data_processed.loc[individual_code][
'Capex_Boiler_peak'] + \
data_processed.loc[individual_code][
'Capex_Boiler_backup']
data_processed.loc[individual_code]['Opex_Boiler_Total'] = data_processed.loc[individual_code]['Opex_BackupBoiler_NG'] + \
data_processed.loc[individual_code][
'Opex_BackupBoiler_BG'] + \
data_processed.loc[individual_code][
'Opex_PeakBoiler_NG'] + \
data_processed.loc[individual_code][
'Opex_PeakBoiler_BG'] + \
data_processed.loc[individual_code][
'Opex_BaseBoiler_NG'] + \
data_processed.loc[individual_code][
'Opex_BaseBoiler_BG']
data_processed.loc[individual_code]['Opex_CHP_Total'] = data_processed.loc[individual_code]['Opex_CHP_NG'] + \
data_processed.loc[individual_code][
'Opex_CHP_BG']
data_processed.loc[individual_code]['Opex_Furnace_Total'] = data_processed.loc[individual_code]['Opex_Furnace_wet'] + \
data_processed.loc[individual_code]['Opex_Furnace_dry']
data_processed.loc[individual_code]['Electricity_Costs'] = preprocessing_costs['elecCosts'].values[0]
data_processed.loc[individual_code]['Process_Heat_Costs'] = preprocessing_costs['hpCosts'].values[0]
data_processed.loc[individual_code]['Opex_Centralized'] \
= data_processed.loc[individual_code]['Opex_HP_Sewage'] + data_processed.loc[individual_code]['Opex_HP_Lake'] + \
data_processed.loc[individual_code]['Opex_GHP'] + data_processed.loc[individual_code]['Opex_CHP_BG'] + \
data_processed.loc[individual_code]['Opex_CHP_NG'] + data_processed.loc[individual_code]['Opex_Furnace_wet'] + \
data_processed.loc[individual_code]['Opex_Furnace_dry'] + data_processed.loc[individual_code]['Opex_BaseBoiler_BG'] + \
data_processed.loc[individual_code]['Opex_BaseBoiler_NG'] + data_processed.loc[individual_code]['Opex_PeakBoiler_BG'] + \
data_processed.loc[individual_code]['Opex_PeakBoiler_NG'] + data_processed.loc[individual_code]['Opex_BackupBoiler_BG'] + \
data_processed.loc[individual_code]['Opex_BackupBoiler_NG'] + \
data_processed.loc[individual_code]['Electricity_Costs'] + data_processed.loc[individual_code][
'Process_Heat_Costs']
data_processed.loc[individual_code]['Capex_Centralized'] = data_processed.loc[individual_code]['Capex_SC'] + \
data_processed.loc[individual_code]['Capex_PVT'] + data_processed.loc[individual_code]['Capex_Boiler_backup'] + \
data_processed.loc[individual_code]['Capex_storage_HEX'] + data_processed.loc[individual_code]['Capex_furnace'] + \
data_processed.loc[individual_code]['Capex_Boiler'] + data_processed.loc[individual_code]['Capex_Boiler_peak'] + \
data_processed.loc[individual_code]['Capex_Lake'] + data_processed.loc[individual_code]['Capex_Sewage'] + \
data_processed.loc[individual_code]['Capex_pump']
data_processed.loc[individual_code]['Capex_Decentralized'] = df_heating_costs['Capex_Disconnected']
data_processed.loc[individual_code]['Opex_Decentralized'] = df_heating_costs['Opex_Disconnected']
data_processed.loc[individual_code]['Capex_Total'] = data_processed.loc[individual_code]['Capex_Centralized'] + data_processed.loc[individual_code]['Capex_Decentralized']
data_processed.loc[individual_code]['Opex_Total'] = data_processed.loc[individual_code]['Opex_Centralized'] + data_processed.loc[individual_code]['Opex_Decentralized']
elif config.plots_optimization.network_type == 'DC':
data_activation_path = os.path.join(
locator.get_optimization_slave_investment_cost_detailed(individual_pointer, generation_pointer))
disconnected_costs = pd.read_csv(data_activation_path)
data_activation_path = os.path.join(
locator.get_optimization_slave_investment_cost_detailed_cooling(individual_pointer, generation_pointer))
df_cooling_costs = pd.read_csv(data_activation_path)
data_activation_path = os.path.join(
locator.get_optimization_slave_cooling_activation_pattern(individual_pointer, generation_pointer))
df_cooling = pd.read_csv(data_activation_path).set_index("DATE")
data_load = pd.read_csv(os.path.join(
locator.get_optimization_slave_cooling_activation_pattern(individual_pointer, generation_pointer)))
data_load_electricity = pd.read_csv(os.path.join(
locator.get_optimization_slave_electricity_activation_pattern_cooling(individual_pointer, generation_pointer)))
for column_name in df_cooling_costs.columns.values:
data_processed.loc[individual_code][column_name] = df_cooling_costs[column_name].values
data_processed.loc[individual_code]['Opex_var_ACH'] = np.sum(df_cooling['Opex_var_ACH'])
data_processed.loc[individual_code]['Opex_var_CCGT'] = np.sum(df_cooling['Opex_var_CCGT'])
data_processed.loc[individual_code]['Opex_var_CT'] = np.sum(df_cooling['Opex_var_CT'])
data_processed.loc[individual_code]['Opex_var_Lake'] = np.sum(df_cooling['Opex_var_Lake'])
data_processed.loc[individual_code]['Opex_var_VCC'] = np.sum(df_cooling['Opex_var_VCC'])
data_processed.loc[individual_code]['Opex_var_VCC_backup'] = np.sum(df_cooling['Opex_var_VCC_backup'])
data_processed.loc[individual_code]['Opex_var_pumps'] = np.sum(data_processed.loc[individual_code]['Opex_var_pump'])
data_processed.loc[individual_code]['Opex_var_PV'] = -np.sum(data_load_electricity['KEV'])
Absorption_chiller_cost_data = pd.read_excel(locator.get_supply_systems(config.region),
sheetname="Absorption_chiller",
usecols=['type', 'code', 'cap_min', 'cap_max', 'a', 'b',
'c', 'd', 'e', 'IR_%',
'LT_yr', 'O&M_%'])
Absorption_chiller_cost_data = Absorption_chiller_cost_data[
Absorption_chiller_cost_data['type'] == 'double']
max_chiller_size = max(Absorption_chiller_cost_data['cap_max'].values)
Q_ACH_max_W = data_load['Q_from_ACH_W'].max()
Q_ACH_max_W = Q_ACH_max_W * (1 + SIZING_MARGIN)
number_of_ACH_chillers = int(ceil(Q_ACH_max_W / max_chiller_size))
VCC_cost_data = pd.read_excel(locator.get_supply_systems(config.region), sheetname="Chiller")
VCC_cost_data = VCC_cost_data[VCC_cost_data['code'] == 'CH3']
max_VCC_chiller_size = max(VCC_cost_data['cap_max'].values)
Q_VCC_max_W = data_load['Q_from_VCC_W'].max()
Q_VCC_max_W = Q_VCC_max_W * (1 + SIZING_MARGIN)
number_of_VCC_chillers = int(ceil(Q_VCC_max_W / max_VCC_chiller_size))
PV_peak_kW = data_load_electricity['E_PV_W'].max() / 1000
Capex_a_PV, Opex_fixed_PV = calc_Cinv_pv(PV_peak_kW, locator, config)
data_processed.loc[individual_code]['Capex_ACH'] = (data_processed.loc[individual_code]['Capex_a_ACH'] + data_processed.loc[individual_code]['Opex_fixed_ACH']) * number_of_ACH_chillers
data_processed.loc[individual_code]['Capex_CCGT'] = data_processed.loc[individual_code]['Capex_a_CCGT'] + data_processed.loc[individual_code]['Opex_fixed_CCGT']
data_processed.loc[individual_code]['Capex_CT'] = data_processed.loc[individual_code]['Capex_a_CT']+ data_processed.loc[individual_code]['Opex_fixed_CT']
data_processed.loc[individual_code]['Capex_Tank'] = data_processed.loc[individual_code]['Capex_a_Tank'] + data_processed.loc[individual_code]['Opex_fixed_Tank']
data_processed.loc[individual_code]['Capex_VCC'] = (data_processed.loc[individual_code]['Capex_a_VCC']+ data_processed.loc[individual_code]['Opex_fixed_VCC']) * number_of_VCC_chillers
data_processed.loc[individual_code]['Capex_VCC_backup'] = data_processed.loc[individual_code]['Capex_a_VCC_backup'] + data_processed.loc[individual_code]['Opex_fixed_VCC_backup']
data_processed.loc[individual_code]['Capex_a_pump'] = data_processed.loc[individual_code]['Capex_pump']+ data_processed.loc[individual_code]['Opex_fixed_pump']
data_processed.loc[individual_code]['Capex_a_PV'] = Capex_a_PV + Opex_fixed_PV
data_processed.loc[individual_code]['Disconnected_costs'] = disconnected_costs['CostDiscBuild']
data_processed.loc[individual_code]['Capex_Decentralized'] = disconnected_costs['Capex_Disconnected']
data_processed.loc[individual_code]['Opex_Decentralized'] = disconnected_costs['Opex_Disconnected']
data_processed.loc[individual_code]['Electricitycosts_for_appliances'] = preprocessing_costs['elecCosts'].values[0]
data_processed.loc[individual_code]['Process_Heat_Costs'] = preprocessing_costs['hpCosts'].values[0]
E_for_hot_water_demand_W = np.zeros(8760)
lca = lca_calculations(locator, config)
for name in building_names: # adding the electricity demand from the decentralized buildings
building_demand = pd.read_csv(locator.get_demand_results_folder() + '//' + name + ".csv",
usecols=['E_ww_kWh'])
E_for_hot_water_demand_W += building_demand['E_ww_kWh'] * 1000
data_processed.loc[individual_code]['Electricitycosts_for_hotwater'] = E_for_hot_water_demand_W.sum() * lca.ELEC_PRICE
data_processed.loc[individual_code]['Opex_Centralized'] = data_processed.loc[individual_code]['Opex_var_ACH'] + data_processed.loc[individual_code]['Opex_var_CCGT'] + \
data_processed.loc[individual_code]['Opex_var_CT'] + data_processed.loc[individual_code]['Opex_var_Lake'] + \
data_processed.loc[individual_code]['Opex_var_VCC'] + data_processed.loc[individual_code]['Opex_var_VCC_backup'] + data_processed.loc[individual_code]['Opex_var_pumps'] + \
data_processed.loc[individual_code]['Electricitycosts_for_appliances'] + data_processed.loc[individual_code]['Process_Heat_Costs'] + \
data_processed.loc[individual_code]['Opex_var_PV'] + data_processed.loc[individual_code]['Electricitycosts_for_hotwater']
data_processed.loc[individual_code]['Capex_Centralized'] = data_processed.loc[individual_code]['Capex_a_ACH'] + data_processed.loc[individual_code]['Capex_a_CCGT'] + \
data_processed.loc[individual_code]['Capex_a_CT'] + data_processed.loc[individual_code]['Capex_a_Tank'] + \
data_processed.loc[individual_code]['Capex_a_VCC'] + data_processed.loc[individual_code]['Capex_a_VCC_backup'] + \
data_processed.loc[individual_code]['Capex_pump'] + data_processed.loc[individual_code]['Opex_fixed_ACH'] + \
data_processed.loc[individual_code]['Opex_fixed_CCGT'] + data_processed.loc[individual_code]['Opex_fixed_CT'] + \
data_processed.loc[individual_code]['Opex_fixed_Tank'] + data_processed.loc[individual_code]['Opex_fixed_VCC'] + \
data_processed.loc[individual_code]['Opex_fixed_VCC_backup'] + data_processed.loc[individual_code]['Opex_fixed_pump'] + Capex_a_PV + Opex_fixed_PV
data_processed.loc[individual_code]['Capex_Total'] = data_processed.loc[individual_code]['Capex_Centralized'] + data_processed.loc[individual_code]['Capex_Decentralized']
data_processed.loc[individual_code]['Opex_Total'] = data_processed.loc[individual_code]['Opex_Centralized'] + data_processed.loc[individual_code]['Opex_Decentralized']
individual_names = ['ind' + str(i) for i in data_processed.index.values]
data_processed['indiv'] = individual_names
data_processed.set_index('indiv', inplace=True)
return data_processed
def supply_calculation(individual, building_names, total_demand, locator,
extra_costs, extra_CO2, extra_primary_energy,
solar_features, network_features, gv, config, prices,
lca):
"""
This function evaluates one supply system configuration of the case study.
:param individual: a list that indicates the supply system configuration
:type individual: list
:param building_names: names of all building in the district
:type building_names: ndarray
:param locator:
:param extra_costs: cost of decentralized supply systems
:param extra_CO2: CO2 emission of decentralized supply systems
:param extra_primary_energy: Primary energy of decentralized supply systems
:param solar_features: Energy production potentials of solar technologies, including area of installed panels and annual production
:type solar_features: dict
:param network_features: hourly network operating conditions (thermal/pressure losses) and capital costs
:type network_features: dict
:param gv:
:param config:
:param prices:
:return:
"""
individual = evaluation.check_invalid(individual, len(building_names),
config)
# Initialize objective functions costs, CO2 and primary energy
costs = 0
CO2 = extra_CO2
prim = extra_primary_energy
QUncoveredDesign = 0
QUncoveredAnnual = 0
# Create the string representation of the individual
DHN_barcode, DCN_barcode, DHN_configuration, DCN_configuration = sFn.individual_to_barcode(
individual, building_names)
# read the total loads from buildings connected to thermal networks
if DHN_barcode.count("1") == gv.num_tot_buildings:
network_file_name_heating = "Network_summary_result_all.csv"
Q_DHNf_W = pd.read_csv(
locator.get_optimization_network_all_results_summary('all'),
usecols=["Q_DHNf_W"]).values
Q_heating_max_W = Q_DHNf_W.max()
elif DHN_barcode.count("1") == 0:
network_file_name_heating = "Network_summary_result_all.csv"
Q_heating_max_W = 0
else:
# Run the substation and distribution routines
sMain.substation_main(locator,
total_demand,
building_names,
DHN_configuration,
DCN_configuration,
Flag=True)
nM.network_main(locator, total_demand, building_names, config, gv,
DHN_barcode)
network_file_name_heating = "Network_summary_result_" + hex(
int(str(DHN_barcode), 2)) + ".csv"
Q_DHNf_W = pd.read_csv(
locator.get_optimization_network_results_summary(DHN_barcode),
usecols=["Q_DHNf_W"]).values
Q_heating_max_W = Q_DHNf_W.max()
if DCN_barcode.count("1") == gv.num_tot_buildings:
network_file_name_cooling = "Network_summary_result_all.csv"
if individual[
N_HEAT *
2] == 1: # if heat recovery is ON, then only need to satisfy cooling load of space cooling and refrigeration
Q_DCNf_W = pd.read_csv(
locator.get_optimization_network_all_results_summary('all'),
usecols=["Q_DCNf_space_cooling_and_refrigeration_W"]).values
else:
Q_DCNf_W = pd.read_csv(
locator.get_optimization_network_all_results_summary('all'),
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 = "Network_summary_result_none.csv"
Q_cooling_max_W = 0
else:
# Run the substation and distribution routines
sMain.substation_main(locator,
total_demand,
building_names,
DHN_configuration,
DCN_configuration,
Flag=True)
nM.network_main(locator, total_demand, building_names, config, gv,
DCN_barcode)
network_file_name_cooling = "Network_summary_result_" + hex(
int(str(DCN_barcode), 2)) + ".csv"
if individual[
N_HEAT *
2] == 1: # if heat recovery is ON, then only need to satisfy cooling load of space cooling and refrigeration
Q_DCNf_W = pd.read_csv(
locator.get_optimization_network_results_summary(DCN_barcode),
usecols=["Q_DCNf_space_cooling_and_refrigeration_W"]).values
else:
Q_DCNf_W = pd.read_csv(
locator.get_optimization_network_results_summary(DCN_barcode),
usecols=[
"Q_DCNf_space_cooling_data_center_and_refrigeration_W"
]).values
Q_cooling_max_W = Q_DCNf_W.max()
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)
# Modify the individual with the extra GHP constraint
try:
cCheck.GHPCheck(individual, locator, Q_heating_nom_W, gv)
except:
print "No GHP constraint check possible \n"
# Export to context
individual_number = calc_individual_number(locator)
master_to_slave_vars = evaluation.calc_master_to_slave_variables(
individual, Q_heating_max_W, Q_cooling_max_W, building_names,
individual_number, GENERATION_NUMBER)
master_to_slave_vars.network_data_file_heating = network_file_name_heating
master_to_slave_vars.network_data_file_cooling = network_file_name_cooling
master_to_slave_vars.total_buildings = len(building_names)
if master_to_slave_vars.number_of_buildings_connected_heating > 1:
if DHN_barcode.count("0") == 0:
master_to_slave_vars.fNameTotalCSV = locator.get_total_demand()
else:
master_to_slave_vars.fNameTotalCSV = os.path.join(
locator.get_optimization_network_totals_folder(),
"Total_%(DHN_barcode)s.csv" % locals())
else:
master_to_slave_vars.fNameTotalCSV = locator.get_optimization_substations_total_file(
DHN_barcode)
if master_to_slave_vars.number_of_buildings_connected_cooling > 1:
if DCN_barcode.count("0") == 0:
master_to_slave_vars.fNameTotalCSV = locator.get_total_demand()
else:
master_to_slave_vars.fNameTotalCSV = os.path.join(
locator.get_optimization_network_totals_folder(),
"Total_%(DCN_barcode)s.csv" % locals())
else:
master_to_slave_vars.fNameTotalCSV = locator.get_optimization_substations_total_file(
DCN_barcode)
# slave optimization of heating networks
if config.optimization.isheating:
if DHN_barcode.count("1") > 0:
(slavePrim, slaveCO2, slaveCosts, QUncoveredDesign,
QUncoveredAnnual) = sM.slave_main(locator, master_to_slave_vars,
solar_features, gv, config,
prices)
else:
slaveCO2 = 0
slaveCosts = 0
slavePrim = 0
else:
slaveCO2 = 0
slaveCosts = 0
slavePrim = 0
costs += slaveCosts
CO2 += slaveCO2
prim += slavePrim
# slave optimization of cooling networks
if gv.ZernezFlag == 1:
coolCosts, coolCO2, coolPrim = 0, 0, 0
elif config.optimization.iscooling and DCN_barcode.count("1") > 0:
reduced_timesteps_flag = config.supply_system_simulation.reduced_timesteps
(coolCosts, coolCO2,
coolPrim) = coolMain.coolingMain(locator, master_to_slave_vars,
network_features, gv, prices, lca,
config, reduced_timesteps_flag)
# if reduced_timesteps_flag:
# # reduced timesteps simulation for a month (May)
# coolCosts = coolCosts * (8760/(3624/2880))
# coolCO2 = coolCO2 * (8760/(3624/2880))
# coolPrim = coolPrim * (8760/(3624/2880))
# # FIXME: check results
else:
coolCosts, coolCO2, coolPrim = 0, 0, 0
# print "Add extra costs"
# add costs of disconnected buildings (best configuration)
(addCosts, addCO2,
addPrim) = eM.addCosts(DHN_barcode, DCN_barcode, building_names, locator,
master_to_slave_vars, QUncoveredDesign,
QUncoveredAnnual, solar_features, network_features,
gv, config, prices, lca)
# recalculate the addCosts by substracting the decentralized costs and add back to corresponding supply system
Cost_diff, CO2_diff, Prim_diff = calc_decentralized_building_costs(
config, locator, master_to_slave_vars, DHN_barcode, DCN_barcode,
building_names)
addCosts = addCosts + Cost_diff
addCO2 = addCO2 + CO2_diff
addPrim = addPrim + Prim_diff
# add Capex and Opex of PV
data_electricity = pd.read_csv(
os.path.join(
locator.
get_optimization_slave_electricity_activation_pattern_cooling(
individual_number, GENERATION_NUMBER)))
total_area_for_pv = data_electricity['Area_PV_m2'].max()
# remove the area installed with solar collectors
sc_installed_area = 0
if config.supply_system_simulation.decentralized_systems == 'Single-effect Absorption Chiller':
for (index, building_name) in zip(DCN_barcode, building_names):
if index == "0":
sc_installed_area = sc_installed_area + pd.read_csv(
locator.PV_results(building_name))['Area_PV_m2'].max()
pv_installed_area = total_area_for_pv - sc_installed_area
Capex_a_PV, Opex_fixed_PV = calc_Cinv_pv(pv_installed_area, locator,
config)
pv_annual_production_kWh = (data_electricity['E_PV_W'].sum()) / 1000
# electricity calculations
data_network_electricity = pd.read_csv(
os.path.join(
locator.
get_optimization_slave_electricity_activation_pattern_cooling(
individual_number, GENERATION_NUMBER)))
data_cooling = pd.read_csv(
os.path.join(
locator.get_optimization_slave_cooling_activation_pattern(
individual_number, GENERATION_NUMBER)))
total_demand = pd.read_csv(locator.get_total_demand())
building_names = total_demand.Name.values
total_electricity_demand_W = data_network_electricity['E_total_req_W']
E_decentralized_appliances_W = np.zeros(8760)
for i, name in zip(
DCN_barcode, building_names
): # adding the electricity demand from the decentralized buildings
if i is '0':
building_demand = pd.read_csv(locator.get_demand_results_folder() +
'//' + name + ".csv",
usecols=['E_sys_kWh'])
E_decentralized_appliances_W += building_demand['E_sys_kWh'] * 1000
total_electricity_demand_W = total_electricity_demand_W.add(
E_decentralized_appliances_W)
E_for_hot_water_demand_W = np.zeros(8760)
for i, name in zip(
DCN_barcode, building_names
): # adding the electricity demand for hot water from all buildings
building_demand = pd.read_csv(locator.get_demand_results_folder() +
'//' + name + ".csv",
usecols=['E_ww_kWh'])
E_for_hot_water_demand_W += building_demand['E_ww_kWh'] * 1000
total_electricity_demand_W = total_electricity_demand_W.add(
E_for_hot_water_demand_W)
# Electricity of Energy Systems
lca = lca_calculations(locator, config)
E_VCC_W = data_cooling['Opex_var_VCC'] / lca.ELEC_PRICE
E_VCC_backup_W = data_cooling['Opex_var_VCC_backup'] / lca.ELEC_PRICE
E_ACH_W = data_cooling['Opex_var_ACH'] / lca.ELEC_PRICE
E_CT_W = abs(data_cooling['Opex_var_CT']) / lca.ELEC_PRICE
total_electricity_demand_W = total_electricity_demand_W.add(E_VCC_W)
total_electricity_demand_W = total_electricity_demand_W.add(E_VCC_backup_W)
total_electricity_demand_W = total_electricity_demand_W.add(E_ACH_W)
total_electricity_demand_W = total_electricity_demand_W.add(E_CT_W)
E_from_CHP_W = data_network_electricity[
'E_CHP_to_directload_W'] + data_network_electricity['E_CHP_to_grid_W']
E_from_PV_W = data_network_electricity[
'E_PV_to_directload_W'] + data_network_electricity['E_PV_to_grid_W']
E_CHP_to_directload_W = np.zeros(8760)
E_CHP_to_grid_W = np.zeros(8760)
E_PV_to_directload_W = np.zeros(8760)
E_PV_to_grid_W = np.zeros(8760)
E_from_grid_W = np.zeros(8760)
# modify simulation timesteps
if reduced_timesteps_flag == False:
start_t = 0
stop_t = 8760
else:
# timesteps in May
start_t = 2880
stop_t = 3624
timesteps = range(start_t, stop_t)
for hour in timesteps:
E_hour_W = total_electricity_demand_W[hour]
if E_hour_W > 0:
if E_from_PV_W[hour] > E_hour_W:
E_PV_to_directload_W[hour] = E_hour_W
E_PV_to_grid_W[hour] = E_from_PV_W[
hour] - total_electricity_demand_W[hour]
E_hour_W = 0
else:
E_hour_W = E_hour_W - E_from_PV_W[hour]
E_PV_to_directload_W[hour] = E_from_PV_W[hour]
if E_from_CHP_W[hour] > E_hour_W:
E_CHP_to_directload_W[hour] = E_hour_W
E_CHP_to_grid_W[hour] = E_from_CHP_W[hour] - E_hour_W
E_hour_W = 0
else:
E_hour_W = E_hour_W - E_from_CHP_W[hour]
E_CHP_to_directload_W[hour] = E_from_CHP_W[hour]
E_from_grid_W[hour] = E_hour_W
date = data_network_electricity.DATE.values
results = pd.DataFrame(
{
"DATE": date,
"E_total_req_W": total_electricity_demand_W,
"E_from_grid_W": E_from_grid_W,
"E_VCC_W": E_VCC_W,
"E_VCC_backup_W": E_VCC_backup_W,
"E_ACH_W": E_ACH_W,
"E_CT_W": E_CT_W,
"E_PV_to_directload_W": E_PV_to_directload_W,
"E_CHP_to_directload_W": E_CHP_to_directload_W,
"E_CHP_to_grid_W": E_CHP_to_grid_W,
"E_PV_to_grid_W": E_PV_to_grid_W,
"E_for_hot_water_demand_W": E_for_hot_water_demand_W,
"E_decentralized_appliances_W": E_decentralized_appliances_W,
"E_total_to_grid_W_negative": -E_PV_to_grid_W - E_CHP_to_grid_W
}
) # let's keep this negative so it is something exported, we can use it in the graphs of likelihood
if reduced_timesteps_flag:
reduced_el_costs = ((results['E_from_grid_W'].sum() +
results['E_total_to_grid_W_negative'].sum()) *
lca.ELEC_PRICE)
electricity_costs = reduced_el_costs * (8760 / (stop_t - start_t))
else:
electricity_costs = ((results['E_from_grid_W'].sum() +
results['E_total_to_grid_W_negative'].sum()) *
lca.ELEC_PRICE)
# emission from data
data_emissions = pd.read_csv(
os.path.join(
locator.get_optimization_slave_investment_cost_detailed(
individual_number, GENERATION_NUMBER)))
update_PV_emission = abs(
2 * data_emissions['CO2_PV_disconnected']).values[0] # kg-CO2
update_PV_primary = abs(
2 * data_emissions['Eprim_PV_disconnected']).values[0] # MJ oil-eq
costs += addCosts + coolCosts + electricity_costs + Capex_a_PV + Opex_fixed_PV
CO2 = CO2 + addCO2 + coolCO2 - update_PV_emission
prim = prim + addPrim + coolPrim - update_PV_primary
# Converting costs into float64 to avoid longer values
costs = (np.float64(costs) / 1e6).round(2) # $ to Mio$
CO2 = (np.float64(CO2) / 1e6).round(2) # kg to kilo-ton
prim = (np.float64(prim) / 1e6).round(2) # MJ to TJ
# add electricity costs corresponding to
# print ('Additional costs = ' + str(addCosts))
# print ('Additional CO2 = ' + str(addCO2))
# print ('Additional prim = ' + str(addPrim))
print('Total annualized costs [USD$(2015) Mio/yr] = ' + str(costs))
print('Green house gas emission [kton-CO2/yr] = ' + str(CO2))
print('Primary energy [TJ-oil-eq/yr] = ' + str(prim))
results = {
'TAC_Mio_per_yr': [costs.round(2)],
'CO2_kton_per_yr': [CO2.round(2)],
'Primary_Energy_TJ_per_yr': [prim.round(2)]
}
results_df = pd.DataFrame(results)
results_path = os.path.join(
locator.get_optimization_slave_results_folder(GENERATION_NUMBER),
'ind_' + str(individual_number) + '_results.csv')
results_df.to_csv(results_path)
with open(locator.get_optimization_checkpoint_initial(), "wb") as fp:
pop = []
g = GENERATION_NUMBER
epsInd = []
invalid_ind = []
fitnesses = []
capacities = []
disconnected_capacities = []
halloffame = []
halloffame_fitness = []
euclidean_distance = []
spread = []
cp = dict(population=pop,
generation=g,
epsIndicator=epsInd,
testedPop=invalid_ind,
population_fitness=fitnesses,
capacities=capacities,
disconnected_capacities=disconnected_capacities,
halloffame=halloffame,
halloffame_fitness=halloffame_fitness,
euclidean_distance=euclidean_distance,
spread=spread)
json.dump(cp, fp)
return costs, CO2, prim, master_to_slave_vars, individual
def addCosts(buildList, locator, master_to_slave_vars, Q_uncovered_design_W,
Q_uncovered_annual_W, solar_features, network_features, gv,
config, prices, lca):
"""
Computes additional costs / GHG emisions / primary energy needs
for the individual
addCosts = additional costs
addCO2 = GHG emissions
addPrm = primary energy needs
:param DHN_barcode: parameter indicating if the building is connected or not
:param buildList: list of buildings in the district
:param locator: input locator set to scenario
:param master_to_slave_vars: class containing the features of a specific individual
:param Q_uncovered_design_W: hourly max of the heating uncovered demand
:param Q_uncovered_annual_W: total heating uncovered
:param solar_features: solar features
:param network_features: network features
:param gv: global variables
:type indCombi: string
:type buildList: list
:type locator: string
:type master_to_slave_vars: class
:type Q_uncovered_design_W: float
:type Q_uncovered_annual_W: float
:type solar_features: class
:type network_features: class
:type gv: class
:return: returns the objectives addCosts, addCO2, addPrim
:rtype: tuple
"""
DHN_barcode = master_to_slave_vars.DHN_barcode
DCN_barcode = master_to_slave_vars.DCN_barcode
addcosts_Capex_a_USD = 0
addcosts_Opex_fixed_USD = 0
addcosts_Capex_USD = 0
addCO2 = 0
addPrim = 0
nBuildinNtw = 0
# Add the features from the disconnected buildings
CostDiscBuild = 0
CO2DiscBuild = 0
PrimDiscBuild = 0
Capex_Disconnected = 0
Opex_Disconnected = 0
Capex_a_furnace_USD = 0
Capex_a_CHP_USD = 0
Capex_a_Boiler_USD = 0
Capex_a_Boiler_peak_USD = 0
Capex_a_Lake_USD = 0
Capex_a_Sewage_USD = 0
Capex_a_GHP_USD = 0
Capex_a_PV_USD = 0
Capex_a_SC_ET_USD = 0
Capex_a_SC_FP_USD = 0
Capex_a_PVT_USD = 0
Capex_a_Boiler_backup_USD = 0
Capex_a_HEX = 0
Capex_a_storage_HP = 0
Capex_a_HP_storage_USD = 0
Opex_fixed_SC = 0
Opex_fixed_PVT_USD = 0
Opex_fixed_HP_PVT_USD = 0
Opex_fixed_furnace_USD = 0
Opex_fixed_CHP_USD = 0
Opex_fixed_Boiler_USD = 0
Opex_fixed_Boiler_peak_USD = 0
Opex_fixed_Boiler_backup_USD = 0
Opex_fixed_Lake_USD = 0
Opex_fixed_wasteserver_HEX_USD = 0
Opex_fixed_wasteserver_HP_USD = 0
Opex_fixed_PV_USD = 0
Opex_fixed_GHP_USD = 0
Opex_fixed_storage_USD = 0
Opex_fixed_Sewage_USD = 0
Opex_fixed_HP_storage_USD = 0
StorageInvC = 0
NetworkCost_a_USD = 0
SubstHEXCost_capex = 0
SubstHEXCost_opex = 0
PVTHEXCost_Capex = 0
PVTHEXCost_Opex = 0
SCHEXCost_Capex = 0
SCHEXCost_Opex = 0
pumpCosts = 0
GasConnectionInvCost = 0
cost_PV_disconnected = 0
CO2_PV_disconnected = 0
Eprim_PV_disconnected = 0
Capex_furnace_USD = 0
Capex_CHP_USD = 0
Capex_Boiler_USD = 0
Capex_Boiler_peak_USD = 0
Capex_Lake_USD = 0
Capex_Sewage_USD = 0
Capex_GHP = 0
Capex_PV_USD = 0
Capex_SC = 0
Capex_PVT_USD = 0
Capex_Boiler_backup_USD = 0
Capex_HEX = 0
Capex_storage_HP = 0
Capex_HP_storage = 0
Capex_SC_ET_USD = 0
Capex_SC_FP_USD = 0
Capex_PVT_USD = 0
Capex_Boiler_backup_USD = 0
Capex_HP_storage_USD = 0
Capex_storage_HP = 0
Capex_CHP_USD = 0
Capex_furnace_USD = 0
Capex_Boiler_USD = 0
Capex_Boiler_peak_USD = 0
Capex_Lake_USD = 0
Capex_Sewage_USD = 0
Capex_pump_USD = 0
if config.district_heating_network:
for (index, building_name) in zip(DHN_barcode, buildList):
if index == "0":
df = pd.read_csv(
locator.
get_optimization_decentralized_folder_building_result_heating(
building_name))
dfBest = df[df["Best configuration"] == 1]
CostDiscBuild += dfBest["Total Costs [CHF]"].iloc[0] # [CHF]
CO2DiscBuild += dfBest["CO2 Emissions [kgCO2-eq]"].iloc[
0] # [kg CO2]
PrimDiscBuild += dfBest[
"Primary Energy Needs [MJoil-eq]"].iloc[0] # [MJ-oil-eq]
Capex_Disconnected += dfBest[
"Annualized Investment Costs [CHF]"].iloc[0]
Opex_Disconnected += dfBest["Operation Costs [CHF]"].iloc[0]
else:
nBuildinNtw += 1
if config.district_cooling_network:
PV_barcode = ''
for (index, building_name) in zip(DCN_barcode, buildList):
if index == "0": # choose the best decentralized configuration
df = pd.read_csv(
locator.
get_optimization_decentralized_folder_building_result_cooling(
building_name, configuration='AHU_ARU_SCU'))
dfBest = df[df["Best configuration"] == 1]
CostDiscBuild += dfBest["Total Costs [CHF]"].iloc[0] # [CHF]
CO2DiscBuild += dfBest["CO2 Emissions [kgCO2-eq]"].iloc[
0] # [kg CO2]
PrimDiscBuild += dfBest[
"Primary Energy Needs [MJoil-eq]"].iloc[0] # [MJ-oil-eq]
Capex_Disconnected += dfBest[
"Annualized Investment Costs [CHF]"].iloc[0]
Opex_Disconnected += dfBest["Operation Costs [CHF]"].iloc[0]
to_PV = 1
if dfBest["single effect ACH to AHU_ARU_SCU Share (FP)"].iloc[
0] == 1:
to_PV = 0
if dfBest["single effect ACH to AHU_ARU_SCU Share (ET)"].iloc[
0] == 1:
to_PV = 0
if dfBest["single effect ACH to SCU Share (FP)"].iloc[0] == 1:
to_PV = 0
else: # adding costs for buildings in which the centralized plant provides a part of the load requirements
DCN_unit_configuration = master_to_slave_vars.DCN_supplyunits
if DCN_unit_configuration == 1: # corresponds to AHU in the central plant, so remaining load need to be provided by decentralized plant
decentralized_configuration = 'ARU_SCU'
df = pd.read_csv(
locator.
get_optimization_decentralized_folder_building_result_cooling(
building_name, decentralized_configuration))
dfBest = df[df["Best configuration"] == 1]
CostDiscBuild += dfBest["Total Costs [CHF]"].iloc[
0] # [CHF]
CO2DiscBuild += dfBest["CO2 Emissions [kgCO2-eq]"].iloc[
0] # [kg CO2]
PrimDiscBuild += dfBest[
"Primary Energy Needs [MJoil-eq]"].iloc[
0] # [MJ-oil-eq]
Capex_Disconnected += dfBest[
"Annualized Investment Costs [CHF]"].iloc[0]
Opex_Disconnected += dfBest["Operation Costs [CHF]"].iloc[
0]
to_PV = 1
if dfBest["single effect ACH to ARU_SCU Share (FP)"].iloc[
0] == 1:
to_PV = 0
if dfBest["single effect ACH to ARU_SCU Share (ET)"].iloc[
0] == 1:
to_PV = 0
if DCN_unit_configuration == 2: # corresponds to ARU in the central plant, so remaining load need to be provided by decentralized plant
decentralized_configuration = 'AHU_SCU'
df = pd.read_csv(
locator.
get_optimization_decentralized_folder_building_result_cooling(
building_name, decentralized_configuration))
dfBest = df[df["Best configuration"] == 1]
CostDiscBuild += dfBest["Total Costs [CHF]"].iloc[
0] # [CHF]
CO2DiscBuild += dfBest["CO2 Emissions [kgCO2-eq]"].iloc[
0] # [kg CO2]
PrimDiscBuild += dfBest[
"Primary Energy Needs [MJoil-eq]"].iloc[
0] # [MJ-oil-eq]
Capex_Disconnected += dfBest[
"Annualized Investment Costs [CHF]"].iloc[0]
Opex_Disconnected += dfBest["Operation Costs [CHF]"].iloc[
0]
to_PV = 1
if dfBest["single effect ACH to AHU_SCU Share (FP)"].iloc[
0] == 1:
to_PV = 0
if dfBest["single effect ACH to AHU_SCU Share (ET)"].iloc[
0] == 1:
to_PV = 0
if DCN_unit_configuration == 3: # corresponds to SCU in the central plant, so remaining load need to be provided by decentralized plant
decentralized_configuration = 'AHU_ARU'
df = pd.read_csv(
locator.
get_optimization_decentralized_folder_building_result_cooling(
building_name, decentralized_configuration))
dfBest = df[df["Best configuration"] == 1]
CostDiscBuild += dfBest["Total Costs [CHF]"].iloc[
0] # [CHF]
CO2DiscBuild += dfBest["CO2 Emissions [kgCO2-eq]"].iloc[
0] # [kg CO2]
PrimDiscBuild += dfBest[
"Primary Energy Needs [MJoil-eq]"].iloc[
0] # [MJ-oil-eq]
Capex_Disconnected += dfBest[
"Annualized Investment Costs [CHF]"].iloc[0]
Opex_Disconnected += dfBest["Operation Costs [CHF]"].iloc[
0]
to_PV = 1
if dfBest["single effect ACH to AHU_ARU Share (FP)"].iloc[
0] == 1:
to_PV = 0
if dfBest["single effect ACH to AHU_ARU Share (ET)"].iloc[
0] == 1:
to_PV = 0
if DCN_unit_configuration == 4: # corresponds to AHU + ARU in the central plant, so remaining load need to be provided by decentralized plant
decentralized_configuration = 'SCU'
df = pd.read_csv(
locator.
get_optimization_decentralized_folder_building_result_cooling(
building_name, decentralized_configuration))
dfBest = df[df["Best configuration"] == 1]
CostDiscBuild += dfBest["Total Costs [CHF]"].iloc[
0] # [CHF]
CO2DiscBuild += dfBest["CO2 Emissions [kgCO2-eq]"].iloc[
0] # [kg CO2]
PrimDiscBuild += dfBest[
"Primary Energy Needs [MJoil-eq]"].iloc[
0] # [MJ-oil-eq]
Capex_Disconnected += dfBest[
"Annualized Investment Costs [CHF]"].iloc[0]
Opex_Disconnected += dfBest["Operation Costs [CHF]"].iloc[
0]
to_PV = 1
if dfBest["single effect ACH to SCU Share (FP)"].iloc[
0] == 1:
to_PV = 0
if dfBest["single effect ACH to SCU Share (ET)"].iloc[
0] == 1:
to_PV = 0
if DCN_unit_configuration == 5: # corresponds to AHU + SCU in the central plant, so remaining load need to be provided by decentralized plant
decentralized_configuration = 'ARU'
df = pd.read_csv(
locator.
get_optimization_decentralized_folder_building_result_cooling(
building_name, decentralized_configuration))
dfBest = df[df["Best configuration"] == 1]
CostDiscBuild += dfBest["Total Costs [CHF]"].iloc[
0] # [CHF]
CO2DiscBuild += dfBest["CO2 Emissions [kgCO2-eq]"].iloc[
0] # [kg CO2]
PrimDiscBuild += dfBest[
"Primary Energy Needs [MJoil-eq]"].iloc[
0] # [MJ-oil-eq]
Capex_Disconnected += dfBest[
"Annualized Investment Costs [CHF]"].iloc[0]
Opex_Disconnected += dfBest["Operation Costs [CHF]"].iloc[
0]
to_PV = 1
if dfBest["single effect ACH to ARU Share (FP)"].iloc[
0] == 1:
to_PV = 0
if dfBest["single effect ACH to ARU Share (ET)"].iloc[
0] == 1:
to_PV = 0
if DCN_unit_configuration == 6: # corresponds to ARU + SCU in the central plant, so remaining load need to be provided by decentralized plant
decentralized_configuration = 'AHU'
df = pd.read_csv(
locator.
get_optimization_decentralized_folder_building_result_cooling(
building_name, decentralized_configuration))
dfBest = df[df["Best configuration"] == 1]
CostDiscBuild += dfBest["Total Costs [CHF]"].iloc[
0] # [CHF]
CO2DiscBuild += dfBest["CO2 Emissions [kgCO2-eq]"].iloc[
0] # [kg CO2]
PrimDiscBuild += dfBest[
"Primary Energy Needs [MJoil-eq]"].iloc[
0] # [MJ-oil-eq]
Capex_Disconnected += dfBest[
"Annualized Investment Costs [CHF]"].iloc[0]
Opex_Disconnected += dfBest["Operation Costs [CHF]"].iloc[
0]
to_PV = 1
if dfBest["single effect ACH to AHU Share (FP)"].iloc[
0] == 1:
to_PV = 0
if dfBest["single effect ACH to AHU Share (ET)"].iloc[
0] == 1:
to_PV = 0
if DCN_unit_configuration == 7: # corresponds to AHU + ARU + SCU from central plant
to_PV = 1
nBuildinNtw += 1
PV_barcode = PV_barcode + str(to_PV)
addcosts_Capex_a_USD += CostDiscBuild
addCO2 += CO2DiscBuild
addPrim += PrimDiscBuild
# Solar technologies
PV_installed_area_m2 = master_to_slave_vars.SOLAR_PART_PV * solar_features.A_PV_m2 # kW
Capex_a_PV_USD, Opex_fixed_PV_USD, Capex_PV_USD = pv.calc_Cinv_pv(
PV_installed_area_m2, locator, config)
addcosts_Capex_a_USD += Capex_a_PV_USD
addcosts_Opex_fixed_USD += Opex_fixed_PV_USD
addcosts_Capex_USD += Capex_PV_USD
SC_ET_area_m2 = master_to_slave_vars.SOLAR_PART_SC_ET * solar_features.A_SC_ET_m2
Capex_a_SC_ET_USD, Opex_fixed_SC_ET_USD, Capex_SC_ET_USD = stc.calc_Cinv_SC(
SC_ET_area_m2, locator, config, 'ET')
addcosts_Capex_a_USD += Capex_a_SC_ET_USD
addcosts_Opex_fixed_USD += Opex_fixed_SC_ET_USD
addcosts_Capex_USD += Capex_SC_ET_USD
SC_FP_area_m2 = master_to_slave_vars.SOLAR_PART_SC_FP * solar_features.A_SC_FP_m2
Capex_a_SC_FP_USD, Opex_fixed_SC_FP_USD, Capex_SC_FP_USD = stc.calc_Cinv_SC(
SC_FP_area_m2, locator, config, 'FP')
addcosts_Capex_a_USD += Capex_a_SC_FP_USD
addcosts_Opex_fixed_USD += Opex_fixed_SC_FP_USD
addcosts_Capex_USD += Capex_SC_FP_USD
PVT_peak_kW = master_to_slave_vars.SOLAR_PART_PVT * solar_features.A_PVT_m2 * N_PVT # kW
Capex_a_PVT_USD, Opex_fixed_PVT_USD, Capex_PVT_USD = pvt.calc_Cinv_PVT(
PVT_peak_kW, locator, config)
addcosts_Capex_a_USD += Capex_a_PVT_USD
addcosts_Opex_fixed_USD += Opex_fixed_PVT_USD
addcosts_Capex_USD += Capex_PVT_USD
# Add the features for the distribution
if DHN_barcode.count("1") > 0 and config.district_heating_network:
os.chdir(
locator.get_optimization_slave_results_folder(
master_to_slave_vars.generation_number))
# Add the investment costs of the energy systems
# Furnace
if master_to_slave_vars.Furnace_on == 1:
P_design_W = master_to_slave_vars.Furnace_Q_max_W
fNameSlavePP = locator.get_optimization_slave_heating_activation_pattern_heating(
master_to_slave_vars.configKey,
master_to_slave_vars.individual_number,
master_to_slave_vars.generation_number)
dfFurnace = pd.read_csv(fNameSlavePP, usecols=["Q_Furnace_W"])
arrayFurnace_W = np.array(dfFurnace)
Q_annual_W = 0
for i in range(int(np.shape(arrayFurnace_W)[0])):
Q_annual_W += arrayFurnace_W[i][0]
Capex_a_furnace_USD, Opex_fixed_furnace_USD, Capex_furnace_USD = furnace.calc_Cinv_furnace(
P_design_W, Q_annual_W, config, locator, 'FU1')
addcosts_Capex_a_USD += Capex_a_furnace_USD
addcosts_Opex_fixed_USD += Opex_fixed_furnace_USD
addcosts_Capex_USD += Capex_furnace_USD
# CC
if master_to_slave_vars.CC_on == 1:
CC_size_W = master_to_slave_vars.CC_GT_SIZE_W
Capex_a_CHP_USD, Opex_fixed_CHP_USD, Capex_CHP_USD = chp.calc_Cinv_CCGT(
CC_size_W, locator, config)
addcosts_Capex_a_USD += Capex_a_CHP_USD
addcosts_Opex_fixed_USD += Opex_fixed_CHP_USD
addcosts_Capex_USD += Capex_CHP_USD
# Boiler Base
if master_to_slave_vars.Boiler_on == 1:
Q_design_W = master_to_slave_vars.Boiler_Q_max_W
fNameSlavePP = locator.get_optimization_slave_heating_activation_pattern(
master_to_slave_vars.individual_number,
master_to_slave_vars.generation_number)
dfBoilerBase = pd.read_csv(fNameSlavePP,
usecols=["Q_BaseBoiler_W"])
arrayBoilerBase_W = np.array(dfBoilerBase)
Q_annual_W = 0
for i in range(int(np.shape(arrayBoilerBase_W)[0])):
Q_annual_W += arrayBoilerBase_W[i][0]
Capex_a_Boiler_USD, Opex_fixed_Boiler_USD, Capex_Boiler_USD = boiler.calc_Cinv_boiler(
Q_design_W, locator, config, 'BO1')
addcosts_Capex_a_USD += Capex_a_Boiler_USD
addcosts_Opex_fixed_USD += Opex_fixed_Boiler_USD
addcosts_Capex_USD += Capex_Boiler_USD
# Boiler Peak
if master_to_slave_vars.BoilerPeak_on == 1:
Q_design_W = master_to_slave_vars.BoilerPeak_Q_max_W
fNameSlavePP = locator.get_optimization_slave_heating_activation_pattern(
master_to_slave_vars.individual_number,
master_to_slave_vars.generation_number)
dfBoilerPeak = pd.read_csv(fNameSlavePP,
usecols=["Q_PeakBoiler_W"])
arrayBoilerPeak_W = np.array(dfBoilerPeak)
Q_annual_W = 0
for i in range(int(np.shape(arrayBoilerPeak_W)[0])):
Q_annual_W += arrayBoilerPeak_W[i][0]
Capex_a_Boiler_peak_USD, Opex_fixed_Boiler_peak_USD, Capex_Boiler_peak_USD = boiler.calc_Cinv_boiler(
Q_design_W, locator, config, 'BO1')
addcosts_Capex_a_USD += Capex_a_Boiler_peak_USD
addcosts_Opex_fixed_USD += Opex_fixed_Boiler_peak_USD
addcosts_Capex_USD += Capex_Boiler_peak_USD
# HP Lake
if master_to_slave_vars.HP_Lake_on == 1:
HP_Size_W = master_to_slave_vars.HPLake_maxSize_W
Capex_a_Lake_USD, Opex_fixed_Lake_USD, Capex_Lake_USD = hp.calc_Cinv_HP(
HP_Size_W, locator, config, 'HP2')
addcosts_Capex_a_USD += Capex_a_Lake_USD
addcosts_Opex_fixed_USD += Opex_fixed_Lake_USD
addcosts_Capex_USD += Capex_Lake_USD
# HP Sewage
if master_to_slave_vars.HP_Sew_on == 1:
HP_Size_W = master_to_slave_vars.HPSew_maxSize_W
Capex_a_Sewage_USD, Opex_fixed_Sewage_USD, Capex_Sewage_USD = hp.calc_Cinv_HP(
HP_Size_W, locator, config, 'HP2')
addcosts_Capex_a_USD += Capex_a_Sewage_USD
addcosts_Opex_fixed_USD += Opex_fixed_Sewage_USD
addcosts_Capex_USD += Capex_Sewage_USD
# GHP
if master_to_slave_vars.GHP_on == 1:
fNameSlavePP = locator.get_optimization_slave_electricity_activation_pattern_heating(
master_to_slave_vars.individual_number,
master_to_slave_vars.generation_number)
dfGHP = pd.read_csv(fNameSlavePP, usecols=["E_used_GHP_W"])
arrayGHP_W = np.array(dfGHP)
GHP_Enom_W = np.amax(arrayGHP_W)
Capex_a_GHP_USD, Opex_fixed_GHP_USD, Capex_GHP_USD = hp.calc_Cinv_GHP(
GHP_Enom_W, locator, config)
addcosts_Capex_a_USD += Capex_a_GHP_USD * prices.EURO_TO_CHF
addcosts_Opex_fixed_USD += Opex_fixed_GHP_USD * prices.EURO_TO_CHF
addcosts_Capex_USD += Capex_GHP_USD
# Back-up boiler
Capex_a_Boiler_backup_USD, Opex_fixed_Boiler_backup_USD, Capex_Boiler_backup_USD = boiler.calc_Cinv_boiler(
Q_uncovered_design_W, locator, config, 'BO1')
addcosts_Capex_a_USD += Capex_a_Boiler_backup_USD
addcosts_Opex_fixed_USD += Opex_fixed_Boiler_backup_USD
addcosts_Capex_USD += Capex_Boiler_backup_USD
master_to_slave_vars.BoilerBackup_Q_max_W = Q_uncovered_design_W
# Hex and HP for Heat recovery
if master_to_slave_vars.WasteServersHeatRecovery == 1:
df = pd.read_csv(os.path.join(
locator.get_optimization_network_results_folder(),
master_to_slave_vars.network_data_file_heating),
usecols=["Qcdata_netw_total_kWh"])
array = np.array(df)
Q_HEX_max_kWh = np.amax(array)
Capex_a_wasteserver_HEX_USD, Opex_fixed_wasteserver_HEX_USD, Capex_wasteserver_HEX_USD = hex.calc_Cinv_HEX(
Q_HEX_max_kWh, locator, config, 'HEX1')
addcosts_Capex_a_USD += (Capex_a_wasteserver_HEX_USD)
addcosts_Opex_fixed_USD += Opex_fixed_wasteserver_HEX_USD
addcosts_Capex_USD += Capex_wasteserver_HEX_USD
df = pd.read_csv(
locator.get_optimization_slave_storage_operation_data(
master_to_slave_vars.individual_number,
master_to_slave_vars.generation_number),
usecols=["HPServerHeatDesignArray_kWh"])
array = np.array(df)
Q_HP_max_kWh = np.amax(array)
Capex_a_wasteserver_HP_USD, Opex_fixed_wasteserver_HP_USD, Capex_wasteserver_HP_USD = hp.calc_Cinv_HP(
Q_HP_max_kWh, locator, config, 'HP2')
addcosts_Capex_a_USD += (Capex_a_wasteserver_HP_USD)
addcosts_Opex_fixed_USD += Opex_fixed_wasteserver_HP_USD
addcosts_Capex_USD += Capex_wasteserver_HP_USD
# Heat pump from solar to DH
df = pd.read_csv(
locator.get_optimization_slave_storage_operation_data(
master_to_slave_vars.individual_number,
master_to_slave_vars.generation_number),
usecols=["HPScDesignArray_Wh", "HPpvt_designArray_Wh"])
array = np.array(df)
Q_HP_max_PVT_wh = np.amax(array[:, 1])
Q_HP_max_SC_Wh = np.amax(array[:, 0])
Capex_a_HP_PVT_USD, Opex_fixed_HP_PVT_USD, Capex_HP_PVT_USD = hp.calc_Cinv_HP(
Q_HP_max_PVT_wh, locator, config, 'HP2')
Capex_a_storage_HP += (Capex_a_HP_PVT_USD)
addcosts_Opex_fixed_USD += Opex_fixed_HP_PVT_USD
addcosts_Capex_USD += Capex_HP_PVT_USD
Capex_a_HP_SC_USD, Opex_fixed_HP_SC_USD, Capex_HP_SC_USD = hp.calc_Cinv_HP(
Q_HP_max_SC_Wh, locator, config, 'HP2')
Capex_a_storage_HP += (Capex_a_HP_SC_USD)
addcosts_Opex_fixed_USD += Opex_fixed_HP_SC_USD
addcosts_Capex_USD += Capex_HP_SC_USD
# HP for storage operation for charging from solar and discharging to DH
df = pd.read_csv(locator.get_optimization_slave_storage_operation_data(
master_to_slave_vars.individual_number,
master_to_slave_vars.generation_number),
usecols=[
"E_aux_ch_W", "E_aux_dech_W",
"Q_from_storage_used_W", "Q_to_storage_W"
])
array = np.array(df)
Q_HP_max_storage_W = 0
for i in range(DAYS_IN_YEAR * HOURS_IN_DAY):
if array[i][0] > 0:
Q_HP_max_storage_W = max(Q_HP_max_storage_W,
array[i][3] + array[i][0])
elif array[i][1] > 0:
Q_HP_max_storage_W = max(Q_HP_max_storage_W,
array[i][2] + array[i][1])
Capex_a_HP_storage_USD, Opex_fixed_HP_storage_USD, Capex_HP_storage_USD = hp.calc_Cinv_HP(
Q_HP_max_storage_W, locator, config, 'HP2')
addcosts_Capex_a_USD += (Capex_a_HP_storage_USD)
addcosts_Opex_fixed_USD += Opex_fixed_HP_storage_USD
addcosts_Capex_USD += Capex_HP_storage_USD
# Storage
df = pd.read_csv(locator.get_optimization_slave_storage_operation_data(
master_to_slave_vars.individual_number,
master_to_slave_vars.generation_number),
usecols=["Storage_Size_m3"],
nrows=1)
StorageVol_m3 = np.array(df)[0][0]
Capex_a_storage_USD, Opex_fixed_storage_USD, Capex_storage_USD = storage.calc_Cinv_storage(
StorageVol_m3, locator, config, 'TES2')
addcosts_Capex_a_USD += Capex_a_storage_USD
addcosts_Opex_fixed_USD += Opex_fixed_storage_USD
addcosts_Capex_USD += Capex_storage_USD
# Costs from distribution configuration
if gv.ZernezFlag == 1:
NetworkCost_a_USD, NetworkCost_USD = network.calc_Cinv_network_linear(
gv.NetworkLengthZernez, gv)
NetworkCost_a_USD = NetworkCost_a_USD * nBuildinNtw / len(
buildList)
NetworkCost_USD = NetworkCost_USD * nBuildinNtw / len(buildList)
else:
NetworkCost_USD = network_features.pipesCosts_DHN_USD
NetworkCost_USD = NetworkCost_USD * nBuildinNtw / len(buildList)
NetworkCost_a_USD = NetworkCost_USD * gv.PipeInterestRate * (
1 + gv.PipeInterestRate)**gv.PipeLifeTime / (
(1 + gv.PipeInterestRate)**gv.PipeLifeTime - 1)
addcosts_Capex_a_USD += NetworkCost_a_USD
addcosts_Capex_USD += NetworkCost_USD
# HEX (1 per building in ntw)
for (index, building_name) in zip(DHN_barcode, buildList):
if index == "1":
df = pd.read_csv(
locator.get_optimization_substations_results_file(
building_name),
usecols=["Q_dhw_W", "Q_heating_W"])
subsArray = np.array(df)
Q_max_W = np.amax(subsArray[:, 0] + subsArray[:, 1])
Capex_a_HEX_building_USD, Opex_fixed_HEX_building_USD, Capex_HEX_building_USD = hex.calc_Cinv_HEX(
Q_max_W, locator, config, 'HEX1')
addcosts_Capex_a_USD += Capex_a_HEX_building_USD
addcosts_Opex_fixed_USD += Opex_fixed_HEX_building_USD
addcosts_Capex_USD += Capex_HEX_building_USD
# HEX for solar
roof_area_m2 = np.array(
pd.read_csv(locator.get_total_demand(), usecols=["Aroof_m2"]))
areaAvail = 0
for i in range(len(DHN_barcode)):
index = DHN_barcode[i]
if index == "1":
areaAvail += roof_area_m2[i][0]
for i in range(len(DHN_barcode)):
index = DHN_barcode[i]
if index == "1":
share = roof_area_m2[i][0] / areaAvail
#print share, "solar area share", buildList[i]
Q_max_SC_ET_Wh = solar_features.Q_nom_SC_ET_Wh * master_to_slave_vars.SOLAR_PART_SC_ET * share
Capex_a_HEX_SC_ET_USD, Opex_fixed_HEX_SC_ET_USD, Capex_HEX_SC_ET_USD = hex.calc_Cinv_HEX(
Q_max_SC_ET_Wh, locator, config, 'HEX1')
addcosts_Capex_a_USD += Capex_a_HEX_SC_ET_USD
addcosts_Opex_fixed_USD += Opex_fixed_HEX_SC_ET_USD
addcosts_Capex_USD += Capex_HEX_SC_ET_USD
Q_max_SC_FP_Wh = solar_features.Q_nom_SC_FP_Wh * master_to_slave_vars.SOLAR_PART_SC_FP * share
Capex_a_HEX_SC_FP_USD, Opex_fixed_HEX_SC_FP_USD, Capex_HEX_SC_FP_USD = hex.calc_Cinv_HEX(
Q_max_SC_FP_Wh, locator, config, 'HEX1')
addcosts_Capex_a_USD += Capex_a_HEX_SC_FP_USD
addcosts_Opex_fixed_USD += Opex_fixed_HEX_SC_FP_USD
addcosts_Capex_USD += Capex_HEX_SC_FP_USD
Q_max_PVT_Wh = solar_features.Q_nom_PVT_Wh * master_to_slave_vars.SOLAR_PART_PVT * share
Capex_a_HEX_PVT_USD, Opex_fixed_HEX_PVT_USD, Capex_HEX_PVT_USD = hex.calc_Cinv_HEX(
Q_max_PVT_Wh, locator, config, 'HEX1')
addcosts_Capex_a_USD += Capex_a_HEX_PVT_USD
addcosts_Opex_fixed_USD += Opex_fixed_HEX_PVT_USD
addcosts_Capex_USD += Capex_HEX_PVT_USD
# Pump operation costs
Capex_a_pump_USD, Opex_fixed_pump_USD, Opex_var_pump_USD, Capex_pump_USD = pumps.calc_Ctot_pump(
master_to_slave_vars, network_features, gv, locator, lca, config)
addcosts_Capex_a_USD += Capex_a_pump_USD
addcosts_Opex_fixed_USD += Opex_fixed_pump_USD
addcosts_Capex_USD += Capex_pump_USD
# import gas consumption data from:
if DHN_barcode.count("1") > 0 and config.district_heating_network:
# import gas consumption data from:
EgasPrimaryDataframe_W = pd.read_csv(
locator.get_optimization_slave_natural_gas_imports(
master_to_slave_vars.individual_number,
master_to_slave_vars.generation_number))
E_gas_primary_peak_power_W = np.amax(
EgasPrimaryDataframe_W['NG_total_W'])
GasConnectionInvCost = ngas.calc_Cinv_gas(E_gas_primary_peak_power_W,
gv)
elif DCN_barcode.count("1") > 0 and config.district_cooling_network:
EgasPrimaryDataframe_W = pd.read_csv(
locator.get_optimization_slave_natural_gas_imports(
master_to_slave_vars.individual_number,
master_to_slave_vars.generation_number))
E_gas_primary_peak_power_W = np.amax(
EgasPrimaryDataframe_W['NG_total_W'])
GasConnectionInvCost = ngas.calc_Cinv_gas(E_gas_primary_peak_power_W,
gv)
else:
GasConnectionInvCost = 0.0
addcosts_Capex_a_USD += GasConnectionInvCost
# Save data
results = pd.DataFrame({
"Capex_a_SC_ET_USD": [Capex_a_SC_ET_USD],
"Capex_a_SC_FP_USD": [Capex_a_SC_FP_USD],
"Opex_fixed_SC": [Opex_fixed_SC],
"Capex_a_PVT": [Capex_a_PVT_USD],
"Opex_fixed_PVT": [Opex_fixed_PVT_USD],
"Capex_a_Boiler_backup": [Capex_a_Boiler_backup_USD],
"Opex_fixed_Boiler_backup": [Opex_fixed_Boiler_backup_USD],
"Capex_a_storage_HEX": [Capex_a_HP_storage_USD],
"Opex_fixed_storage_HEX": [Opex_fixed_HP_storage_USD],
"Capex_a_storage_HP": [Capex_a_storage_HP],
"Capex_a_CHP": [Capex_a_CHP_USD],
"Opex_fixed_CHP": [Opex_fixed_CHP_USD],
"StorageInvC": [StorageInvC],
"StorageCostSum": [StorageInvC + Capex_a_storage_HP + Capex_a_HEX],
"NetworkCost": [NetworkCost_a_USD],
"SubstHEXCost": [SubstHEXCost_capex],
"DHNInvestCost": [addcosts_Capex_a_USD - CostDiscBuild],
"PVTHEXCost_Capex": [PVTHEXCost_Capex],
"CostDiscBuild": [CostDiscBuild],
"CO2DiscBuild": [CO2DiscBuild],
"PrimDiscBuild": [PrimDiscBuild],
"Capex_a_furnace": [Capex_a_furnace_USD],
"Opex_fixed_furnace": [Opex_fixed_furnace_USD],
"Capex_a_Boiler": [Capex_a_Boiler_USD],
"Opex_fixed_Boiler": [Opex_fixed_Boiler_USD],
"Capex_a_Boiler_peak": [Capex_a_Boiler_peak_USD],
"Opex_fixed_Boiler_peak": [Opex_fixed_Boiler_peak_USD],
"Capex_Disconnected": [Capex_Disconnected],
"Opex_Disconnected": [Opex_Disconnected],
"Capex_a_Lake": [Capex_a_Lake_USD],
"Opex_fixed_Lake": [Opex_fixed_Lake_USD],
"Capex_a_Sewage": [Capex_a_Sewage_USD],
"Opex_fixed_Sewage": [Opex_fixed_Sewage_USD],
"SCHEXCost_Capex": [SCHEXCost_Capex],
"Capex_a_pump": [Capex_a_pump_USD],
"Opex_fixed_pump": [Opex_fixed_pump_USD],
"Opex_var_pump": [Opex_var_pump_USD],
"Sum_CAPEX": [addcosts_Capex_a_USD],
"Sum_OPEX_fixed": [addcosts_Opex_fixed_USD],
"GasConnectionInvCa": [GasConnectionInvCost],
"CO2_PV_disconnected": [CO2_PV_disconnected],
"cost_PV_disconnected": [cost_PV_disconnected],
"Eprim_PV_disconnected": [Eprim_PV_disconnected],
"Capex_SC_ET_USD": [Capex_SC_ET_USD],
"Capex_SC_FP_USD": [Capex_SC_FP_USD],
"Capex_PVT": [Capex_PVT_USD],
"Capex_Boiler_backup": [Capex_Boiler_backup_USD],
"Capex_storage_HEX": [Capex_HP_storage_USD],
"Capex_storage_HP": [Capex_storage_HP],
"Capex_CHP": [Capex_CHP_USD],
"Capex_furnace": [Capex_furnace_USD],
"Capex_Boiler_base": [Capex_Boiler_USD],
"Capex_Boiler_peak": [Capex_Boiler_peak_USD],
"Capex_Lake": [Capex_Lake_USD],
"Capex_Sewage": [Capex_Sewage_USD],
"Capex_pump": [Capex_pump_USD],
})
results.to_csv(locator.get_optimization_slave_investment_cost_detailed(
master_to_slave_vars.individual_number,
master_to_slave_vars.generation_number),
sep=',')
return (addcosts_Capex_a_USD + addcosts_Opex_fixed_USD, addCO2, addPrim)
def addCosts(DHN_barcode, DCN_barcode, buildList, locator,
master_to_slave_vars, Q_uncovered_design_W, Q_uncovered_annual_W,
solarFeat, ntwFeat, gv, config, prices, lca):
"""
Computes additional costs / GHG emisions / primary energy needs
for the individual
addCosts = additional costs
addCO2 = GHG emissions
addPrm = primary energy needs
:param DHN_barcode: parameter indicating if the building is connected or not
:param buildList: list of buildings in the district
:param locator: input locator set to scenario
:param master_to_slave_vars: class containing the features of a specific individual
:param Q_uncovered_design_W: hourly max of the heating uncovered demand
:param Q_uncovered_annual_W: total heating uncovered
:param solarFeat: solar features
:param ntwFeat: network features
:param gv: global variables
:type indCombi: string
:type buildList: list
:type locator: string
:type master_to_slave_vars: class
:type Q_uncovered_design_W: float
:type Q_uncovered_annual_W: float
:type solarFeat: class
:type ntwFeat: class
:type gv: class
:return: returns the objectives addCosts, addCO2, addPrim
:rtype: tuple
"""
addcosts_Capex_a = 0
addcosts_Opex_fixed = 0
addCO2 = 0
addPrim = 0
nBuildinNtw = 0
# Add the features from the disconnected buildings
CostDiscBuild = 0
CO2DiscBuild = 0
PrimDiscBuild = 0
Capex_Disconnected = 0
Opex_Disconnected = 0
Capex_a_furnace = 0
Capex_a_CHP = 0
Capex_a_Boiler = 0
Capex_a_Boiler_peak = 0
Capex_a_Lake = 0
Capex_a_Sewage = 0
Capex_a_GHP = 0
Capex_a_PV = 0
Capex_a_SC = 0
Capex_a_PVT = 0
Capex_a_Boiler_backup = 0
Capex_a_HEX = 0
Capex_a_storage_HP = 0
Capex_a_HP_storage = 0
Opex_fixed_SC = 0
Opex_fixed_PVT = 0
Opex_fixed_HP_PVT = 0
Opex_fixed_furnace = 0
Opex_fixed_CHP = 0
Opex_fixed_Boiler = 0
Opex_fixed_Boiler_peak = 0
Opex_fixed_Boiler_backup = 0
Opex_fixed_Lake = 0
Opex_fixed_wasteserver_HEX = 0
Opex_fixed_wasteserver_HP = 0
Opex_fixed_PV = 0
Opex_fixed_GHP = 0
Opex_fixed_storage = 0
Opex_fixed_Sewage = 0
Opex_fixed_HP_storage = 0
StorageInvC = 0
NetworkCost = 0
SubstHEXCost_capex = 0
SubstHEXCost_opex = 0
PVTHEXCost_Capex = 0
PVTHEXCost_Opex = 0
SCHEXCost_Capex = 0
SCHEXCost_Opex = 0
pumpCosts = 0
GasConnectionInvCost = 0
cost_PV_disconnected = 0
CO2_PV_disconnected = 0
Eprim_PV_disconnected = 0
if config.optimization.isheating:
for (index, building_name) in zip(DHN_barcode, buildList):
if index == "0":
df = pd.read_csv(
locator.
get_optimization_disconnected_folder_building_result_heating(
building_name))
dfBest = df[df["Best configuration"] == 1]
CostDiscBuild += dfBest["Total Costs [CHF]"].iloc[0] # [CHF]
CO2DiscBuild += dfBest["CO2 Emissions [kgCO2-eq]"].iloc[
0] # [kg CO2]
PrimDiscBuild += dfBest[
"Primary Energy Needs [MJoil-eq]"].iloc[0] # [MJ-oil-eq]
Capex_Disconnected += dfBest[
"Annualized Investment Costs [CHF]"].iloc[0]
Opex_Disconnected += dfBest["Operation Costs [CHF]"].iloc[0]
else:
nBuildinNtw += 1
if config.optimization.iscooling:
PV_barcode = ''
for (index, building_name) in zip(DCN_barcode, buildList):
if index == "0": # choose the best decentralized configuration
df = pd.read_csv(
locator.
get_optimization_disconnected_folder_building_result_cooling(
building_name, configuration='AHU_ARU_SCU'))
dfBest = df[df["Best configuration"] == 1]
CostDiscBuild += dfBest["Total Costs [CHF]"].iloc[0] # [CHF]
CO2DiscBuild += dfBest["CO2 Emissions [kgCO2-eq]"].iloc[
0] # [kg CO2]
PrimDiscBuild += dfBest[
"Primary Energy Needs [MJoil-eq]"].iloc[0] # [MJ-oil-eq]
Capex_Disconnected += dfBest[
"Annualized Investment Costs [CHF]"].iloc[0]
Opex_Disconnected += dfBest["Operation Costs [CHF]"].iloc[0]
to_PV = 1
if dfBest["single effect ACH to AHU_ARU_SCU Share (FP)"].iloc[
0] == 1:
to_PV = 0
if dfBest["single effect ACH to AHU_ARU_SCU Share (ET)"].iloc[
0] == 1:
to_PV = 0
if dfBest["single effect ACH to SCU Share (FP)"].iloc[0] == 1:
to_PV = 0
else: # adding costs for buildings in which the centralized plant provides a part of the load requirements
DCN_unit_configuration = master_to_slave_vars.DCN_supplyunits
if DCN_unit_configuration == 1: # corresponds to AHU in the central plant, so remaining load need to be provided by decentralized plant
decentralized_configuration = 'ARU_SCU'
df = pd.read_csv(
locator.
get_optimization_disconnected_folder_building_result_cooling(
building_name, decentralized_configuration))
dfBest = df[df["Best configuration"] == 1]
CostDiscBuild += dfBest["Total Costs [CHF]"].iloc[
0] # [CHF]
CO2DiscBuild += dfBest["CO2 Emissions [kgCO2-eq]"].iloc[
0] # [kg CO2]
PrimDiscBuild += dfBest[
"Primary Energy Needs [MJoil-eq]"].iloc[
0] # [MJ-oil-eq]
Capex_Disconnected += dfBest[
"Annualized Investment Costs [CHF]"].iloc[0]
Opex_Disconnected += dfBest["Operation Costs [CHF]"].iloc[
0]
to_PV = 1
if dfBest["single effect ACH to ARU_SCU Share (FP)"].iloc[
0] == 1:
to_PV = 0
if dfBest["single effect ACH to ARU_SCU Share (ET)"].iloc[
0] == 1:
to_PV = 0
if DCN_unit_configuration == 2: # corresponds to ARU in the central plant, so remaining load need to be provided by decentralized plant
decentralized_configuration = 'AHU_SCU'
df = pd.read_csv(
locator.
get_optimization_disconnected_folder_building_result_cooling(
building_name, decentralized_configuration))
dfBest = df[df["Best configuration"] == 1]
CostDiscBuild += dfBest["Total Costs [CHF]"].iloc[
0] # [CHF]
CO2DiscBuild += dfBest["CO2 Emissions [kgCO2-eq]"].iloc[
0] # [kg CO2]
PrimDiscBuild += dfBest[
"Primary Energy Needs [MJoil-eq]"].iloc[
0] # [MJ-oil-eq]
Capex_Disconnected += dfBest[
"Annualized Investment Costs [CHF]"].iloc[0]
Opex_Disconnected += dfBest["Operation Costs [CHF]"].iloc[
0]
to_PV = 1
if dfBest["single effect ACH to AHU_SCU Share (FP)"].iloc[
0] == 1:
to_PV = 0
if dfBest["single effect ACH to AHU_SCU Share (ET)"].iloc[
0] == 1:
to_PV = 0
if DCN_unit_configuration == 3: # corresponds to SCU in the central plant, so remaining load need to be provided by decentralized plant
decentralized_configuration = 'AHU_ARU'
df = pd.read_csv(
locator.
get_optimization_disconnected_folder_building_result_cooling(
building_name, decentralized_configuration))
dfBest = df[df["Best configuration"] == 1]
CostDiscBuild += dfBest["Total Costs [CHF]"].iloc[
0] # [CHF]
CO2DiscBuild += dfBest["CO2 Emissions [kgCO2-eq]"].iloc[
0] # [kg CO2]
PrimDiscBuild += dfBest[
"Primary Energy Needs [MJoil-eq]"].iloc[
0] # [MJ-oil-eq]
Capex_Disconnected += dfBest[
"Annualized Investment Costs [CHF]"].iloc[0]
Opex_Disconnected += dfBest["Operation Costs [CHF]"].iloc[
0]
to_PV = 1
if dfBest["single effect ACH to AHU_ARU Share (FP)"].iloc[
0] == 1:
to_PV = 0
if dfBest["single effect ACH to AHU_ARU Share (ET)"].iloc[
0] == 1:
to_PV = 0
if DCN_unit_configuration == 4: # corresponds to AHU + ARU in the central plant, so remaining load need to be provided by decentralized plant
decentralized_configuration = 'SCU'
df = pd.read_csv(
locator.
get_optimization_disconnected_folder_building_result_cooling(
building_name, decentralized_configuration))
dfBest = df[df["Best configuration"] == 1]
CostDiscBuild += dfBest["Total Costs [CHF]"].iloc[
0] # [CHF]
CO2DiscBuild += dfBest["CO2 Emissions [kgCO2-eq]"].iloc[
0] # [kg CO2]
PrimDiscBuild += dfBest[
"Primary Energy Needs [MJoil-eq]"].iloc[
0] # [MJ-oil-eq]
Capex_Disconnected += dfBest[
"Annualized Investment Costs [CHF]"].iloc[0]
Opex_Disconnected += dfBest["Operation Costs [CHF]"].iloc[
0]
to_PV = 1
if dfBest["single effect ACH to SCU Share (FP)"].iloc[
0] == 1:
to_PV = 0
if dfBest["single effect ACH to SCU Share (ET)"].iloc[
0] == 1:
to_PV = 0
if DCN_unit_configuration == 5: # corresponds to AHU + SCU in the central plant, so remaining load need to be provided by decentralized plant
decentralized_configuration = 'ARU'
df = pd.read_csv(
locator.
get_optimization_disconnected_folder_building_result_cooling(
building_name, decentralized_configuration))
dfBest = df[df["Best configuration"] == 1]
CostDiscBuild += dfBest["Total Costs [CHF]"].iloc[
0] # [CHF]
CO2DiscBuild += dfBest["CO2 Emissions [kgCO2-eq]"].iloc[
0] # [kg CO2]
PrimDiscBuild += dfBest[
"Primary Energy Needs [MJoil-eq]"].iloc[
0] # [MJ-oil-eq]
Capex_Disconnected += dfBest[
"Annualized Investment Costs [CHF]"].iloc[0]
Opex_Disconnected += dfBest["Operation Costs [CHF]"].iloc[
0]
to_PV = 1
if dfBest["single effect ACH to ARU Share (FP)"].iloc[
0] == 1:
to_PV = 0
if dfBest["single effect ACH to ARU Share (ET)"].iloc[
0] == 1:
to_PV = 0
if DCN_unit_configuration == 6: # corresponds to ARU + SCU in the central plant, so remaining load need to be provided by decentralized plant
decentralized_configuration = 'AHU'
df = pd.read_csv(
locator.
get_optimization_disconnected_folder_building_result_cooling(
building_name, decentralized_configuration))
dfBest = df[df["Best configuration"] == 1]
CostDiscBuild += dfBest["Total Costs [CHF]"].iloc[
0] # [CHF]
CO2DiscBuild += dfBest["CO2 Emissions [kgCO2-eq]"].iloc[
0] # [kg CO2]
PrimDiscBuild += dfBest[
"Primary Energy Needs [MJoil-eq]"].iloc[
0] # [MJ-oil-eq]
Capex_Disconnected += dfBest[
"Annualized Investment Costs [CHF]"].iloc[0]
Opex_Disconnected += dfBest["Operation Costs [CHF]"].iloc[
0]
to_PV = 1
if dfBest["single effect ACH to AHU Share (FP)"].iloc[
0] == 1:
to_PV = 0
if dfBest["single effect ACH to AHU Share (ET)"].iloc[
0] == 1:
to_PV = 0
if DCN_unit_configuration == 7: # corresponds to AHU + ARU + SCU from central plant
to_PV = 1
nBuildinNtw += 1
PV_barcode = PV_barcode + str(to_PV)
addcosts_Capex_a += CostDiscBuild
addCO2 += CO2DiscBuild
addPrim += PrimDiscBuild
if not config.optimization.isheating:
if PV_barcode.count("1") > 0:
df1 = pd.DataFrame({'A': []})
for (i, index) in enumerate(PV_barcode):
if index == str(1):
if df1.empty:
data = pd.read_csv(locator.PV_results(buildList[i]))
df1 = data
else:
data = pd.read_csv(locator.PV_results(buildList[i]))
df1 = df1 + data
if not df1.empty:
df1.to_csv(locator.PV_network(PV_barcode),
index=True,
float_format='%.2f')
solar_data = pd.read_csv(locator.PV_network(PV_barcode),
usecols=['E_PV_gen_kWh', 'Area_PV_m2'],
nrows=8760)
E_PV_sum_kW = np.sum(solar_data['E_PV_gen_kWh'])
E_PV_W = solar_data['E_PV_gen_kWh'] * 1000
Area_AvailablePV_m2 = np.max(solar_data['Area_PV_m2'])
Q_PowerPeakAvailablePV_kW = Area_AvailablePV_m2 * ETA_AREA_TO_PEAK
KEV_RpPerkWhPV = calc_Crem_pv(Q_PowerPeakAvailablePV_kW * 1000.0)
KEV_total = KEV_RpPerkWhPV / 100 * np.sum(E_PV_sum_kW)
addcosts_Capex_a = addcosts_Capex_a - KEV_total
addCO2 = addCO2 - (E_PV_sum_kW * 1000 *
(lca.EL_PV_TO_CO2 - lca.EL_TO_CO2_GREEN) *
WH_TO_J / 1.0E6)
addPrim = addPrim - (E_PV_sum_kW * 1000 *
(lca.EL_PV_TO_OIL_EQ - lca.EL_TO_OIL_EQ_GREEN)
* WH_TO_J / 1.0E6)
cost_PV_disconnected = KEV_total
CO2_PV_disconnected = (E_PV_sum_kW * 1000 *
(lca.EL_PV_TO_CO2 - lca.EL_TO_CO2_GREEN) *
WH_TO_J / 1.0E6)
Eprim_PV_disconnected = (
E_PV_sum_kW * 1000 *
(lca.EL_PV_TO_OIL_EQ - lca.EL_TO_OIL_EQ_GREEN) * WH_TO_J /
1.0E6)
network_data = pd.read_csv(
locator.get_optimization_network_data_folder(
master_to_slave_vars.network_data_file_cooling))
E_total_req_W = np.array(network_data['Electr_netw_total_W'])
cooling_data = pd.read_csv(
locator.get_optimization_slave_cooling_activation_pattern(
master_to_slave_vars.individual_number,
master_to_slave_vars.generation_number))
E_from_CHP_W = np.array(cooling_data[
'E_gen_CCGT_associated_with_absorption_chillers_W'])
E_CHP_to_directload_W = np.zeros(8760)
E_CHP_to_grid_W = np.zeros(8760)
E_PV_to_directload_W = np.zeros(8760)
E_PV_to_grid_W = np.zeros(8760)
E_from_grid_W = np.zeros(8760)
for hour in range(8760):
E_hour_W = E_total_req_W[hour]
if E_hour_W > 0:
if E_PV_W[hour] > E_hour_W:
E_PV_to_directload_W[hour] = E_hour_W
E_PV_to_grid_W[
hour] = E_PV_W[hour] - E_total_req_W[hour]
E_hour_W = 0
else:
E_hour_W = E_hour_W - E_PV_W[hour]
E_PV_to_directload_W[hour] = E_PV_W[hour]
if E_from_CHP_W[hour] > E_hour_W:
E_CHP_to_directload_W[hour] = E_hour_W
E_CHP_to_grid_W[hour] = E_from_CHP_W[hour] - E_hour_W
E_hour_W = 0
else:
E_hour_W = E_hour_W - E_from_CHP_W[hour]
E_CHP_to_directload_W[hour] = E_from_CHP_W[hour]
E_from_grid_W[hour] = E_hour_W
date = network_data.DATE.values
results = pd.DataFrame({
"DATE":
date,
"E_total_req_W":
E_total_req_W,
"E_PV_W":
solar_data['E_PV_gen_kWh'] * 1000,
"Area_PV_m2":
solar_data['Area_PV_m2'],
"KEV":
KEV_RpPerkWhPV / 100 * solar_data['E_PV_gen_kWh'],
"E_from_grid_W":
E_from_grid_W,
"E_PV_to_directload_W":
E_PV_to_directload_W,
"E_CHP_to_directload_W":
E_CHP_to_directload_W,
"E_CHP_to_grid_W":
E_CHP_to_grid_W,
"E_PV_to_grid_W":
E_PV_to_grid_W
})
results.to_csv(
locator.
get_optimization_slave_electricity_activation_pattern_cooling(
master_to_slave_vars.individual_number,
master_to_slave_vars.generation_number),
index=False)
# Add the features for the distribution
if DHN_barcode.count("1") > 0 and config.optimization.isheating:
os.chdir(
locator.get_optimization_slave_results_folder(
master_to_slave_vars.generation_number))
# Add the investment costs of the energy systems
# Furnace
if master_to_slave_vars.Furnace_on == 1:
P_design_W = master_to_slave_vars.Furnace_Q_max
fNameSlavePP = locator.get_optimization_slave_heating_activation_pattern_heating(
master_to_slave_vars.configKey,
master_to_slave_vars.individual_number,
master_to_slave_vars.generation_number)
dfFurnace = pd.read_csv(fNameSlavePP, usecols=["Q_Furnace_W"])
arrayFurnace_W = np.array(dfFurnace)
Q_annual_W = 0
for i in range(int(np.shape(arrayFurnace_W)[0])):
Q_annual_W += arrayFurnace_W[i][0]
Capex_a_furnace, Opex_fixed_furnace = furnace.calc_Cinv_furnace(
P_design_W, Q_annual_W, config, locator, 'FU1')
addcosts_Capex_a += Capex_a_furnace
addcosts_Opex_fixed += Opex_fixed_furnace
# CC
if master_to_slave_vars.CC_on == 1:
CC_size_W = master_to_slave_vars.CC_GT_SIZE
Capex_a_CHP, Opex_fixed_CHP = chp.calc_Cinv_CCGT(
CC_size_W, locator, config)
addcosts_Capex_a += Capex_a_CHP
addcosts_Opex_fixed += Opex_fixed_CHP
# Boiler Base
if master_to_slave_vars.Boiler_on == 1:
Q_design_W = master_to_slave_vars.Boiler_Q_max
fNameSlavePP = locator.get_optimization_slave_heating_activation_pattern(
master_to_slave_vars.individual_number,
master_to_slave_vars.generation_number)
dfBoilerBase = pd.read_csv(fNameSlavePP,
usecols=["Q_BaseBoiler_W"])
arrayBoilerBase_W = np.array(dfBoilerBase)
Q_annual_W = 0
for i in range(int(np.shape(arrayBoilerBase_W)[0])):
Q_annual_W += arrayBoilerBase_W[i][0]
Capex_a_Boiler, Opex_fixed_Boiler = boiler.calc_Cinv_boiler(
Q_design_W, locator, config, 'BO1')
addcosts_Capex_a += Capex_a_Boiler
addcosts_Opex_fixed += Opex_fixed_Boiler
# Boiler Peak
if master_to_slave_vars.BoilerPeak_on == 1:
Q_design_W = master_to_slave_vars.BoilerPeak_Q_max
fNameSlavePP = locator.get_optimization_slave_heating_activation_pattern(
master_to_slave_vars.individual_number,
master_to_slave_vars.generation_number)
dfBoilerPeak = pd.read_csv(fNameSlavePP,
usecols=["Q_PeakBoiler_W"])
arrayBoilerPeak_W = np.array(dfBoilerPeak)
Q_annual_W = 0
for i in range(int(np.shape(arrayBoilerPeak_W)[0])):
Q_annual_W += arrayBoilerPeak_W[i][0]
Capex_a_Boiler_peak, Opex_fixed_Boiler_peak = boiler.calc_Cinv_boiler(
Q_design_W, locator, config, 'BO1')
addcosts_Capex_a += Capex_a_Boiler_peak
addcosts_Opex_fixed += Opex_fixed_Boiler_peak
# HP Lake
if master_to_slave_vars.HP_Lake_on == 1:
HP_Size_W = master_to_slave_vars.HPLake_maxSize
Capex_a_Lake, Opex_fixed_Lake = hp.calc_Cinv_HP(
HP_Size_W, locator, config, 'HP2')
addcosts_Capex_a += Capex_a_Lake
addcosts_Opex_fixed += Opex_fixed_Lake
# HP Sewage
if master_to_slave_vars.HP_Sew_on == 1:
HP_Size_W = master_to_slave_vars.HPSew_maxSize
Capex_a_Sewage, Opex_fixed_Sewage = hp.calc_Cinv_HP(
HP_Size_W, locator, config, 'HP2')
addcosts_Capex_a += Capex_a_Sewage
addcosts_Opex_fixed += Opex_fixed_Sewage
# GHP
if master_to_slave_vars.GHP_on == 1:
fNameSlavePP = locator.get_optimization_slave_electricity_activation_pattern_heating(
master_to_slave_vars.individual_number,
master_to_slave_vars.generation_number)
dfGHP = pd.read_csv(fNameSlavePP, usecols=["E_GHP_req_W"])
arrayGHP_W = np.array(dfGHP)
GHP_Enom_W = np.amax(arrayGHP_W)
Capex_a_GHP, Opex_fixed_GHP = hp.calc_Cinv_GHP(
GHP_Enom_W, locator, config)
addcosts_Capex_a += Capex_a_GHP * prices.EURO_TO_CHF
addcosts_Opex_fixed += Opex_fixed_GHP * prices.EURO_TO_CHF
# Solar technologies
PV_installed_area_m2 = master_to_slave_vars.SOLAR_PART_PV * solarFeat.A_PV_m2 #kW
Capex_a_PV, Opex_fixed_PV = pv.calc_Cinv_pv(PV_installed_area_m2,
locator, config)
addcosts_Capex_a += Capex_a_PV
addcosts_Opex_fixed += Opex_fixed_PV
SC_ET_area_m2 = master_to_slave_vars.SOLAR_PART_SC_ET * solarFeat.A_SC_ET_m2
Capex_a_SC_ET, Opex_fixed_SC_ET = stc.calc_Cinv_SC(
SC_ET_area_m2, locator, config, 'ET')
addcosts_Capex_a += Capex_a_SC_ET
addcosts_Opex_fixed += Opex_fixed_SC_ET
SC_FP_area_m2 = master_to_slave_vars.SOLAR_PART_SC_FP * solarFeat.A_SC_FP_m2
Capex_a_SC_FP, Opex_fixed_SC_FP = stc.calc_Cinv_SC(
SC_FP_area_m2, locator, config, 'FP')
addcosts_Capex_a += Capex_a_SC_FP
addcosts_Opex_fixed += Opex_fixed_SC_FP
PVT_peak_kW = master_to_slave_vars.SOLAR_PART_PVT * solarFeat.A_PVT_m2 * N_PVT #kW
Capex_a_PVT, Opex_fixed_PVT = pvt.calc_Cinv_PVT(
PVT_peak_kW, locator, config)
addcosts_Capex_a += Capex_a_PVT
addcosts_Opex_fixed += Opex_fixed_PVT
# Back-up boiler
Capex_a_Boiler_backup, Opex_fixed_Boiler_backup = boiler.calc_Cinv_boiler(
Q_uncovered_design_W, locator, config, 'BO1')
addcosts_Capex_a += Capex_a_Boiler_backup
addcosts_Opex_fixed += Opex_fixed_Boiler_backup
# Hex and HP for Heat recovery
if master_to_slave_vars.WasteServersHeatRecovery == 1:
df = pd.read_csv(os.path.join(
locator.get_optimization_network_results_folder(),
master_to_slave_vars.network_data_file_heating),
usecols=["Qcdata_netw_total_kWh"])
array = np.array(df)
Q_HEX_max_kWh = np.amax(array)
Capex_a_wasteserver_HEX, Opex_fixed_wasteserver_HEX = hex.calc_Cinv_HEX(
Q_HEX_max_kWh, locator, config, 'HEX1')
addcosts_Capex_a += (Capex_a_wasteserver_HEX)
addcosts_Opex_fixed += Opex_fixed_wasteserver_HEX
df = pd.read_csv(
locator.get_optimization_slave_storage_operation_data(
master_to_slave_vars.individual_number,
master_to_slave_vars.generation_number),
usecols=["HPServerHeatDesignArray_kWh"])
array = np.array(df)
Q_HP_max_kWh = np.amax(array)
Capex_a_wasteserver_HP, Opex_fixed_wasteserver_HP = hp.calc_Cinv_HP(
Q_HP_max_kWh, locator, config, 'HP2')
addcosts_Capex_a += (Capex_a_wasteserver_HP)
addcosts_Opex_fixed += Opex_fixed_wasteserver_HP
# if master_to_slave_vars.WasteCompressorHeatRecovery == 1:
# df = pd.read_csv(
# os.path.join(locator.get_optimization_network_results_folder(), master_to_slave_vars.network_data_file_heating),
# usecols=["Ecaf_netw_total_kWh"])
# array = np.array(df)
# Q_HEX_max_kWh = np.amax(array)
#
# Capex_a_wastecompressor_HEX, Opex_fixed_wastecompressor_HEX = hex.calc_Cinv_HEX(Q_HEX_max_kWh, locator,
# config, 'HEX1')
# addcosts_Capex_a += (Capex_a_wastecompressor_HEX)
# addcosts_Opex_fixed += Opex_fixed_wastecompressor_HEX
# df = pd.read_csv(
# locator.get_optimization_slave_storage_operation_data(master_to_slave_vars.individual_number,
# master_to_slave_vars.generation_number),
# usecols=["HPCompAirDesignArray_kWh"])
# array = np.array(df)
# Q_HP_max_kWh = np.amax(array)
# Capex_a_wastecompressor_HP, Opex_fixed_wastecompressor_HP = hp.calc_Cinv_HP(Q_HP_max_kWh, locator, config, 'HP2')
# addcosts_Capex_a += (Capex_a_wastecompressor_HP)
# addcosts_Opex_fixed += Opex_fixed_wastecompressor_HP
# Heat pump from solar to DH
df = pd.read_csv(
locator.get_optimization_slave_storage_operation_data(
master_to_slave_vars.individual_number,
master_to_slave_vars.generation_number),
usecols=["HPScDesignArray_Wh", "HPpvt_designArray_Wh"])
array = np.array(df)
Q_HP_max_PVT_wh = np.amax(array[:, 1])
Q_HP_max_SC_Wh = np.amax(array[:, 0])
Capex_a_HP_PVT, Opex_fixed_HP_PVT = hp.calc_Cinv_HP(
Q_HP_max_PVT_wh, locator, config, 'HP2')
Capex_a_storage_HP += (Capex_a_HP_PVT)
addcosts_Opex_fixed += Opex_fixed_HP_PVT
Capex_a_HP_SC, Opex_fixed_HP_SC = hp.calc_Cinv_HP(
Q_HP_max_SC_Wh, locator, config, 'HP2')
Capex_a_storage_HP += (Capex_a_HP_SC)
addcosts_Opex_fixed += Opex_fixed_HP_SC
# HP for storage operation for charging from solar and discharging to DH
df = pd.read_csv(locator.get_optimization_slave_storage_operation_data(
master_to_slave_vars.individual_number,
master_to_slave_vars.generation_number),
usecols=[
"E_aux_ch_W", "E_aux_dech_W",
"Q_from_storage_used_W", "Q_to_storage_W"
])
array = np.array(df)
Q_HP_max_storage_W = 0
for i in range(DAYS_IN_YEAR * HOURS_IN_DAY):
if array[i][0] > 0:
Q_HP_max_storage_W = max(Q_HP_max_storage_W,
array[i][3] + array[i][0])
elif array[i][1] > 0:
Q_HP_max_storage_W = max(Q_HP_max_storage_W,
array[i][2] + array[i][1])
Capex_a_HP_storage, Opex_fixed_HP_storage = hp.calc_Cinv_HP(
Q_HP_max_storage_W, locator, config, 'HP2')
addcosts_Capex_a += (Capex_a_HP_storage)
addcosts_Opex_fixed += Opex_fixed_HP_storage
# Storage
df = pd.read_csv(locator.get_optimization_slave_storage_operation_data(
master_to_slave_vars.individual_number,
master_to_slave_vars.generation_number),
usecols=["Storage_Size_m3"],
nrows=1)
StorageVol_m3 = np.array(df)[0][0]
Capex_a_storage, Opex_fixed_storage = storage.calc_Cinv_storage(
StorageVol_m3, locator, config, 'TES2')
addcosts_Capex_a += Capex_a_storage
addcosts_Opex_fixed += Opex_fixed_storage
# Costs from distribution configuration
if gv.ZernezFlag == 1:
NetworkCost += network.calc_Cinv_network_linear(
gv.NetworkLengthZernez, gv) * nBuildinNtw / len(buildList)
else:
NetworkCost += ntwFeat.pipesCosts_DHN * nBuildinNtw / len(
buildList)
addcosts_Capex_a += NetworkCost
# HEX (1 per building in ntw)
for (index, building_name) in zip(DHN_barcode, buildList):
if index == "1":
df = pd.read_csv(
locator.get_optimization_substations_results_file(
building_name),
usecols=["Q_dhw_W", "Q_heating_W"])
subsArray = np.array(df)
Q_max_W = np.amax(subsArray[:, 0] + subsArray[:, 1])
Capex_a_HEX_building, Opex_fixed_HEX_building = hex.calc_Cinv_HEX(
Q_max_W, locator, config, 'HEX1')
addcosts_Capex_a += Capex_a_HEX_building
addcosts_Opex_fixed += Opex_fixed_HEX_building
# HEX for solar
roof_area_m2 = np.array(
pd.read_csv(locator.get_total_demand(), usecols=["Aroof_m2"]))
areaAvail = 0
for i in range(len(DHN_barcode)):
index = DHN_barcode[i]
if index == "1":
areaAvail += roof_area_m2[i][0]
for i in range(len(DHN_barcode)):
index = DHN_barcode[i]
if index == "1":
share = roof_area_m2[i][0] / areaAvail
#print share, "solar area share", buildList[i]
Q_max_SC_ET_Wh = solarFeat.Q_nom_SC_ET_Wh * master_to_slave_vars.SOLAR_PART_SC_ET * share
Capex_a_HEX_SC_ET, Opex_fixed_HEX_SC_ET = hex.calc_Cinv_HEX(
Q_max_SC_ET_Wh, locator, config, 'HEX1')
addcosts_Capex_a += Capex_a_HEX_SC_ET
addcosts_Opex_fixed += Opex_fixed_HEX_SC_ET
Q_max_SC_FP_Wh = solarFeat.Q_nom_SC_FP_Wh * master_to_slave_vars.SOLAR_PART_SC_FP * share
Capex_a_HEX_SC_FP, Opex_fixed_HEX_SC_FP = hex.calc_Cinv_HEX(
Q_max_SC_FP_Wh, locator, config, 'HEX1')
addcosts_Capex_a += Capex_a_HEX_SC_FP
addcosts_Opex_fixed += Opex_fixed_HEX_SC_FP
Q_max_PVT_Wh = solarFeat.Q_nom_PVT_Wh * master_to_slave_vars.SOLAR_PART_PVT * share
Capex_a_HEX_PVT, Opex_fixed_HEX_PVT = hex.calc_Cinv_HEX(
Q_max_PVT_Wh, locator, config, 'HEX1')
addcosts_Capex_a += Capex_a_HEX_PVT
addcosts_Opex_fixed += Opex_fixed_HEX_PVT
# Pump operation costs
Capex_a_pump, Opex_fixed_pump, Opex_var_pump = pumps.calc_Ctot_pump(
master_to_slave_vars, ntwFeat, gv, locator, lca, config)
addcosts_Capex_a += Capex_a_pump
addcosts_Opex_fixed += Opex_fixed_pump
# import gas consumption data from:
if DHN_barcode.count("1") > 0 and config.optimization.isheating:
# import gas consumption data from:
EgasPrimaryDataframe_W = pd.read_csv(
locator.get_optimization_slave_cost_prime_primary_energy_data(
master_to_slave_vars.individual_number,
master_to_slave_vars.generation_number),
usecols=["E_gas_PrimaryPeakPower_W"])
E_gas_primary_peak_power_W = float(np.array(EgasPrimaryDataframe_W))
GasConnectionInvCost = ngas.calc_Cinv_gas(E_gas_primary_peak_power_W,
gv)
else:
GasConnectionInvCost = 0.0
addcosts_Capex_a += GasConnectionInvCost
# Save data
results = pd.DataFrame({
"Capex_a_SC": [Capex_a_SC],
"Opex_fixed_SC": [Opex_fixed_SC],
"Capex_a_PVT": [Capex_a_PVT],
"Opex_fixed_PVT": [Opex_fixed_PVT],
"Capex_a_Boiler_backup": [Capex_a_Boiler_backup],
"Opex_fixed_Boiler_backup": [Opex_fixed_Boiler_backup],
"Capex_a_storage_HEX": [Capex_a_HP_storage],
"Opex_fixed_storage_HEX": [Opex_fixed_HP_storage],
"Capex_a_storage_HP": [Capex_a_storage_HP],
"Capex_a_CHP": [Capex_a_CHP],
"Opex_fixed_CHP": [Opex_fixed_CHP],
"StorageInvC": [StorageInvC],
"StorageCostSum": [StorageInvC + Capex_a_storage_HP + Capex_a_HEX],
"NetworkCost": [NetworkCost],
"SubstHEXCost": [SubstHEXCost_capex],
"DHNInvestCost": [addcosts_Capex_a - CostDiscBuild],
"PVTHEXCost_Capex": [PVTHEXCost_Capex],
"CostDiscBuild": [CostDiscBuild],
"CO2DiscBuild": [CO2DiscBuild],
"PrimDiscBuild": [PrimDiscBuild],
"Capex_a_furnace": [Capex_a_furnace],
"Opex_fixed_furnace": [Opex_fixed_furnace],
"Capex_a_Boiler": [Capex_a_Boiler],
"Opex_fixed_Boiler": [Opex_fixed_Boiler],
"Capex_a_Boiler_peak": [Capex_a_Boiler_peak],
"Opex_fixed_Boiler_peak": [Opex_fixed_Boiler_peak],
"Capex_Disconnected": [Capex_Disconnected],
"Opex_Disconnected": [Opex_Disconnected],
"Capex_a_Lake": [Capex_a_Lake],
"Opex_fixed_Lake": [Opex_fixed_Lake],
"Capex_a_Sewage": [Capex_a_Sewage],
"Opex_fixed_Sewage": [Opex_fixed_Sewage],
"SCHEXCost_Capex": [SCHEXCost_Capex],
"Capex_a_pump": [Capex_a_pump],
"Opex_fixed_pump": [Opex_fixed_pump],
"Opex_var_pump": [Opex_var_pump],
"Sum_CAPEX": [addcosts_Capex_a],
"Sum_OPEX_fixed": [addcosts_Opex_fixed],
"GasConnectionInvCa": [GasConnectionInvCost],
"CO2_PV_disconnected": [CO2_PV_disconnected],
"cost_PV_disconnected": [cost_PV_disconnected],
"Eprim_PV_disconnected": [Eprim_PV_disconnected]
})
results.to_csv(locator.get_optimization_slave_investment_cost_detailed(
master_to_slave_vars.individual_number,
master_to_slave_vars.generation_number),
sep=',')
return (addcosts_Capex_a + addcosts_Opex_fixed, addCO2, addPrim)
