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)
