def heating_source_activator(Q_therm_req_W, hour, master_to_slave_vars, mdot_DH_req_kgpers, tdhsup_K, tdhret_req_K, TretsewArray_K, gv, prices, lca, T_ground): """ :param Q_therm_req_W: :param hour: :param context: :type Q_therm_req_W: float :type hour: int :type context: list :return: cost_data_centralPlant_op, source_info, Q_source_data, E_coldsource_data, E_PP_el_data, E_gas_data, E_wood_data, Q_excess :rtype: """ current_source = ACT_FIRST # Start with first source, no cost yet Q_therm_req_W_copy = Q_therm_req_W # Initializing resulting values (necessairy as not all of them are over-written): Q_uncovered_W = 0 cost_HPSew_USD, cost_HPLake_USD, cost_GHP_USD, cost_CHP_USD, cost_Furnace_USD, cost_BaseBoiler_USD, cost_PeakBoiler_USD = 0, 0, 0, 0, 0, 0, 0 # initialize all sources to be off = 0 (turn to "on" with setting to 1) source_HP_Sewage = 0 source_HP_Lake = 0 source_GHP = 0 source_CHP = 0 source_Furnace = 0 source_BaseBoiler = 0 source_PeakBoiler = 0 Q_excess_W = 0 Q_HPSew_gen_W, Q_HPLake_gen_W, Q_GHP_gen_W, Q_CHP_gen_W, Q_Furnace_gen_W, Q_BaseBoiler_gen_W, Q_PeakBoiler_gen_W = 0, 0, 0, 0, 0, 0, 0 E_HPSew_req_W, E_HPLake_req_W, E_GHP_req_W, E_CHP_gen_W, E_Furnace_gen_W, E_BaseBoiler_req_W, E_PeakBoiler_req_W = 0, 0, 0, 0, 0, 0, 0 Gas_used_HPSew_W, Gas_used_HPLake_W, Gas_used_GHP_W, Gas_used_CHP_W, Gas_used_Furnace_W, Gas_used_BaseBoiler_W, Gas_used_PeakBoiler_W = 0, 0, 0, 0, 0, 0, 0 Wood_used_HPSew_W, Wood_used_HPLake_W, Wood_used_GHP_W, Wood_used_CHP_W, Wood_used_Furnace_W, Wood_used_BaseBoiler_W, Wood_used_PeakBoiler_W = 0, 0, 0, 0, 0, 0, 0 Q_coldsource_HPSew_W, Q_coldsource_HPLake_W, Q_coldsource_GHP_W, Q_coldsource_CHP_W, \ Q_coldsource_Furnace_W, Q_coldsource_BaseBoiler_W, Q_coldsource_PeakBoiler_W = 0, 0, 0, 0, 0, 0, 0 while Q_therm_req_W > 1E-1: # cover demand as long as the supply is lower than demand! if current_source == 'HP': # use heat pumps available! if (master_to_slave_vars.HP_Sew_on) == 1 and Q_therm_req_W > 0 and HP_SEW_ALLOWED == 1: # activate if its available source_HP_Sewage = 0 cost_HPSew_USD = 0.0 Q_HPSew_gen_W = 0.0 E_HPSew_req_W = 0.0 Q_coldsource_HPSew_W = 0.0 if Q_therm_req_W > master_to_slave_vars.HPSew_maxSize_W: Q_therm_Sew_W = master_to_slave_vars.HPSew_maxSize_W mdot_DH_to_Sew_kgpers = mdot_DH_req_kgpers * Q_therm_Sew_W / Q_therm_req_W.copy() # scale down the mass flow if the thermal demand is lowered else: Q_therm_Sew_W = float(Q_therm_req_W.copy()) mdot_DH_to_Sew_kgpers = float(mdot_DH_req_kgpers.copy()) C_HPSew_el_pure, C_HPSew_per_kWh_th_pure, Q_HPSew_cold_primary_W, Q_HPSew_therm_W, E_HPSew_req_W = HPSew_op_cost(mdot_DH_to_Sew_kgpers, tdhsup_K, tdhret_req_K, TretsewArray_K, lca, Q_therm_Sew_W) Q_therm_req_W -= Q_HPSew_therm_W # Storing data for further processing if Q_HPSew_therm_W > 0: source_HP_Sewage = 1 cost_HPSew_USD = float(C_HPSew_el_pure) Q_HPSew_gen_W = float(Q_HPSew_therm_W) E_HPSew_req_W = float(E_HPSew_req_W) Q_coldsource_HPSew_W = float(Q_HPSew_cold_primary_W) if (master_to_slave_vars.GHP_on) == 1 and hour >= master_to_slave_vars.GHP_SEASON_ON and hour <= master_to_slave_vars.GHP_SEASON_OFF and Q_therm_req_W > 0 and not np.isclose( tdhsup_K, tdhret_req_K): # activating GHP plant if possible source_GHP = 0 cost_GHP_USD = 0.0 Q_GHP_gen_W = 0.0 E_GHP_req_W = 0.0 Q_coldsource_GHP_W = 0.0 Q_max_W, GHP_COP = GHP_Op_max(tdhsup_K, T_ground, master_to_slave_vars.GHP_number) if Q_therm_req_W > Q_max_W: mdot_DH_to_GHP_kgpers = Q_max_W / (HEAT_CAPACITY_OF_WATER_JPERKGK * (tdhsup_K - tdhret_req_K)) Q_therm_req_W -= Q_max_W else: # regular operation possible, demand is covered mdot_DH_to_GHP_kgpers = Q_therm_req_W.copy() / (HEAT_CAPACITY_OF_WATER_JPERKGK * (tdhsup_K - tdhret_req_K)) Q_therm_req_W = 0 C_GHP_el, E_GHP_req_W, Q_GHP_cold_primary_W, Q_GHP_therm_W = GHP_op_cost(mdot_DH_to_GHP_kgpers, tdhsup_K, tdhret_req_K, GHP_COP, lca) # Storing data for further processing source_GHP = 1 cost_GHP_USD = C_GHP_el Q_GHP_gen_W = Q_GHP_therm_W E_GHP_req_W = E_GHP_req_W Q_coldsource_GHP_W = Q_GHP_cold_primary_W if (master_to_slave_vars.HP_Lake_on) == 1 and Q_therm_req_W > 0 and HP_LAKE_ALLOWED == 1 and not np.isclose(tdhsup_K, tdhret_req_K): # run Heat Pump Lake source_HP_Lake = 0 cost_HPLake_USD = 0 Q_HPLake_gen_W = 0 E_HPLake_req_W = 0 Q_coldsource_HPLake_W = 0 if Q_therm_req_W > master_to_slave_vars.HPLake_maxSize_W: # Scale down Load, 100% load achieved Q_therm_HPL_W = master_to_slave_vars.HPLake_maxSize_W mdot_DH_to_Lake_kgpers = Q_therm_HPL_W / ( HEAT_CAPACITY_OF_WATER_JPERKGK * ( tdhsup_K - tdhret_req_K)) # scale down the mass flow if the thermal demand is lowered Q_therm_req_W -= master_to_slave_vars.HPLake_maxSize_W else: # regular operation possible Q_therm_HPL_W = Q_therm_req_W.copy() mdot_DH_to_Lake_kgpers = Q_therm_HPL_W / (HEAT_CAPACITY_OF_WATER_JPERKGK * (tdhsup_K - tdhret_req_K)) Q_therm_req_W = 0 C_HPL_el, E_HPLake_req_W, Q_HPL_cold_primary_W, Q_HPL_therm_W = HPLake_op_cost(mdot_DH_to_Lake_kgpers, tdhsup_K, tdhret_req_K, T_LAKE, lca) # Storing Data source_HP_Lake = 1 cost_HPLake_USD = C_HPL_el Q_HPLake_gen_W = Q_therm_HPL_W E_HPLake_req_W = E_HPLake_req_W Q_coldsource_HPLake_W = Q_HPL_cold_primary_W if current_source == 'CHP' and Q_therm_req_W > 0: # start activating the combined cycles # By definition, one can either activate the CHP (NG-CC) or ORC (Furnace) BUT NOT BOTH at the same time (not activated by Master) Cost_CC = 0.0 source_CHP = 0 cost_CHP_USD = 0.0 Q_CHP_gen_W = 0.0 Gas_used_CHP_W = 0.0 E_CHP_gen_W = 0 if (master_to_slave_vars.CC_on) == 1 and Q_therm_req_W > 0 and CC_ALLOWED == 1: # only operate if the plant is available CC_op_cost_data = calc_cop_CCGT(master_to_slave_vars.CC_GT_SIZE_W, tdhsup_K, master_to_slave_vars.gt_fuel, prices, lca) # create cost information Q_used_prim_CC_fn_W = CC_op_cost_data['q_input_fn_q_output_W'] cost_per_Wh_CC_fn = CC_op_cost_data['fuel_cost_per_Wh_th_fn_q_output_W'] # gets interpolated cost function q_output_CC_min_W = CC_op_cost_data['q_output_min_W'] Q_output_CC_max_W = CC_op_cost_data['q_output_max_W'] eta_elec_interpol = CC_op_cost_data['eta_el_fn_q_input'] if Q_therm_req_W > q_output_CC_min_W: # operation Possible if above minimal load if Q_therm_req_W < Q_output_CC_max_W: # Normal operation Possible within partload regime cost_per_Wh_CC = cost_per_Wh_CC_fn(Q_therm_req_W) Q_used_prim_CC_W = Q_used_prim_CC_fn_W(Q_therm_req_W) Q_CC_delivered_W = Q_therm_req_W.copy() Q_therm_req_W = 0 E_CHP_gen_W = np.float(eta_elec_interpol(Q_used_prim_CC_W)) * Q_used_prim_CC_W else: # Only part of the demand can be delivered as 100% load achieved cost_per_Wh_CC = cost_per_Wh_CC_fn(Q_output_CC_max_W) Q_used_prim_CC_W = Q_used_prim_CC_fn_W(Q_output_CC_max_W) Q_CC_delivered_W = Q_output_CC_max_W Q_therm_req_W -= Q_output_CC_max_W E_CHP_gen_W = np.float(eta_elec_interpol(Q_output_CC_max_W)) * Q_used_prim_CC_W Cost_CC = cost_per_Wh_CC * Q_CC_delivered_W source_CHP = 1 cost_CHP_USD = Cost_CC Q_CHP_gen_W = Q_CC_delivered_W Gas_used_CHP_W = Q_used_prim_CC_W if (master_to_slave_vars.Furnace_on) == 1 and Q_therm_req_W > 0: # Activate Furnace if its there. By definition, either ORC or NG-CC! Q_Furn_therm_W = 0 source_Furnace = 0 cost_Furnace_USD = 0.0 Q_Furnace_gen_W = 0.0 Wood_used_Furnace_W = 0.0 Q_Furn_prim_W = 0.0 if Q_therm_req_W > ( gv.Furn_min_Load * master_to_slave_vars.Furnace_Q_max_W): # Operate only if its above minimal load if Q_therm_req_W > master_to_slave_vars.Furnace_Q_max_W: # scale down if above maximum load, Furnace operates at max. capacity Furnace_Cost_Data = furnace_op_cost(master_to_slave_vars.Furnace_Q_max_W, master_to_slave_vars.Furnace_Q_max_W, tdhret_req_K, master_to_slave_vars.Furn_Moist_type, gv) C_Furn_therm = Furnace_Cost_Data[0] Q_Furn_prim_W = Furnace_Cost_Data[2] Q_Furn_therm_W = master_to_slave_vars.Furnace_Q_max_W Q_therm_req_W -= Q_Furn_therm_W E_Furnace_gen_W = Furnace_Cost_Data[4] else: # Normal Operation Possible Furnace_Cost_Data = furnace_op_cost(Q_therm_req_W, master_to_slave_vars.Furnace_Q_max_W, tdhret_req_K, master_to_slave_vars.Furn_Moist_type, gv) Q_Furn_prim_W = Furnace_Cost_Data[2] C_Furn_therm = Furnace_Cost_Data[0] Q_Furn_therm_W = Q_therm_req_W.copy() E_Furnace_gen_W = Furnace_Cost_Data[4] Q_therm_req_W = 0 source_Furnace = 1 cost_Furnace_USD = C_Furn_therm.copy() Q_Furnace_gen_W = Q_Furn_therm_W Wood_used_Furnace_W = Q_Furn_prim_W if current_source == 'BoilerBase' and Q_therm_req_W > 0: Q_therm_boiler_W = 0 if (master_to_slave_vars.Boiler_on) == 1: source_BaseBoiler = 0 cost_BaseBoiler_USD = 0.0 Q_BaseBoiler_gen_W = 0.0 Gas_used_BaseBoiler_W = 0.0 E_BaseBoiler_req_W = 0.0 if Q_therm_req_W >= BOILER_MIN * master_to_slave_vars.Boiler_Q_max_W: # Boiler can be activated? # Q_therm_boiler = Q_therm_req if Q_therm_req_W >= master_to_slave_vars.Boiler_Q_max_W: # Boiler above maximum Load? Q_therm_boiler_W = master_to_slave_vars.Boiler_Q_max_W else: Q_therm_boiler_W = Q_therm_req_W.copy() C_boil_therm, C_boil_per_Wh, Q_primary_W, E_aux_Boiler_req_W = cond_boiler_op_cost(Q_therm_boiler_W, master_to_slave_vars.Boiler_Q_max_W, tdhret_req_K, \ master_to_slave_vars.BoilerType, master_to_slave_vars.EL_TYPE, gv, prices, lca) source_BaseBoiler = 1 cost_BaseBoiler_USD = C_boil_therm Q_BaseBoiler_gen_W = Q_therm_boiler_W Gas_used_BaseBoiler_W = Q_primary_W E_BaseBoiler_req_W = E_aux_Boiler_req_W Q_therm_req_W -= Q_therm_boiler_W if current_source == 'BoilerPeak' and Q_therm_req_W > 0: if (master_to_slave_vars.BoilerPeak_on) == 1: source_PeakBoiler = 0 cost_PeakBoiler_USD = 0.0 Q_PeakBoiler_gen_W = 0.0 Gas_used_PeakBoiler_W = 0 E_PeakBoiler_req_W = 0 if Q_therm_req_W > 0: # gv.Boiler_min*master_to_slave_vars.BoilerPeak_Q_max: # Boiler can be activated? if Q_therm_req_W > master_to_slave_vars.BoilerPeak_Q_max_W: # Boiler above maximum Load? Q_therm_boilerP_W = master_to_slave_vars.BoilerPeak_Q_max_W Q_therm_req_W -= Q_therm_boilerP_W else: Q_therm_boilerP_W = Q_therm_req_W.copy() Q_therm_req_W = 0 C_boil_thermP, C_boil_per_WhP, Q_primaryP_W, E_aux_BoilerP_W = cond_boiler_op_cost(Q_therm_boilerP_W, master_to_slave_vars.BoilerPeak_Q_max_W, tdhret_req_K, \ master_to_slave_vars.BoilerPeakType, master_to_slave_vars.EL_TYPE, gv, prices, lca) source_PeakBoiler = 1 cost_PeakBoiler_USD = C_boil_thermP Q_PeakBoiler_gen_W = Q_therm_boilerP_W Gas_used_PeakBoiler_W = Q_primaryP_W E_PeakBoiler_req_W = E_aux_BoilerP_W Q_excess_W = 0 if np.floor(Q_therm_req_W) > 0: if current_source == ACT_FIRST: current_source = ACT_SECOND elif current_source == ACT_SECOND: current_source = ACT_THIRD elif current_source == ACT_THIRD: current_source = ACT_FOURTH else: Q_uncovered_W = Q_therm_req_W break elif round(Q_therm_req_W, 0) != 0: Q_uncovered_W = 0 # Q_therm_req Q_excess_W = -Q_therm_req_W Q_therm_req_W = 0 # break else: Q_therm_req_W = 0 source_info = source_HP_Sewage, source_HP_Lake, source_GHP, source_CHP, source_Furnace, source_BaseBoiler, source_PeakBoiler Q_source_data_W = Q_HPSew_gen_W, Q_HPLake_gen_W, Q_GHP_gen_W, Q_CHP_gen_W, Q_Furnace_gen_W, Q_BaseBoiler_gen_W, Q_PeakBoiler_gen_W, Q_uncovered_W E_PP_el_data_W = E_HPSew_req_W, E_HPLake_req_W, E_GHP_req_W, E_CHP_gen_W, E_Furnace_gen_W, E_BaseBoiler_req_W, E_PeakBoiler_req_W E_gas_data_W = Gas_used_HPSew_W, Gas_used_HPLake_W, Gas_used_GHP_W, Gas_used_CHP_W, Gas_used_Furnace_W, Gas_used_BaseBoiler_W, Gas_used_PeakBoiler_W E_wood_data_W = Wood_used_HPSew_W, Wood_used_HPLake_W, Wood_used_GHP_W, Wood_used_CHP_W, Wood_used_Furnace_W, Wood_used_BaseBoiler_W, Wood_used_PeakBoiler_W E_coldsource_data_W = Q_coldsource_HPSew_W, Q_coldsource_HPLake_W, Q_coldsource_GHP_W, Q_coldsource_CHP_W, \ Q_coldsource_Furnace_W, Q_coldsource_BaseBoiler_W, Q_coldsource_PeakBoiler_W opex_output = {'Opex_var_HP_Sewage_USD':cost_HPSew_USD, 'Opex_var_HP_Lake_USD': cost_HPLake_USD, 'Opex_var_GHP_USD': cost_GHP_USD, 'Opex_var_CHP_USD': cost_CHP_USD, 'Opex_var_Furnace_USD': cost_Furnace_USD, 'Opex_var_BaseBoiler_USD': cost_BaseBoiler_USD, 'Opex_var_PeakBoiler_USD': cost_PeakBoiler_USD} source_output = {'HP_Sewage': source_HP_Sewage, 'HP_Lake': source_HP_Lake, 'GHP': source_GHP, 'CHP': source_CHP, 'Furnace': source_Furnace, 'BaseBoiler': source_BaseBoiler, 'PeakBoiler': source_PeakBoiler} Q_output = {'Q_HPSew_gen_W': Q_HPSew_gen_W, 'Q_HPLake_gen_W': Q_HPLake_gen_W, 'Q_GHP_gen_W': Q_GHP_gen_W, 'Q_CHP_gen_W': Q_CHP_gen_W, 'Q_Furnace_gen_W': Q_Furnace_gen_W, 'Q_BaseBoiler_gen_W': Q_BaseBoiler_gen_W, 'Q_PeakBoiler_gen_W': Q_PeakBoiler_gen_W, 'Q_uncovered_W': Q_uncovered_W} E_output = {'E_HPSew_req_W': E_HPSew_req_W, 'E_HPLake_req_W': E_HPLake_req_W, 'E_GHP_req_W': E_GHP_req_W, 'E_CHP_gen_W': E_CHP_gen_W, 'E_Furnace_gen_W': E_Furnace_gen_W, 'E_BaseBoiler_req_W': E_BaseBoiler_req_W, 'E_PeakBoiler_req_W': E_PeakBoiler_req_W} Gas_output = {'Gas_used_HPSew_W': Gas_used_HPSew_W, 'Gas_used_HPLake_W': Gas_used_HPLake_W, 'Gas_used_GHP_W': Gas_used_GHP_W, 'Gas_used_CHP_W': Gas_used_CHP_W, 'Gas_used_Furnace_W': Gas_used_Furnace_W, 'Gas_used_BaseBoiler_W': Gas_used_BaseBoiler_W, 'Gas_used_PeakBoiler_W': Gas_used_PeakBoiler_W} Wood_output = {'Wood_used_HPSew_W': Wood_used_HPSew_W, 'Wood_used_HPLake_W': Wood_used_HPLake_W, 'Wood_used_GHP_W': Wood_used_GHP_W, 'Wood_used_CHP_W': Wood_used_CHP_W, 'Wood_used_Furnace_W': Wood_used_Furnace_W, 'Wood_used_BaseBoiler_W': Wood_used_BaseBoiler_W, 'Wood_used_PeakBoiler_W': Wood_used_PeakBoiler_W} coldsource_output = {'Q_coldsource_HPSew_W': Q_coldsource_HPSew_W, 'Q_coldsource_HPLake_W': Q_coldsource_HPLake_W, 'Q_coldsource_GHP_W': Q_coldsource_GHP_W, 'Q_coldsource_CHP_W': Q_coldsource_CHP_W, 'Q_coldsource_Furnace_W': Q_coldsource_Furnace_W, 'Q_coldsource_BaseBoiler_W': Q_coldsource_BaseBoiler_W, 'Q_coldsource_PeakBoiler_W': Q_coldsource_PeakBoiler_W} return opex_output, source_output, Q_output, E_output, Gas_output, Wood_output, coldsource_output, Q_excess_W
def cooling_calculations_of_DC_buildings(locator, master_to_slave_vars, ntwFeat, prices, lca, config, reduced_timesteps_flag): """ Computes the parameters for the cooling of the complete DCN :param locator: path to res folder :param ntwFeat: network features :param prices: Prices imported from the database :type locator: string :type ntwFeat: class :type prices: class :return: costs, co2, prim :rtype: tuple """ ############# Recover the cooling needs # Cooling demands in a neighborhood are divided into three categories currently. They are # 1. Space Cooling in buildings # 2. Data center Cooling # 3. Refrigeration Needs # Data center cooling can also be done by recovering the heat and heating other demands during the same time # whereas Space cooling and refrigeration needs are to be provided by District Cooling Network or decentralized cooling # Currently, all the buildings are assumed to be connected to DCN # In the following code, the cooling demands of Space cooling and refrigeration are first satisfied by using Lake and VCC # This is then followed by checking of the Heat recovery from Data Centre, if it is allowed, then the corresponding # cooling demand is ignored. If not, the corresponding coolind demand is also satisfied by DCN. t0 = time.time() DCN_barcode = master_to_slave_vars.DCN_barcode print ('Cooling Main is Running') # Space cooling previously aggregated in the substation routine if master_to_slave_vars.WasteServersHeatRecovery == 1: df = pd.read_csv(locator.get_optimization_network_data_folder(master_to_slave_vars.network_data_file_cooling), usecols=["T_DCNf_space_cooling_and_refrigeration_sup_K", "T_DCNf_space_cooling_and_refrigeration_re_K", "mdot_cool_space_cooling_and_refrigeration_netw_all_kgpers"]) df = df.fillna(0) T_sup_K = df['T_DCNf_space_cooling_and_refrigeration_sup_K'].values T_re_K = df['T_DCNf_space_cooling_and_refrigeration_re_K'].values mdot_kgpers = df['mdot_cool_space_cooling_and_refrigeration_netw_all_kgpers'].values else: df = pd.read_csv(locator.get_optimization_network_data_folder(master_to_slave_vars.network_data_file_cooling), usecols=["T_DCNf_space_cooling_data_center_and_refrigeration_sup_K", "T_DCNf_space_cooling_data_center_and_refrigeration_re_K", "mdot_cool_space_cooling_data_center_and_refrigeration_netw_all_kgpers"]) df = df.fillna(0) T_sup_K = df['T_DCNf_space_cooling_data_center_and_refrigeration_sup_K'].values T_re_K = df['T_DCNf_space_cooling_data_center_and_refrigeration_re_K'].values mdot_kgpers = df['mdot_cool_space_cooling_data_center_and_refrigeration_netw_all_kgpers'].values DCN_operation_parameters = df.fillna(0) DCN_operation_parameters_array = DCN_operation_parameters.values Qc_DCN_W = np.array( pd.read_csv(locator.get_optimization_network_data_folder(master_to_slave_vars.network_data_file_cooling), usecols=["Q_DCNf_space_cooling_and_refrigeration_W", "Q_DCNf_space_cooling_data_center_and_refrigeration_W"])) # importing the cooling demands of DCN (space cooling + refrigeration) # Data center cooling, (treated separately for each building) df = pd.read_csv(locator.get_total_demand(), usecols=["Name", "Qcdata_sys_MWhyr"]) arrayData = np.array(df) # total cooling requirements based on the Heat Recovery Flag Q_cooling_req_W = np.zeros(8760) if master_to_slave_vars.WasteServersHeatRecovery == 0: for hour in range(8760): # summing cooling loads of space cooling, refrigeration and data center Q_cooling_req_W[hour] = Qc_DCN_W[hour][1] else: for hour in range(8760): # only including cooling loads of space cooling and refrigeration Q_cooling_req_W[hour] = Qc_DCN_W[hour][0] ############# Recover the heat already taken from the Lake by the heat pumps if config.district_heating_network: try: dfSlave = pd.read_csv( locator.get_optimization_slave_heating_activation_pattern(master_to_slave_vars.individual_number, master_to_slave_vars.generation_number), usecols=["Q_coldsource_HPLake_W"]) Q_Lake_Array_W = np.array(dfSlave) except: Q_Lake_Array_W = [0] else: Q_Lake_Array_W = [0] ### input parameters Qc_VCC_max_W = master_to_slave_vars.VCC_cooling_size_W Qc_ACH_max_W = master_to_slave_vars.Absorption_chiller_size_W T_ground_K = calculate_ground_temperature(locator, config) # sizing cold water storage tank if master_to_slave_vars.Storage_cooling_size_W > 0: Qc_tank_discharge_peak_W = master_to_slave_vars.Storage_cooling_size_W Qc_tank_charge_max_W = (Qc_VCC_max_W + Qc_ACH_max_W) * 0.8 # assume reduced capacity when Tsup is lower peak_hour = np.argmax(Q_cooling_req_W) area_HEX_tank_discharege_m2, UA_HEX_tank_discharge_WperK, \ area_HEX_tank_charge_m2, UA_HEX_tank_charge_WperK, \ V_tank_m3 = storage_tank.calc_storage_tank_properties(DCN_operation_parameters, Qc_tank_charge_max_W, Qc_tank_discharge_peak_W, peak_hour, master_to_slave_vars) else: Qc_tank_discharge_peak_W = 0 Qc_tank_charge_max_W = 0 area_HEX_tank_discharege_m2 = 0 UA_HEX_tank_discharge_WperK = 0 area_HEX_tank_charge_m2 = 0 UA_HEX_tank_charge_WperK = 0 V_tank_m3 = 0 VCC_cost_data = pd.read_excel(locator.get_supply_systems(config.region), sheetname="Chiller") VCC_cost_data = VCC_cost_data[VCC_cost_data['code'] == 'CH3'] max_VCC_chiller_size = max(VCC_cost_data['cap_max'].values) Absorption_chiller_cost_data = pd.read_excel(locator.get_supply_systems(config.region), sheetname="Absorption_chiller") Absorption_chiller_cost_data = Absorption_chiller_cost_data[Absorption_chiller_cost_data['type'] == ACH_TYPE_DOUBLE] max_ACH_chiller_size = max(Absorption_chiller_cost_data['cap_max'].values) # deciding the number of chillers and the nominal size based on the maximum chiller size Qc_VCC_max_W = Qc_VCC_max_W * (1 + SIZING_MARGIN) Qc_ACH_max_W = Qc_ACH_max_W * (1 + SIZING_MARGIN) Q_peak_load_W = Q_cooling_req_W.max() * (1 + SIZING_MARGIN) Qc_VCC_backup_max_W = (Q_peak_load_W - Qc_ACH_max_W - Qc_VCC_max_W - Qc_tank_discharge_peak_W) if Qc_VCC_backup_max_W < 0: Qc_VCC_backup_max_W = 0 if Qc_VCC_max_W <= max_VCC_chiller_size: Qnom_VCC_W = Qc_VCC_max_W number_of_VCC_chillers = 1 else: number_of_VCC_chillers = int(ceil(Qc_VCC_max_W / max_VCC_chiller_size)) Qnom_VCC_W = Qc_VCC_max_W / number_of_VCC_chillers if Qc_VCC_backup_max_W <= max_VCC_chiller_size: Qnom_VCC_backup_W = Qc_VCC_backup_max_W number_of_VCC_backup_chillers = 1 else: number_of_VCC_backup_chillers = int(ceil(Qc_VCC_backup_max_W / max_VCC_chiller_size)) Qnom_VCC_backup_W = Qc_VCC_backup_max_W / number_of_VCC_backup_chillers if Qc_ACH_max_W <= max_ACH_chiller_size: Qnom_ACH_W = Qc_ACH_max_W number_of_ACH_chillers = 1 else: number_of_ACH_chillers = int(ceil(Qc_ACH_max_W / max_ACH_chiller_size)) Qnom_ACH_W = Qc_ACH_max_W / number_of_ACH_chillers limits = {'Qc_VCC_max_W': Qc_VCC_max_W, 'Qc_ACH_max_W': Qc_ACH_max_W, 'Qc_peak_load_W': Qc_tank_discharge_peak_W, 'Qnom_VCC_W': Qnom_VCC_W, 'number_of_VCC_chillers': number_of_VCC_chillers, 'Qnom_ACH_W': Qnom_ACH_W, 'number_of_ACH_chillers': number_of_ACH_chillers, 'Qnom_VCC_backup_W': Qnom_VCC_backup_W, 'number_of_VCC_backup_chillers': number_of_VCC_backup_chillers, 'Qc_tank_discharge_peak_W': Qc_tank_discharge_peak_W, 'Qc_tank_charge_max_W': Qc_tank_charge_max_W, 'V_tank_m3': V_tank_m3, 'T_tank_fully_charged_K': T_TANK_FULLY_CHARGED_K, 'area_HEX_tank_discharge_m2': area_HEX_tank_discharege_m2, 'UA_HEX_tank_discharge_WperK': UA_HEX_tank_discharge_WperK, 'area_HEX_tank_charge_m2': area_HEX_tank_charge_m2, 'UA_HEX_tank_charge_WperK': UA_HEX_tank_charge_WperK} ### input variables lake_available_cooling = pd.read_csv(locator.get_lake_potential(), usecols=['lake_potential']) Qc_available_from_lake_W = np.sum(lake_available_cooling).values[0] + np.sum(Q_Lake_Array_W) Qc_from_lake_cumulative_W = 0 cooling_resource_potentials = {'T_tank_K': T_TANK_FULLY_DISCHARGED_K, 'Qc_avail_from_lake_W': Qc_available_from_lake_W, 'Qc_from_lake_cumulative_W': Qc_from_lake_cumulative_W} ############# Output results PipeLifeTime = 40.0 # years, Data from A&W PipeInterestRate = 0.05 # 5% interest rate network_costs_USD = ntwFeat.pipesCosts_DCN_USD * DCN_barcode.count('1') / master_to_slave_vars.total_buildings network_costs_a_USD = network_costs_USD * PipeInterestRate * (1+ PipeInterestRate) ** PipeLifeTime / ((1+PipeInterestRate) ** PipeLifeTime - 1) costs_a_USD = network_costs_a_USD CO2_kgCO2 = 0 prim_MJ = 0 nBuild = int(np.shape(arrayData)[0]) if reduced_timesteps_flag == False: start_t = 0 stop_t = int(np.shape(DCN_operation_parameters)[0]) else: # timesteps in May start_t = 2880 stop_t = 3624 timesteps = range(start_t, stop_t) calfactor_buildings = np.zeros(8760) TotalCool = 0 Qc_from_Lake_W = np.zeros(8760) Qc_from_VCC_W = np.zeros(8760) Qc_from_ACH_W = np.zeros(8760) Qc_from_storage_tank_W = np.zeros(8760) Qc_from_VCC_backup_W = np.zeros(8760) Qc_req_from_CT_W = np.zeros(8760) Qh_req_from_CCGT_W = np.zeros(8760) Qh_from_CCGT_W = np.zeros(8760) E_gen_CCGT_W = np.zeros(8760) opex_var_Lake_USD = np.zeros(8760) opex_var_VCC_USD = np.zeros(8760) opex_var_ACH_USD = np.zeros(8760) opex_var_VCC_backup_USD = np.zeros(8760) opex_var_CCGT_USD = np.zeros(8760) opex_var_CT_USD = np.zeros(8760) E_used_Lake_W = np.zeros(8760) E_used_VCC_W = np.zeros(8760) E_used_VCC_backup_W = np.zeros(8760) E_used_ACH_W = np.zeros(8760) E_used_CT_W = np.zeros(8760) co2_Lake_kgCO2 = np.zeros(8760) co2_VCC_kgCO2 = np.zeros(8760) co2_ACH_kgCO2 = np.zeros(8760) co2_VCC_backup_kgCO2 = np.zeros(8760) co2_CCGT_kgCO2 = np.zeros(8760) co2_CT_kgCO2 = np.zeros(8760) prim_energy_Lake_MJ = np.zeros(8760) prim_energy_VCC_MJ = np.zeros(8760) prim_energy_ACH_MJ = np.zeros(8760) prim_energy_VCC_backup_MJ = np.zeros(8760) prim_energy_CCGT_MJ = np.zeros(8760) prim_energy_CT_MJ = np.zeros(8760) NG_used_CCGT_W = np.zeros(8760) calfactor_total = 0 for hour in timesteps: # cooling supply for all buildings excluding cooling loads from data centers performance_indicators_output, \ Qc_supply_to_DCN, calfactor_output, \ Qc_CT_W, Qh_CHP_ACH_W, \ cooling_resource_potentials = cooling_resource_activator(mdot_kgpers[hour], T_sup_K[hour], T_re_K[hour], limits, cooling_resource_potentials, T_ground_K[hour], prices, lca, master_to_slave_vars, config, Q_cooling_req_W[hour], locator) print (hour) # save results for each time-step opex_var_Lake_USD[hour] = performance_indicators_output['Opex_var_Lake_USD'] opex_var_VCC_USD[hour] = performance_indicators_output['Opex_var_VCC_USD'] opex_var_ACH_USD[hour] = performance_indicators_output['Opex_var_ACH_USD'] opex_var_VCC_backup_USD[hour] = performance_indicators_output['Opex_var_VCC_backup_USD'] E_used_Lake_W[hour] = performance_indicators_output['E_used_Lake_W'] E_used_VCC_W[hour] = performance_indicators_output['E_used_VCC_W'] E_used_VCC_backup_W[hour] = performance_indicators_output['E_used_VCC_backup_W'] E_used_ACH_W[hour] = performance_indicators_output['E_used_ACH_W'] co2_Lake_kgCO2[hour] = performance_indicators_output['CO2_Lake_kgCO2'] co2_VCC_kgCO2[hour] = performance_indicators_output['CO2_VCC_kgCO2'] co2_ACH_kgCO2[hour] = performance_indicators_output['CO2_ACH_kgCO2'] co2_VCC_backup_kgCO2[hour] = performance_indicators_output['CO2_VCC_backup_kgCO2'] prim_energy_Lake_MJ[hour] = performance_indicators_output['Primary_Energy_Lake_MJ'] prim_energy_VCC_MJ[hour] = performance_indicators_output['Primary_Energy_VCC_MJ'] prim_energy_ACH_MJ[hour] = performance_indicators_output['Primary_Energy_ACH_MJ'] prim_energy_VCC_backup_MJ[hour] = performance_indicators_output['Primary_Energy_VCC_backup_MJ'] calfactor_buildings[hour] = calfactor_output Qc_from_Lake_W[hour] = Qc_supply_to_DCN['Qc_from_Lake_W'] Qc_from_storage_tank_W[hour] = Qc_supply_to_DCN['Qc_from_Tank_W'] Qc_from_VCC_W[hour] = Qc_supply_to_DCN['Qc_from_VCC_W'] Qc_from_ACH_W[hour] = Qc_supply_to_DCN['Qc_from_ACH_W'] Qc_from_VCC_backup_W[hour] = Qc_supply_to_DCN['Qc_from_backup_VCC_W'] Qc_req_from_CT_W[hour] = Qc_CT_W Qh_req_from_CCGT_W[hour] = Qh_CHP_ACH_W if reduced_timesteps_flag: reduced_costs_USD = np.sum(opex_var_Lake_USD) + np.sum(opex_var_VCC_USD) + np.sum(opex_var_ACH_USD) + np.sum(opex_var_VCC_backup_USD) reduced_CO2_kgCO2 = np.sum(co2_Lake_kgCO2) + np.sum(co2_Lake_kgCO2) + np.sum(co2_ACH_kgCO2) + np.sum(co2_VCC_backup_kgCO2) reduced_prim_MJ = np.sum(prim_energy_Lake_MJ) + np.sum(prim_energy_VCC_MJ) + np.sum(prim_energy_ACH_MJ) + np.sum( prim_energy_VCC_backup_MJ) costs_a_USD += reduced_costs_USD*(8760/(stop_t-start_t)) CO2_kgCO2 += reduced_CO2_kgCO2*(8760/(stop_t-start_t)) prim_MJ += reduced_prim_MJ*(8760/(stop_t-start_t)) else: costs_a_USD += np.sum(opex_var_Lake_USD) + np.sum(opex_var_VCC_USD) + np.sum(opex_var_ACH_USD) + np.sum(opex_var_VCC_backup_USD) CO2_kgCO2 += np.sum(co2_Lake_kgCO2) + np.sum(co2_Lake_kgCO2) + np.sum(co2_ACH_kgCO2) + np.sum(co2_VCC_backup_kgCO2) prim_MJ += np.sum(prim_energy_Lake_MJ) + np.sum(prim_energy_VCC_MJ) + np.sum(prim_energy_ACH_MJ) + np.sum( prim_energy_VCC_backup_MJ) calfactor_total += np.sum(calfactor_buildings) TotalCool += np.sum(Qc_from_Lake_W) + np.sum(Qc_from_VCC_W) + np.sum(Qc_from_ACH_W) + np.sum(Qc_from_VCC_backup_W) + np.sum(Qc_from_storage_tank_W) Q_VCC_nom_W = limits['Qnom_VCC_W'] Q_ACH_nom_W = limits['Qnom_ACH_W'] Q_VCC_backup_nom_W = limits['Qnom_VCC_backup_W'] Q_CT_nom_W = np.amax(Qc_req_from_CT_W) Qh_req_from_CCGT_max_W = np.amax(Qh_req_from_CCGT_W) # the required heat output from CCGT at peak mdot_Max_kgpers = np.amax(DCN_operation_parameters_array[:, 1]) # sizing of DCN network pumps Q_GT_nom_W = 0 ########## Operation of the cooling tower if Q_CT_nom_W > 0: for hour in timesteps: wdot_CT = CTModel.calc_CT(Qc_req_from_CT_W[hour], Q_CT_nom_W) opex_var_CT_USD[hour] = (wdot_CT) * lca.ELEC_PRICE co2_CT_kgCO2[hour] = (wdot_CT) * lca.EL_TO_CO2 * 3600E-6 prim_energy_CT_MJ[hour] = (wdot_CT) * lca.EL_TO_OIL_EQ * 3600E-6 E_used_CT_W[hour] = wdot_CT if reduced_timesteps_flag: reduced_costs_USD = np.sum(opex_var_CT_USD) reduced_CO2_kgCO2 = np.sum(co2_CT_kgCO2) reduced_prim_MJ = np.sum(prim_energy_CT_MJ) costs_a_USD += reduced_costs_USD * (8760 / (stop_t - start_t)) CO2_kgCO2 += reduced_CO2_kgCO2 * (8760 / (stop_t - start_t)) prim_MJ += reduced_prim_MJ * (8760 / (stop_t - start_t)) else: costs_a_USD += np.sum(opex_var_CT_USD) CO2_kgCO2 += np.sum(co2_CT_kgCO2) prim_MJ += np.sum(prim_energy_CT_MJ) ########## Operation of the CCGT if Qh_req_from_CCGT_max_W > 0: # Sizing of CCGT GT_fuel_type = 'NG' # assumption for scenarios in SG Q_GT_nom_sizing_W = Qh_req_from_CCGT_max_W # starting guess for the size of GT Qh_output_CCGT_max_W = 0 # the heat output of CCGT at currently installed size (Q_GT_nom_sizing_W) while (Qh_output_CCGT_max_W - Qh_req_from_CCGT_max_W) <= 0: Q_GT_nom_sizing_W += 1000 # update GT size # get CCGT performance limits and functions at Q_GT_nom_sizing_W CCGT_performances = cogeneration.calc_cop_CCGT(Q_GT_nom_sizing_W, ACH_T_IN_FROM_CHP, GT_fuel_type, prices, lca) Qh_output_CCGT_max_W = CCGT_performances['q_output_max_W'] # unpack CCGT performance functions Q_GT_nom_W = Q_GT_nom_sizing_W * (1 + SIZING_MARGIN) # installed CCGT capacity CCGT_performances = cogeneration.calc_cop_CCGT(Q_GT_nom_W, ACH_T_IN_FROM_CHP, GT_fuel_type, prices, lca) Q_used_prim_W_CCGT_fn = CCGT_performances['q_input_fn_q_output_W'] cost_per_Wh_th_CCGT_fn = CCGT_performances[ 'fuel_cost_per_Wh_th_fn_q_output_W'] # gets interpolated cost function Qh_output_CCGT_min_W = CCGT_performances['q_output_min_W'] Qh_output_CCGT_max_W = CCGT_performances['q_output_max_W'] eta_elec_interpol = CCGT_performances['eta_el_fn_q_input'] for hour in timesteps: if Qh_req_from_CCGT_W[hour] > Qh_output_CCGT_min_W: # operate above minimal load if Qh_req_from_CCGT_W[hour] < Qh_output_CCGT_max_W: # Normal operation Possible within partload regime cost_per_Wh_th = cost_per_Wh_th_CCGT_fn(Qh_req_from_CCGT_W[hour]) Q_used_prim_CCGT_W = Q_used_prim_W_CCGT_fn(Qh_req_from_CCGT_W[hour]) Qh_from_CCGT_W[hour] = Qh_req_from_CCGT_W[hour].copy() E_gen_CCGT_W[hour] = np.float(eta_elec_interpol(Q_used_prim_CCGT_W)) * Q_used_prim_CCGT_W else: raise ValueError('Incorrect CCGT sizing!') else: # operate at minimum load cost_per_Wh_th = cost_per_Wh_th_CCGT_fn(Qh_output_CCGT_min_W) Q_used_prim_CCGT_W = Q_used_prim_W_CCGT_fn(Qh_output_CCGT_min_W) Qh_from_CCGT_W[hour] = Qh_output_CCGT_min_W E_gen_CCGT_W[hour] = np.float(eta_elec_interpol( Qh_output_CCGT_max_W)) * Q_used_prim_CCGT_W opex_var_CCGT_USD[hour] = cost_per_Wh_th * Qh_from_CCGT_W[hour] - E_gen_CCGT_W[hour] * lca.ELEC_PRICE co2_CCGT_kgCO2[hour] = Q_used_prim_CCGT_W * lca.NG_CC_TO_CO2_STD * WH_TO_J / 1.0E6 - E_gen_CCGT_W[hour] * lca.EL_TO_CO2 * 3600E-6 prim_energy_CCGT_MJ[hour] = Q_used_prim_CCGT_W * lca.NG_CC_TO_OIL_STD * WH_TO_J / 1.0E6 - E_gen_CCGT_W[hour] * lca.EL_TO_OIL_EQ * 3600E-6 NG_used_CCGT_W[hour] = Q_used_prim_CCGT_W if reduced_timesteps_flag: reduced_costs_USD = np.sum(opex_var_CCGT_USD) reduced_CO2_kgCO2 = np.sum(co2_CCGT_kgCO2) reduced_prim_MJ = np.sum(prim_energy_CCGT_MJ) costs_a_USD += reduced_costs_USD * (8760 / (stop_t - start_t)) CO2_kgCO2 += reduced_CO2_kgCO2 * (8760 / (stop_t - start_t)) prim_MJ += reduced_prim_MJ * (8760 / (stop_t - start_t)) else: costs_a_USD += np.sum(opex_var_CCGT_USD) CO2_kgCO2 += np.sum(co2_CCGT_kgCO2) prim_MJ += np.sum(prim_energy_CCGT_MJ) ########## Add investment costs for i in range(limits['number_of_VCC_chillers']): Capex_a_VCC_USD, Opex_fixed_VCC_USD, Capex_VCC_USD = VCCModel.calc_Cinv_VCC(Q_VCC_nom_W, locator, config, 'CH3') costs_a_USD += Capex_a_VCC_USD + Opex_fixed_VCC_USD for i in range(limits['number_of_VCC_backup_chillers']): Capex_a_VCC_backup_USD, Opex_fixed_VCC_backup_USD, Capex_VCC_backup_USD = VCCModel.calc_Cinv_VCC(Q_VCC_backup_nom_W, locator, config, 'CH3') costs_a_USD += Capex_a_VCC_backup_USD + Opex_fixed_VCC_backup_USD master_to_slave_vars.VCC_backup_cooling_size_W = Q_VCC_backup_nom_W * limits['number_of_VCC_backup_chillers'] for i in range(limits['number_of_ACH_chillers']): Capex_a_ACH_USD, Opex_fixed_ACH_USD, Capex_ACH_USD = chiller_absorption.calc_Cinv_ACH(Q_ACH_nom_W, locator, ACH_TYPE_DOUBLE, config) costs_a_USD += Capex_a_ACH_USD + Opex_fixed_ACH_USD Capex_a_CCGT_USD, Opex_fixed_CCGT_USD, Capex_CCGT_USD = cogeneration.calc_Cinv_CCGT(Q_GT_nom_W, locator, config) costs_a_USD += Capex_a_CCGT_USD + Opex_fixed_CCGT_USD Capex_a_Tank_USD, Opex_fixed_Tank_USD, Capex_Tank_USD = thermal_storage.calc_Cinv_storage(V_tank_m3, locator, config, 'TES2') costs_a_USD += Capex_a_Tank_USD + Opex_fixed_Tank_USD Capex_a_CT_USD, Opex_fixed_CT_USD, Capex_CT_USD = CTModel.calc_Cinv_CT(Q_CT_nom_W, locator, config, 'CT1') costs_a_USD += Capex_a_CT_USD + Opex_fixed_CT_USD Capex_a_pump_USD, Opex_fixed_pump_USD, Opex_var_pump_USD, Capex_pump_USD = PumpModel.calc_Ctot_pump(master_to_slave_vars, ntwFeat, locator, lca, config) costs_a_USD += Capex_a_pump_USD + Opex_fixed_pump_USD + Opex_var_pump_USD network_data = pd.read_csv(locator.get_optimization_network_data_folder(master_to_slave_vars.network_data_file_cooling)) date = network_data.DATE.values results = pd.DataFrame({"DATE": date, "Q_total_cooling_W": Q_cooling_req_W, "Opex_var_Lake_USD": opex_var_Lake_USD, "Opex_var_VCC_USD": opex_var_VCC_USD, "Opex_var_ACH_USD": opex_var_ACH_USD, "Opex_var_VCC_backup_USD": opex_var_VCC_backup_USD, "Opex_var_CT_USD": opex_var_CT_USD, "Opex_var_CCGT_USD": opex_var_CCGT_USD, "E_used_Lake_W": E_used_Lake_W, "E_used_VCC_W": E_used_VCC_W, "E_used_VCC_backup_W": E_used_VCC_backup_W, "E_used_ACH_W": E_used_ACH_W, "E_used_CT_W": E_used_CT_W, "NG_used_CCGT_W": NG_used_CCGT_W, "CO2_from_using_Lake": co2_Lake_kgCO2, "CO2_from_using_VCC": co2_VCC_kgCO2, "CO2_from_using_ACH": co2_ACH_kgCO2, "CO2_from_using_VCC_backup": co2_VCC_backup_kgCO2, "CO2_from_using_CT": co2_CT_kgCO2, "CO2_from_using_CCGT": co2_CCGT_kgCO2, "Primary_Energy_from_Lake": prim_energy_Lake_MJ, "Primary_Energy_from_VCC": prim_energy_VCC_MJ, "Primary_Energy_from_ACH": prim_energy_ACH_MJ, "Primary_Energy_from_VCC_backup": prim_energy_VCC_backup_MJ, "Primary_Energy_from_CT": prim_energy_CT_MJ, "Primary_Energy_from_CCGT": prim_energy_CCGT_MJ, "Q_from_Lake_W": Qc_from_Lake_W, "Q_from_VCC_W": Qc_from_VCC_W, "Q_from_ACH_W": Qc_from_ACH_W, "Q_from_VCC_backup_W": Qc_from_VCC_backup_W, "Q_from_storage_tank_W": Qc_from_storage_tank_W, "Qc_CT_associated_with_all_chillers_W": Qc_req_from_CT_W, "Qh_CCGT_associated_with_absorption_chillers_W": Qh_from_CCGT_W, "E_gen_CCGT_associated_with_absorption_chillers_W": E_gen_CCGT_W }) results.to_csv(locator.get_optimization_slave_cooling_activation_pattern(master_to_slave_vars.individual_number, master_to_slave_vars.generation_number), index=False) ########### Adjust and add the pumps for filtering and pre-treatment of the water calibration = calfactor_total / 50976000 extraElec = (127865400 + 85243600) * calibration costs_a_USD += extraElec * lca.ELEC_PRICE CO2_kgCO2 += extraElec * lca.EL_TO_CO2 * 3600E-6 prim_MJ += extraElec * lca.EL_TO_OIL_EQ * 3600E-6 # Converting costs into float64 to avoid longer values costs_a_USD = np.float64(costs_a_USD) CO2_kgCO2 = np.float64(CO2_kgCO2) prim_MJ = np.float64(prim_MJ) # Capex_a and Opex_fixed results = pd.DataFrame({"Capex_a_VCC_USD": [Capex_a_VCC_USD], "Opex_fixed_VCC_USD": [Opex_fixed_VCC_USD], "Capex_a_VCC_backup_USD": [Capex_a_VCC_backup_USD], "Opex_fixed_VCC_backup_USD": [Opex_fixed_VCC_backup_USD], "Capex_a_ACH_USD": [Capex_a_ACH_USD], "Opex_fixed_ACH_USD": [Opex_fixed_ACH_USD], "Capex_a_CCGT_USD": [Capex_a_CCGT_USD], "Opex_fixed_CCGT_USD": [Opex_fixed_CCGT_USD], "Capex_a_Tank_USD": [Capex_a_Tank_USD], "Opex_fixed_Tank_USD": [Opex_fixed_Tank_USD], "Capex_a_CT_USD": [Capex_a_CT_USD], "Opex_fixed_CT_USD": [Opex_fixed_CT_USD], "Capex_a_pump_USD": [Capex_a_pump_USD], "Opex_fixed_pump_USD": [Opex_fixed_pump_USD], "Opex_var_pump_USD": [Opex_var_pump_USD], "Capex_VCC_USD": [Capex_VCC_USD], "Capex_VCC_backup_USD": [Capex_VCC_backup_USD], "Capex_ACH_USD": [Capex_ACH_USD], "Capex_CCGT_USD": [Capex_CCGT_USD], "Capex_Tank_USD": [Capex_Tank_USD], "Capex_CT_USD": [Capex_CT_USD], "Capex_pump_USD": [Capex_pump_USD] }) results.to_csv(locator.get_optimization_slave_investment_cost_detailed_cooling(master_to_slave_vars.individual_number, master_to_slave_vars.generation_number), index=False) # print " Cooling main done (", round(time.time()-t0, 1), " seconds used for this task)" # print ('Cooling costs = ' + str(costs)) # print ('Cooling CO2 = ' + str(CO2)) # print ('Cooling Eprim = ' + str(prim)) return (costs_a_USD, CO2_kgCO2, prim_MJ)
def district_cooling_network(locator, master_to_slave_variables, config, prices, network_features): """ Computes the parameters for the cooling of the complete DCN :param cea.inputlocator.InputLocator locator: path to res folder :param network_features: network features :param prices: Prices imported from the database :type network_features: class :type prices: class :return: costs, co2, prim :rtype: tuple """ if master_to_slave_variables.DCN_exists: # THERMAL STORAGE + NETWORK # Import Temperatures from Network Summary: Q_thermal_req_W, \ T_district_cooling_return_K, \ T_district_cooling_supply_K, \ mdot_kgpers = calc_network_summary_DCN(master_to_slave_variables) # Initialize daily storage calss T_ground_K = calculate_ground_temperature(locator) daily_storage = LoadLevelingDailyStorage(master_to_slave_variables.Storage_cooling_on, master_to_slave_variables.Storage_cooling_size_W, min(T_district_cooling_supply_K) - DT_COOL, max(T_district_cooling_return_K) - DT_COOL, T_TANK_FULLY_DISCHARGED_K, np.mean(T_ground_K) ) # Import Data - potentials lake heat if master_to_slave_variables.WS_BaseVCC_on == 1 or master_to_slave_variables.WS_PeakVCC_on == 1: HPlake_Data = pd.read_csv(locator.get_water_body_potential()) Q_therm_Lake = np.array(HPlake_Data['QLake_kW']) * 1E3 total_WS_VCC_installed = master_to_slave_variables.WS_BaseVCC_size_W + master_to_slave_variables.WS_PeakVCC_size_W Q_therm_Lake_W = [x if x < total_WS_VCC_installed else total_WS_VCC_installed for x in Q_therm_Lake] T_source_average_Lake_K = np.array(HPlake_Data['Ts_C']) + 273 else: Q_therm_Lake_W = np.zeros(HOURS_IN_YEAR) T_source_average_Lake_K = np.zeros(HOURS_IN_YEAR) # get properties of technology used in this script absorption_chiller = AbsorptionChiller(pd.read_excel(locator.get_database_conversion_systems(), sheet_name="Absorption_chiller"), 'double') CCGT_prop = calc_cop_CCGT(master_to_slave_variables.NG_Trigen_ACH_size_W, ACH_T_IN_FROM_CHP_K, "NG") VCC_database = pd.read_excel(locator.get_database_conversion_systems(), sheet_name="Chiller") technology_type = VCC_CODE_CENTRALIZED VCC_database = VCC_database[VCC_database['code'] == technology_type] max_VCC_capacity = int(VCC_database['cap_max']) min_VCC_capacity = int(VCC_database['cap_min']) # G_VALUE = VCC_database['ISENTROPIC_EFFICIENCY'] # create vessel to carry down gvalue and max_VCC_capacity, min_VCC_capacity to VCC module # initialize variables Q_Trigen_NG_gen_W = np.zeros(HOURS_IN_YEAR) Q_BaseVCC_WS_gen_W = np.zeros(HOURS_IN_YEAR) Q_PeakVCC_WS_gen_W = np.zeros(HOURS_IN_YEAR) Q_BaseVCC_AS_gen_W = np.zeros(HOURS_IN_YEAR) Q_PeakVCC_AS_gen_W = np.zeros(HOURS_IN_YEAR) Q_DailyStorage_gen_directload_W = np.zeros(HOURS_IN_YEAR) E_Trigen_NG_gen_W = np.zeros(HOURS_IN_YEAR) E_BaseVCC_AS_req_W = np.zeros(HOURS_IN_YEAR) E_PeakVCC_AS_req_W = np.zeros(HOURS_IN_YEAR) E_BaseVCC_WS_req_W = np.zeros(HOURS_IN_YEAR) E_PeakVCC_WS_req_W = np.zeros(HOURS_IN_YEAR) NG_Trigen_req_W = np.zeros(HOURS_IN_YEAR) Q_BackupVCC_AS_gen_W = np.zeros(HOURS_IN_YEAR) Q_Trigen_NG_gen_directload_W = np.zeros(HOURS_IN_YEAR) Q_BaseVCC_WS_gen_directload_W = np.zeros(HOURS_IN_YEAR) Q_PeakVCC_WS_gen_directload_W = np.zeros(HOURS_IN_YEAR) Q_BaseVCC_AS_gen_directload_W = np.zeros(HOURS_IN_YEAR) Q_PeakVCC_AS_gen_directload_W = np.zeros(HOURS_IN_YEAR) Q_BackupVCC_AS_directload_W = np.zeros(HOURS_IN_YEAR) for hour in range(HOURS_IN_YEAR): # cooling supply for all buildings excluding cooling loads from data centers if Q_thermal_req_W[hour] > 0.0: # only if there is a cooling load! daily_storage, \ thermal_output, \ electricity_output, \ gas_output = cooling_resource_activator(Q_thermal_req_W[hour], T_district_cooling_supply_K[hour], T_district_cooling_return_K[hour], Q_therm_Lake_W[hour], T_source_average_Lake_K[hour], daily_storage, T_ground_K[hour], master_to_slave_variables, absorption_chiller, CCGT_prop, min_VCC_capacity, max_VCC_capacity) Q_DailyStorage_gen_directload_W[hour] = thermal_output['Q_DailyStorage_gen_directload_W'] Q_Trigen_NG_gen_directload_W[hour] = thermal_output['Q_Trigen_NG_gen_directload_W'] Q_BaseVCC_WS_gen_directload_W[hour] = thermal_output['Q_BaseVCC_WS_gen_directload_W'] Q_PeakVCC_WS_gen_directload_W[hour] = thermal_output['Q_PeakVCC_WS_gen_directload_W'] Q_BaseVCC_AS_gen_directload_W[hour] = thermal_output['Q_BaseVCC_AS_gen_directload_W'] Q_PeakVCC_AS_gen_directload_W[hour] = thermal_output['Q_PeakVCC_AS_gen_directload_W'] Q_BackupVCC_AS_directload_W[hour] = thermal_output['Q_BackupVCC_AS_directload_W'] Q_Trigen_NG_gen_W[hour] = thermal_output['Q_Trigen_NG_gen_W'] Q_BaseVCC_WS_gen_W[hour] = thermal_output['Q_BaseVCC_WS_gen_W'] Q_PeakVCC_WS_gen_W[hour] = thermal_output['Q_PeakVCC_WS_gen_W'] Q_BaseVCC_AS_gen_W[hour] = thermal_output['Q_BaseVCC_AS_gen_W'] Q_PeakVCC_AS_gen_W[hour] = thermal_output['Q_PeakVCC_AS_gen_W'] Q_BackupVCC_AS_gen_W[hour] = thermal_output['Q_BackupVCC_AS_gen_W'] E_BaseVCC_WS_req_W[hour] = electricity_output['E_BaseVCC_WS_req_W'] E_PeakVCC_WS_req_W[hour] = electricity_output['E_PeakVCC_WS_req_W'] E_BaseVCC_AS_req_W[hour] = electricity_output['E_BaseVCC_AS_req_W'] E_PeakVCC_AS_req_W[hour] = electricity_output['E_PeakVCC_AS_req_W'] E_Trigen_NG_gen_W[hour] = electricity_output['E_Trigen_NG_gen_W'] NG_Trigen_req_W[hour] = gas_output['NG_Trigen_req_W'] #calculate the electrical capacity as a function of the peak produced by the turbine master_to_slave_variables.NG_Trigen_CCGT_size_electrical_W = E_Trigen_NG_gen_W.max() # BACK-UPP VCC - AIR SOURCE scale = 'DISTRICT' master_to_slave_variables.AS_BackupVCC_size_W = np.amax(Q_BackupVCC_AS_gen_W) size_chiller_CT = master_to_slave_variables.AS_BackupVCC_size_W if master_to_slave_variables.AS_BackupVCC_size_W != 0.0: master_to_slave_variables.AS_BackupVCC_on = 1 Q_BackupVCC_AS_gen_W, E_BackupVCC_AS_req_W = np.vectorize(calc_vcc_CT_operation)(Q_BackupVCC_AS_gen_W, T_district_cooling_return_K, T_district_cooling_supply_K, VCC_T_COOL_IN, size_chiller_CT, min_VCC_capacity, max_VCC_capacity, scale) else: E_BackupVCC_AS_req_W = np.zeros(HOURS_IN_YEAR) # CAPEX (ANNUAL, TOTAL) AND OPEX (FIXED, VAR, ANNUAL) GENERATION UNITS supply_systems = SupplySystemsDatabase(locator) mdotnMax_kgpers = np.amax(mdot_kgpers) performance_costs_generation, \ district_cooling_capacity_installed = cost_model.calc_generation_costs_capacity_installed_cooling(locator, master_to_slave_variables, supply_systems, mdotnMax_kgpers ) # CAPEX (ANNUAL, TOTAL) AND OPEX (FIXED, VAR, ANNUAL) STORAGE UNITS performance_costs_storage = cost_model.calc_generation_costs_cooling_storage(locator, master_to_slave_variables, config, daily_storage ) # CAPEX (ANNUAL, TOTAL) AND OPEX (FIXED, VAR, ANNUAL) NETWORK performance_costs_network, \ E_used_district_cooling_network_W = cost_model.calc_network_costs_cooling(locator, master_to_slave_variables, network_features, "DC", prices) # MERGE COSTS AND EMISSIONS IN ONE FILE performance = dict(performance_costs_generation, **performance_costs_storage) district_cooling_costs = dict(performance, **performance_costs_network) else: Q_thermal_req_W = np.zeros(HOURS_IN_YEAR) Q_DailyStorage_gen_directload_W = np.zeros(HOURS_IN_YEAR) Q_Trigen_NG_gen_directload_W = np.zeros(HOURS_IN_YEAR) Q_BaseVCC_WS_gen_directload_W = np.zeros(HOURS_IN_YEAR) Q_PeakVCC_WS_gen_directload_W = np.zeros(HOURS_IN_YEAR) Q_BaseVCC_AS_gen_directload_W = np.zeros(HOURS_IN_YEAR) Q_PeakVCC_AS_gen_directload_W = np.zeros(HOURS_IN_YEAR) Q_BackupVCC_AS_directload_W = np.zeros(HOURS_IN_YEAR) Q_Trigen_NG_gen_W = np.zeros(HOURS_IN_YEAR) Q_BaseVCC_WS_gen_W = np.zeros(HOURS_IN_YEAR) Q_PeakVCC_WS_gen_W = np.zeros(HOURS_IN_YEAR) Q_BaseVCC_AS_gen_W = np.zeros(HOURS_IN_YEAR) Q_PeakVCC_AS_gen_W = np.zeros(HOURS_IN_YEAR) Q_BackupVCC_AS_gen_W = np.zeros(HOURS_IN_YEAR) E_Trigen_NG_gen_W = np.zeros(HOURS_IN_YEAR) E_used_district_cooling_network_W = np.zeros(HOURS_IN_YEAR) E_BaseVCC_WS_req_W = np.zeros(HOURS_IN_YEAR) E_PeakVCC_WS_req_W = np.zeros(HOURS_IN_YEAR) E_BaseVCC_AS_req_W = np.zeros(HOURS_IN_YEAR) E_PeakVCC_AS_req_W = np.zeros(HOURS_IN_YEAR) E_BackupVCC_AS_req_W = np.zeros(HOURS_IN_YEAR) NG_Trigen_req_W = np.zeros(HOURS_IN_YEAR) district_cooling_costs = {} district_cooling_capacity_installed = {} # SAVE district_cooling_generation_dispatch = { # demand of the network "Q_districtcooling_sys_req_W": Q_thermal_req_W, # ENERGY GENERATION TO DIRECT LOAD # from storage "Q_DailyStorage_gen_directload_W": Q_DailyStorage_gen_directload_W, # cooling "Q_Trigen_NG_gen_directload_W": Q_Trigen_NG_gen_directload_W, "Q_BaseVCC_WS_gen_directload_W": Q_BaseVCC_WS_gen_directload_W, "Q_PeakVCC_WS_gen_directload_W": Q_PeakVCC_WS_gen_directload_W, "Q_BaseVCC_AS_gen_directload_W": Q_BaseVCC_AS_gen_directload_W, "Q_PeakVCC_AS_gen_directload_W": Q_PeakVCC_AS_gen_directload_W, "Q_BackupVCC_AS_directload_W": Q_BackupVCC_AS_directload_W, # ENERGY GENERATION TOTAL # cooling "Q_Trigen_NG_gen_W": Q_Trigen_NG_gen_W, "Q_BaseVCC_WS_gen_W": Q_BaseVCC_WS_gen_W, "Q_PeakVCC_WS_gen_W": Q_PeakVCC_WS_gen_W, "Q_BaseVCC_AS_gen_W": Q_BaseVCC_AS_gen_W, "Q_PeakVCC_AS_gen_W": Q_PeakVCC_AS_gen_W, "Q_BackupVCC_AS_W": Q_BackupVCC_AS_gen_W, # electricity "E_Trigen_NG_gen_W": E_Trigen_NG_gen_W } district_cooling_electricity_requirements_dispatch = { # ENERGY REQUIREMENTS # Electricity "E_DCN_req_W": E_used_district_cooling_network_W, "E_BaseVCC_WS_req_W": E_BaseVCC_WS_req_W, "E_PeakVCC_WS_req_W": E_PeakVCC_WS_req_W, "E_BaseVCC_AS_req_W": E_BaseVCC_AS_req_W, "E_PeakVCC_AS_req_W": E_PeakVCC_AS_req_W, "E_BackupVCC_AS_req_W": E_BackupVCC_AS_req_W, } district_cooling_fuel_requirements_dispatch = { # fuels "NG_Trigen_req_W": NG_Trigen_req_W } # PLOT RESULTS return district_cooling_costs, \ district_cooling_generation_dispatch, \ district_cooling_electricity_requirements_dispatch, \ district_cooling_fuel_requirements_dispatch, \ district_cooling_capacity_installed
def heating_source_activator(Q_therm_req_W, master_to_slave_vars, Q_therm_GHP_W, TretGHPArray_K, TretLakeArray_K, Q_therm_Lake_W, Q_therm_Sew_W, TretsewArray_K, tdhsup_K, tdhret_req_K): """ :param Q_therm_req_W: :param hour: :param context: :type Q_therm_req_W: float :type hour: int :type context: list :return: cost_data_centralPlant_op, source_info, Q_source_data, E_coldsource_data, E_PP_el_data, E_gas_data, E_wood_data, Q_excess :rtype: """ ## initializing unmet heating load Q_heat_unmet_W = Q_therm_req_W # ACTIVATE THE COGEN if master_to_slave_vars.CC_on == 1 and Q_heat_unmet_W > 0.0: CC_op_cost_data = calc_cop_CCGT(master_to_slave_vars.CCGT_SIZE_W, tdhsup_K, "NG") # create cost information Q_used_prim_CC_fn_W = CC_op_cost_data['q_input_fn_q_output_W'] q_output_CC_min_W = CC_op_cost_data['q_output_min_W'] Q_output_CC_max_W = CC_op_cost_data['q_output_max_W'] eta_elec_interpol = CC_op_cost_data['eta_el_fn_q_input'] if Q_heat_unmet_W >= q_output_CC_min_W: # operation Possible if above minimal load if Q_heat_unmet_W <= Q_output_CC_max_W: # Normal operation Possible within partload regime Q_CHP_gen_W = Q_heat_unmet_W NG_CHP_req_W = Q_used_prim_CC_fn_W(Q_CHP_gen_W) E_CHP_gen_W = np.float( eta_elec_interpol(NG_CHP_req_W)) * NG_CHP_req_W else: # Only part of the demand can be delivered as 100% load achieved Q_CHP_gen_W = Q_output_CC_max_W NG_CHP_req_W = Q_used_prim_CC_fn_W(Q_CHP_gen_W) E_CHP_gen_W = np.float( eta_elec_interpol(NG_CHP_req_W)) * NG_CHP_req_W else: NG_CHP_req_W = 0.0 E_CHP_gen_W = 0.0 Q_CHP_gen_W = 0.0 Q_heat_unmet_W = Q_heat_unmet_W - Q_CHP_gen_W else: NG_CHP_req_W = 0.0 E_CHP_gen_W = 0.0 Q_CHP_gen_W = 0.0 # WET FURNACE if master_to_slave_vars.Furnace_wet_on == 1 and Q_heat_unmet_W > 0.0: # Activate Furnace if its there. # Operate only if its above minimal load if Q_heat_unmet_W > master_to_slave_vars.WBFurnace_Q_max_W: if Q_heat_unmet_W > master_to_slave_vars.WBFurnace_Q_max_W: Q_Furnace_wet_gen_W = master_to_slave_vars.WBFurnace_Q_max_W # scale down if above maximum load, Furnace operates at max. capacity DryBiomass_Furnace_req_W, E_Furnace_wet_gen_W = furnace_op_cost( Q_Furnace_wet_gen_W, master_to_slave_vars.WBFurnace_Q_max_W, tdhret_req_K, "wet") else: # Normal Operation Possible Q_Furnace_wet_gen_W = Q_heat_unmet_W DryBiomass_Furnace_req_W, E_Furnace_wet_gen_W = furnace_op_cost( Q_Furnace_wet_gen_W, master_to_slave_vars.WBFurnace_Q_max_W, tdhret_req_K, "wet") else: E_Furnace_wet_gen_W = 0.0 DryBiomass_Furnace_req_W = 0.0 Q_Furnace_wet_gen_W = 0.0 Q_heat_unmet_W = Q_heat_unmet_W - Q_Furnace_wet_gen_W else: E_Furnace_wet_gen_W = 0.0 DryBiomass_Furnace_req_W = 0.0 Q_Furnace_wet_gen_W = 0.0 # DRY FURNACE if master_to_slave_vars.Furnace_dry_on == 1 and Q_heat_unmet_W > 0.0: # Activate Furnace if its there. # Operate only if its above minimal load if Q_heat_unmet_W > master_to_slave_vars.DBFurnace_Q_max_W: if Q_heat_unmet_W > master_to_slave_vars.DBFurnace_Q_max_W: Q_Furnace_dry_gen_W = master_to_slave_vars.DBFurnace_Q_max_W # scale down if above maximum load, Furnace operates at max. capacity WetBiomass_Furnace_req_W, E_Furnace_dry_gen_W = furnace_op_cost( Q_Furnace_dry_gen_W, master_to_slave_vars.DBFurnace_Q_max_W, tdhret_req_K, "dry") else: # Normal Operation Possible Q_Furnace_dry_gen_W = Q_heat_unmet_W WetBiomass_Furnace_req_W, E_Furnace_dry_gen_W = furnace_op_cost( Q_Furnace_dry_gen_W, master_to_slave_vars.DBFurnace_Q_max_W, tdhret_req_K, "dry") else: E_Furnace_dry_gen_W = 0.0 WetBiomass_Furnace_req_W = 0.0 Q_Furnace_dry_gen_W = 0.0 Q_heat_unmet_W = Q_heat_unmet_W - Q_Furnace_dry_gen_W else: E_Furnace_dry_gen_W = 0.0 WetBiomass_Furnace_req_W = 0.0 Q_Furnace_dry_gen_W = 0.0 if (master_to_slave_vars.HPSew_on ) == 1 and Q_heat_unmet_W > 0.0 and not np.isclose( tdhsup_K, tdhret_req_K): # activate if its available if Q_heat_unmet_W > Q_therm_Sew_W: Q_HPSew_gen_W = Q_therm_Sew_W mdot_DH_to_Sew_kgpers = Q_HPSew_gen_W / ( HEAT_CAPACITY_OF_WATER_JPERKGK * (tdhsup_K - tdhret_req_K)) else: Q_HPSew_gen_W = Q_heat_unmet_W mdot_DH_to_Sew_kgpers = Q_HPSew_gen_W / ( HEAT_CAPACITY_OF_WATER_JPERKGK * (tdhsup_K - tdhret_req_K)) E_HPSew_req_W, \ Q_coldsource_HPSew_W, \ Q_HPSew_gen_W = HPSew_op_cost(mdot_DH_to_Sew_kgpers, tdhsup_K, tdhret_req_K, TretsewArray_K, Q_HPSew_gen_W ) Q_heat_unmet_W = Q_heat_unmet_W - Q_HPSew_gen_W else: E_HPSew_req_W = 0.0 Q_HPSew_gen_W = 0.0 if (master_to_slave_vars.HPLake_on ) == 1 and Q_heat_unmet_W > 0.0 and not np.isclose( tdhsup_K, tdhret_req_K): if Q_heat_unmet_W > Q_therm_Lake_W: # Scale down Load, 100% load achieved Q_HPLake_gen_W = Q_therm_Lake_W else: # regular operation possible Q_HPLake_gen_W = Q_heat_unmet_W E_HPLake_req_W, Q_coldsource_HPLake_W, Q_HPLake_gen_W = HPLake_op_cost( Q_HPLake_gen_W, tdhsup_K, tdhret_req_K, TretLakeArray_K) E_pump_req_W = calc_water_body_uptake_pumping(Q_HPLake_gen_W, tdhret_req_K, tdhsup_K) E_HPLake_req_W += E_pump_req_W Q_heat_unmet_W = Q_heat_unmet_W - Q_HPLake_gen_W else: E_HPLake_req_W = 0.0 Q_HPLake_gen_W = 0.0 if (master_to_slave_vars.GHP_on ) == 1 and Q_heat_unmet_W > 0.0 and not np.isclose( tdhsup_K, tdhret_req_K): if Q_heat_unmet_W > Q_therm_GHP_W: Q_GHP_gen_W = Q_therm_GHP_W mdot_DH_to_GHP_kgpers = Q_GHP_gen_W / ( HEAT_CAPACITY_OF_WATER_JPERKGK * (tdhsup_K - tdhret_req_K)) else: # regular operation possible, demand is covered Q_GHP_gen_W = Q_heat_unmet_W mdot_DH_to_GHP_kgpers = Q_GHP_gen_W / ( HEAT_CAPACITY_OF_WATER_JPERKGK * (tdhsup_K - tdhret_req_K)) E_GHP_req_W, Q_coldsource_GHP_W, Q_GHP_gen_W = GHP_op_cost( mdot_DH_to_GHP_kgpers, tdhsup_K, tdhret_req_K, TretGHPArray_K, Q_GHP_gen_W) Q_heat_unmet_W = Q_heat_unmet_W - Q_GHP_gen_W else: E_GHP_req_W = 0.0 Q_GHP_gen_W = 0.0 if (master_to_slave_vars.Boiler_on) == 1 and Q_heat_unmet_W > 0: if Q_heat_unmet_W >= BOILER_MIN * master_to_slave_vars.Boiler_Q_max_W: # Boiler can be activated? if Q_heat_unmet_W >= master_to_slave_vars.Boiler_Q_max_W: # Boiler above maximum Load? Q_BaseBoiler_gen_W = master_to_slave_vars.Boiler_Q_max_W else: Q_BaseBoiler_gen_W = Q_heat_unmet_W NG_BaseBoiler_req_W, E_BaseBoiler_req_W = cond_boiler_op_cost( Q_BaseBoiler_gen_W, master_to_slave_vars.Boiler_Q_max_W, tdhret_req_K) else: Q_BaseBoiler_gen_W = 0.0 NG_BaseBoiler_req_W = 0.0 E_BaseBoiler_req_W = 0.0 Q_heat_unmet_W = Q_heat_unmet_W - Q_BaseBoiler_gen_W else: Q_BaseBoiler_gen_W = 0.0 NG_BaseBoiler_req_W = 0.0 E_BaseBoiler_req_W = 0.0 if master_to_slave_vars.BoilerPeak_on == 1 and Q_heat_unmet_W > 0: if Q_heat_unmet_W >= BOILER_MIN * master_to_slave_vars.BoilerPeak_Q_max_W: # Boiler can be activated? if Q_heat_unmet_W > master_to_slave_vars.BoilerPeak_Q_max_W: # Boiler above maximum Load? Q_PeakBoiler_gen_W = master_to_slave_vars.BoilerPeak_Q_max_W else: Q_PeakBoiler_gen_W = Q_heat_unmet_W NG_PeakBoiler_req_W, E_PeakBoiler_req_W = cond_boiler_op_cost( Q_PeakBoiler_gen_W, master_to_slave_vars.BoilerPeak_Q_max_W, tdhret_req_K) else: Q_PeakBoiler_gen_W = 0.0 NG_PeakBoiler_req_W = 0 E_PeakBoiler_req_W = 0.0 Q_heat_unmet_W = Q_heat_unmet_W - Q_PeakBoiler_gen_W else: Q_PeakBoiler_gen_W = 0.0 NG_PeakBoiler_req_W = 0 E_PeakBoiler_req_W = 0.0 if Q_heat_unmet_W > 1.0E-3: Q_uncovered_W = Q_heat_unmet_W # this will become the back-up boiler else: Q_uncovered_W = 0.0 return Q_HPSew_gen_W, \ Q_HPLake_gen_W, \ Q_GHP_gen_W, \ Q_CHP_gen_W, \ Q_Furnace_dry_gen_W, \ Q_Furnace_wet_gen_W, \ Q_BaseBoiler_gen_W, \ Q_PeakBoiler_gen_W, \ Q_uncovered_W, \ E_HPSew_req_W, \ E_HPLake_req_W, \ E_BaseBoiler_req_W, \ E_PeakBoiler_req_W, \ E_GHP_req_W, \ E_CHP_gen_W, \ E_Furnace_dry_gen_W, \ E_Furnace_wet_gen_W, \ NG_CHP_req_W, \ NG_BaseBoiler_req_W, \ NG_PeakBoiler_req_W, \ WetBiomass_Furnace_req_W, \ DryBiomass_Furnace_req_W