def calc_Cinv_VCC(Q_nom_W, locator, technology_type): """ Annualized investment costs for the vapor compressor chiller :type Q_nom_W : float :param Q_nom_W: Nominal cooling demand in [W] :returns InvCa: annualized chiller investment cost in CHF/a :rtype InvCa: float """ Capex_a_VCC_USD = 0 Opex_fixed_VCC_USD = 0 Capex_VCC_USD = 0 if Q_nom_W > 0: VCC_cost_data = pd.read_excel(locator.get_database_conversion_systems(), sheet_name="Chiller") VCC_cost_data = VCC_cost_data[VCC_cost_data['code'] == technology_type] max_chiller_size = max(VCC_cost_data['cap_max'].values) # 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 Q_nom_W < VCC_cost_data.iloc[0]['cap_min']: Q_nom_W = VCC_cost_data.iloc[0]['cap_min'] if Q_nom_W <= max_chiller_size: VCC_cost_data = VCC_cost_data[(VCC_cost_data['cap_min'] <= Q_nom_W) & (VCC_cost_data['cap_max'] >= Q_nom_W)] Inv_a = VCC_cost_data.iloc[0]['a'] Inv_b = VCC_cost_data.iloc[0]['b'] Inv_c = VCC_cost_data.iloc[0]['c'] Inv_d = VCC_cost_data.iloc[0]['d'] Inv_e = VCC_cost_data.iloc[0]['e'] Inv_IR = VCC_cost_data.iloc[0]['IR_%'] Inv_LT = VCC_cost_data.iloc[0]['LT_yr'] Inv_OM = VCC_cost_data.iloc[0]['O&M_%'] / 100 InvC = Inv_a + Inv_b * (Q_nom_W) ** Inv_c + (Inv_d + Inv_e * Q_nom_W) * log(Q_nom_W) Capex_a_VCC_USD = calc_capex_annualized(InvC, Inv_IR, Inv_LT) Opex_fixed_VCC_USD = InvC * Inv_OM Capex_VCC_USD = InvC else: # more than one unit of ACH are activated number_of_chillers = int(ceil(Q_nom_W / max_chiller_size)) Q_nom_each_chiller = Q_nom_W / number_of_chillers for i in range(number_of_chillers): VCC_cost_data = VCC_cost_data[ (VCC_cost_data['cap_min'] <= Q_nom_each_chiller) & (VCC_cost_data['cap_max'] >= Q_nom_each_chiller)] Inv_a = VCC_cost_data.iloc[0]['a'] Inv_b = VCC_cost_data.iloc[0]['b'] Inv_c = VCC_cost_data.iloc[0]['c'] Inv_d = VCC_cost_data.iloc[0]['d'] Inv_e = VCC_cost_data.iloc[0]['e'] Inv_IR = VCC_cost_data.iloc[0]['IR_%'] Inv_LT = VCC_cost_data.iloc[0]['LT_yr'] Inv_OM = VCC_cost_data.iloc[0]['O&M_%'] / 100 InvC = Inv_a + Inv_b * (Q_nom_each_chiller) ** Inv_c + (Inv_d + Inv_e * Q_nom_each_chiller) * log( Q_nom_each_chiller) Capex_a1 = calc_capex_annualized(InvC, Inv_IR, Inv_LT) Capex_a_VCC_USD = Capex_a_VCC_USD + Capex_a1 Opex_fixed_VCC_USD = Opex_fixed_VCC_USD + InvC * Inv_OM Capex_VCC_USD = Capex_VCC_USD + InvC return Capex_a_VCC_USD, Opex_fixed_VCC_USD, Capex_VCC_USD
def calc_Cinv_GHP(GHP_Size_W, GHP_cost_data, BH_cost_data): """ Calculates the annualized investment costs for the geothermal heat pump :type GHP_Size_W : float :param GHP_Size_W: Design electrical size of the heat pump in [Wel] InvCa : float annualized investment costs in EUROS/a """ # 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 GHP_Size_W < GHP_cost_data['cap_min'][0]: GHP_Size_W = GHP_cost_data['cap_min'][0] GHP_cost_data = GHP_cost_data[(GHP_cost_data['cap_min'] <= GHP_Size_W) & (GHP_cost_data['cap_max'] > GHP_Size_W)] Inv_a = GHP_cost_data.iloc[0]['a'] Inv_b = GHP_cost_data.iloc[0]['b'] Inv_c = GHP_cost_data.iloc[0]['c'] Inv_d = GHP_cost_data.iloc[0]['d'] Inv_e = GHP_cost_data.iloc[0]['e'] Inv_IR = GHP_cost_data.iloc[0]['IR_%'] Inv_LT = GHP_cost_data.iloc[0]['LT_yr'] Inv_OM = GHP_cost_data.iloc[0]['O&M_%'] / 100 InvC_GHP = Inv_a + Inv_b * (GHP_Size_W)**Inv_c + ( Inv_d + Inv_e * GHP_Size_W) * log(GHP_Size_W) Capex_a_GHP_USD = calc_capex_annualized(InvC_GHP, Inv_IR, Inv_LT) Opex_fixed_GHP_USD = InvC_GHP * Inv_OM # 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 GHP_Size_W < BH_cost_data['cap_min'][0]: GHP_Size_W = BH_cost_data['cap_min'][0] BH_cost_data = BH_cost_data[(BH_cost_data['cap_min'] <= GHP_Size_W) & (BH_cost_data['cap_max'] > GHP_Size_W)] Inv_a = BH_cost_data.iloc[0]['a'] Inv_b = BH_cost_data.iloc[0]['b'] Inv_c = BH_cost_data.iloc[0]['c'] Inv_d = BH_cost_data.iloc[0]['d'] Inv_e = BH_cost_data.iloc[0]['e'] Inv_IR = BH_cost_data.iloc[0]['IR_%'] Inv_LT = BH_cost_data.iloc[0]['LT_yr'] Inv_OM = BH_cost_data.iloc[0]['O&M_%'] / 100 InvC_BH = Inv_a + Inv_b * (GHP_Size_W)**Inv_c + ( Inv_d + Inv_e * GHP_Size_W) * log(GHP_Size_W) Capex_a_BH_USD = calc_capex_annualized(InvC_BH, Inv_IR, Inv_LT) Opex_fixed_BH_USD = InvC_BH * Inv_OM Capex_a_GHP_total_USD = Capex_a_BH_USD + Capex_a_GHP_USD Opex_fixed_GHP_total_USD = Opex_fixed_BH_USD + Opex_fixed_GHP_USD Capex_GHP_total_USD = InvC_BH + InvC_GHP return Capex_a_GHP_total_USD, Opex_fixed_GHP_total_USD, Capex_GHP_total_USD
def calc_Cinv_PVT(PVT_peak_W, locator, technology=0): """ P_peak in kW result in CHF technology = 0 represents the first technology when there are multiple technologies. FIXME: handle multiple technologies when cost calculations are done """ if PVT_peak_W > 0.0: PVT_cost_data = pd.read_excel(locator.get_database_conversion_systems(), sheet_name="PV") technology_code = list(set(PVT_cost_data['code'])) PVT_cost_data = PVT_cost_data[PVT_cost_data['code'] == technology_code[technology]] # 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 PVT_peak_W < PVT_cost_data['cap_min'].values[0]: PVT_peak_W = PVT_cost_data['cap_min'].values[0] PVT_cost_data = PVT_cost_data[ (PVT_cost_data['cap_min'] <= PVT_peak_W) & (PVT_cost_data['cap_max'] > PVT_peak_W)] Inv_a = PVT_cost_data.iloc[0]['a'] Inv_b = PVT_cost_data.iloc[0]['b'] Inv_c = PVT_cost_data.iloc[0]['c'] Inv_d = PVT_cost_data.iloc[0]['d'] Inv_e = PVT_cost_data.iloc[0]['e'] Inv_IR = PVT_cost_data.iloc[0]['IR_%'] Inv_LT = PVT_cost_data.iloc[0]['LT_yr'] Inv_OM = PVT_cost_data.iloc[0]['O&M_%'] / 100 InvC = Inv_a + Inv_b * (PVT_peak_W) ** Inv_c + (Inv_d + Inv_e * PVT_peak_W) * log(PVT_peak_W) Capex_a = calc_capex_annualized(InvC, Inv_IR, Inv_LT) Opex_fixed = InvC * Inv_OM Capex = InvC else: Capex_a = Opex_fixed = Capex = 0.0 return Capex_a, Opex_fixed, Capex
def calc_Cinv_FC(P_design_W, FC_cost_data): """ Calculates the investment cost of a Fuel Cell in CHF http://hexis.com/sites/default/files/media/publikationen/140623_hexis_galileo_ibb_profitpaket.pdf?utm_source=HEXIS+Mitarbeitende&utm_campaign=06d2c528a5-1_Newsletter_2014_Mitarbeitende_DE&utm_medium=email&utm_term=0_e97bc1703e-06d2c528a5- :type P_design_W : float :param P_design_W: Design thermal Load of Fuel Cell [W_th] :rtype InvCa: float :returns InvCa: annualized investment costs in CHF """ # 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 P_design_W < FC_cost_data['cap_min'][0]: P_design_W = FC_cost_data['cap_min'][0] FC_cost_data = FC_cost_data[(FC_cost_data['cap_min'] <= P_design_W) & (FC_cost_data['cap_max'] > P_design_W)] Inv_a = FC_cost_data.iloc[0]['a'] Inv_b = FC_cost_data.iloc[0]['b'] Inv_c = FC_cost_data.iloc[0]['c'] Inv_d = FC_cost_data.iloc[0]['d'] Inv_e = FC_cost_data.iloc[0]['e'] Inv_IR = FC_cost_data.iloc[0]['IR_%'] Inv_LT = FC_cost_data.iloc[0]['LT_yr'] Inv_OM = FC_cost_data.iloc[0]['O&M_%'] / 100 InvC = Inv_a + Inv_b * (P_design_W)**Inv_c + ( Inv_d + Inv_e * P_design_W) * log(P_design_W) Capex_a_FC_USD = calc_capex_annualized(InvC, Inv_IR, Inv_LT) Opex_fixed_FC_USD = InvC * Inv_OM Capex_FC_USD = InvC return Capex_a_FC_USD, Opex_fixed_FC_USD, Capex_FC_USD
def calc_Capex_a_network_pipes(network_info): ''' Calculates network piping costs''' if network_info.network_type == 'DH': InvC = network_info.network_features.pipesCosts_DHN_USD else: InvC = network_info.network_features.pipesCosts_DCN_USD # Assume lifetime of 25 years and 5 % IR Inv_IR = 5 Inv_LT = 25 #TODO: find reference Capex_a_netw = calc_capex_annualized(InvC, Inv_IR, Inv_LT) return Capex_a_netw
def calc_Cinv_HEX(Q_design_W, locator, config, technology_type): """ Calculates the cost of a heat exchanger (based on A+W cost of oil boilers) [CHF / a] :type Q_design_W : float :param Q_design_W: Design Load of Boiler :rtype InvC_return : float :returns InvC_return: total investment Cost in [CHF] :rtype InvCa : float :returns InvCa: annualized investment costs in [CHF/a] """ if Q_design_W > 0: HEX_cost_data = pd.read_excel( locator.get_database_conversion_systems(), sheet_name="HEX") HEX_cost_data = HEX_cost_data[HEX_cost_data['code'] == technology_type] # 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 Q_design_W < HEX_cost_data.iloc[0]['cap_min']: Q_design_W = HEX_cost_data.iloc[0]['cap_min'] HEX_cost_data = HEX_cost_data[(HEX_cost_data['cap_min'] <= Q_design_W) & (HEX_cost_data['cap_max'] > Q_design_W)] Inv_a = HEX_cost_data.iloc[0]['a'] Inv_b = HEX_cost_data.iloc[0]['b'] Inv_c = HEX_cost_data.iloc[0]['c'] Inv_d = HEX_cost_data.iloc[0]['d'] Inv_e = HEX_cost_data.iloc[0]['e'] Inv_IR = HEX_cost_data.iloc[0]['IR_%'] Inv_LT = HEX_cost_data.iloc[0]['LT_yr'] Inv_OM = HEX_cost_data.iloc[0]['O&M_%'] / 100 InvC = Inv_a + Inv_b * (Q_design_W)**Inv_c + ( Inv_d + Inv_e * Q_design_W) * log(Q_design_W) Capex_a_HEX_USD = calc_capex_annualized(InvC, Inv_IR, Inv_LT) Opex_fixed_HEX_USD = InvC * Inv_OM Capex_HEX_USD = InvC else: Capex_a_HEX_USD = 0.0 Opex_fixed_HEX_USD = 0.0 Capex_HEX_USD = 0.0 return Capex_a_HEX_USD, Opex_fixed_HEX_USD, Capex_HEX_USD
def calc_Cinv_furnace(Q_design_W, locator, technology_type): """ Calculates the annualized investment cost of a Furnace based on Bioenergy 2020 (AFO) and POLYCITY Ostfildern :type Q_design_W : float :param Q_design_W: Design Load of Boiler :type Q_annual_W : float :param Q_annual_W: annual thermal Power output [Wh] :rtype InvC_return : float :returns InvC_return: total investment Cost for building the plant :rtype InvCa : float :returns InvCa: annualized investment costs in [CHF] including O&M """ furnace_cost_data = pd.read_excel( locator.get_database_conversion_systems(), sheet_name="Furnace") furnace_cost_data = furnace_cost_data[furnace_cost_data['code'] == technology_type] # 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 Q_design_W < furnace_cost_data.iloc[0]['cap_min']: Q_design_W = furnace_cost_data.iloc[0]['cap_min'] furnace_cost_data = furnace_cost_data[ (furnace_cost_data['cap_min'] <= Q_design_W) & (furnace_cost_data['cap_max'] > Q_design_W)] Inv_a = furnace_cost_data.iloc[0]['a'] Inv_b = furnace_cost_data.iloc[0]['b'] Inv_c = furnace_cost_data.iloc[0]['c'] Inv_d = furnace_cost_data.iloc[0]['d'] Inv_e = furnace_cost_data.iloc[0]['e'] Inv_IR = furnace_cost_data.iloc[0]['IR_%'] Inv_LT = furnace_cost_data.iloc[0]['LT_yr'] Inv_OM = furnace_cost_data.iloc[0]['O&M_%'] / 100 InvC = Inv_a + Inv_b * (Q_design_W)**Inv_c + ( Inv_d + Inv_e * Q_design_W) * log(Q_design_W) Capex_a_furnace_USD = calc_capex_annualized(InvC, Inv_IR, Inv_LT) Opex_fixed_furnace_USD = InvC * Inv_OM Capex_furnace_USD = InvC return Capex_a_furnace_USD, Opex_fixed_furnace_USD, Capex_furnace_USD
def calc_Cinv_storage(V_tank_m3, locator, config, technology_type): """ calculate the annualized investment cost of a thermal storage tank :param V_tank_m3: storage tank volume :type V_tank_m3: float :returns InvCa: """ if V_tank_m3 > 0: storage_cost_data = pd.read_excel( locator.get_database_conversion_systems(), sheet_name="TES") storage_cost_data = storage_cost_data[storage_cost_data['code'] == technology_type] # 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 V_tank_m3 < storage_cost_data.iloc[0]['cap_min']: V_tank_m3 = storage_cost_data[0]['cap_min'] storage_cost_data = storage_cost_data[ (storage_cost_data['cap_min'] <= V_tank_m3) & (storage_cost_data['cap_max'] > V_tank_m3)] Inv_a = storage_cost_data.iloc[0]['a'] Inv_b = storage_cost_data.iloc[0]['b'] Inv_c = storage_cost_data.iloc[0]['c'] Inv_d = storage_cost_data.iloc[0]['d'] Inv_e = storage_cost_data.iloc[0]['e'] Inv_IR = storage_cost_data.iloc[0]['IR_%'] Inv_LT = storage_cost_data.iloc[0]['LT_yr'] Inv_OM = storage_cost_data.iloc[0]['O&M_%'] / 100 Capex_total_USD = Inv_a + Inv_b * (V_tank_m3)**Inv_c + ( Inv_d + Inv_e * V_tank_m3) * log(V_tank_m3) Capex_a_storage_USD = calc_capex_annualized(Capex_total_USD, Inv_IR, Inv_LT) Opex_fixed_storage_USD = Capex_total_USD * Inv_OM else: Capex_a_storage_USD = 0.0 Opex_fixed_storage_USD = 0.0 Capex_total_USD = 0.0 return Capex_a_storage_USD, Opex_fixed_storage_USD, Capex_total_USD
def calc_Cinv_CCGT(CC_size_W, CCGT_cost_data): """ Annualized investment costs for the Combined cycle :type CC_size_W : float :param CC_size_W: Electrical size of the CC :rtype InvCa : float :returns InvCa: annualized investment costs in CHF ..[C. Weber, 2008] C.Weber, Multi-objective design and optimization of district energy systems including polygeneration energy conversion technologies., PhD Thesis, EPFL """ # 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 CC_size_W < CCGT_cost_data['cap_min'][0]: CC_size_W = CCGT_cost_data['cap_min'][0] CCGT_cost_data = CCGT_cost_data[(CCGT_cost_data['cap_min'] <= CC_size_W) & (CCGT_cost_data['cap_max'] > CC_size_W)] #costs of connection connection_costs = ngas.calc_Cinv_gas(CC_size_W) Inv_a = CCGT_cost_data.iloc[0]['a'] Inv_b = CCGT_cost_data.iloc[0]['b'] Inv_c = CCGT_cost_data.iloc[0]['c'] Inv_d = CCGT_cost_data.iloc[0]['d'] Inv_e = CCGT_cost_data.iloc[0]['e'] Inv_IR = CCGT_cost_data.iloc[0]['IR_%'] Inv_LT = CCGT_cost_data.iloc[0]['LT_yr'] Inv_OM = CCGT_cost_data.iloc[0]['O&M_%'] / 100 InvC = Inv_a + Inv_b * (CC_size_W)**Inv_c + ( Inv_d + Inv_e * CC_size_W) * log(CC_size_W) Capex_a_CCGT_USD = calc_capex_annualized((InvC + connection_costs), Inv_IR, Inv_LT) Opex_fixed_CCGT_USD = InvC * Inv_OM Capex_CCGT_USD = InvC return Capex_a_CCGT_USD, Opex_fixed_CCGT_USD, Capex_CCGT_USD
def calc_Cinv_pv(total_module_area_m2, locator, technology=0): """ To calculate capital cost of PV modules, assuming 20 year system lifetime. :param P_peak: installed capacity of PV module [kW] :return InvCa: capital cost of the installed PV module [CHF/Y] """ PV_cost_data = pd.read_excel(locator.get_database_conversion_systems(), sheet_name="PV") technology_code = list(set(PV_cost_data['code'])) PV_cost_data = PV_cost_data[PV_cost_data['code'] == technology_code[technology]] nominal_efficiency = PV_cost_data[ PV_cost_data['code'] == technology_code[technology]]['PV_n'].max() P_nominal_W = total_module_area_m2 * (constants.STC_RADIATION_Wperm2 * nominal_efficiency) # 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 P_nominal_W < PV_cost_data['cap_min'][0]: P_nominal_W = PV_cost_data['cap_min'][0] PV_cost_data = PV_cost_data[(PV_cost_data['cap_min'] <= P_nominal_W) & (PV_cost_data['cap_max'] > P_nominal_W)] Inv_a = PV_cost_data.iloc[0]['a'] Inv_b = PV_cost_data.iloc[0]['b'] Inv_c = PV_cost_data.iloc[0]['c'] Inv_d = PV_cost_data.iloc[0]['d'] Inv_e = PV_cost_data.iloc[0]['e'] Inv_IR = PV_cost_data.iloc[0]['IR_%'] Inv_LT = PV_cost_data.iloc[0]['LT_yr'] Inv_OM = PV_cost_data.iloc[0]['O&M_%'] / 100 InvC = Inv_a + Inv_b * (P_nominal_W)**Inv_c + ( Inv_d + Inv_e * P_nominal_W) * log(P_nominal_W) Capex_a_PV_USD = calc_capex_annualized(InvC, Inv_IR, Inv_LT) Opex_fixed_PV_USD = InvC * Inv_OM Capex_PV_USD = InvC return Capex_a_PV_USD, Opex_fixed_PV_USD, Capex_PV_USD, P_nominal_W
def calc_Cinv_DX(Q_design_W): """ Assume the same cost as gas boilers. :type Q_design_W : float :param Q_design_W: Design Load of Boiler in [W] :rtype InvCa : float :returns InvCa: Annualized investment costs in CHF/a including Maintenance Cost """ Capex_a_DX_USD = 0 Opex_fixed_DX_USD = 0 Capex_DX_USD = 0 if Q_design_W > 0: InvC = Q_design_W * PRICE_DX_PER_W Inv_IR = 5 Inv_LT = 25 Inv_OM = 5 / 100 Capex_a_DX_USD = calc_capex_annualized(InvC, Inv_IR, Inv_LT) Opex_fixed_DX_USD = InvC * Inv_OM Capex_DX_USD = InvC return Capex_a_DX_USD, Opex_fixed_DX_USD, Capex_DX_USD
def calc_Cinv_ACH(Q_nom_W, Absorption_chiller_cost_data, ACH_type): """ Annualized investment costs for the vapor compressor chiller :type Q_nom_W : float :param Q_nom_W: peak cooling demand in [W] :returns InvCa: annualized chiller investment cost in CHF/a :rtype InvCa: float """ Capex_a_ACH_USD = 0 Opex_fixed_ACH_USD = 0 Capex_ACH_USD = 0 if Q_nom_W > 0: Absorption_chiller_cost_data = Absorption_chiller_cost_data[Absorption_chiller_cost_data['type'] == ACH_type] max_chiller_size = max(Absorption_chiller_cost_data['cap_max'].values) Q_nom_W = Absorption_chiller_cost_data['cap_min'].values.min() if Q_nom_W < Absorption_chiller_cost_data[ 'cap_min'].values.min() else Q_nom_W # minimum technology size if Q_nom_W <= max_chiller_size: Absorption_chiller_cost_data = Absorption_chiller_cost_data[ (Absorption_chiller_cost_data['cap_min'] <= Q_nom_W) & ( Absorption_chiller_cost_data[ 'cap_max'] > Q_nom_W)] # keep properties of the associated capacity Inv_a = Absorption_chiller_cost_data.iloc[0]['a'] Inv_b = Absorption_chiller_cost_data.iloc[0]['b'] Inv_c = Absorption_chiller_cost_data.iloc[0]['c'] Inv_d = Absorption_chiller_cost_data.iloc[0]['d'] Inv_e = Absorption_chiller_cost_data.iloc[0]['e'] Inv_IR = Absorption_chiller_cost_data.iloc[0]['IR_%'] Inv_LT = Absorption_chiller_cost_data.iloc[0]['LT_yr'] Inv_OM = Absorption_chiller_cost_data.iloc[0]['O&M_%'] / 100 InvC = Inv_a + Inv_b * (Q_nom_W) ** Inv_c + (Inv_d + Inv_e * Q_nom_W) * log(Q_nom_W) Capex_a_ACH_USD = calc_capex_annualized(InvC, Inv_IR, Inv_LT) Opex_fixed_ACH_USD = InvC * Inv_OM Capex_ACH_USD = InvC else: number_of_chillers = int(ceil(Q_nom_W / max_chiller_size)) Q_nom_each_chiller = Q_nom_W / number_of_chillers for i in range(number_of_chillers): Absorption_chiller_cost_data = Absorption_chiller_cost_data[ (Absorption_chiller_cost_data['cap_min'] <= Q_nom_each_chiller) & ( Absorption_chiller_cost_data[ 'cap_max'] > Q_nom_each_chiller)] # keep properties of the associated capacity Inv_a = Absorption_chiller_cost_data.iloc[0]['a'] Inv_b = Absorption_chiller_cost_data.iloc[0]['b'] Inv_c = Absorption_chiller_cost_data.iloc[0]['c'] Inv_d = Absorption_chiller_cost_data.iloc[0]['d'] Inv_e = Absorption_chiller_cost_data.iloc[0]['e'] Inv_IR = Absorption_chiller_cost_data.iloc[0]['IR_%'] Inv_LT = Absorption_chiller_cost_data.iloc[0]['LT_yr'] Inv_OM = Absorption_chiller_cost_data.iloc[0]['O&M_%'] / 100 InvC = Inv_a + Inv_b * (Q_nom_each_chiller) ** Inv_c + (Inv_d + Inv_e * Q_nom_each_chiller) * log(Q_nom_each_chiller) Capex_a1 = calc_capex_annualized(InvC, Inv_IR, Inv_LT) Capex_a_ACH_USD = Capex_a_ACH_USD + Capex_a1 Opex_fixed_ACH_USD = Opex_fixed_ACH_USD + InvC * Inv_OM Capex_ACH_USD = Capex_ACH_USD + InvC return Capex_a_ACH_USD, Opex_fixed_ACH_USD, Capex_ACH_USD
def calc_Cinv_boiler(Q_design_W, technology_type, boiler_cost_data): """ Calculates the annual cost of a boiler (based on A+W cost of oil boilers) [CHF / a] and Faz. 2012 data :type Q_design_W : float :param Q_design_W: Design Load of Boiler in [W] :rtype InvCa : float :returns InvCa: Annualized investment costs in CHF/a including Maintenance Cost """ Capex_a_Boiler_USD = 0.0 Opex_a_fix_Boiler_USD = 0.0 Capex_Boiler_USD = 0.0 if Q_design_W > 0.0: boiler_cost_data = boiler_cost_data[boiler_cost_data['code'] == technology_type] # 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 Q_design_W < boiler_cost_data.iloc[0]['cap_min']: Q_design_W = boiler_cost_data.iloc[0]['cap_min'] max_boiler_size = boiler_cost_data.iloc[0]['cap_max'] if Q_design_W <= max_boiler_size: boiler_cost_data = boiler_cost_data[ (boiler_cost_data['cap_min'] <= Q_design_W) & (boiler_cost_data['cap_max'] > Q_design_W)] Inv_a = boiler_cost_data.iloc[0]['a'] Inv_b = boiler_cost_data.iloc[0]['b'] Inv_c = boiler_cost_data.iloc[0]['c'] Inv_d = boiler_cost_data.iloc[0]['d'] Inv_e = boiler_cost_data.iloc[0]['e'] Inv_IR = boiler_cost_data.iloc[0]['IR_%'] Inv_LT = boiler_cost_data.iloc[0]['LT_yr'] Inv_OM = boiler_cost_data.iloc[0]['O&M_%'] / 100.0 InvC = Inv_a + Inv_b * (Q_design_W) ** Inv_c + (Inv_d + Inv_e * Q_design_W) * log(Q_design_W) Capex_a_Boiler_USD = calc_capex_annualized(InvC, Inv_IR, Inv_LT) Opex_a_fix_Boiler_USD = InvC * Inv_OM Capex_Boiler_USD = InvC else: number_of_boilers = int(ceil(Q_design_W / max_boiler_size)) Q_nom_W = Q_design_W / number_of_boilers boiler_cost_data = boiler_cost_data[ (boiler_cost_data['cap_min'] <= Q_nom_W) & (boiler_cost_data['cap_max'] > Q_nom_W)] Inv_a = boiler_cost_data.iloc[0]['a'] Inv_b = boiler_cost_data.iloc[0]['b'] Inv_c = boiler_cost_data.iloc[0]['c'] Inv_d = boiler_cost_data.iloc[0]['d'] Inv_e = boiler_cost_data.iloc[0]['e'] Inv_IR = boiler_cost_data.iloc[0]['IR_%'] Inv_LT = boiler_cost_data.iloc[0]['LT_yr'] Inv_OM = boiler_cost_data.iloc[0]['O&M_%'] / 100.0 InvC = (Inv_a + Inv_b * (Q_nom_W) ** Inv_c + (Inv_d + Inv_e * Q_nom_W) * log(Q_nom_W)) * number_of_boilers Capex_a_Boiler_USD = calc_capex_annualized(InvC, Inv_IR, Inv_LT) Opex_a_fix_Boiler_USD = InvC * Inv_OM Capex_Boiler_USD = InvC return Capex_a_Boiler_USD, Opex_a_fix_Boiler_USD, Capex_Boiler_USD
def calc_Cinv_HEX_hisaka(network_info): """ Calculates costs of all substation heat exchangers in a network. Used in thermal_network_optimization. """ ## read in cost values from database HEX_prices = pd.read_excel( network_info.locator.get_database_conversion_systems(), sheet_name="HEX", index_col=0) a = HEX_prices['a']['District substation heat exchanger'] b = HEX_prices['b']['District substation heat exchanger'] c = HEX_prices['c']['District substation heat exchanger'] d = HEX_prices['d']['District substation heat exchanger'] e = HEX_prices['e']['District substation heat exchanger'] Inv_IR = HEX_prices['IR_%']['District substation heat exchanger'] Inv_LT = HEX_prices['LT_yr']['District substation heat exchanger'] Inv_OM = HEX_prices['O&M_%']['District substation heat exchanger'] / 100 ## list node id of all substations # read in nodes list all_nodes = pd.read_csv( network_info.locator.get_thermal_network_node_types_csv_file( network_info.network_type, network_info.network_name)) Capex_a = 0.0 Opex_a_fixed = 0.0 substation_node_id_list = [] # add buildings to node id list for building in network_info.building_names: # check if building is connected to network if building not in network_info.building_names[ network_info.disconnected_buildings_index]: # add HEX cost node_id = int(np.where(all_nodes['Building'] == building)[0]) substation_node_id_list.append(all_nodes['Name'][node_id]) # add plants to node id list plant_id_list = np.where(all_nodes['Type'] == 'Plant')[0] # find plant nodes for plant_id in plant_id_list: substation_node_id_list.append('NODE' + str(plant_id)) ## calculate costs of hex at substations for node_id in substation_node_id_list: # read in node mass flows node_flows = pd.read_csv( network_info.locator.get_nominal_node_mass_flow_csv_file( network_info.network_type, network_info.network_name)) # find design condition node mcp node_flow = max(node_flows[node_id]) if node_flow > 0: # 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 # TODO: add minimum capacity to cost function # Split into several HEXs if flows are too high if node_flow <= MAX_NODE_FLOW: mcp_sub = node_flow * HEAT_CAPACITY_OF_WATER_JPERKGK Capex_substation_hex = a + b * mcp_sub**c + d * np.log( mcp_sub) + e * mcp_sub * np.log(mcp_sub) else: # we need to split into several HEXs Capex_substation_hex = 0 number_of_HEXs = int(ceil(node_flow / MAX_NODE_FLOW)) nodeflow_nom = node_flow / number_of_HEXs mcp_sub = nodeflow_nom * HEAT_CAPACITY_OF_WATER_JPERKGK for i in range(number_of_HEXs): Capex_substation_hex = Capex_substation_hex + ( a + b * mcp_sub**c + d * np.log(mcp_sub) + e * mcp_sub * np.log(mcp_sub)) Capex_a_substation_hex = calc_capex_annualized( Capex_substation_hex, Inv_IR, Inv_LT) Opex_fixed_substation_hex = Capex_substation_hex * Inv_OM # aggregate all substation costs in a network Capex_a = Capex_a + Capex_a_substation_hex Opex_a_fixed = Opex_a_fixed + Opex_fixed_substation_hex return Capex_a, Opex_a_fixed
def calc_Cinv_pump(pump_peak_W, locator, technology_type): """ Calculates the cost of a pumping device. if the nominal load (electric) > 375kW, a new pump is installed if the nominal load (electric) < 500W, a pump with Pel_design = 500W is assumed Investement costs are calculated upon the life time of a GHP (20y) and a GHP- related interest rate of 6% :type deltaP : float :param deltaP: nominal pressure drop that has to be overcome with the pump :type mdot_kgpers : float :param mdot_kgpers: nominal mass flow :type eta_pumping : float :param pump efficiency: (set 0.8 as standard value, eta = E_pumping / E_elec) :rtype InvC_return : float :returns InvC_return: total investment Cost in CHF :rtype InvCa : float :returns InvCa: annualized investment costs in CHF/year """ Pump_max_kW = 375.0 Pump_min_kW = 0.5 nPumps = int(np.ceil(pump_peak_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 = pump_peak_W Capex_a_pump_USD = 0.0 Opex_fixed_pump_USD = 0.0 Capex_pump_USD = 0.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_database_conversion_systems(), sheet_name="Pump") pump_cost_data = PUMP_COST_DATA[PUMP_COST_DATA['code'] == technology_type] # 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_%'] 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_a_pump_USD += calc_capex_annualized(InvC, Inv_IR, Inv_LT) Opex_fixed_pump_USD += InvC * Inv_OM Capex_pump_USD += InvC return Capex_a_pump_USD, Opex_fixed_pump_USD, Capex_pump_USD
def calc_Cinv_CT(Q_nom_CT_W, locator, technology_type): """ Annualized investment costs for the Combined cycle :type Q_nom_CT_W : float :param Q_nom_CT_W: Nominal size of the cooling tower in [W] :rtype InvCa : float :returns InvCa: annualized investment costs in Dollars """ Capex_a_CT_USD = 0.0 Opex_fixed_CT_USD = 0.0 Capex_CT_USD = 0.0 if Q_nom_CT_W > 0: CT_cost_data = pd.read_excel(locator.get_database_conversion_systems(), sheet_name="CT") CT_cost_data = CT_cost_data[CT_cost_data['code'] == technology_type] max_chiller_size = max(CT_cost_data['cap_max'].values) # 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 Q_nom_CT_W < CT_cost_data.iloc[0]['cap_min']: Q_nom_CT_W = CT_cost_data.iloc[0]['cap_min'] if Q_nom_CT_W <= max_chiller_size: CT_cost_data = CT_cost_data[(CT_cost_data['cap_min'] <= Q_nom_CT_W) & (CT_cost_data['cap_max'] > Q_nom_CT_W)] Inv_a = CT_cost_data.iloc[0]['a'] Inv_b = CT_cost_data.iloc[0]['b'] Inv_c = CT_cost_data.iloc[0]['c'] Inv_d = CT_cost_data.iloc[0]['d'] Inv_e = CT_cost_data.iloc[0]['e'] Inv_IR = CT_cost_data.iloc[0]['IR_%'] Inv_LT = CT_cost_data.iloc[0]['LT_yr'] Inv_OM = CT_cost_data.iloc[0]['O&M_%'] / 100 InvC = Inv_a + Inv_b * (Q_nom_CT_W)**Inv_c + ( Inv_d + Inv_e * Q_nom_CT_W) * log(Q_nom_CT_W) Capex_a_CT_USD = calc_capex_annualized(InvC, Inv_IR, Inv_LT) Opex_fixed_CT_USD = InvC * Inv_OM Capex_CT_USD = InvC else: number_of_chillers = int(ceil(Q_nom_CT_W / max_chiller_size)) Q_nom_each_CT = Q_nom_CT_W / number_of_chillers for i in range(number_of_chillers): CT_cost_data = CT_cost_data[ (CT_cost_data['cap_min'] <= Q_nom_each_CT) & (CT_cost_data['cap_max'] > Q_nom_each_CT)] Inv_a = CT_cost_data.iloc[0]['a'] Inv_b = CT_cost_data.iloc[0]['b'] Inv_c = CT_cost_data.iloc[0]['c'] Inv_d = CT_cost_data.iloc[0]['d'] Inv_e = CT_cost_data.iloc[0]['e'] Inv_IR = CT_cost_data.iloc[0]['IR_%'] Inv_LT = CT_cost_data.iloc[0]['LT_yr'] Inv_OM = CT_cost_data.iloc[0]['O&M_%'] / 100 InvC = Inv_a + Inv_b * (Q_nom_each_CT)**Inv_c + ( Inv_d + Inv_e * Q_nom_each_CT) * log(Q_nom_each_CT) Capex_a1 = calc_capex_annualized(InvC, Inv_IR, Inv_LT) Capex_a_CT_USD = Capex_a_CT_USD + Capex_a1 Opex_fixed_CT_USD = Opex_fixed_CT_USD + InvC * Inv_OM Capex_CT_USD = Capex_CT_USD + InvC return Capex_a_CT_USD, Opex_fixed_CT_USD, Capex_CT_USD
def calc_Cinv_HP(HP_Size, locator, technology_type): """ Calculates the annualized investment costs for a water to water heat pump. :type HP_Size : float :param HP_Size: Design thermal size of the heat pump in [W] :rtype InvCa : float :returns InvCa: annualized investment costs in [CHF/a] ..[C. Weber, 2008] C.Weber, Multi-objective design and optimization of district energy systems including polygeneration energy conversion technologies., PhD Thesis, EPFL """ Capex_a_HP_USD = 0.0 Opex_fixed_HP_USD = 0.0 Capex_HP_USD = 0.0 if HP_Size > 0.0: HP_cost_data = pd.read_excel(locator.get_database_conversion_systems(), sheet_name="HP") HP_cost_data = HP_cost_data[HP_cost_data['code'] == technology_type] # 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 HP_Size < HP_cost_data.iloc[0]['cap_min']: HP_Size = HP_cost_data.iloc[0]['cap_min'] max_HP_size = max(HP_cost_data['cap_max'].values) if HP_Size <= max_HP_size: HP_cost_data = HP_cost_data[ (HP_cost_data['cap_min'] <= HP_Size) & (HP_cost_data['cap_max'] > HP_Size)] Inv_a = HP_cost_data.iloc[0]['a'] Inv_b = HP_cost_data.iloc[0]['b'] Inv_c = HP_cost_data.iloc[0]['c'] Inv_d = HP_cost_data.iloc[0]['d'] Inv_e = HP_cost_data.iloc[0]['e'] Inv_IR = HP_cost_data.iloc[0]['IR_%'] Inv_LT = HP_cost_data.iloc[0]['LT_yr'] Inv_OM = HP_cost_data.iloc[0]['O&M_%'] / 100 InvC = Inv_a + Inv_b * (HP_Size) ** Inv_c + (Inv_d + Inv_e * HP_Size) * log(HP_Size) Capex_a_HP_USD = calc_capex_annualized(InvC, Inv_IR, Inv_LT) Opex_fixed_HP_USD = InvC * Inv_OM Capex_HP_USD = InvC else: number_of_chillers = int(ceil(HP_Size / max_HP_size)) Q_nom_each_chiller = HP_Size / number_of_chillers HP_cost_data = HP_cost_data[ (HP_cost_data['cap_min'] <= Q_nom_each_chiller) & (HP_cost_data['cap_max'] > Q_nom_each_chiller)] for i in range(number_of_chillers): Inv_a = HP_cost_data.iloc[0]['a'] Inv_b = HP_cost_data.iloc[0]['b'] Inv_c = HP_cost_data.iloc[0]['c'] Inv_d = HP_cost_data.iloc[0]['d'] Inv_e = HP_cost_data.iloc[0]['e'] Inv_IR = HP_cost_data.iloc[0]['IR_%'] Inv_LT = HP_cost_data.iloc[0]['LT_yr'] Inv_OM = HP_cost_data.iloc[0]['O&M_%'] / 100 InvC = Inv_a + Inv_b * (Q_nom_each_chiller) ** Inv_c + (Inv_d + Inv_e * Q_nom_each_chiller) * log(Q_nom_each_chiller) Capex_a_HP_USD += calc_capex_annualized(InvC, Inv_IR, Inv_LT) Opex_fixed_HP_USD += InvC * Inv_OM Capex_HP_USD += InvC else: Capex_a_HP_USD = Opex_fixed_HP_USD = Capex_HP_USD = 0.0 return Capex_a_HP_USD, Opex_fixed_HP_USD, Capex_HP_USD
def calculate_contributions(df, year_to_calculate): """ Calculate the embodied energy/emissions for each building based on their construction year, and the area and renovation year of each building component. :param archetype: String that defines whether the 'EMBODIED_ENERGY' or 'EMBODIED_EMISSIONS' are being calculated. :type archetype: str :param df: DataFrame with joined data of all categories for each building, that is: occupancy, age, geometry, architecture, building component area, construction category and renovation category for each building component :type df: DataFrame :param locator: an InputLocator instance set to the scenario to work on :type locator: InputLocator :param year_to_calculate: year in which the calculation is done; since the embodied energy and emissions are calculated over 60 years, if the year of calculation is more than 60 years after construction, the results will be 0 :type year_to_calculate: int :param total_column: label for the column with the total results (e.g., 'GEN_GJ') :type total_column: str :param specific_column: label for the column with the results per square meter (e.g., 'GEN_MJm2') :type specific_column: str :return result: DataFrame with the calculation results (i.e., the total and specific embodied energy or emisisons for each building) :rtype result: DataFrame """ # calculate the embodied energy/emissions due to construction total_column = 'saver' ## calculate how many years before the calculation year the building was built in df['delta_year'] = year_to_calculate - df['YEAR'] ## if it was built more than X years before, the embodied energy/emissions have been "paid off" and are set to 0 df['confirm'] = df.apply( lambda x: calc_if_existing(x['delta_year'], SERVICE_LIFE_OF_BUILDINGS), axis=1) ## if it was built less than X years before, the contribution from each building component is calculated df[total_column] = ( (df['capex_WALL'] * (df['area_walls_ext_ag'] + df['area_walls_ext_bg']) + df['capex_WIN'] * df['windows_ag'] + df['capex_FLOOR'] * df['floor_area_ag'] + df['capex_CONS'] * (df['floor_area_bg'] + df['floor_area_ag']) + df['capex_LEAK'] * (df['area_walls_ext_ag'] + df['area_walls_ext_bg']) + df['capex_hvacCS'] * df['floor_area_ag'] + df['capex_hvacHS'] * df['floor_area_ag'] + df['capex_hvacVENT'] * df['floor_area_ag'] + df['capex_BASE'] * df['floor_area_bg'] + df['capex_PART'] * (df['floor_area_ag'] + df['floor_area_bg']) * CONVERSION_AREA_TO_FLOOR_AREA_RATIO + df['capex_ROOF'] * df['footprint']) / SERVICE_LIFE_OF_TECHNICAL_SYSTEMS) * df['confirm'] # df[total_column] += (((df['floor_area_ag'] + df['floor_area_bg']) * EMISSIONS_EMBODIED_TECHNICAL_SYSTEMS) / SERVICE_LIFE_OF_TECHNICAL_SYSTEMS) * df['confirm'] # the total cost intensity df['capex_total_cost_m2'] = df[total_column] / df['GFA_m2'] # the total and specific embodied energy/emissions are returned # result = df[['Name', 'GHG_sys_embodied_tonCO2', 'GHG_sys_embodied_kgCO2m2', 'GFA_m2']] df['capex_building_systems'] = df[total_column] df['opex_building_systems'] = df['capex_building_systems'] * (.05) df['capex_ann_building_systems'] = df.apply( lambda x: calc_capex_annualized(x['capex_building_systems'], 5, 30), axis=1) df['opex_ann_building_systems'] = df.apply( lambda x: calc_opex_annualized(x['opex_building_systems'], 5, 30), axis=1) df['TAC_building_systems'] = df['capex_ann_building_systems'] + df[ 'opex_ann_building_systems'] return df