def calc_chiller_absorption_operation(Qc_ACH_req_W, T_DCN_re_K, T_DCN_sup_K, T_ACH_in_C, T_ground_K, chiller_prop, size_ACH_W): if T_DCN_re_K == T_DCN_sup_K: mdot_ACH_kgpers = 0 else: mdot_ACH_kgpers = Qc_ACH_req_W / ( (T_DCN_re_K - T_DCN_sup_K) * HEAT_CAPACITY_OF_WATER_JPERKGK) # required chw flow rate from ACH ACH_operation = chiller_absorption.calc_chiller_main(mdot_ACH_kgpers, T_DCN_sup_K, T_DCN_re_K, T_ACH_in_C, T_ground_K, chiller_prop) Qc_CT_ACH_W = ACH_operation['q_cw_W'] # calculate cooling tower wdot_CT_Wh = CTModel.calc_CT(Qc_CT_ACH_W, size_ACH_W) # calcualte energy consumption and variable costs Qh_CHP_ACH_W = ACH_operation['q_hw_W'] E_used_ACH_W = ACH_operation['wdot_W'] + wdot_CT_Wh return Qc_CT_ACH_W, Qh_CHP_ACH_W, E_used_ACH_W
def calc_vcc_CT_operation(Qc_from_VCC_W, T_DCN_re_K, T_DCN_sup_K, T_source_K, size_chiller_CT, VCC_chiller): VCC_operation = chiller_vapor_compression.calc_VCC(size_chiller_CT, Qc_from_VCC_W, T_DCN_sup_K, T_DCN_re_K, T_source_K, VCC_chiller) # unpack outputs Qc_CT_VCC_W = VCC_operation['q_cw_W'] Qc_VCC_W = VCC_operation['q_chw_W'] # calculate cooling tower wdot_CT_Wh = CTModel.calc_CT(Qc_CT_VCC_W, size_chiller_CT) # calcualte energy consumption and variable costs E_used_VCC_W = (VCC_operation['wdot_W'] + wdot_CT_Wh) return Qc_VCC_W, E_used_VCC_W
def calc_vcc_CT_operation(Qc_from_VCC_W, T_DCN_re_K, T_DCN_sup_K, T_source_K): from cea.technologies.constants import G_VALUE_CENTRALIZED # this is where to differentiate chiller performances VCC_operation = chiller_vapor_compression.calc_VCC(Qc_from_VCC_W, T_DCN_sup_K, T_DCN_re_K, T_source_K, G_VALUE_CENTRALIZED) # unpack outputs Qc_CT_VCC_W = VCC_operation['q_cw_W'] Qc_VCC_W = VCC_operation['q_chw_W'] # calculate cooling tower wdot_CT_Wh = CTModel.calc_CT(Qc_CT_VCC_W, Qc_CT_VCC_W) # calcualte energy consumption and variable costs E_used_VCC_W = (VCC_operation['wdot_W'] + wdot_CT_Wh) return Qc_VCC_W, E_used_VCC_W
def calc_vcc_CT_operation(Qc_from_VCC_W, T_DCN_re_K, T_DCN_sup_K, T_source_K, size_chiller_CT, min_VCC_capacity, max_VCC_capacity, scale): g_value = G_VALUE_CENTRALIZED VCC_operation = chiller_vapor_compression.calc_VCC( size_chiller_CT, Qc_from_VCC_W, T_DCN_sup_K, T_DCN_re_K, T_source_K, g_value, min_VCC_capacity, max_VCC_capacity, scale) # unpack outputs Qc_CT_VCC_W = VCC_operation['q_cw_W'] Qc_VCC_W = VCC_operation['q_chw_W'] # calculate cooling tower wdot_CT_Wh = CTModel.calc_CT(Qc_CT_VCC_W, size_chiller_CT) # calcualte energy consumption and variable costs E_used_VCC_W = (VCC_operation['wdot_W'] + wdot_CT_Wh) return Qc_VCC_W, E_used_VCC_W
def coolingMain(locator, configKey, ntwFeat, HRdata, gv): """ Computes the parameters for the cooling of the complete DCN Parameters ---------- locator : string path to res folder configKey : string configuration key for the DHN ntwFeat : class ntwFeatures HRdata : inf 0 if no data heat recovery, 1 if so Returns ------- (costs, co2, prim) : tuple """ ############# Recover the cooling needs # Space cooling previously aggregated in the substation routine df = pd.read_csv( locator.pathNtwRes + "/Network_summary_result_all.csv", usecols=["T_sst_cool_return_netw_total", "mdot_cool_netw_total"]) coolArray = np.nan_to_num(np.array(df)) TsupCool = gv.TsupCool # Data center cooling, (treated separately for each building) df = pd.read_csv(locator.get_total_demand(), usecols=["Name", "Qcdataf_MWhyr"]) arrayData = np.array(df) # Ice hockey rings, (treated separately for each building) df = pd.read_csv(locator.get_total_demand(), usecols=["Name", "Qcref_MWhyr"]) arrayQice = np.array(df) ############# Recover the heat already taken from the lake by the heat pumps try: os.chdir(locator.pathSlaveRes) fNameSlaveRes = configKey + "PPActivationPattern.csv" dfSlave = pd.read_csv(fNameSlaveRes, usecols=["Qcold_HPLake"]) QlakeArray = np.array(dfSlave) Qlake = np.sum(QlakeArray) except: Qlake = 0 Qavail = gv.DeltaU + Qlake print Qavail, "Qavail" ############# Output results costs = ntwFeat.pipesCosts_DCN CO2 = 0 prim = 0 nBuild = int(np.shape(arrayData)[0]) nHour = int(np.shape(coolArray)[0]) CTLoad = np.zeros(nHour) VCCnom = 0 calFactor = 0 TotalCool = 0 ############ Function for cooling operation def coolOperation(dataArray, el, QavailIni, TempSup=0): toTotalCool = 0 toCalfactor = 0 toCosts = 0 toCO2 = 0 toPrim = 0 QavailCopy = QavailIni VCCnomIni = 0 for i in range(el): if TempSup > 0: Tsup = TempSup Tret = dataArray[i][-2] mdot = abs(dataArray[i][-1]) else: Tsup = dataArray[i][-3] + 273 Tret = dataArray[i][-2] + 273 mdot = abs(dataArray[i][-1] * 1E3 / gv.cp) Qneed = abs(mdot * gv.cp * (Tret - Tsup)) toTotalCool += Qneed if QavailCopy - Qneed >= 0: # Free cooling possible from the lake QavailCopy -= Qneed # Delta P from linearization after network optimization deltaP = 2 * (gv.DeltaP_Coeff * mdot + gv.DeltaP_Origin) toCalfactor += deltaP * mdot / 1000 / gv.etaPump toCosts += deltaP * mdot / 1000 * gv.ELEC_PRICE / gv.etaPump toCO2 += deltaP * mdot / 1000 * gv.EL_TO_CO2 / gv.etaPump * 0.0036 toPrim += deltaP * mdot / 1000 * gv.EL_TO_OIL_EQ / gv.etaPump * 0.0036 else: print "Lake exhausted !" wdot, qhotdot = VCCModel.calc_VCC(mdot, Tsup, Tret, gv) if Qneed > VCCnomIni: VCCnomIni = Qneed * (1 + gv.Qmargin_Disc) toCosts += wdot * gv.ELEC_PRICE toCO2 += wdot * gv.EL_TO_CO2 * 3600E-6 toPrim += wdot * gv.EL_TO_OIL_EQ * 3600E-6 CTLoad[i] += qhotdot return toCosts, toCO2, toPrim, toCalfactor, toTotalCool, QavailCopy, VCCnomIni ########## Cooling operation with Circulating pump and VCC print "Space cooling operation" toCosts, toCO2, toPrim, toCalfactor, toTotalCool, QavailCopy, VCCnomIni = coolOperation( coolArray, nHour, Qavail, TempSup=TsupCool) costs += toCosts CO2 += toCO2 prim += toPrim calFactor += toCalfactor TotalCool += toTotalCool VCCnom = max(VCCnom, VCCnomIni) Qavail = QavailCopy print Qavail, "Qavail after space cooling" mdotMax = np.amax(coolArray[:, 1]) costs += PumpModel.Pump_Cost(2 * ntwFeat.DeltaP_DCN, mdotMax, gv.etaPump, gv) if HRdata == 0: print "Data centers cooling operation" for i in range(nBuild): if arrayData[i][1] > 0: buildName = arrayData[i][0] print buildName df = pd.read_csv( locator.get_demand_results_file(buildName), usecols=["Tsdata_C", "Trdata_C", "mcpdata_kWC"]) arrayBuild = np.array(df) mdotMaxData = abs(np.amax(arrayBuild[:, -1]) / gv.cp * 1E3) costs += PumpModel.Pump_Cost(2 * ntwFeat.DeltaP_DCN, mdotMaxData, gv.etaPump, gv) toCosts, toCO2, toPrim, toCalfactor, toTotalCool, QavailCopy, VCCnomIni = coolOperation( arrayBuild, nHour, Qavail) costs += toCosts CO2 += toCO2 prim += toPrim calFactor += toCalfactor TotalCool += toTotalCool VCCnom = max(VCCnom, VCCnomIni) Qavail = QavailCopy print Qavail, "Qavail after data center" print "refrigeration cooling operation" for i in range(nBuild): if arrayQice[i][1] > 0: buildName = arrayQice[i][0] print buildName df = pd.read_csv(locator.pathRaw + "/" + buildName + ".csv", usecols=["Tsref_C", "Trref_C", "mcpref_kWC"]) arrayBuild = np.array(df) mdotMaxice = abs(np.amax(arrayBuild[:, -1]) / gv.cp * 1E3) costs += PumpModel.Pump_Cost(2 * ntwFeat.DeltaP_DCN, mdotMaxice, gv.etaPump, gv) toCosts, toCO2, toPrim, toCalfactor, toTotalCool, QavailCopy, VCCnomIni = coolOperation( arrayBuild, nHour, Qavail) costs += toCosts CO2 += toCO2 prim += toPrim calFactor += toCalfactor TotalCool += toTotalCool VCCnom = max(VCCnom, VCCnomIni) Qavail = QavailCopy print Qavail, "Qavail after ice" print costs, CO2, prim, "operation for cooling" print TotalCool, "TotalCool" ########## Operation of the cooling tower CTnom = np.amax(CTLoad) costCopy = costs if CTnom > 0: for i in range(nHour): wdot = CTModel.calc_CT(CTLoad[i], CTnom, gv) costs += wdot * gv.ELEC_PRICE CO2 += wdot * gv.EL_TO_CO2 * 3600E-6 prim += wdot * gv.EL_TO_OIL_EQ * 3600E-6 print costs - costCopy, "costs after operation of CT" ########## Add investment costs costs += VCCModel.calc_Cinv_VCC(VCCnom, gv) print VCCModel.calc_Cinv_VCC(VCCnom, gv), "InvC VCC" costs += CTModel.calc_Cinv_CT(CTnom, gv) print CTModel.calc_Cinv_CT(CTnom, gv), "InvC CT" ########### Adjust and add the pumps for filtering and pre-treatment of the water calibration = calFactor / 50976000 print calibration, "adjusting factor" extraElec = (127865400 + 85243600) * calibration costs += extraElec * gv.ELEC_PRICE CO2 += extraElec * gv.EL_TO_CO2 * 3600E-6 prim += extraElec * gv.EL_TO_OIL_EQ * 3600E-6 return (costs, CO2, prim)
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 coolingMain(locator, configKey, ntwFeat, HRdata, gv): """ Computes the parameters for the cooling of the complete DCN Parameters ---------- locator : string path to res folder configKey : string configuration key for the DHN ntwFeat : class ntwFeatures HRdata : inf 0 if no data heat recovery, 1 if so Returns ------- (costs, co2, prim) : tuple """ ############# Recover the cooling needs # Space cooling previously aggregated in the substation routine df = pd.read_csv(locator.pathNtwRes + "/Network_summary_result_all.csv", usecols=["T_sst_cool_return_netw_total", "mdot_cool_netw_total"]) coolArray = np.nan_to_num( np.array(df) ) TsupCool = gv.TsupCool # Data center cooling, (treated separately for each building) df = pd.read_csv(locator.get_total_demand(), usecols=["Name", "Qcdataf_MWhyr"]) arrayData = np.array(df) # Ice hockey rings, (treated separately for each building) df = pd.read_csv(locator.get_total_demand(), usecols=["Name", "Qcref_MWhyr"]) arrayQice = np.array(df) ############# Recover the heat already taken from the lake by the heat pumps try: os.chdir(locator.pathSlaveRes) fNameSlaveRes = configKey + "PPActivationPattern.csv" dfSlave = pd.read_csv(fNameSlaveRes, usecols=["Qcold_HPLake"]) QlakeArray = np.array(dfSlave) Qlake = np.sum(QlakeArray) except: Qlake = 0 Qavail = gv.DeltaU + Qlake print Qavail, "Qavail" ############# Output results costs = ntwFeat.pipesCosts_DCN CO2 = 0 prim = 0 nBuild = int( np.shape(arrayData)[0] ) nHour = int( np.shape(coolArray)[0] ) CTLoad = np.zeros(nHour) VCCnom = 0 calFactor = 0 TotalCool = 0 ############ Function for cooling operation def coolOperation(dataArray, el, QavailIni, TempSup = 0): toTotalCool = 0 toCalfactor = 0 toCosts = 0 toCO2 = 0 toPrim = 0 QavailCopy = QavailIni VCCnomIni = 0 for i in range(el): if TempSup > 0: Tsup = TempSup Tret = dataArray[i][-2] mdot = abs ( dataArray[i][-1] ) else: Tsup = dataArray[i][-3] + 273 Tret = dataArray[i][-2] + 273 mdot = abs ( dataArray[i][-1] * 1E3 / gv.cp ) Qneed = abs( mdot * gv.cp * (Tret - Tsup) ) toTotalCool += Qneed if QavailCopy - Qneed >= 0: # Free cooling possible from the lake QavailCopy -= Qneed # Delta P from linearization after network optimization deltaP = 2* (gv.DeltaP_Coeff * mdot + gv.DeltaP_Origin) toCalfactor += deltaP * mdot / 1000 / gv.etaPump toCosts += deltaP * mdot / 1000 * gv.ELEC_PRICE / gv.etaPump toCO2 += deltaP * mdot / 1000 * gv.EL_TO_CO2 / gv.etaPump * 0.0036 toPrim += deltaP * mdot / 1000 * gv.EL_TO_OIL_EQ / gv.etaPump * 0.0036 else: print "Lake exhausted !" wdot, qhotdot = VCCModel.calc_VCC(mdot, Tsup, Tret, gv) if Qneed > VCCnomIni: VCCnomIni = Qneed * (1+gv.Qmargin_Disc) toCosts += wdot * gv.ELEC_PRICE toCO2 += wdot * gv.EL_TO_CO2 * 3600E-6 toPrim += wdot * gv.EL_TO_OIL_EQ * 3600E-6 CTLoad[i] += qhotdot return toCosts, toCO2, toPrim, toCalfactor, toTotalCool, QavailCopy, VCCnomIni ########## Cooling operation with Circulating pump and VCC print "Space cooling operation" toCosts, toCO2, toPrim, toCalfactor, toTotalCool, QavailCopy, VCCnomIni = coolOperation(coolArray, nHour, Qavail, TempSup = TsupCool) costs += toCosts CO2 += toCO2 prim += toPrim calFactor += toCalfactor TotalCool += toTotalCool VCCnom = max(VCCnom, VCCnomIni) Qavail = QavailCopy print Qavail, "Qavail after space cooling" mdotMax = np.amax(coolArray[:,1]) costs += PumpModel.Pump_Cost(2*ntwFeat.DeltaP_DCN, mdotMax, gv.etaPump, gv) if HRdata == 0: print "Data centers cooling operation" for i in range(nBuild): if arrayData[i][1] > 0: buildName = arrayData[i][0] print buildName df = pd.read_csv(locator.get_demand_results_file(buildName), usecols=["Tsdata_C", "Trdata_C", "mcpdata_kWC"]) arrayBuild = np.array(df) mdotMaxData = abs( np.amax(arrayBuild[:,-1]) / gv.cp * 1E3) costs += PumpModel.Pump_Cost(2*ntwFeat.DeltaP_DCN, mdotMaxData, gv.etaPump, gv) toCosts, toCO2, toPrim, toCalfactor, toTotalCool, QavailCopy, VCCnomIni = coolOperation(arrayBuild, nHour, Qavail) costs += toCosts CO2 += toCO2 prim += toPrim calFactor += toCalfactor TotalCool += toTotalCool VCCnom = max(VCCnom, VCCnomIni) Qavail = QavailCopy print Qavail, "Qavail after data center" print "refrigeration cooling operation" for i in range(nBuild): if arrayQice[i][1] > 0: buildName = arrayQice[i][0] print buildName df = pd.read_csv(locator.pathRaw + "/" + buildName + ".csv", usecols=["Tsref_C", "Trref_C", "mcpref_kWC"]) arrayBuild = np.array(df) mdotMaxice = abs( np.amax(arrayBuild[:,-1]) / gv.cp * 1E3) costs += PumpModel.Pump_Cost(2*ntwFeat.DeltaP_DCN, mdotMaxice, gv.etaPump, gv) toCosts, toCO2, toPrim, toCalfactor, toTotalCool, QavailCopy, VCCnomIni = coolOperation(arrayBuild, nHour, Qavail) costs += toCosts CO2 += toCO2 prim += toPrim calFactor += toCalfactor TotalCool += toTotalCool VCCnom = max(VCCnom, VCCnomIni) Qavail = QavailCopy print Qavail, "Qavail after ice" print costs, CO2, prim, "operation for cooling" print TotalCool, "TotalCool" ########## Operation of the cooling tower CTnom = np.amax(CTLoad) costCopy = costs if CTnom > 0 : for i in range(nHour): wdot = CTModel.calc_CT(CTLoad[i], CTnom, gv) costs += wdot * gv.ELEC_PRICE CO2 += wdot * gv.EL_TO_CO2 * 3600E-6 prim += wdot * gv.EL_TO_OIL_EQ * 3600E-6 print costs - costCopy, "costs after operation of CT" ########## Add investment costs costs += VCCModel.calc_Cinv_VCC(VCCnom, gv) print VCCModel.calc_Cinv_VCC(VCCnom, gv), "InvC VCC" costs += CTModel.calc_Cinv_CT(CTnom, gv) print CTModel.calc_Cinv_CT(CTnom, gv), "InvC CT" ########### Adjust and add the pumps for filtering and pre-treatment of the water calibration = calFactor / 50976000 print calibration, "adjusting factor" extraElec = (127865400 + 85243600) * calibration costs += extraElec * gv.ELEC_PRICE CO2 += extraElec * gv.EL_TO_CO2 * 3600E-6 prim += extraElec * gv.EL_TO_OIL_EQ * 3600E-6 return (costs, CO2, prim)
def coolingMain(locator, configKey, ntwFeat, HRdata, gv): """ Computes the parameters for the cooling of the complete DCN :param locator: path to res folder :param configKey: configuration key for the District Heating Network (DHN) :param ntwFeat: network features :param HRdata: Heat recovery data, 0 if no heat recovery data, 1 if so :param gv: global variables :type locator: string :type configKey: string :type ntwFeat: class :type HRdata: int :type gv: class :return: costs, co2, prim :rtype: tuple """ ############# Recover the cooling needs # Space cooling previously aggregated in the substation routine df = pd.read_csv(os.path.join( locator.get_optimization_network_results_folder(), "Network_summary_result_all.csv"), usecols=["T_DCNf_re_K", "mdot_cool_netw_total_kgpers"]) coolArray = np.nan_to_num(np.array(df)) T_sup_Cool_K = gv.TsupCool # Data center cooling, (treated separately for each building) df = pd.read_csv(locator.get_total_demand(), usecols=["Name", "Qcdataf_MWhyr"]) arrayData = np.array(df) # Ice hockey rings, (treated separately for each building) df = pd.read_csv(locator.get_total_demand(), usecols=["Name", "Qcref_MWhyr"]) arrayQice = np.array(df) ############# Recover the heat already taken from the lake by the heat pumps try: os.chdir(locator.get_optimization_slave_results_folder()) fNameSlaveRes = configKey + "PPActivationPattern.csv" dfSlave = pd.read_csv(fNameSlaveRes, usecols=["Qcold_HPLake_W"]) Q_lake_Array_W = np.array(dfSlave) Q_lake_W = np.sum(Q_lake_Array_W) except: Q_lake_W = 0 Q_avail_W = gv.DeltaU + Q_lake_W print Q_avail_W, "Qavail" ############# Output results costs = ntwFeat.pipesCosts_DCN CO2 = 0 prim = 0 nBuild = int(np.shape(arrayData)[0]) nHour = int(np.shape(coolArray)[0]) CT_Load_W = np.zeros(nHour) VCC_nom_W = 0 calFactor = 0 TotalCool = 0 ############ Function for cooling operation def coolOperation(dataArray, el, Q_availIni_W, TempSup=0): """ :param dataArray: :param el: :param Q_availIni_W: :param TempSup: :type dataArray: list :type el: :type Q_availIni_W: float? :type TempSup: :return: toCosts, toCO2, toPrim, toCalfactor, toTotalCool, QavailCopy, VCCnomIni :rtype: float, float, float, float, float, float, float """ toTotalCool = 0 toCalfactor = 0 toCosts = 0 toCO2 = 0 toPrim = 0 Q_availCopy_W = Q_availIni_W VCC_nom_Ini_W = 0 for i in range(el): if TempSup > 0: T_sup_K = TempSup T_re_K = dataArray[i][-2] mdot_kgpers = abs(dataArray[i][-1]) else: T_sup_K = dataArray[i][-3] + 273 T_re_K = dataArray[i][-2] + 273 mdot_kgpers = abs(dataArray[i][-1] * 1E3 / gv.cp) Q_need_W = abs(mdot_kgpers * gv.cp * (T_re_K - T_sup_K)) toTotalCool += Q_need_W if Q_availCopy_W - Q_need_W >= 0: # Free cooling possible from the lake Q_availCopy_W -= Q_need_W # Delta P from linearization after distribution optimization deltaP = 2 * (gv.DeltaP_Coeff * mdot_kgpers + gv.DeltaP_Origin) toCalfactor += deltaP * mdot_kgpers / 1000 / gv.etaPump toCosts += deltaP * mdot_kgpers / 1000 * gv.ELEC_PRICE / gv.etaPump toCO2 += deltaP * mdot_kgpers / 1000 * gv.EL_TO_CO2 / gv.etaPump * 0.0036 toPrim += deltaP * mdot_kgpers / 1000 * gv.EL_TO_OIL_EQ / gv.etaPump * 0.0036 else: print "Lake exhausted !" wdot_W, qhotdot_W = VCCModel.calc_VCC(mdot_kgpers, T_sup_K, T_re_K, gv) if Q_need_W > VCC_nom_Ini_W: VCC_nom_Ini_W = Q_need_W * (1 + gv.Qmargin_Disc) toCosts += wdot_W * gv.ELEC_PRICE toCO2 += wdot_W * gv.EL_TO_CO2 * 3600E-6 toPrim += wdot_W * gv.EL_TO_OIL_EQ * 3600E-6 CT_Load_W[i] += qhotdot_W return toCosts, toCO2, toPrim, toCalfactor, toTotalCool, Q_availCopy_W, VCC_nom_Ini_W ########## Cooling operation with Circulating pump and VCC print "Space cooling operation" toCosts, toCO2, toPrim, toCalfactor, toTotalCool, Q_availCopy_W, VCC_nom_Ini_W = coolOperation( coolArray, nHour, Q_avail_W, TempSup=T_sup_Cool_K) costs += toCosts CO2 += toCO2 prim += toPrim calFactor += toCalfactor TotalCool += toTotalCool VCC_nom_W = max(VCC_nom_W, VCC_nom_Ini_W) Q_avail_W = Q_availCopy_W print Q_avail_W, "Qavail after space cooling" mdot_Max_kgpers = np.amax(coolArray[:, 1]) costs += PumpModel.Pump_Cost(2 * ntwFeat.DeltaP_DCN, mdot_Max_kgpers, gv.etaPump, gv) if HRdata == 0: print "Data centers cooling operation" for i in range(nBuild): if arrayData[i][1] > 0: buildName = arrayData[i][0] print buildName df = pd.read_csv(locator.get_demand_results_file(buildName), usecols=[ "Tcdataf_sup_C", "Tcdataf_re_C", "mcpdataf_kWperC" ]) arrayBuild = np.array(df) mdot_max_Data_kWperC = abs( np.amax(arrayBuild[:, -1]) / gv.cp * 1E3) costs += PumpModel.Pump_Cost(2 * ntwFeat.DeltaP_DCN, mdot_max_Data_kWperC, gv.etaPump, gv) toCosts, toCO2, toPrim, toCalfactor, toTotalCool, Q_availCopy_W, VCC_nom_Ini_W = coolOperation( arrayBuild, nHour, Q_avail_W) costs += toCosts CO2 += toCO2 prim += toPrim calFactor += toCalfactor TotalCool += toTotalCool VCC_nom_W = max(VCC_nom_W, VCC_nom_Ini_W) Q_avail_W = Q_availCopy_W print Q_avail_W, "Qavail after data center" print "refrigeration cooling operation" for i in range(nBuild): if arrayQice[i][1] > 0: buildName = arrayQice[i][0] print buildName df = pd.read_csv(locator.pathRaw + "/" + buildName + ".csv", usecols=["Tsref_C", "Trref_C", "mcpref_kWperC"]) arrayBuild = np.array(df) mdot_max_ice_kgpers = abs(np.amax(arrayBuild[:, -1]) / gv.cp * 1E3) costs += PumpModel.Pump_Cost(2 * ntwFeat.DeltaP_DCN, mdot_max_ice_kgpers, gv.etaPump, gv) toCosts, toCO2, toPrim, toCalfactor, toTotalCool, Q_availCopy_W, VCC_nom_Ini_W = coolOperation( arrayBuild, nHour, Q_avail_W) costs += toCosts CO2 += toCO2 prim += toPrim calFactor += toCalfactor TotalCool += toTotalCool VCC_nom_W = max(VCC_nom_W, VCC_nom_Ini_W) Q_avail_W = Q_availCopy_W print Q_avail_W, "Qavail after ice" print costs, CO2, prim, "operation for cooling" print TotalCool, "TotalCool" ########## Operation of the cooling tower CT_nom_W = np.amax(CT_Load_W) costCopy = costs if CT_nom_W > 0: for i in range(nHour): wdot_W = CTModel.calc_CT(CT_Load_W[i], CT_nom_W, gv) costs += wdot_W * gv.ELEC_PRICE CO2 += wdot_W * gv.EL_TO_CO2 * 3600E-6 prim += wdot_W * gv.EL_TO_OIL_EQ * 3600E-6 print costs - costCopy, "costs after operation of CT" ########## Add investment costs costs += VCCModel.calc_Cinv_VCC(VCC_nom_W, gv) print VCCModel.calc_Cinv_VCC(VCC_nom_W, gv), "InvC VCC" costs += CTModel.calc_Cinv_CT(CT_nom_W, gv) print CTModel.calc_Cinv_CT(CT_nom_W, gv), "InvC CT" ########### Adjust and add the pumps for filtering and pre-treatment of the water calibration = calFactor / 50976000 print calibration, "adjusting factor" extraElec = (127865400 + 85243600) * calibration costs += extraElec * gv.ELEC_PRICE CO2 += extraElec * gv.EL_TO_CO2 * 3600E-6 prim += extraElec * gv.EL_TO_OIL_EQ * 3600E-6 save_file = 1 if save_file == 1: results = pd.DataFrame({ "costs": [costs], "CO2": [CO2], "prim": [prim] }) results.to_csv( locator.get_optimization_slave_pp_activation_cooling_pattern( configKey), sep=',') print "Cooling Results saved in : ", locator.get_optimization_slave_results_folder( ) print " as : ", configKey + "_coolingresults.csv" return (costs, CO2, prim)