def disconnected_buildings_heating_main(locator, building_names, config, prices, lca): """ Computes the parameters for the operation of disconnected buildings output results in csv files. There is no optimization at this point. The different technologies are calculated and compared 1 to 1 to each technology. it is a classical combinatorial problem. :param locator: locator class :param building_names: list with names of buildings :type locator: class :type building_names: list :return: results of operation of buildings located in locator.get_optimization_disconnected_folder :rtype: Nonetype """ t0 = time.clock() prop_geometry = Gdf.from_file(locator.get_zone_geometry()) restrictions = Gdf.from_file(locator.get_building_restrictions()) geometry = pd.DataFrame({ 'Name': prop_geometry.Name, 'Area': prop_geometry.area }) geothermal_potential_data = dbf.dbf_to_dataframe( locator.get_building_supply()) geothermal_potential_data = pd.merge(geothermal_potential_data, geometry, on='Name').merge(restrictions, on='Name') geothermal_potential_data['Area_geo'] = ( 1 - geothermal_potential_data['GEOTHERMAL'] ) * geothermal_potential_data['Area'] weather_data = epwreader.epw_reader(config.weather)[[ 'year', 'drybulb_C', 'wetbulb_C', 'relhum_percent', 'windspd_ms', 'skytemp_C' ]] ground_temp = calc_ground_temperature(locator, weather_data['drybulb_C'], depth_m=10) BestData = {} total_demand = pd.read_csv(locator.get_total_demand()) def calc_new_load(mdot, TsupDH, Tret): """ This function calculates the load distribution side of the district heating distribution. :param mdot: mass flow :param TsupDH: supply temeperature :param Tret: return temperature :param gv: global variables class :type mdot: float :type TsupDH: float :type Tret: float :type gv: class :return: Qload: load of the distribution :rtype: float """ Qload = mdot * HEAT_CAPACITY_OF_WATER_JPERKGK * (TsupDH - Tret) * ( 1 + Q_LOSS_DISCONNECTED) if Qload < 0: Qload = 0 return Qload for building_name in building_names: print building_name substation.substation_main(locator, total_demand, building_names=[building_name], heating_configuration=7, cooling_configuration=7, Flag=False) loads = pd.read_csv( locator.get_optimization_substations_results_file(building_name), usecols=[ "T_supply_DH_result_K", "T_return_DH_result_K", "mdot_DH_result_kgpers" ]) Qload = np.vectorize(calc_new_load)(loads["mdot_DH_result_kgpers"], loads["T_supply_DH_result_K"], loads["T_return_DH_result_K"]) Qannual = Qload.sum() Qnom = Qload.max() * (1 + SIZING_MARGIN ) # 1% reliability margin on installed capacity # Create empty matrices result = np.zeros((13, 7)) result[0][0] = 1 result[1][1] = 1 result[2][2] = 1 InvCosts = np.zeros((13, 1)) resourcesRes = np.zeros((13, 4)) QannualB_GHP = np.zeros( (10, 1)) # For the investment costs of the boiler used with GHP Wel_GHP = np.zeros((10, 1)) # For the investment costs of the GHP # Supply with the Boiler / FC / GHP Tret = loads["T_return_DH_result_K"].values TsupDH = loads["T_supply_DH_result_K"].values mdot = loads["mdot_DH_result_kgpers"].values for hour in range(8760): if Tret[hour] == 0: Tret[hour] = TsupDH[hour] # Boiler NG BoilerEff = Boiler.calc_Cop_boiler(Qload[hour], Qnom, Tret[hour]) Qgas = Qload[hour] / BoilerEff result[0][4] += prices.NG_PRICE * Qgas # CHF result[0][ 5] += lca.NG_BACKUPBOILER_TO_CO2_STD * Qgas * 3600E-6 # kgCO2 result[0][ 6] += lca.NG_BACKUPBOILER_TO_OIL_STD * Qgas * 3600E-6 # MJ-oil-eq resourcesRes[0][0] += Qload[hour] if DISC_BIOGAS_FLAG == 1: result[0][4] += prices.BG_PRICE * Qgas # CHF result[0][ 5] += lca.BG_BACKUPBOILER_TO_CO2_STD * Qgas * 3600E-6 # kgCO2 result[0][ 6] += lca.BG_BACKUPBOILER_TO_OIL_STD * Qgas * 3600E-6 # MJ-oil-eq # Boiler BG result[1][4] += prices.BG_PRICE * Qgas # CHF result[1][ 5] += lca.BG_BACKUPBOILER_TO_CO2_STD * Qgas * 3600E-6 # kgCO2 result[1][ 6] += lca.BG_BACKUPBOILER_TO_OIL_STD * Qgas * 3600E-6 # MJ-oil-eq resourcesRes[1][1] += Qload[hour] # FC (FC_Effel, FC_Effth) = FC.calc_eta_FC(Qload[hour], Qnom, 1, "B") Qgas = Qload[hour] / (FC_Effth + FC_Effel) Qelec = Qgas * FC_Effel result[2][ 4] += prices.NG_PRICE * Qgas - lca.ELEC_PRICE * Qelec # CHF, extra electricity sold to grid result[2][ 5] += 0.0874 * Qgas * 3600E-6 + 773 * 0.45 * Qelec * 1E-6 - lca.EL_TO_CO2 * Qelec * 3600E-6 # kgCO2 # Bloom box emissions within the FC: 773 lbs / MWh_el (and 1 lbs = 0.45 kg) # http://www.carbonlighthouse.com/2011/09/16/bloom-box/ result[2][ 6] += 1.51 * Qgas * 3600E-6 - lca.EL_TO_OIL_EQ * Qelec * 3600E-6 # MJ-oil-eq resourcesRes[2][0] += Qload[hour] resourcesRes[2][2] += Qelec # GHP for i in range(10): QnomBoiler = i / 10 * Qnom QnomGHP = Qnom - QnomBoiler if Qload[hour] <= QnomGHP: (wdot_el, qcolddot, qhotdot_missing, tsup2) = HP.calc_Cop_GHP(ground_temp[hour], mdot[hour], TsupDH[hour], Tret[hour]) if Wel_GHP[i][0] < wdot_el: Wel_GHP[i][0] = wdot_el result[3 + i][4] += lca.ELEC_PRICE * wdot_el # CHF result[3 + i][ 5] += lca.SMALL_GHP_TO_CO2_STD * wdot_el * 3600E-6 # kgCO2 result[3 + i][ 6] += lca.SMALL_GHP_TO_OIL_STD * wdot_el * 3600E-6 # MJ-oil-eq resourcesRes[3 + i][2] -= wdot_el resourcesRes[3 + i][3] += Qload[hour] - qhotdot_missing if qhotdot_missing > 0: print "GHP unable to cover the whole demand, boiler activated!" BoilerEff = Boiler.calc_Cop_boiler( qhotdot_missing, QnomBoiler, tsup2) Qgas = qhotdot_missing / BoilerEff result[3 + i][4] += prices.NG_PRICE * Qgas # CHF result[3 + i][ 5] += lca.NG_BACKUPBOILER_TO_CO2_STD * Qgas * 3600E-6 # kgCO2 result[3 + i][ 6] += lca.NG_BACKUPBOILER_TO_OIL_STD * Qgas * 3600E-6 # MJ-oil-eq QannualB_GHP[i][0] += qhotdot_missing resourcesRes[3 + i][0] += qhotdot_missing else: # print "Boiler activated to compensate GHP", i # if gv.DiscGHPFlag == 0: # print QnomGHP # QnomGHP = 0 # print "GHP not allowed 2, set QnomGHP to zero" TexitGHP = QnomGHP / ( mdot[hour] * HEAT_CAPACITY_OF_WATER_JPERKGK) + Tret[hour] (wdot_el, qcolddot, qhotdot_missing, tsup2) = HP.calc_Cop_GHP(ground_temp[hour], mdot[hour], TexitGHP, Tret[hour]) if Wel_GHP[i][0] < wdot_el: Wel_GHP[i][0] = wdot_el result[3 + i][4] += lca.ELEC_PRICE * wdot_el # CHF result[3 + i][ 5] += lca.SMALL_GHP_TO_CO2_STD * wdot_el * 3600E-6 # kgCO2 result[3 + i][ 6] += lca.SMALL_GHP_TO_OIL_STD * wdot_el * 3600E-6 # MJ-oil-eq resourcesRes[3 + i][2] -= wdot_el resourcesRes[3 + i][3] += QnomGHP - qhotdot_missing if qhotdot_missing > 0: print "GHP unable to cover the whole demand, boiler activated!" BoilerEff = Boiler.calc_Cop_boiler( qhotdot_missing, QnomBoiler, tsup2) Qgas = qhotdot_missing / BoilerEff result[3 + i][4] += prices.NG_PRICE * Qgas # CHF result[3 + i][ 5] += lca.NG_BACKUPBOILER_TO_CO2_STD * Qgas * 3600E-6 # kgCO2 result[3 + i][ 6] += lca.NG_BACKUPBOILER_TO_OIL_STD * Qgas * 3600E-6 # MJ-oil-eq QannualB_GHP[i][0] += qhotdot_missing resourcesRes[3 + i][0] += qhotdot_missing QtoBoiler = Qload[hour] - QnomGHP QannualB_GHP[i][0] += QtoBoiler BoilerEff = Boiler.calc_Cop_boiler(QtoBoiler, QnomBoiler, TexitGHP) Qgas = QtoBoiler / BoilerEff result[3 + i][4] += prices.NG_PRICE * Qgas # CHF result[3 + i][ 5] += lca.NG_BACKUPBOILER_TO_CO2_STD * Qgas * 3600E-6 # kgCO2 result[3 + i][ 6] += lca.NG_BACKUPBOILER_TO_OIL_STD * Qgas * 3600E-6 # MJ-oil-eq resourcesRes[3 + i][0] += QtoBoiler # Investment Costs / CO2 / Prim Capex_a_Boiler, Opex_Boiler = Boiler.calc_Cinv_boiler( Qnom, locator, config, 'BO1') InvCosts[0][0] = Capex_a_Boiler + Opex_Boiler InvCosts[1][0] = Capex_a_Boiler + Opex_Boiler Capex_a_FC, Opex_FC = FC.calc_Cinv_FC(Qnom, locator, config) InvCosts[2][0] = Capex_a_FC + Opex_FC for i in range(10): result[3 + i][0] = i / 10 result[3 + i][3] = 1 - i / 10 QnomBoiler = i / 10 * Qnom Capex_a_Boiler, Opex_Boiler = Boiler.calc_Cinv_boiler( QnomBoiler, locator, config, 'BO1') InvCosts[3 + i][0] = Capex_a_Boiler + Opex_Boiler Capex_a_GHP, Opex_GHP = HP.calc_Cinv_GHP(Wel_GHP[i][0], locator, config) InvCaGHP = Capex_a_GHP + Opex_GHP InvCosts[3 + i][0] += InvCaGHP * prices.EURO_TO_CHF # Best configuration Best = np.zeros((13, 1)) indexBest = 0 TotalCosts = np.zeros((13, 2)) TotalCO2 = np.zeros((13, 2)) TotalPrim = np.zeros((13, 2)) for i in range(13): TotalCosts[i][0] = TotalCO2[i][0] = TotalPrim[i][0] = i TotalCosts[i][1] = InvCosts[i][0] + result[i][4] TotalCO2[i][1] = result[i][5] TotalPrim[i][1] = result[i][6] CostsS = TotalCosts[np.argsort(TotalCosts[:, 1])] CO2S = TotalCO2[np.argsort(TotalCO2[:, 1])] PrimS = TotalPrim[np.argsort(TotalPrim[:, 1])] el = len(CostsS) rank = 0 Bestfound = False optsearch = np.empty(el) optsearch.fill(3) indexBest = 0 geothermal_potential = geothermal_potential_data.set_index('Name') # Check the GHP area constraint for i in range(10): QGHP = (1 - i / 10) * Qnom areaAvail = geothermal_potential.ix[building_name, 'Area_geo'] Qallowed = np.ceil(areaAvail / GHP_A) * GHP_HMAX_SIZE # [W_th] if Qallowed < QGHP: optsearch[i + 3] += 1 Best[i + 3][0] = -1 while not Bestfound and rank < el: optsearch[int(CostsS[rank][0])] -= 1 optsearch[int(CO2S[rank][0])] -= 1 optsearch[int(PrimS[rank][0])] -= 1 if np.count_nonzero(optsearch) != el: Bestfound = True indexBest = np.where(optsearch == 0)[0][0] rank += 1 # get the best option according to the ranking. Best[indexBest][0] = 1 Qnom_array = np.ones(len(Best[:, 0])) * Qnom # Save results in csv file dico = {} dico["BoilerNG Share"] = result[:, 0] dico["BoilerBG Share"] = result[:, 1] dico["FC Share"] = result[:, 2] dico["GHP Share"] = result[:, 3] dico["Operation Costs [CHF]"] = result[:, 4] dico["CO2 Emissions [kgCO2-eq]"] = result[:, 5] dico["Primary Energy Needs [MJoil-eq]"] = result[:, 6] dico["Annualized Investment Costs [CHF]"] = InvCosts[:, 0] dico["Total Costs [CHF]"] = TotalCosts[:, 1] dico["Best configuration"] = Best[:, 0] dico["Nominal Power"] = Qnom_array dico["QfromNG"] = resourcesRes[:, 0] dico["QfromBG"] = resourcesRes[:, 1] dico["EforGHP"] = resourcesRes[:, 2] dico["QfromGHP"] = resourcesRes[:, 3] results_to_csv = pd.DataFrame(dico) fName_result = locator.get_optimization_disconnected_folder_building_result_heating( building_name) results_to_csv.to_csv(fName_result, sep=',') BestComb = {} BestComb["BoilerNG Share"] = result[indexBest, 0] BestComb["BoilerBG Share"] = result[indexBest, 1] BestComb["FC Share"] = result[indexBest, 2] BestComb["GHP Share"] = result[indexBest, 3] BestComb["Operation Costs [CHF]"] = result[indexBest, 4] BestComb["CO2 Emissions [kgCO2-eq]"] = result[indexBest, 5] BestComb["Primary Energy Needs [MJoil-eq]"] = result[indexBest, 6] BestComb["Annualized Investment Costs [CHF]"] = InvCosts[indexBest, 0] BestComb["Total Costs [CHF]"] = TotalCosts[indexBest, 1] BestComb["Best configuration"] = Best[indexBest, 0] BestComb["Nominal Power"] = Qnom BestData[building_name] = BestComb if 0: fName = locator.get_optimization_disconnected_folder_disc_op_summary_heating( ) results_to_csv = pd.DataFrame(BestData) results_to_csv.to_csv(fName, sep=',') print time.clock( ) - t0, "seconds process time for the Disconnected Building Routine \n"
def addCosts(indCombi, buildList, locator, dicoSupply, Q_uncovered_design_W, Q_uncovered_annual_W, solarFeat, ntwFeat, gv): """ Computes additional costs / GHG emisions / primary energy needs for the individual addCosts = additional costs addCO2 = GHG emissions addPrm = primary energy needs :param indCombi: 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 dicoSupply: 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 dicoSupply: 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 = 0 addCO2 = 0 addPrim = 0 nBuildinNtw = 0 # Add the features from the disconnected buildings print "\n COSTS FROM DISCONNECTED BUILDINGS" os.chdir(locator.get_optimization_disconnected_folder()) CostDiscBuild = 0 CO2DiscBuild = 0 PrimDiscBuild = 0 FurnaceInvCost = 0 CCInvCost = 0 BoilerBInvCost = 0 BoilerPInvCost = 0 HPLakeInvC = 0 HPSewInvC = 0 GHPInvC = 0 PVInvC = 0 SCInvC = 0 PVTInvC = 0 BoilerAddInvC = 0 StorageHEXCost = 0 StorageHPCost = 0 StorageInvC = 0 NetworkCost = 0 SubstHEXCost = 0 PVTHEXCost = 0 SCHEXCost = 0 pumpCosts = 0 GasConnectionInvCost = 0 for (index, building_name) in zip(indCombi, buildList): if index == "0": discFileName = "DiscOp_" + building_name + "_result.csv" df = pd.read_csv(discFileName) 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] print dfBest["Total Costs [CHF]"].iloc[ 0], building_name, "disconnected" else: nBuildinNtw += 1 addCosts += CostDiscBuild addCO2 += CO2DiscBuild addPrim += PrimDiscBuild # Add the features for the distribution if indCombi.count("1") > 0: os.chdir(locator.get_optimization_slave_results_folder()) print " \n MACHINERY COSTS" # Add the investment costs of the energy systems # Furnace if dicoSupply.Furnace_on == 1: P_design_W = dicoSupply.Furnace_Q_max fNameSlavePP = locator.get_optimization_slave_pp_activation_pattern( dicoSupply.configKey) 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] FurnaceInvCost = furnace.calc_Cinv_furnace(P_design_W, Q_annual_W, gv) addCosts += FurnaceInvCost print furnace.calc_Cinv_furnace(P_design_W, Q_annual_W, gv), " Furnace" # CC if dicoSupply.CC_on == 1: CC_size_W = dicoSupply.CC_GT_SIZE CCInvCost = chp.calc_Cinv_CCT(CC_size_W, gv) addCosts += CCInvCost print chp.calc_Cinv_CCT(CC_size_W, gv), " CC" # Boiler Base if dicoSupply.Boiler_on == 1: Q_design_W = dicoSupply.Boiler_Q_max fNameSlavePP = locator.get_optimization_slave_pp_activation_pattern( dicoSupply.configKey) dfBoilerBase = pd.read_csv(fNameSlavePP, usecols=["Q_BoilerBase_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] BoilerBInvCost = boiler.calc_Cinv_boiler(Q_design_W, Q_annual_W, gv) addCosts += BoilerBInvCost print boiler.calc_Cinv_boiler(Q_design_W, Q_annual_W, gv), " Boiler Base " # Boiler Peak if dicoSupply.BoilerPeak_on == 1: Q_design_W = dicoSupply.BoilerPeak_Q_max fNameSlavePP = locator.get_optimization_slave_pp_activation_pattern( dicoSupply.configKey) dfBoilerPeak = pd.read_csv(fNameSlavePP, usecols=["Q_BoilerPeak_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] BoilerPInvCost = boiler.calc_Cinv_boiler(Q_design_W, Q_annual_W, gv) addCosts += BoilerPInvCost print boiler.calc_Cinv_boiler(Q_design_W, Q_annual_W, gv), " Boiler Peak" # HP Lake if dicoSupply.HP_Lake_on == 1: HP_Size_W = dicoSupply.HPLake_maxSize HPLakeInvC = hp.calc_Cinv_HP(HP_Size_W, gv) addCosts += HPLakeInvC print hp.calc_Cinv_HP(HP_Size_W, gv), " HP Lake" # HP Sewage if dicoSupply.HP_Sew_on == 1: HP_Size_W = dicoSupply.HPSew_maxSize HPSewInvC = hp.calc_Cinv_HP(HP_Size_W, gv) addCosts += HPSewInvC print hp.calc_Cinv_HP(HP_Size_W, gv), "HP Sewage" # GHP if dicoSupply.GHP_on == 1: fNameSlavePP = locator.get_optimization_slave_pp_activation_pattern( dicoSupply.configKey) dfGHP = pd.read_csv(fNameSlavePP, usecols=["E_GHP_req_W"]) arrayGHP_W = np.array(dfGHP) GHP_Enom_W = np.amax(arrayGHP_W) GHPInvC = hp.calc_Cinv_GHP(GHP_Enom_W, gv) * gv.EURO_TO_CHF addCosts += GHPInvC print hp.calc_Cinv_GHP(GHP_Enom_W, gv) * gv.EURO_TO_CHF, " GHP" # Solar technologies PV_peak_kW = dicoSupply.SOLAR_PART_PV * solarFeat.A_PV_m2 * gv.nPV #kW PVInvC = pv.calc_Cinv_pv(PV_peak_kW) addCosts += PVInvC print pv.calc_Cinv_pv(PV_peak_kW), "PV peak" SC_area_m2 = dicoSupply.SOLAR_PART_SC * solarFeat.A_SC_m2 SCInvC = stc.calc_Cinv_SC(SC_area_m2, gv) addCosts += SCInvC print stc.calc_Cinv_SC(SC_area_m2, gv), "SC area" PVT_peak_kW = dicoSupply.SOLAR_PART_PVT * solarFeat.A_PVT_m2 * gv.nPVT #kW PVTInvC = pvt.calc_Cinv_PVT(PVT_peak_kW, gv) addCosts += PVTInvC print pvt.calc_Cinv_PVT(PVT_peak_kW, gv), "PVT peak" # Back-up boiler BoilerAddInvC = boiler.calc_Cinv_boiler(Q_uncovered_design_W, Q_uncovered_annual_W, gv) addCosts += BoilerAddInvC print boiler.calc_Cinv_boiler(Q_uncovered_design_W, Q_uncovered_annual_W, gv), "backup boiler" # Hex and HP for Heat recovery print "\n STORAGE PART COSTS" if dicoSupply.WasteServersHeatRecovery == 1: df = pd.read_csv(os.path.join( locator.get_optimization_network_results_folder(), dicoSupply.NETWORK_DATA_FILE), usecols=["Qcdata_netw_total_kWh"]) array = np.array(df) Q_HEX_max_kWh = np.amax(array) StorageHEXCost += hex.calc_Cinv_HEX(Q_HEX_max_kWh, gv) print hex.calc_Cinv_HEX(Q_HEX_max_kWh, gv), "Hex for data center" df = pd.read_csv( locator.get_optimization_slave_storage_operation_data( dicoSupply.configKey), usecols=["HPServerHeatDesignArray_kWh"]) array = np.array(df) Q_HP_max_kWh = np.amax(array) StorageHEXCost += hp.calc_Cinv_HP(Q_HP_max_kWh, gv) print hp.calc_Cinv_HP(Q_HP_max_kWh, gv), "HP for data center" if dicoSupply.WasteCompressorHeatRecovery == 1: df = pd.read_csv(os.path.join( locator.get_optimization_network_results_folder(), dicoSupply.NETWORK_DATA_FILE), usecols=["Ecaf_netw_total_kWh"]) array = np.array(df) Q_HEX_max_kWh = np.amax(array) StorageHEXCost += hex.calc_Cinv_HEX(Q_HEX_max_kWh, gv) print hex.calc_Cinv_HEX(Q_HEX_max_kWh, gv), "Hex for compressed air" df = pd.read_csv( locator.get_optimization_slave_storage_operation_data( dicoSupply.configKey), usecols=["HPCompAirDesignArray_kWh"]) array = np.array(df) Q_HP_max_kWh = np.amax(array) StorageHEXCost += hp.calc_Cinv_HP(Q_HP_max_kWh, gv) print hp.calc_Cinv_HP(Q_HP_max_kWh, gv), "HP for compressed air" addCosts += StorageHEXCost # Heat pump solar to storage df = pd.read_csv( locator.get_optimization_slave_storage_operation_data( dicoSupply.configKey), usecols=["HPScDesignArray_Wh", "HPpvt_designArray_Wh"]) array = np.array(df) Q_HP_max_PVT_Wh = np.amax(array[:, 1]) QhpMax_SC_Wh = np.amax(array[:, 0]) StorageHPCost += hp.calc_Cinv_HP(Q_HP_max_PVT_Wh, gv) print hp.calc_Cinv_HP(Q_HP_max_PVT_Wh, gv), "HP for PVT" StorageHPCost += hp.calc_Cinv_HP(QhpMax_SC_Wh, gv) print hp.calc_Cinv_HP(QhpMax_SC_Wh, gv), "HP for SC" # HP for storage operation df = pd.read_csv(locator.get_optimization_slave_storage_operation_data( dicoSupply.configKey), 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(gv.DAYS_IN_YEAR * gv.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]) StorageHPCost += hp.calc_Cinv_HP(Q_HP_max_storage_W, gv) addCosts += StorageHPCost print hp.calc_Cinv_HP(Q_HP_max_storage_W, gv), "HP for storage" # Storage df = pd.read_csv(locator.get_optimization_slave_storage_operation_data( dicoSupply.configKey), usecols=["Storage_Size_m3"], nrows=1) StorageVol_m3 = np.array(df)[0][0] StorageInvC += storage.calc_Cinv_storage(StorageVol_m3, gv) addCosts += StorageInvC print storage.calc_Cinv_storage(StorageVol_m3, gv), "Storage Costs" # Costs from distribution configuration print "\n COSTS FROM NETWORK 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 += NetworkCost print ntwFeat.pipesCosts_DHN * nBuildinNtw / len( buildList), "Pipes Costs" # HEX (1 per building in ntw) for (index, building_name) in zip(indCombi, 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]) SubstHEXCost += hex.calc_Cinv_HEX(Q_max_W, gv) print hex.calc_Cinv_HEX(Q_max_W, gv), "Hex", building_name addCosts += SubstHEXCost # 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(indCombi)): index = indCombi[i] if index == "1": areaAvail += roof_area_m2[i][0] for i in range(len(indCombi)): index = indCombi[i] if index == "1": share = roof_area_m2[i][0] / areaAvail #print share, "solar area share", buildList[i] Q_max_SC_Wh = solarFeat.Q_nom_SC_Wh * dicoSupply.SOLAR_PART_SC * share SCHEXCost += hex.calc_Cinv_HEX(Q_max_SC_Wh, gv) print hex.calc_Cinv_HEX(Q_max_SC_Wh, gv), "Hex SC", buildList[i] Q_max_PVT_Wh = solarFeat.Q_nom_PVT_Wh * dicoSupply.SOLAR_PART_PVT * share PVTHEXCost += hex.calc_Cinv_HEX(Q_max_PVT_Wh, gv) print hex.calc_Cinv_HEX(Q_max_PVT_Wh, gv), "Hex PVT", buildList[i] addCosts += SCHEXCost addCosts += PVTHEXCost print addCosts, "addCosts in extraCostsMain" # Pump operation costs pumpCosts = pumps.calc_Ctot_pump( dicoSupply, buildList, locator.get_optimization_network_results_folder(), ntwFeat, gv) addCosts += pumpCosts print pumpCosts, "Pump Operation costs in extraCostsMain\n" # import gas consumption data from: if indCombi.count("1") > 0: # import gas consumption data from: E_gas_PrimaryDataframe_W = pd.read_csv( locator.get_optimization_slave_primary_energy_by_source( dicoSupply.configKey), usecols=["E_gas_PrimaryPeakPower_W"]) E_gas_primary_peak_power_W = float(np.array(E_gas_PrimaryDataframe_W)) GasConnectionInvCost = ngas.calc_Cinv_gas(E_gas_primary_peak_power_W, gv) else: GasConnectionInvCost = 0.0 addCosts += GasConnectionInvCost # Save data results = pd.DataFrame({ "SCInvC": [SCInvC], "PVTInvC": [PVTInvC], "BoilerAddInvC": [BoilerAddInvC], "StorageHEXCost": [StorageHEXCost], "StorageHPCost": [StorageHPCost], "StorageInvC": [StorageInvC], "StorageCostSum": [StorageInvC + StorageHPCost + StorageHEXCost], "NetworkCost": [NetworkCost], "SubstHEXCost": [SubstHEXCost], "DHNInvestCost": [addCosts - CostDiscBuild], "PVTHEXCost": [PVTHEXCost], "CostDiscBuild": [CostDiscBuild], "CO2DiscBuild": [CO2DiscBuild], "PrimDiscBuild": [PrimDiscBuild], "FurnaceInvCost": [FurnaceInvCost], "BoilerBInvCost": [BoilerBInvCost], "BoilerPInvCost": [BoilerPInvCost], "HPLakeInvC": [HPLakeInvC], "HPSewInvC": [HPSewInvC], "SCHEXCost": [SCHEXCost], "pumpCosts": [pumpCosts], "SumInvestCost": [addCosts], "GasConnectionInvCa": [GasConnectionInvCost] }) results.to_csv(locator.get_optimization_slave_investment_cost_detailed( dicoSupply.configKey), sep=',') return (addCosts, addCO2, addPrim)
def disconnected_buildings_heating_main(locator, total_demand, building_names, config, prices, lca): """ Computes the parameters for the operation of disconnected buildings output results in csv files. There is no optimization at this point. The different technologies are calculated and compared 1 to 1 to each technology. it is a classical combinatorial problem. :param locator: locator class :param building_names: list with names of buildings :type locator: class :type building_names: list :return: results of operation of buildings located in locator.get_optimization_decentralized_folder :rtype: Nonetype """ t0 = time.clock() prop_geometry = Gdf.from_file(locator.get_zone_geometry()) geometry = pd.DataFrame({'Name': prop_geometry.Name, 'Area': prop_geometry.area}) geothermal_potential_data = dbf.dbf_to_dataframe(locator.get_building_supply()) geothermal_potential_data = pd.merge(geothermal_potential_data, geometry, on='Name') geothermal_potential_data['Area_geo'] = geothermal_potential_data['Area'] weather_path = locator.get_weather_file() weather_data = epwreader.epw_reader(weather_path)[['year', 'drybulb_C', 'wetbulb_C', 'relhum_percent', 'windspd_ms', 'skytemp_C']] T_ground_K = calc_ground_temperature(locator, weather_data['drybulb_C'], depth_m=10) # This will calculate the substation state if all buildings where connected(this is how we study this) substation.substation_main_heating(locator, total_demand, building_names) for building_name in building_names: print('running for building %s') %(building_name) # run substation model to derive temperatures of the building substation_results = pd.read_csv(locator.get_optimization_substations_results_file(building_name, "DH", "")) q_load_Wh = np.vectorize(calc_new_load)(substation_results["mdot_DH_result_kgpers"], substation_results["T_supply_DH_result_K"], substation_results["T_return_DH_result_K"]) Qnom_W = q_load_Wh.max() # Create empty matrices Opex_a_var_USD = np.zeros((13, 7)) Capex_total_USD = np.zeros((13, 7)) Capex_a_USD = np.zeros((13, 7)) Opex_a_fixed_USD = np.zeros((13, 7)) Capex_opex_a_fixed_only_USD = np.zeros((13, 7)) Opex_a_USD = np.zeros((13, 7)) GHG_tonCO2 = np.zeros((13, 7)) PEN_MJoil = np.zeros((13, 7)) # indicate supply technologies for each configuration Opex_a_var_USD[0][0] = 1 # Boiler NG Opex_a_var_USD[1][1] = 1 # Boiler BG Opex_a_var_USD[2][2] = 1 # Fuel Cell resourcesRes = np.zeros((13, 4)) Q_Boiler_for_GHP_W = np.zeros((10, 1)) # Save peak capacity of GHP Backup Boilers GHP_el_size_W = np.zeros((10, 1)) # Save peak capacity of GHP # save supply system activation of all supply configurations heating_dispatch = {} # Supply with the Boiler / FC / GHP Tret_K = substation_results["T_return_DH_result_K"].values Tsup_K = substation_results["T_supply_DH_result_K"].values mdot_kgpers = substation_results["mdot_DH_result_kgpers"].values ## Start Hourly calculation print building_name, ' decentralized heating supply systems simulations...' Tret_K = np.where(Tret_K > 0.0, Tret_K, Tsup_K) ## 0: Boiler NG BoilerEff = np.vectorize(Boiler.calc_Cop_boiler)(q_load_Wh, Qnom_W, Tret_K) Qgas_to_Boiler_Wh = np.divide(q_load_Wh, BoilerEff, out=np.zeros_like(q_load_Wh), where=BoilerEff != 0.0) Boiler_Status = np.where(Qgas_to_Boiler_Wh > 0.0, 1, 0) # add costs Opex_a_var_USD[0][4] += sum(prices.NG_PRICE * Qgas_to_Boiler_Wh) # CHF GHG_tonCO2[0][5] += calc_emissions_Whyr_to_tonCO2yr(sum(Qgas_to_Boiler_Wh), lca.NG_TO_CO2_EQ) # ton CO2 PEN_MJoil[0][6] += calc_pen_Whyr_to_MJoilyr(sum(Qgas_to_Boiler_Wh), lca.NG_TO_OIL_EQ) # MJ-oil-eq # add activation resourcesRes[0][0] += sum(q_load_Wh) # q from NG heating_dispatch[0] = {'Q_Boiler_gen_directload_W': q_load_Wh, 'Boiler_Status': Boiler_Status, 'NG_Boiler_req_W': Qgas_to_Boiler_Wh, 'E_hs_ww_req_W': np.zeros(8760)} ## 1: Boiler BG # add costs Opex_a_var_USD[1][4] += sum(prices.BG_PRICE * Qgas_to_Boiler_Wh) # CHF GHG_tonCO2[1][5] += calc_emissions_Whyr_to_tonCO2yr(sum(Qgas_to_Boiler_Wh), lca.NG_TO_CO2_EQ) # ton CO2 PEN_MJoil[1][6] += calc_pen_Whyr_to_MJoilyr(sum(Qgas_to_Boiler_Wh), lca.NG_TO_OIL_EQ) # MJ-oil-eq # add activation resourcesRes[1][1] += sum(q_load_Wh) # q from BG heating_dispatch[1] = {'Q_Boiler_gen_directload_W': q_load_Wh, 'Boiler_Status': Boiler_Status, 'BG_Boiler_req_W': Qgas_to_Boiler_Wh, 'E_hs_ww_req_W': np.zeros(8760)} ## 2: Fuel Cell (FC_Effel, FC_Effth) = np.vectorize(FC.calc_eta_FC)(q_load_Wh, Qnom_W, 1, "B") Qgas_to_FC_Wh = q_load_Wh / (FC_Effth + FC_Effel) # FIXME: should be q_load_Wh/FC_Effth? el_from_FC_Wh = Qgas_to_FC_Wh * FC_Effel FC_Status = np.where(Qgas_to_FC_Wh > 0.0, 1, 0) # add variable costs, emissions and primary energy Opex_a_var_USD[2][4] += sum(prices.NG_PRICE * Qgas_to_FC_Wh - prices.ELEC_PRICE_EXPORT * el_from_FC_Wh) # CHF, extra electricity sold to grid GHG_tonCO2_from_FC = (0.0874 * Qgas_to_FC_Wh * 3600E-6 + 773 * 0.45 * el_from_FC_Wh * 1E-6 - lca.EL_TO_CO2_EQ * el_from_FC_Wh * 3600E-6) / 1E3 GHG_tonCO2[2][5] += sum(GHG_tonCO2_from_FC) # tonCO2 # Bloom box emissions within the FC: 773 lbs / MWh_el (and 1 lbs = 0.45 kg) # http://www.carbonlighthouse.com/2011/09/16/bloom-box/ PEN_MJoil_from_FC = 1.51 * Qgas_to_FC_Wh * 3600E-6 - lca.EL_TO_OIL_EQ * el_from_FC_Wh * 3600E-6 PEN_MJoil[2][6] += sum(PEN_MJoil_from_FC) # MJ-oil-eq # add activation resourcesRes[2][0] = sum(q_load_Wh) # q from NG resourcesRes[2][2] = sum(el_from_FC_Wh) # el for GHP # FIXME: el from FC heating_dispatch[2] = {'Q_Fuelcell_gen_directload_W': q_load_Wh, 'Fuelcell_Status': FC_Status, 'NG_FuelCell_req_W': Qgas_to_FC_Wh, 'E_Fuelcell_gen_export_W': el_from_FC_Wh, 'E_hs_ww_req_W': np.zeros(8760)} # 3-13: Boiler NG + GHP for i in range(10): # set nominal size for Boiler and GHP QnomBoiler_W = i / 10.0 * Qnom_W mdot_kgpers_Boiler = i / 10.0 * mdot_kgpers QnomGHP_W = Qnom_W - QnomBoiler_W # GHP operation Texit_GHP_nom_K = QnomGHP_W / (mdot_kgpers * HEAT_CAPACITY_OF_WATER_JPERKGK) + Tret_K el_GHP_Wh, q_load_NG_Boiler_Wh, \ qhot_missing_Wh, \ Texit_GHP_K, q_from_GHP_Wh = np.vectorize(calc_GHP_operation)(QnomGHP_W, T_ground_K, Texit_GHP_nom_K, Tret_K, Tsup_K, mdot_kgpers, q_load_Wh) GHP_el_size_W[i][0] = max(el_GHP_Wh) GHP_Status = np.where(q_from_GHP_Wh > 0.0, 1, 0) # GHP Backup Boiler operation if max(qhot_missing_Wh) > 0.0: print "GHP unable to cover the whole demand, boiler activated!" Qnom_GHP_Backup_Boiler_W = max(qhot_missing_Wh) BoilerEff = np.vectorize(Boiler.calc_Cop_boiler)(qhot_missing_Wh, Qnom_GHP_Backup_Boiler_W, Texit_GHP_K) Qgas_to_GHPBoiler_Wh = np.divide(qhot_missing_Wh, BoilerEff, out=np.zeros_like(qhot_missing_Wh), where=BoilerEff != 0.0) else: Qgas_to_GHPBoiler_Wh = np.zeros(q_load_Wh.shape[0]) Qnom_GHP_Backup_Boiler_W = 0.0 Q_Boiler_for_GHP_W[i][0] = Qnom_GHP_Backup_Boiler_W GHPbackupBoiler_Status = np.where(qhot_missing_Wh > 0.0, 1, 0) # NG Boiler operation BoilerEff = np.vectorize(Boiler.calc_Cop_boiler)(q_load_NG_Boiler_Wh, QnomBoiler_W, Texit_GHP_K) Qgas_to_Boiler_Wh = np.divide(q_load_NG_Boiler_Wh, BoilerEff, out=np.zeros_like(q_load_NG_Boiler_Wh), where=BoilerEff != 0.0) Boiler_Status = np.where(q_load_NG_Boiler_Wh > 0.0, 1, 0) # add costs # electricity el_total_Wh = el_GHP_Wh Opex_a_var_USD[3 + i][4] += sum(prices.ELEC_PRICE * el_total_Wh) # CHF GHG_tonCO2[3 + i][5] += calc_emissions_Whyr_to_tonCO2yr(sum(el_total_Wh), lca.EL_TO_CO2_EQ) # ton CO2 PEN_MJoil[3 + i][6] += calc_pen_Whyr_to_MJoilyr(sum(el_total_Wh), lca.EL_TO_OIL_EQ) # MJ-oil-eq # gas Q_gas_total_Wh = Qgas_to_GHPBoiler_Wh + Qgas_to_Boiler_Wh Opex_a_var_USD[3 + i][4] += sum(prices.NG_PRICE * Q_gas_total_Wh) # CHF GHG_tonCO2[3 + i][5] += calc_emissions_Whyr_to_tonCO2yr(sum(Q_gas_total_Wh), lca.NG_TO_CO2_EQ) # ton CO2 PEN_MJoil[3 + i][6] += calc_pen_Whyr_to_MJoilyr(sum(Q_gas_total_Wh), lca.NG_TO_OIL_EQ) # MJ-oil-eq # add activation resourcesRes[3 + i][0] = sum(qhot_missing_Wh + q_load_NG_Boiler_Wh) resourcesRes[3 + i][2] = sum(el_GHP_Wh) resourcesRes[3 + i][3] = sum(q_from_GHP_Wh) heating_dispatch[3 + i] = {'Q_GHP_gen_directload_W': q_from_GHP_Wh, 'Q_BackupBoiler_gen_directload_W': qhot_missing_Wh, 'Q_Boiler_gen_directload_W': q_load_NG_Boiler_Wh, 'GHP_Status': GHP_Status, 'BackupBoiler_Status': GHPbackupBoiler_Status, 'Boiler_Status': Boiler_Status, 'NG_BackupBoiler_req_Wh': Qgas_to_GHPBoiler_Wh, 'NG_Boiler_req_Wh': Qgas_to_Boiler_Wh, 'E_hs_ww_req_W': el_GHP_Wh} # Add all costs # 0: Boiler NG Capex_a_Boiler_USD, Opex_a_fixed_Boiler_USD, Capex_Boiler_USD = Boiler.calc_Cinv_boiler(Qnom_W, locator, config, 'BO1') Capex_total_USD[0][0] = Capex_Boiler_USD Capex_a_USD[0][0] = Capex_a_Boiler_USD Opex_a_fixed_USD[0][0] = Opex_a_fixed_Boiler_USD Capex_opex_a_fixed_only_USD[0][0] = Capex_a_Boiler_USD + Opex_a_fixed_Boiler_USD # TODO:variable price? # 1: Boiler BG Capex_total_USD[1][0] = Capex_Boiler_USD Capex_a_USD[1][0] = Capex_a_Boiler_USD Opex_a_fixed_USD[1][0] = Opex_a_fixed_Boiler_USD Capex_opex_a_fixed_only_USD[1][0] = Capex_a_Boiler_USD + Opex_a_fixed_Boiler_USD # TODO:variable price? # 2: Fuel Cell Capex_a_FC_USD, Opex_fixed_FC_USD, Capex_FC_USD = FC.calc_Cinv_FC(Qnom_W, locator, config) Capex_total_USD[2][0] = Capex_FC_USD Capex_a_USD[2][0] = Capex_a_FC_USD Opex_a_fixed_USD[2][0] = Opex_fixed_FC_USD Capex_opex_a_fixed_only_USD[2][0] = Capex_a_FC_USD + Opex_fixed_FC_USD # TODO:variable price? # 3-13: BOILER + GHP for i in range(10): Opex_a_var_USD[3 + i][0] = i / 10.0 # Boiler share Opex_a_var_USD[3 + i][3] = 1 - i / 10.0 # GHP share # Get boiler costs QnomBoiler_W = i / 10.0 * Qnom_W Capex_a_Boiler_USD, Opex_a_fixed_Boiler_USD, Capex_Boiler_USD = Boiler.calc_Cinv_boiler(QnomBoiler_W, locator, config, 'BO1') Capex_total_USD[3 + i][0] += Capex_Boiler_USD Capex_a_USD[3 + i][0] += Capex_a_Boiler_USD Opex_a_fixed_USD[3 + i][0] += Opex_a_fixed_Boiler_USD Capex_opex_a_fixed_only_USD[3 + i][ 0] += Capex_a_Boiler_USD + Opex_a_fixed_Boiler_USD # TODO:variable price? # Get back up boiler costs Qnom_Backup_Boiler_W = Q_Boiler_for_GHP_W[i][0] Capex_a_GHPBoiler_USD, Opex_a_fixed_GHPBoiler_USD, Capex_GHPBoiler_USD = Boiler.calc_Cinv_boiler( Qnom_Backup_Boiler_W, locator, config, 'BO1') Capex_total_USD[3 + i][0] += Capex_GHPBoiler_USD Capex_a_USD[3 + i][0] += Capex_a_GHPBoiler_USD Opex_a_fixed_USD[3 + i][0] += Opex_a_fixed_GHPBoiler_USD Capex_opex_a_fixed_only_USD[3 + i][ 0] += Capex_a_GHPBoiler_USD + Opex_a_fixed_GHPBoiler_USD # TODO:variable price? # Get ground source heat pump costs Capex_a_GHP_USD, Opex_a_fixed_GHP_USD, Capex_GHP_USD = HP.calc_Cinv_GHP(GHP_el_size_W[i][0], locator, config) Capex_total_USD[3 + i][0] += Capex_GHP_USD Capex_a_USD[3 + i][0] += Capex_a_GHP_USD Opex_a_fixed_USD[3 + i][0] += Opex_a_fixed_GHP_USD Capex_opex_a_fixed_only_USD[3 + i][0] += Capex_a_GHP_USD + Opex_a_fixed_GHP_USD # TODO:variable price? # Best configuration Best = np.zeros((13, 1)) indexBest = 0 TAC_USD = np.zeros((13, 2)) TotalCO2 = np.zeros((13, 2)) TotalPrim = np.zeros((13, 2)) for i in range(13): TAC_USD[i][0] = TotalCO2[i][0] = TotalPrim[i][0] = i Opex_a_USD[i][1] = Opex_a_fixed_USD[i][0] + + Opex_a_var_USD[i][4] TAC_USD[i][1] = Capex_opex_a_fixed_only_USD[i][0] + Opex_a_var_USD[i][4] TotalCO2[i][1] = GHG_tonCO2[i][5] TotalPrim[i][1] = PEN_MJoil[i][6] CostsS = TAC_USD[np.argsort(TAC_USD[:, 1])] CO2S = TotalCO2[np.argsort(TotalCO2[:, 1])] PrimS = TotalPrim[np.argsort(TotalPrim[:, 1])] el = len(CostsS) rank = 0 Bestfound = False optsearch = np.empty(el) optsearch.fill(3) indexBest = 0 geothermal_potential = geothermal_potential_data.set_index('Name') # Check the GHP area constraint for i in range(10): QGHP = (1 - i / 10.0) * Qnom_W areaAvail = geothermal_potential.ix[building_name, 'Area_geo'] Qallowed = np.ceil(areaAvail / GHP_A) * GHP_HMAX_SIZE # [W_th] if Qallowed < QGHP: optsearch[i + 3] += 1 Best[i + 3][0] = - 1 while not Bestfound and rank < el: optsearch[int(CostsS[rank][0])] -= 1 optsearch[int(CO2S[rank][0])] -= 1 optsearch[int(PrimS[rank][0])] -= 1 if np.count_nonzero(optsearch) != el: Bestfound = True indexBest = np.where(optsearch == 0)[0][0] rank += 1 # get the best option according to the ranking. Best[indexBest][0] = 1 # Save results in csv file performance_results = { "Nominal heating load": Qnom_W, "Capacity_BaseBoiler_NG_W": Qnom_W * Opex_a_var_USD[:, 0], "Capacity_FC_NG_W": Qnom_W * Opex_a_var_USD[:, 2], "Capacity_GS_HP_W": Qnom_W * Opex_a_var_USD[:, 3], "TAC_USD": TAC_USD[:, 1], "Capex_a_USD": Capex_a_USD[:, 0], "Capex_total_USD": Capex_total_USD[:, 0], "Opex_fixed_USD": Opex_a_fixed_USD[:, 0], "Opex_var_USD": Opex_a_var_USD[:, 4], "GHG_tonCO2": GHG_tonCO2[:, 5], "PEN_MJoil": PEN_MJoil[:, 6], "Best configuration": Best[:, 0]} results_to_csv = pd.DataFrame(performance_results) fName_result = locator.get_optimization_decentralized_folder_building_result_heating(building_name) results_to_csv.to_csv(fName_result, sep=',') # save activation for the best supply system configuration best_activation_df = pd.DataFrame.from_dict(heating_dispatch[indexBest]) # best_activation_df.to_csv( locator.get_optimization_decentralized_folder_building_result_heating_activation(building_name)) print time.clock() - t0, "seconds process time for the Disconnected Building Routine \n"
def disconnected_heating_for_building(building_name, supply_systems, T_ground_K, geothermal_potential_data, lca, locator, prices): print('{building_name} disconnected heating supply system simulations...'. format(building_name=building_name)) GHP_cost_data = supply_systems.HP BH_cost_data = supply_systems.BH boiler_cost_data = supply_systems.Boiler # run substation model to derive temperatures of the building substation_results = pd.read_csv( locator.get_optimization_substations_results_file( building_name, "DH", "")) q_load_Wh = np.vectorize(calc_new_load)( substation_results["mdot_DH_result_kgpers"], substation_results["T_supply_DH_result_K"], substation_results["T_return_DH_result_K"]) Qnom_W = q_load_Wh.max() # Create empty matrices Opex_a_var_USD = np.zeros((13, 7)) Capex_total_USD = np.zeros((13, 7)) Capex_a_USD = np.zeros((13, 7)) Opex_a_fixed_USD = np.zeros((13, 7)) Capex_opex_a_fixed_only_USD = np.zeros((13, 7)) Opex_a_USD = np.zeros((13, 7)) GHG_tonCO2 = np.zeros((13, 7)) # indicate supply technologies for each configuration Opex_a_var_USD[0][0] = 1 # Boiler NG Opex_a_var_USD[1][1] = 1 # Boiler BG Opex_a_var_USD[2][2] = 1 # Fuel Cell resourcesRes = np.zeros((13, 4)) Q_Boiler_for_GHP_W = np.zeros( (10, 1)) # Save peak capacity of GHP Backup Boilers GHP_el_size_W = np.zeros((10, 1)) # Save peak capacity of GHP # save supply system activation of all supply configurations heating_dispatch = {} # Supply with the Boiler / FC / GHP Tret_K = substation_results["T_return_DH_result_K"].values Tsup_K = substation_results["T_supply_DH_result_K"].values mdot_kgpers = substation_results["mdot_DH_result_kgpers"].values ## Start Hourly calculation print(building_name, ' decentralized heating supply systems simulations...') Tret_K = np.where(Tret_K > 0.0, Tret_K, Tsup_K) ## 0: Boiler NG BoilerEff = np.vectorize(Boiler.calc_Cop_boiler)(q_load_Wh, Qnom_W, Tret_K) Qgas_to_Boiler_Wh = np.divide(q_load_Wh, BoilerEff, out=np.zeros_like(q_load_Wh), where=BoilerEff != 0.0) Boiler_Status = np.where(Qgas_to_Boiler_Wh > 0.0, 1, 0) # add costs Opex_a_var_USD[0][4] += sum(prices.NG_PRICE * Qgas_to_Boiler_Wh) # CHF GHG_tonCO2[0][5] += sum( calc_emissions_Whyr_to_tonCO2yr(Qgas_to_Boiler_Wh, lca.NG_TO_CO2_EQ)) # ton CO2 # add activation resourcesRes[0][0] += sum(q_load_Wh) # q from NG heating_dispatch[0] = { 'Q_Boiler_gen_directload_W': q_load_Wh, 'Boiler_Status': Boiler_Status, 'NG_Boiler_req_W': Qgas_to_Boiler_Wh, 'E_hs_ww_req_W': np.zeros(8760) } ## 1: Boiler BG # add costs Opex_a_var_USD[1][4] += sum(prices.BG_PRICE * Qgas_to_Boiler_Wh) # CHF GHG_tonCO2[1][5] += sum( calc_emissions_Whyr_to_tonCO2yr(Qgas_to_Boiler_Wh, lca.NG_TO_CO2_EQ)) # ton CO2 # add activation resourcesRes[1][1] += sum(q_load_Wh) # q from BG heating_dispatch[1] = { 'Q_Boiler_gen_directload_W': q_load_Wh, 'Boiler_Status': Boiler_Status, 'BG_Boiler_req_W': Qgas_to_Boiler_Wh, 'E_hs_ww_req_W': np.zeros(8760) } ## 2: Fuel Cell (FC_Effel, FC_Effth) = np.vectorize(FC.calc_eta_FC)(q_load_Wh, Qnom_W, 1, "B") Qgas_to_FC_Wh = q_load_Wh / (FC_Effth + FC_Effel ) # FIXME: should be q_load_Wh/FC_Effth? el_from_FC_Wh = Qgas_to_FC_Wh * FC_Effel FC_Status = np.where(Qgas_to_FC_Wh > 0.0, 1, 0) # add variable costs, emissions and primary energy Opex_a_var_USD[2][4] += sum( prices.NG_PRICE * Qgas_to_FC_Wh - prices.ELEC_PRICE_EXPORT * el_from_FC_Wh) # CHF, extra electricity sold to grid GHG_tonCO2_from_FC = (0.0874 * Qgas_to_FC_Wh * 3600E-6 + 773 * 0.45 * el_from_FC_Wh * 1E-6 - lca.EL_TO_CO2_EQ * el_from_FC_Wh * 3600E-6) / 1E3 GHG_tonCO2[2][5] += sum(GHG_tonCO2_from_FC) # tonCO2 # Bloom box emissions within the FC: 773 lbs / MWh_el (and 1 lbs = 0.45 kg) # http://www.carbonlighthouse.com/2011/09/16/bloom-box/ # add activation resourcesRes[2][0] = sum(q_load_Wh) # q from NG resourcesRes[2][2] = sum(el_from_FC_Wh) # el for GHP # FIXME: el from FC heating_dispatch[2] = { 'Q_Fuelcell_gen_directload_W': q_load_Wh, 'Fuelcell_Status': FC_Status, 'NG_FuelCell_req_W': Qgas_to_FC_Wh, 'E_Fuelcell_gen_export_W': el_from_FC_Wh, 'E_hs_ww_req_W': np.zeros(8760) } # 3-13: Boiler NG + GHP for i in range(10): # set nominal size for Boiler and GHP QnomBoiler_W = i / 10.0 * Qnom_W QnomGHP_W = Qnom_W - QnomBoiler_W # GHP operation Texit_GHP_nom_K = QnomGHP_W / (mdot_kgpers * HEAT_CAPACITY_OF_WATER_JPERKGK) + Tret_K el_GHP_Wh, q_load_NG_Boiler_Wh, \ qhot_missing_Wh, \ Texit_GHP_K, q_from_GHP_Wh = np.vectorize(calc_GHP_operation)(QnomGHP_W, T_ground_K, Texit_GHP_nom_K, Tret_K, Tsup_K, mdot_kgpers, q_load_Wh) GHP_el_size_W[i][0] = max(el_GHP_Wh) GHP_Status = np.where(q_from_GHP_Wh > 0.0, 1, 0) # GHP Backup Boiler operation if max(qhot_missing_Wh) > 0.0: print("GHP unable to cover the whole demand, boiler activated!") Qnom_GHP_Backup_Boiler_W = max(qhot_missing_Wh) BoilerEff = np.vectorize(Boiler.calc_Cop_boiler)( qhot_missing_Wh, Qnom_GHP_Backup_Boiler_W, Texit_GHP_K) Qgas_to_GHPBoiler_Wh = np.divide( qhot_missing_Wh, BoilerEff, out=np.zeros_like(qhot_missing_Wh), where=BoilerEff != 0.0) else: Qgas_to_GHPBoiler_Wh = np.zeros(q_load_Wh.shape[0]) Qnom_GHP_Backup_Boiler_W = 0.0 Q_Boiler_for_GHP_W[i][0] = Qnom_GHP_Backup_Boiler_W GHPbackupBoiler_Status = np.where(qhot_missing_Wh > 0.0, 1, 0) # NG Boiler operation BoilerEff = np.vectorize(Boiler.calc_Cop_boiler)(q_load_NG_Boiler_Wh, QnomBoiler_W, Texit_GHP_K) Qgas_to_Boiler_Wh = np.divide(q_load_NG_Boiler_Wh, BoilerEff, out=np.zeros_like(q_load_NG_Boiler_Wh), where=BoilerEff != 0.0) Boiler_Status = np.where(q_load_NG_Boiler_Wh > 0.0, 1, 0) # add costs # electricity el_total_Wh = el_GHP_Wh Opex_a_var_USD[3 + i][4] += sum(prices.ELEC_PRICE * el_total_Wh) # CHF GHG_tonCO2[3 + i][5] += sum( calc_emissions_Whyr_to_tonCO2yr(el_total_Wh, lca.EL_TO_CO2_EQ)) # ton CO2 # gas Q_gas_total_Wh = Qgas_to_GHPBoiler_Wh + Qgas_to_Boiler_Wh Opex_a_var_USD[3 + i][4] += sum(prices.NG_PRICE * Q_gas_total_Wh) # CHF GHG_tonCO2[3 + i][5] += sum( calc_emissions_Whyr_to_tonCO2yr(Q_gas_total_Wh, lca.NG_TO_CO2_EQ)) # ton CO2 # add activation resourcesRes[3 + i][0] = sum(qhot_missing_Wh + q_load_NG_Boiler_Wh) resourcesRes[3 + i][2] = sum(el_GHP_Wh) resourcesRes[3 + i][3] = sum(q_from_GHP_Wh) heating_dispatch[3 + i] = { 'Q_GHP_gen_directload_W': q_from_GHP_Wh, 'Q_BackupBoiler_gen_directload_W': qhot_missing_Wh, 'Q_Boiler_gen_directload_W': q_load_NG_Boiler_Wh, 'GHP_Status': GHP_Status, 'BackupBoiler_Status': GHPbackupBoiler_Status, 'Boiler_Status': Boiler_Status, 'NG_BackupBoiler_req_Wh': Qgas_to_GHPBoiler_Wh, 'NG_Boiler_req_Wh': Qgas_to_Boiler_Wh, 'E_hs_ww_req_W': el_GHP_Wh } # Add all costs # 0: Boiler NG Capex_a_Boiler_USD, Opex_a_fixed_Boiler_USD, Capex_Boiler_USD = Boiler.calc_Cinv_boiler( Qnom_W, 'BO1', boiler_cost_data) Capex_total_USD[0][0] = Capex_Boiler_USD Capex_a_USD[0][0] = Capex_a_Boiler_USD Opex_a_fixed_USD[0][0] = Opex_a_fixed_Boiler_USD Capex_opex_a_fixed_only_USD[0][ 0] = Capex_a_Boiler_USD + Opex_a_fixed_Boiler_USD # TODO:variable price? # 1: Boiler BG Capex_total_USD[1][0] = Capex_Boiler_USD Capex_a_USD[1][0] = Capex_a_Boiler_USD Opex_a_fixed_USD[1][0] = Opex_a_fixed_Boiler_USD Capex_opex_a_fixed_only_USD[1][ 0] = Capex_a_Boiler_USD + Opex_a_fixed_Boiler_USD # TODO:variable price? # 2: Fuel Cell Capex_a_FC_USD, Opex_fixed_FC_USD, Capex_FC_USD = FC.calc_Cinv_FC( Qnom_W, supply_systems.FC) Capex_total_USD[2][0] = Capex_FC_USD Capex_a_USD[2][0] = Capex_a_FC_USD Opex_a_fixed_USD[2][0] = Opex_fixed_FC_USD Capex_opex_a_fixed_only_USD[2][ 0] = Capex_a_FC_USD + Opex_fixed_FC_USD # TODO:variable price? # 3-13: BOILER + GHP for i in range(10): Opex_a_var_USD[3 + i][0] = i / 10.0 # Boiler share Opex_a_var_USD[3 + i][3] = 1 - i / 10.0 # GHP share # Get boiler costs QnomBoiler_W = i / 10.0 * Qnom_W Capex_a_Boiler_USD, Opex_a_fixed_Boiler_USD, Capex_Boiler_USD = Boiler.calc_Cinv_boiler( QnomBoiler_W, 'BO1', boiler_cost_data) Capex_total_USD[3 + i][0] += Capex_Boiler_USD Capex_a_USD[3 + i][0] += Capex_a_Boiler_USD Opex_a_fixed_USD[3 + i][0] += Opex_a_fixed_Boiler_USD Capex_opex_a_fixed_only_USD[3 + i][ 0] += Capex_a_Boiler_USD + Opex_a_fixed_Boiler_USD # TODO:variable price? # Get back up boiler costs Qnom_Backup_Boiler_W = Q_Boiler_for_GHP_W[i][0] Capex_a_GHPBoiler_USD, Opex_a_fixed_GHPBoiler_USD, Capex_GHPBoiler_USD = Boiler.calc_Cinv_boiler( Qnom_Backup_Boiler_W, 'BO1', boiler_cost_data) Capex_total_USD[3 + i][0] += Capex_GHPBoiler_USD Capex_a_USD[3 + i][0] += Capex_a_GHPBoiler_USD Opex_a_fixed_USD[3 + i][0] += Opex_a_fixed_GHPBoiler_USD Capex_opex_a_fixed_only_USD[3 + i][ 0] += Capex_a_GHPBoiler_USD + Opex_a_fixed_GHPBoiler_USD # TODO:variable price? # Get ground source heat pump costs Capex_a_GHP_USD, Opex_a_fixed_GHP_USD, Capex_GHP_USD = HP.calc_Cinv_GHP( GHP_el_size_W[i][0], GHP_cost_data, BH_cost_data) Capex_total_USD[3 + i][0] += Capex_GHP_USD Capex_a_USD[3 + i][0] += Capex_a_GHP_USD Opex_a_fixed_USD[3 + i][0] += Opex_a_fixed_GHP_USD Capex_opex_a_fixed_only_USD[3 + i][ 0] += Capex_a_GHP_USD + Opex_a_fixed_GHP_USD # TODO:variable price? # Best configuration Best = np.zeros((13, 1)) indexBest = 0 TAC_USD = np.zeros((13, 2)) TotalCO2 = np.zeros((13, 2)) for i in range(13): TAC_USD[i][0] = TotalCO2[i][0] = i Opex_a_USD[i][1] = Opex_a_fixed_USD[i][0] + +Opex_a_var_USD[i][4] TAC_USD[i][ 1] = Capex_opex_a_fixed_only_USD[i][0] + Opex_a_var_USD[i][4] TotalCO2[i][1] = GHG_tonCO2[i][5] CostsS = TAC_USD[np.argsort(TAC_USD[:, 1])] CO2S = TotalCO2[np.argsort(TotalCO2[:, 1])] el = len(CostsS) rank = 0 Bestfound = False optsearch = np.empty(el) optsearch.fill(3) indexBest = 0 geothermal_potential = geothermal_potential_data.set_index('Name') # Check the GHP area constraint for i in range(10): QGHP = (1 - i / 10.0) * Qnom_W areaAvail = geothermal_potential.loc[building_name, 'Area_geo'] Qallowed = np.ceil(areaAvail / GHP_A) * GHP_HMAX_SIZE # [W_th] if Qallowed < QGHP: optsearch[i + 3] += 1 Best[i + 3][0] = -1 while not Bestfound and rank < el: optsearch[int(CostsS[rank][0])] -= 1 optsearch[int(CO2S[rank][0])] -= 1 if np.count_nonzero(optsearch) != el: Bestfound = True indexBest = np.where(optsearch == 0)[0][0] rank += 1 # get the best option according to the ranking. Best[indexBest][0] = 1 # Save results in csv file performance_results = { "Nominal heating load": Qnom_W, "Capacity_BaseBoiler_NG_W": Qnom_W * Opex_a_var_USD[:, 0], "Capacity_FC_NG_W": Qnom_W * Opex_a_var_USD[:, 2], "Capacity_GS_HP_W": Qnom_W * Opex_a_var_USD[:, 3], "TAC_USD": TAC_USD[:, 1], "Capex_a_USD": Capex_a_USD[:, 0], "Capex_total_USD": Capex_total_USD[:, 0], "Opex_fixed_USD": Opex_a_fixed_USD[:, 0], "Opex_var_USD": Opex_a_var_USD[:, 4], "GHG_tonCO2": GHG_tonCO2[:, 5], "Best configuration": Best[:, 0] } results_to_csv = pd.DataFrame(performance_results) fName_result = locator.get_optimization_decentralized_folder_building_result_heating( building_name) results_to_csv.to_csv(fName_result, sep=',', index=False) # save activation for the best supply system configuration best_activation_df = pd.DataFrame.from_dict(heating_dispatch[indexBest]) # best_activation_df.to_csv( locator. get_optimization_decentralized_folder_building_result_heating_activation( building_name), index=False)
def addCosts(indCombi, buildList, locator, dicoSupply, QUncoveredDesign, QUncoveredAnnual, solarFeat, ntwFeat, gv): """ Computes additional costs / GHG emisions / primary energy needs for the individual Parameters ---------- indCombi : string with 0 if disconnected building, 1 if connected buildList : list list of buildings in the district locator : string path to folders dicoSupply : class context with the features of the specific individual QuncoveredDesign : float hourly max of the heating uncovered demand QuncoveredAnnual : float total heating uncovered solarFeat / ntwFeat : class solarFeatures / ntwFeatures Returns ------- (addCosts, addCO2, addPrim) : tuple """ addCosts = 0 addCO2 = 0 addPrim = 0 nBuildinNtw = 0 # Add the features from the disconnected buildings print "\n COSTS FROM DISCONNECTED BUILDINGS" os.chdir(locator.pathDiscRes) CostDiscBuild = 0 CO2DiscBuild = 0 PrimDiscBuild = 0 FurnaceInvCost = 0 CCInvCost = 0 BoilerBInvCost = 0 BoilerPInvCost = 0 HPLakeInvC = 0 HPSewInvC = 0 GHPInvC = 0 PVInvC = 0 SCInvC = 0 PVTInvC = 0 BoilerAddInvC = 0 StorageHEXCost = 0 StorageHPCost = 0 StorageInvC = 0 NetworkCost = 0 SubstHEXCost = 0 PVTHEXCost = 0 SCHEXCost = 0 pumpCosts = 0 GasConnectionInvCost = 0 for (index, buildName) in zip(indCombi, buildList): if index == "0": discFileName = "DiscOp_" + buildName + "_result.csv" df = pd.read_csv(discFileName) 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] print dfBest["Total Costs [CHF]"].iloc[0], buildName, "disconnected" else: nBuildinNtw += 1 addCosts += CostDiscBuild addCO2 += CO2DiscBuild addPrim += PrimDiscBuild # Add the features for the network if indCombi.count("1") > 0: os.chdir(locator.pathSlaveRes) print " \n MACHINERY COSTS" # Add the investment costs of the energy systems # Furnace if dicoSupply.Furnace_on == 1: P_design = dicoSupply.Furnace_Q_max fNameSlavePP = dicoSupply.configKey + "PPActivationPattern.csv" dfFurnace = pd.read_csv(fNameSlavePP, usecols=["Q_Furnace"]) arrayFurnace = np.array(dfFurnace) Q_annual = 0 for i in range(int(np.shape(arrayFurnace)[0])): Q_annual += arrayFurnace[i][0] FurnaceInvCost = furnace.calc_Cinv_furnace(P_design, Q_annual, gv) addCosts += FurnaceInvCost print furnace.calc_Cinv_furnace(P_design, Q_annual, gv), " Furnace" # CC if dicoSupply.CC_on == 1: CC_size = dicoSupply.CC_GT_SIZE CCInvCost = chp.calc_Cinv_CCT(CC_size, gv) addCosts += CCInvCost print chp.calc_Cinv_CCT(CC_size, gv), " CC" # Boiler Base if dicoSupply.Boiler_on == 1: Q_design = dicoSupply.Boiler_Q_max fNameSlavePP = dicoSupply.configKey + "PPActivationPattern.csv" dfBoilerBase = pd.read_csv(fNameSlavePP, usecols=["Q_BoilerBase"]) arrayBoilerBase = np.array(dfBoilerBase) Q_annual = 0 for i in range(int(np.shape(arrayBoilerBase)[0])): Q_annual += arrayBoilerBase[i][0] BoilerBInvCost = boiler.calc_Cinv_boiler(Q_design, Q_annual, gv) addCosts += BoilerBInvCost print boiler.calc_Cinv_boiler(Q_design, Q_annual, gv), " Boiler Base " # Boiler Peak if dicoSupply.BoilerPeak_on == 1: Q_design = dicoSupply.BoilerPeak_Q_max fNameSlavePP = dicoSupply.configKey + "PPActivationPattern.csv" dfBoilerPeak = pd.read_csv(fNameSlavePP, usecols=["Q_BoilerPeak"]) arrayBoilerPeak = np.array(dfBoilerPeak) Q_annual = 0 for i in range(int(np.shape(arrayBoilerPeak)[0])): Q_annual += arrayBoilerPeak[i][0] BoilerPInvCost = boiler.calc_Cinv_boiler(Q_design, Q_annual, gv) addCosts += BoilerPInvCost print boiler.calc_Cinv_boiler(Q_design, Q_annual, gv), " Boiler Peak" # HP Lake if dicoSupply.HP_Lake_on == 1: HP_Size = dicoSupply.HPLake_maxSize HPLakeInvC = hp.calc_Cinv_HP(HP_Size, gv) addCosts += HPLakeInvC print hp.calc_Cinv_HP(HP_Size, gv), " HP Lake" # HP Sewage if dicoSupply.HP_Sew_on == 1: HP_Size = dicoSupply.HPSew_maxSize HPSewInvC = hp.calc_Cinv_HP(HP_Size, gv) addCosts += HPSewInvC print hp.calc_Cinv_HP(HP_Size, gv), "HP Sewage" # GHP if dicoSupply.GHP_on == 1: fNameSlavePP = dicoSupply.configKey + "PPActivationPattern.csv" dfGHP = pd.read_csv(fNameSlavePP, usecols=["E_GHP"]) arrayGHP = np.array(dfGHP) GHP_Enom = np.amax(arrayGHP) GHPInvC = hp.calc_Cinv_GHP(GHP_Enom, gv) * gv.EURO_TO_CHF addCosts += GHPInvC print hp.calc_Cinv_GHP(GHP_Enom, gv) * gv.EURO_TO_CHF, " GHP" # Solar technologies PV_peak = dicoSupply.SOLAR_PART_PV * solarFeat.SolarAreaPV * gv.nPV #kW PVInvC = pv.calc_Cinv_PV(PV_peak) addCosts += PVInvC print pv.calc_Cinv_PV(PV_peak), "PV peak" SC_area = dicoSupply.SOLAR_PART_SC * solarFeat.SolarAreaSC SCInvC = stc.calc_Cinv_SC(SC_area) addCosts += SCInvC print stc.calc_Cinv_SC(SC_area), "SC area" PVT_peak = dicoSupply.SOLAR_PART_PVT * solarFeat.SolarAreaPVT * gv.nPVT #kW PVTInvC = pvt.calc_Cinv_PVT(PVT_peak) addCosts += PVTInvC print pvt.calc_Cinv_PVT(PVT_peak), "PVT peak" # Back-up boiler BoilerAddInvC = boiler.calc_Cinv_boiler(QUncoveredDesign, QUncoveredAnnual, gv) addCosts += BoilerAddInvC print boiler.calc_Cinv_boiler(QUncoveredDesign, QUncoveredAnnual, gv), "backup boiler" # Hex and HP for Heat recovery print "\n STORAGE PART COSTS" if dicoSupply.WasteServersHeatRecovery == 1: df = pd.read_csv(locator.pathNtwRes + "/" + dicoSupply.NETWORK_DATA_FILE, usecols = ["Qcdata_netw_total"]) array = np.array(df) QhexMax = np.amax(array) StorageHEXCost += hex.calc_Cinv_HEX(QhexMax, gv) print hex.calc_Cinv_HEX(QhexMax, gv), "Hex for data center" df = pd.read_csv(locator.pathSlaveRes + "/" + dicoSupply.configKey + "StorageOperationData.csv", usecols = ["HPServerHeatDesignArray"]) array = np.array(df) QhpMax = np.amax(array) StorageHEXCost += hp.calc_Cinv_HP(QhpMax, gv) print hp.calc_Cinv_HP(QhpMax, gv), "HP for data center" if dicoSupply.WasteCompressorHeatRecovery == 1: df = pd.read_csv(locator.pathNtwRes + "/" + dicoSupply.NETWORK_DATA_FILE, usecols = ["Ecaf_netw_total"]) array = np.array(df) QhexMax = np.amax(array) StorageHEXCost += hex.calc_Cinv_HEX(QhexMax, gv) print hex.calc_Cinv_HEX(QhexMax, gv), "Hex for compressed air" df = pd.read_csv(locator.pathSlaveRes + "/" + dicoSupply.configKey + "StorageOperationData.csv", usecols = ["HPCompAirDesignArray"]) array = np.array(df) QhpMax = np.amax(array) StorageHEXCost += hp.calc_Cinv_HP(QhpMax, gv) print hp.calc_Cinv_HP(QhpMax, gv), "HP for compressed air" addCosts += StorageHEXCost # Heat pump solar to storage df = pd.read_csv(locator.pathSlaveRes + "/" + dicoSupply.configKey + "StorageOperationData.csv", usecols = ["HPScDesignArray", "HPpvt_designArray"]) array = np.array(df) QhpMax_PVT = np.amax(array[:,1]) QhpMax_SC = np.amax(array[:,0]) StorageHPCost += hp.calc_Cinv_HP(QhpMax_PVT, gv) print hp.calc_Cinv_HP(QhpMax_PVT, gv), "HP for PVT" StorageHPCost += hp.calc_Cinv_HP(QhpMax_SC, gv) print hp.calc_Cinv_HP(QhpMax_SC, gv), "HP for SC" # HP for storage operation df = pd.read_csv(locator.pathSlaveRes + "/" + dicoSupply.configKey + "StorageOperationData.csv", usecols = ["E_aux_ch", "E_aux_dech", "Q_from_storage_used", "Q_to_storage"]) array = np.array(df) QmaxHPStorage = 0 for i in range(gv.DAYS_IN_YEAR * gv.HOURS_IN_DAY): if array[i][0] > 0: QmaxHPStorage = max(QmaxHPStorage, array[i][3] + array[i][0]) elif array[i][1] > 0: QmaxHPStorage = max(QmaxHPStorage, array[i][2] + array[i][1]) StorageHPCost += hp.calc_Cinv_HP(QmaxHPStorage, gv) addCosts += StorageHPCost print hp.calc_Cinv_HP(QmaxHPStorage, gv), "HP for storage" # Storage df = pd.read_csv(locator.pathSlaveRes + "/" + dicoSupply.configKey + "StorageOperationData.csv", usecols = ["Storage_Size"], nrows = 1) StorageVol = np.array(df)[0][0] StorageInvC += storage.calc_Cinv_storage(StorageVol, gv) addCosts += StorageInvC print storage.calc_Cinv_storage(StorageVol, gv), "Storage Costs" # Costs from network configuration print "\n COSTS FROM NETWORK 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 += NetworkCost print ntwFeat.pipesCosts_DHN * nBuildinNtw / len(buildList), "Pipes Costs" # HEX (1 per building in ntw) for (index, buildName) in zip(indCombi, buildList): if index == "1": subsFileName = buildName + "_result.csv" df = pd.read_csv(locator.pathSubsRes + "/" + subsFileName, usecols = ["Q_dhw", "Q_heating"]) subsArray = np.array(df) Qmax = np.amax( subsArray[:,0] + subsArray[:,1] ) SubstHEXCost += hex.calc_Cinv_HEX(Qmax, gv) print hex.calc_Cinv_HEX(Qmax, gv), "Hex", buildName addCosts += SubstHEXCost # HEX for solar roof_area = np.array(pd.read_csv(locator.get_total_demand(), usecols=["Aroof_m2"])) areaAvail = 0 for i in range( len(indCombi) ): index = indCombi[i] if index == "1": areaAvail += roof_area[i][0] for i in range( len(indCombi) ): index = indCombi[i] if index == "1": share = roof_area[i][0] / areaAvail #print share, "solar area share", buildList[i] SC_Qmax = solarFeat.SC_Qnom * dicoSupply.SOLAR_PART_SC * share SCHEXCost += hex.calc_Cinv_HEX(SC_Qmax, gv) print hex.calc_Cinv_HEX(SC_Qmax, gv), "Hex SC", buildList[i] PVT_Qmax = solarFeat.PVT_Qnom * dicoSupply.SOLAR_PART_PVT * share PVTHEXCost += hex.calc_Cinv_HEX(PVT_Qmax, gv) print hex.calc_Cinv_HEX(PVT_Qmax, gv), "Hex PVT", buildList[i] addCosts += SCHEXCost addCosts += PVTHEXCost print addCosts,"addCosts in extraCostsMain" # Pump operation costs pumpCosts = pumps.calc_Ctot_pump(dicoSupply, buildList, locator.pathNtwRes, ntwFeat, gv) addCosts += pumpCosts print pumpCosts, "Pump Operation costs in extraCostsMain\n" # import gas consumption data from: if indCombi.count("1") > 0: # import gas consumption data from: FileName = locator.pathSlaveRes + "/" + dicoSupply.configKey + "PrimaryEnergyBySource.csv" colName = "EgasPrimaryPeakPower" EgasPrimaryDataframe = pd.read_csv(FileName, usecols=[colName]) #print EgasPrimaryDataframe #print np.array(EgasPrimaryDataframe) #print float(np.array(EgasPrimaryDataframe)) EgasPrimaryPeakPower = float(np.array(EgasPrimaryDataframe)) GasConnectionInvCost = ngas.calc_Cinv_gas(EgasPrimaryPeakPower, gv) else: GasConnectionInvCost = 0.0 addCosts += GasConnectionInvCost # Save data results = pd.DataFrame({ "SCInvC":[SCInvC], "PVTInvC":[PVTInvC], "BoilerAddInvC":[BoilerAddInvC], "StorageHEXCost":[StorageHEXCost], "StorageHPCost":[StorageHPCost], "StorageInvC":[StorageInvC], "StorageCostSum":[StorageInvC+StorageHPCost+StorageHEXCost], "NetworkCost":[NetworkCost], "SubstHEXCost":[SubstHEXCost], "DHNInvestCost":[addCosts - CostDiscBuild], "PVTHEXCost":[PVTHEXCost], "CostDiscBuild":[CostDiscBuild], "CO2DiscBuild":[CO2DiscBuild], "PrimDiscBuild":[PrimDiscBuild], "FurnaceInvCost":[FurnaceInvCost], "BoilerBInvCost":[BoilerBInvCost], "BoilerPInvCost":[BoilerPInvCost], "HPLakeInvC":[HPLakeInvC], "HPSewInvC":[HPSewInvC], "SCHEXCost":[SCHEXCost], "pumpCosts":[pumpCosts], "SumInvestCost":[addCosts], "GasConnectionInvCa":[GasConnectionInvCost] }) Name = "/" + dicoSupply.configKey + "_InvestmentCostDetailed.csv" results.to_csv(locator.pathSlaveRes + Name, sep=',') return (addCosts, addCO2, addPrim)
def addCosts(indCombi, buildList, locator, dicoSupply, QUncoveredDesign, QUncoveredAnnual, solarFeat, ntwFeat, gv): """ Computes additional costs / GHG emisions / primary energy needs for the individual Parameters ---------- indCombi : string with 0 if disconnected building, 1 if connected buildList : list list of buildings in the district locator : string path to folders dicoSupply : class context with the features of the specific individual QuncoveredDesign : float hourly max of the heating uncovered demand QuncoveredAnnual : float total heating uncovered solarFeat / ntwFeat : class solarFeatures / ntwFeatures Returns ------- (addCosts, addCO2, addPrim) : tuple """ addCosts = 0 addCO2 = 0 addPrim = 0 nBuildinNtw = 0 # Add the features from the disconnected buildings print "\n COSTS FROM DISCONNECTED BUILDINGS" os.chdir(locator.pathDiscRes) CostDiscBuild = 0 CO2DiscBuild = 0 PrimDiscBuild = 0 FurnaceInvCost = 0 CCInvCost = 0 BoilerBInvCost = 0 BoilerPInvCost = 0 HPLakeInvC = 0 HPSewInvC = 0 GHPInvC = 0 PVInvC = 0 SCInvC = 0 PVTInvC = 0 BoilerAddInvC = 0 StorageHEXCost = 0 StorageHPCost = 0 StorageInvC = 0 NetworkCost = 0 SubstHEXCost = 0 PVTHEXCost = 0 SCHEXCost = 0 pumpCosts = 0 GasConnectionInvCost = 0 for (index, buildName) in zip(indCombi, buildList): if index == "0": discFileName = "DiscOp_" + buildName + "_result.csv" df = pd.read_csv(discFileName) 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] print dfBest["Total Costs [CHF]"].iloc[ 0], buildName, "disconnected" else: nBuildinNtw += 1 addCosts += CostDiscBuild addCO2 += CO2DiscBuild addPrim += PrimDiscBuild # Add the features for the network if indCombi.count("1") > 0: os.chdir(locator.pathSlaveRes) print " \n MACHINERY COSTS" # Add the investment costs of the energy systems # Furnace if dicoSupply.Furnace_on == 1: P_design = dicoSupply.Furnace_Q_max fNameSlavePP = dicoSupply.configKey + "PPActivationPattern.csv" dfFurnace = pd.read_csv(fNameSlavePP, usecols=["Q_Furnace"]) arrayFurnace = np.array(dfFurnace) Q_annual = 0 for i in range(int(np.shape(arrayFurnace)[0])): Q_annual += arrayFurnace[i][0] FurnaceInvCost = furnace.calc_Cinv_furnace(P_design, Q_annual, gv) addCosts += FurnaceInvCost print furnace.calc_Cinv_furnace(P_design, Q_annual, gv), " Furnace" # CC if dicoSupply.CC_on == 1: CC_size = dicoSupply.CC_GT_SIZE CCInvCost = chp.calc_Cinv_CCT(CC_size, gv) addCosts += CCInvCost print chp.calc_Cinv_CCT(CC_size, gv), " CC" # Boiler Base if dicoSupply.Boiler_on == 1: Q_design = dicoSupply.Boiler_Q_max fNameSlavePP = dicoSupply.configKey + "PPActivationPattern.csv" dfBoilerBase = pd.read_csv(fNameSlavePP, usecols=["Q_BoilerBase"]) arrayBoilerBase = np.array(dfBoilerBase) Q_annual = 0 for i in range(int(np.shape(arrayBoilerBase)[0])): Q_annual += arrayBoilerBase[i][0] BoilerBInvCost = boiler.calc_Cinv_boiler(Q_design, Q_annual, gv) addCosts += BoilerBInvCost print boiler.calc_Cinv_boiler(Q_design, Q_annual, gv), " Boiler Base " # Boiler Peak if dicoSupply.BoilerPeak_on == 1: Q_design = dicoSupply.BoilerPeak_Q_max fNameSlavePP = dicoSupply.configKey + "PPActivationPattern.csv" dfBoilerPeak = pd.read_csv(fNameSlavePP, usecols=["Q_BoilerPeak"]) arrayBoilerPeak = np.array(dfBoilerPeak) Q_annual = 0 for i in range(int(np.shape(arrayBoilerPeak)[0])): Q_annual += arrayBoilerPeak[i][0] BoilerPInvCost = boiler.calc_Cinv_boiler(Q_design, Q_annual, gv) addCosts += BoilerPInvCost print boiler.calc_Cinv_boiler(Q_design, Q_annual, gv), " Boiler Peak" # HP Lake if dicoSupply.HP_Lake_on == 1: HP_Size = dicoSupply.HPLake_maxSize HPLakeInvC = hp.calc_Cinv_HP(HP_Size, gv) addCosts += HPLakeInvC print hp.calc_Cinv_HP(HP_Size, gv), " HP Lake" # HP Sewage if dicoSupply.HP_Sew_on == 1: HP_Size = dicoSupply.HPSew_maxSize HPSewInvC = hp.calc_Cinv_HP(HP_Size, gv) addCosts += HPSewInvC print hp.calc_Cinv_HP(HP_Size, gv), "HP Sewage" # GHP if dicoSupply.GHP_on == 1: fNameSlavePP = dicoSupply.configKey + "PPActivationPattern.csv" dfGHP = pd.read_csv(fNameSlavePP, usecols=["E_GHP"]) arrayGHP = np.array(dfGHP) GHP_Enom = np.amax(arrayGHP) GHPInvC = hp.calc_Cinv_GHP(GHP_Enom, gv) * gv.EURO_TO_CHF addCosts += GHPInvC print hp.calc_Cinv_GHP(GHP_Enom, gv) * gv.EURO_TO_CHF, " GHP" # Solar technologies PV_peak = dicoSupply.SOLAR_PART_PV * solarFeat.SolarAreaPV * gv.nPV #kW PVInvC = pv.calc_Cinv_PV(PV_peak) addCosts += PVInvC print pv.calc_Cinv_PV(PV_peak), "PV peak" SC_area = dicoSupply.SOLAR_PART_SC * solarFeat.SolarAreaSC SCInvC = stc.calc_Cinv_SC(SC_area) addCosts += SCInvC print stc.calc_Cinv_SC(SC_area), "SC area" PVT_peak = dicoSupply.SOLAR_PART_PVT * solarFeat.SolarAreaPVT * gv.nPVT #kW PVTInvC = pvt.calc_Cinv_PVT(PVT_peak) addCosts += PVTInvC print pvt.calc_Cinv_PVT(PVT_peak), "PVT peak" # Back-up boiler BoilerAddInvC = boiler.calc_Cinv_boiler(QUncoveredDesign, QUncoveredAnnual, gv) addCosts += BoilerAddInvC print boiler.calc_Cinv_boiler(QUncoveredDesign, QUncoveredAnnual, gv), "backup boiler" # Hex and HP for Heat recovery print "\n STORAGE PART COSTS" if dicoSupply.WasteServersHeatRecovery == 1: df = pd.read_csv(locator.pathNtwRes + "/" + dicoSupply.NETWORK_DATA_FILE, usecols=["Qcdata_netw_total"]) array = np.array(df) QhexMax = np.amax(array) StorageHEXCost += hex.calc_Cinv_HEX(QhexMax, gv) print hex.calc_Cinv_HEX(QhexMax, gv), "Hex for data center" df = pd.read_csv(locator.pathSlaveRes + "/" + dicoSupply.configKey + "StorageOperationData.csv", usecols=["HPServerHeatDesignArray"]) array = np.array(df) QhpMax = np.amax(array) StorageHEXCost += hp.calc_Cinv_HP(QhpMax, gv) print hp.calc_Cinv_HP(QhpMax, gv), "HP for data center" if dicoSupply.WasteCompressorHeatRecovery == 1: df = pd.read_csv(locator.pathNtwRes + "/" + dicoSupply.NETWORK_DATA_FILE, usecols=["Ecaf_netw_total"]) array = np.array(df) QhexMax = np.amax(array) StorageHEXCost += hex.calc_Cinv_HEX(QhexMax, gv) print hex.calc_Cinv_HEX(QhexMax, gv), "Hex for compressed air" df = pd.read_csv(locator.pathSlaveRes + "/" + dicoSupply.configKey + "StorageOperationData.csv", usecols=["HPCompAirDesignArray"]) array = np.array(df) QhpMax = np.amax(array) StorageHEXCost += hp.calc_Cinv_HP(QhpMax, gv) print hp.calc_Cinv_HP(QhpMax, gv), "HP for compressed air" addCosts += StorageHEXCost # Heat pump solar to storage df = pd.read_csv(locator.pathSlaveRes + "/" + dicoSupply.configKey + "StorageOperationData.csv", usecols=["HPScDesignArray", "HPpvt_designArray"]) array = np.array(df) QhpMax_PVT = np.amax(array[:, 1]) QhpMax_SC = np.amax(array[:, 0]) StorageHPCost += hp.calc_Cinv_HP(QhpMax_PVT, gv) print hp.calc_Cinv_HP(QhpMax_PVT, gv), "HP for PVT" StorageHPCost += hp.calc_Cinv_HP(QhpMax_SC, gv) print hp.calc_Cinv_HP(QhpMax_SC, gv), "HP for SC" # HP for storage operation df = pd.read_csv(locator.pathSlaveRes + "/" + dicoSupply.configKey + "StorageOperationData.csv", usecols=[ "E_aux_ch", "E_aux_dech", "Q_from_storage_used", "Q_to_storage" ]) array = np.array(df) QmaxHPStorage = 0 for i in range(gv.DAYS_IN_YEAR * gv.HOURS_IN_DAY): if array[i][0] > 0: QmaxHPStorage = max(QmaxHPStorage, array[i][3] + array[i][0]) elif array[i][1] > 0: QmaxHPStorage = max(QmaxHPStorage, array[i][2] + array[i][1]) StorageHPCost += hp.calc_Cinv_HP(QmaxHPStorage, gv) addCosts += StorageHPCost print hp.calc_Cinv_HP(QmaxHPStorage, gv), "HP for storage" # Storage df = pd.read_csv(locator.pathSlaveRes + "/" + dicoSupply.configKey + "StorageOperationData.csv", usecols=["Storage_Size"], nrows=1) StorageVol = np.array(df)[0][0] StorageInvC += storage.calc_Cinv_storage(StorageVol, gv) addCosts += StorageInvC print storage.calc_Cinv_storage(StorageVol, gv), "Storage Costs" # Costs from network configuration print "\n COSTS FROM NETWORK 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 += NetworkCost print ntwFeat.pipesCosts_DHN * nBuildinNtw / len( buildList), "Pipes Costs" # HEX (1 per building in ntw) for (index, buildName) in zip(indCombi, buildList): if index == "1": subsFileName = buildName + "_result.csv" df = pd.read_csv(locator.pathSubsRes + "/" + subsFileName, usecols=["Q_dhw", "Q_heating"]) subsArray = np.array(df) Qmax = np.amax(subsArray[:, 0] + subsArray[:, 1]) SubstHEXCost += hex.calc_Cinv_HEX(Qmax, gv) print hex.calc_Cinv_HEX(Qmax, gv), "Hex", buildName addCosts += SubstHEXCost # HEX for solar roof_area = np.array( pd.read_csv(locator.get_total_demand(), usecols=["Aroof_m2"])) areaAvail = 0 for i in range(len(indCombi)): index = indCombi[i] if index == "1": areaAvail += roof_area[i][0] for i in range(len(indCombi)): index = indCombi[i] if index == "1": share = roof_area[i][0] / areaAvail #print share, "solar area share", buildList[i] SC_Qmax = solarFeat.SC_Qnom * dicoSupply.SOLAR_PART_SC * share SCHEXCost += hex.calc_Cinv_HEX(SC_Qmax, gv) print hex.calc_Cinv_HEX(SC_Qmax, gv), "Hex SC", buildList[i] PVT_Qmax = solarFeat.PVT_Qnom * dicoSupply.SOLAR_PART_PVT * share PVTHEXCost += hex.calc_Cinv_HEX(PVT_Qmax, gv) print hex.calc_Cinv_HEX(PVT_Qmax, gv), "Hex PVT", buildList[i] addCosts += SCHEXCost addCosts += PVTHEXCost print addCosts, "addCosts in extraCostsMain" # Pump operation costs pumpCosts = pumps.calc_Ctot_pump(dicoSupply, buildList, locator.pathNtwRes, ntwFeat, gv) addCosts += pumpCosts print pumpCosts, "Pump Operation costs in extraCostsMain\n" # import gas consumption data from: if indCombi.count("1") > 0: # import gas consumption data from: FileName = locator.pathSlaveRes + "/" + dicoSupply.configKey + "PrimaryEnergyBySource.csv" colName = "EgasPrimaryPeakPower" EgasPrimaryDataframe = pd.read_csv(FileName, usecols=[colName]) #print EgasPrimaryDataframe #print np.array(EgasPrimaryDataframe) #print float(np.array(EgasPrimaryDataframe)) EgasPrimaryPeakPower = float(np.array(EgasPrimaryDataframe)) GasConnectionInvCost = ngas.calc_Cinv_gas(EgasPrimaryPeakPower, gv) else: GasConnectionInvCost = 0.0 addCosts += GasConnectionInvCost # Save data results = pd.DataFrame({ "SCInvC": [SCInvC], "PVTInvC": [PVTInvC], "BoilerAddInvC": [BoilerAddInvC], "StorageHEXCost": [StorageHEXCost], "StorageHPCost": [StorageHPCost], "StorageInvC": [StorageInvC], "StorageCostSum": [StorageInvC + StorageHPCost + StorageHEXCost], "NetworkCost": [NetworkCost], "SubstHEXCost": [SubstHEXCost], "DHNInvestCost": [addCosts - CostDiscBuild], "PVTHEXCost": [PVTHEXCost], "CostDiscBuild": [CostDiscBuild], "CO2DiscBuild": [CO2DiscBuild], "PrimDiscBuild": [PrimDiscBuild], "FurnaceInvCost": [FurnaceInvCost], "BoilerBInvCost": [BoilerBInvCost], "BoilerPInvCost": [BoilerPInvCost], "HPLakeInvC": [HPLakeInvC], "HPSewInvC": [HPSewInvC], "SCHEXCost": [SCHEXCost], "pumpCosts": [pumpCosts], "SumInvestCost": [addCosts], "GasConnectionInvCa": [GasConnectionInvCost] }) Name = "/" + dicoSupply.configKey + "_InvestmentCostDetailed.csv" results.to_csv(locator.pathSlaveRes + Name, sep=',') return (addCosts, addCO2, addPrim)
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 calc_generation_costs_heating( locator, master_to_slave_vars, config, storage_activation_data, ): """ Computes 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 thermal_network: network features :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 thermal_network: class :return: returns the objectives addCosts, addCO2, addPrim :rtype: tuple """ thermal_network = pd.read_csv( locator.get_optimization_thermal_network_data_file( master_to_slave_vars.network_data_file_heating)) # CCGT if master_to_slave_vars.CC_on == 1: CC_size_W = master_to_slave_vars.CCGT_SIZE_W Capex_a_CHP_NG_USD, Opex_fixed_CHP_NG_USD, Capex_CHP_NG_USD = chp.calc_Cinv_CCGT( CC_size_W, locator, config) else: Capex_a_CHP_NG_USD = 0.0 Opex_fixed_CHP_NG_USD = 0.0 Capex_CHP_NG_USD = 0.0 # DRY BIOMASS if master_to_slave_vars.Furnace_dry_on == 1: Dry_Furnace_size_W = master_to_slave_vars.DBFurnace_Q_max_W Capex_a_furnace_dry_USD, \ Opex_fixed_furnace_dry_USD, \ Capex_furnace_dry_USD = furnace.calc_Cinv_furnace(Dry_Furnace_size_W, locator, 'FU1') else: Capex_furnace_dry_USD = 0.0 Capex_a_furnace_dry_USD = 0.0 Opex_fixed_furnace_dry_USD = 0.0 # WET BIOMASS if master_to_slave_vars.Furnace_wet_on == 1: Wet_Furnace_size_W = master_to_slave_vars.WBFurnace_Q_max_W Capex_a_furnace_wet_USD, \ Opex_fixed_furnace_wet_USD, \ Capex_furnace_wet_USD = furnace.calc_Cinv_furnace(Wet_Furnace_size_W, locator, 'FU1') else: Capex_a_furnace_wet_USD = 0.0 Opex_fixed_furnace_wet_USD = 0.0 Capex_furnace_wet_USD = 0.0 # BOILER BASE LOAD if master_to_slave_vars.Boiler_on == 1: Q_design_W = master_to_slave_vars.Boiler_Q_max_W Capex_a_BaseBoiler_NG_USD, \ Opex_fixed_BaseBoiler_NG_USD, \ Capex_BaseBoiler_NG_USD = boiler.calc_Cinv_boiler(Q_design_W, locator, config, 'BO1') else: Capex_a_BaseBoiler_NG_USD = 0.0 Opex_fixed_BaseBoiler_NG_USD = 0.0 Capex_BaseBoiler_NG_USD = 0.0 # BOILER PEAK LOAD if master_to_slave_vars.BoilerPeak_on == 1: Q_design_W = master_to_slave_vars.BoilerPeak_Q_max_W Capex_a_PeakBoiler_NG_USD, \ Opex_fixed_PeakBoiler_NG_USD, \ Capex_PeakBoiler_NG_USD = boiler.calc_Cinv_boiler(Q_design_W, locator, config, 'BO1') else: Capex_a_PeakBoiler_NG_USD = 0.0 Opex_fixed_PeakBoiler_NG_USD = 0.0 Capex_PeakBoiler_NG_USD = 0.0 # HEATPUMP LAKE if master_to_slave_vars.HPLake_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, 'HP2') else: Capex_a_Lake_USD = 0.0 Opex_fixed_Lake_USD = 0.0 Capex_Lake_USD = 0.0 # HEATPUMP_SEWAGE if master_to_slave_vars.HPSew_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, 'HP2') else: Capex_a_Sewage_USD = 0.0 Opex_fixed_Sewage_USD = 0.0 Capex_Sewage_USD = 0.0 # GROUND HEAT PUMP if master_to_slave_vars.GHP_on == 1: GHP_Enom_W = master_to_slave_vars.GHP_maxSize_W Capex_a_GHP_USD, \ Opex_fixed_GHP_USD, \ Capex_GHP_USD = hp.calc_Cinv_GHP(GHP_Enom_W, locator, config) else: Capex_a_GHP_USD = 0.0 Opex_fixed_GHP_USD = 0.0 Capex_GHP_USD = 0.0 # BACK-UP BOILER if master_to_slave_vars.BackupBoiler_on != 0: Q_backup_W = master_to_slave_vars.BackupBoiler_size_W Capex_a_BackupBoiler_NG_USD, \ Opex_fixed_BackupBoiler_NG_USD, \ Capex_BackupBoiler_NG_USD = boiler.calc_Cinv_boiler(Q_backup_W, locator, config, 'BO1') else: Capex_a_BackupBoiler_NG_USD = 0.0 Opex_fixed_BackupBoiler_NG_USD = 0.0 Capex_BackupBoiler_NG_USD = 0.0 # DATA CENTRE SOURCE HEAT PUMP if master_to_slave_vars.WasteServersHeatRecovery == 1: Q_HEX_max_Wh = thermal_network["Qcdata_netw_total_kWh"].max( ) * 1000 # convert to Wh Capex_a_wasteserver_HEX_USD, Opex_fixed_wasteserver_HEX_USD, Capex_wasteserver_HEX_USD = hex.calc_Cinv_HEX( Q_HEX_max_Wh, locator, config, 'HEX1') Q_HP_max_Wh = storage_activation_data["Q_HP_Server_W"].max() Capex_a_wasteserver_HP_USD, Opex_fixed_wasteserver_HP_USD, Capex_wasteserver_HP_USD = hp.calc_Cinv_HP( Q_HP_max_Wh, locator, 'HP2') else: Capex_a_wasteserver_HEX_USD = 0.0 Opex_fixed_wasteserver_HEX_USD = 0.0 Capex_wasteserver_HEX_USD = 0.0 Capex_a_wasteserver_HP_USD = 0.0 Opex_fixed_wasteserver_HP_USD = 0.0 Capex_wasteserver_HP_USD = 0.0 # SOLAR TECHNOLOGIES # ADD COSTS AND EMISSIONS DUE TO SOLAR TECHNOLOGIES SC_ET_area_m2 = master_to_slave_vars.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, 'ET') SC_FP_area_m2 = master_to_slave_vars.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, 'FP') PVT_peak_kW = master_to_slave_vars.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) # HEATPUMP FOR SOLAR UPGRADE TO DISTRICT HEATING Q_HP_max_PVT_wh = storage_activation_data["Q_HP_PVT_W"].max() Capex_a_HP_PVT_USD, \ Opex_fixed_HP_PVT_USD, \ Capex_HP_PVT_USD = hp.calc_Cinv_HP(Q_HP_max_PVT_wh, locator, 'HP2') # hack split into two technologies Q_HP_max_SC_ET_Wh = storage_activation_data["Q_HP_SC_ET_W"].max() Capex_a_HP_SC_ET_USD, \ Opex_fixed_HP_SC_ET_USD, \ Capex_HP_SC_ET_USD = hp.calc_Cinv_HP(Q_HP_max_SC_ET_Wh, locator, 'HP2') Q_HP_max_SC_FP_Wh = storage_activation_data["Q_HP_SC_FP_W"].max() Capex_a_HP_SC_FP_USD, \ Opex_fixed_HP_SC_FP_USD, \ Capex_HP_SC_FP_USD = hp.calc_Cinv_HP(Q_HP_max_SC_FP_Wh, locator, 'HP2') # HEAT EXCHANGER FOR SOLAR COLLECTORS Q_max_SC_ET_Wh = (storage_activation_data["Q_SC_ET_gen_directload_W"] + storage_activation_data["Q_SC_ET_gen_storage_W"]).max() 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') Q_max_SC_FP_Wh = (storage_activation_data["Q_SC_FP_gen_directload_W"] + storage_activation_data["Q_SC_FP_gen_storage_W"]).max() 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') Q_max_PVT_Wh = (storage_activation_data["Q_PVT_gen_directload_W"] + storage_activation_data["Q_PVT_gen_storage_W"]).max() 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') performance_costs = { "Capex_a_SC_ET_connected_USD": Capex_a_SC_ET_USD + Capex_a_HP_SC_ET_USD + Capex_a_HEX_SC_ET_USD, "Capex_a_SC_FP_connected_USD": Capex_a_SC_FP_USD + Capex_a_HP_SC_FP_USD + Capex_a_HEX_SC_FP_USD, "Capex_a_PVT_connected_USD": Capex_a_PVT_USD + Capex_a_HP_PVT_USD + Capex_a_HEX_PVT_USD, "Capex_a_HP_Server_connected_USD": Capex_a_wasteserver_HP_USD + Capex_a_wasteserver_HEX_USD, "Capex_a_HP_Sewage_connected_USD": Capex_a_Sewage_USD, "Capex_a_HP_Lake_connected_USD": Capex_a_Lake_USD, "Capex_a_GHP_connected_USD": Capex_a_GHP_USD, "Capex_a_CHP_NG_connected_USD": Capex_a_CHP_NG_USD, "Capex_a_Furnace_wet_connected_USD": Capex_a_furnace_wet_USD, "Capex_a_Furnace_dry_connected_USD": Capex_a_furnace_dry_USD, "Capex_a_BaseBoiler_NG_connected_USD": Capex_a_BaseBoiler_NG_USD, "Capex_a_PeakBoiler_NG_connected_USD": Capex_a_PeakBoiler_NG_USD, "Capex_a_BackupBoiler_NG_connected_USD": Capex_a_BackupBoiler_NG_USD, # total_capex "Capex_total_SC_ET_connected_USD": Capex_SC_ET_USD + Capex_HP_SC_ET_USD + Capex_HEX_SC_ET_USD, "Capex_total_SC_FP_connected_USD": Capex_SC_FP_USD + Capex_HP_SC_FP_USD + Capex_HEX_SC_FP_USD, "Capex_total_PVT_connected_USD": Capex_PVT_USD + Capex_HP_PVT_USD + Capex_HEX_PVT_USD, "Capex_total_HP_Server_connected_USD": Capex_wasteserver_HP_USD + Capex_wasteserver_HEX_USD, "Capex_total_HP_Sewage_connected_USD": Capex_Sewage_USD, "Capex_total_HP_Lake_connected_USD": Capex_Lake_USD, "Capex_total_GHP_connected_USD": Capex_GHP_USD, "Capex_total_CHP_NG_connected_USD": Capex_CHP_NG_USD, "Capex_total_Furnace_wet_connected_USD": Capex_furnace_wet_USD, "Capex_total_Furnace_dry_connected_USD": Capex_furnace_dry_USD, "Capex_total_BaseBoiler_NG_connected_USD": Capex_BaseBoiler_NG_USD, "Capex_total_PeakBoiler_NG_connected_USD": Capex_PeakBoiler_NG_USD, "Capex_total_BackupBoiler_NG_connected_USD": Capex_BackupBoiler_NG_USD, # opex fixed costs "Opex_fixed_SC_ET_connected_USD": Opex_fixed_SC_ET_USD, "Opex_fixed_SC_FP_connected_USD": Opex_fixed_SC_FP_USD, "Opex_fixed_PVT_connected_USD": Opex_fixed_PVT_USD, "Opex_fixed_HP_Server_connected_USD": Opex_fixed_wasteserver_HP_USD + Opex_fixed_wasteserver_HEX_USD, "Opex_fixed_HP_Sewage_connected_USD": Opex_fixed_Sewage_USD, "Opex_fixed_HP_Lake_connected_USD": Opex_fixed_Lake_USD, "Opex_fixed_GHP_connected_USD": Opex_fixed_GHP_USD, "Opex_fixed_CHP_NG_connected_USD": Opex_fixed_CHP_NG_USD, "Opex_fixed_Furnace_wet_connected_USD": Opex_fixed_furnace_wet_USD, "Opex_fixed_Furnace_dry_connected_USD": Opex_fixed_furnace_dry_USD, "Opex_fixed_BaseBoiler_NG_connected_USD": Opex_fixed_BaseBoiler_NG_USD, "Opex_fixed_PeakBoiler_NG_connected_USD": Opex_fixed_PeakBoiler_NG_USD, "Opex_fixed_BackupBoiler_NG_connected_USD": Opex_fixed_BackupBoiler_NG_USD, } return performance_costs
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)