def calc_temperatures_emission_systems(bpr, tsd):
"""
Calculate temperature of emission systems.
Using radiator function also for cooling ('radiators.calc_radiator')
Modified from legacy
Gabriel Happle, Feb. 2018
:param bpr: Building Properties
:type bpr: BuildingPropertiesRow
:param tsd: Time series data of building
:type tsd: dict
:return: modifies tsd
:rtype: None
"""
from cea.technologies import radiators, heating_coils, tabs
#
# TEMPERATURES HEATING SYSTEMS
#
if not control_heating_cooling_systems.has_heating_system(
bpr.hvac["class_hs"]):
# if no heating system
tsd['Ths_sys_sup_ahu'] = np.zeros(
HOURS_IN_YEAR
) * np.nan # in C #FIXME: I don't like that non-existing temperatures are 0
tsd['Ths_sys_re_ahu'] = np.zeros(
HOURS_IN_YEAR
) * np.nan # in C #FIXME: I don't like that non-existing temperatures are 0
tsd['mcphs_sys_ahu'] = np.zeros(HOURS_IN_YEAR)
tsd['Ths_sys_sup_aru'] = np.zeros(
HOURS_IN_YEAR
) * np.nan # in C #FIXME: I don't like that non-existing temperatures are 0
tsd['Ths_sys_re_aru'] = np.zeros(
HOURS_IN_YEAR
) * np.nan # in C #FIXME: I don't like that non-existing temperatures are 0
tsd['mcphs_sys_aru'] = np.zeros(HOURS_IN_YEAR)
tsd['Ths_sys_sup_shu'] = np.zeros(
HOURS_IN_YEAR
) * np.nan # in C #FIXME: I don't like that non-existing temperatures are 0
tsd['Ths_sys_re_shu'] = np.zeros(
HOURS_IN_YEAR
) * np.nan # in C #FIXME: I don't like that non-existing temperatures are 0
tsd['mcphs_sys_shu'] = np.zeros(HOURS_IN_YEAR)
elif control_heating_cooling_systems.has_radiator_heating_system(bpr):
# if radiator heating system
Ta_heating_0 = np.nanmax(tsd['ta_hs_set'])
Qhs_sys_0 = np.nanmax(tsd['Qhs_sys']) # in W
tsd['Ths_sys_sup_ahu'] = np.zeros(
HOURS_IN_YEAR
) * np.nan # in C #FIXME: I don't like that non-existing temperatures are 0
tsd['Ths_sys_re_ahu'] = np.zeros(
HOURS_IN_YEAR
) * np.nan # in C #FIXME: I don't like that non-existing temperatures are 0
tsd['mcphs_sys_ahu'] = np.zeros(HOURS_IN_YEAR)
tsd['Ths_sys_sup_aru'] = np.zeros(
HOURS_IN_YEAR
) * np.nan # in C #FIXME: I don't like that non-existing temperatures are 0
tsd['Ths_sys_re_aru'] = np.zeros(
HOURS_IN_YEAR
) * np.nan # in C #FIXME: I don't like that non-existing temperatures are 0
tsd['mcphs_sys_aru'] = np.zeros(HOURS_IN_YEAR)
Ths_sup, Ths_re, mcphs = np.vectorize(radiators.calc_radiator)(
tsd['Qhs_sys'], tsd['T_int'], Qhs_sys_0, Ta_heating_0,
bpr.building_systems['Ths_sup_shu_0'],
bpr.building_systems['Ths_re_shu_0'])
tsd['Ths_sys_sup_shu'] = Ths_sup
tsd['Ths_sys_re_shu'] = Ths_re
tsd['mcphs_sys_shu'] = mcphs
elif control_heating_cooling_systems.has_central_ac_heating_system(bpr):
# ahu
# consider losses according to loads of systems
frac_ahu = [
ahu / sys if sys > 0 else 0
for ahu, sys in zip(tsd['Qhs_sen_ahu'], tsd['Qhs_sen_sys'])
]
qhs_sys_ahu = tsd['Qhs_sen_ahu'] + (tsd['Qhs_em_ls'] +
tsd['Qhs_dis_ls']) * frac_ahu
Qhs_sys_ahu_0 = np.nanmax(qhs_sys_ahu) # in W
index = np.where(qhs_sys_ahu == Qhs_sys_ahu_0)
ma_sup_0 = tsd['ma_sup_hs_ahu'][index[0][0]]
Ta_sup_0 = tsd['ta_sup_hs_ahu'][index[0][0]] + KELVIN_OFFSET
Ta_re_0 = tsd['ta_re_hs_ahu'][index[0][0]] + KELVIN_OFFSET
Ths_sup, Ths_re, mcphs = np.vectorize(heating_coils.calc_heating_coil)(
qhs_sys_ahu, Qhs_sys_ahu_0, tsd['ta_sup_hs_ahu'],
tsd['ta_re_hs_ahu'], bpr.building_systems['Ths_sup_ahu_0'],
bpr.building_systems['Ths_re_ahu_0'], tsd['ma_sup_hs_ahu'],
ma_sup_0, Ta_sup_0, Ta_re_0)
tsd['Ths_sys_sup_ahu'] = Ths_sup # in C
tsd['Ths_sys_re_ahu'] = Ths_re # in C
tsd['mcphs_sys_ahu'] = mcphs
# ARU
# consider losses according to loads of systems
frac_aru = [
aru / sys if sys > 0 else 0
for aru, sys in zip(tsd['Qhs_sen_aru'], tsd['Qhs_sen_sys'])
]
qhs_sys_aru = tsd['Qhs_sen_aru'] + (tsd['Qhs_em_ls'] +
tsd['Qhs_dis_ls']) * frac_aru
Qhs_sys_aru_0 = np.nanmax(qhs_sys_aru) # in W
index = np.where(qhs_sys_aru == Qhs_sys_aru_0)
ma_sup_0 = tsd['ma_sup_hs_aru'][index[0][0]]
Ta_sup_0 = tsd['ta_sup_hs_aru'][index[0][0]] + KELVIN_OFFSET
Ta_re_0 = tsd['ta_re_hs_aru'][index[0][0]] + KELVIN_OFFSET
Ths_sup, Ths_re, mcphs = np.vectorize(heating_coils.calc_heating_coil)(
qhs_sys_aru, Qhs_sys_aru_0, tsd['ta_sup_hs_aru'],
tsd['ta_re_hs_aru'], bpr.building_systems['Ths_sup_aru_0'],
bpr.building_systems['Ths_re_aru_0'], tsd['ma_sup_hs_aru'],
ma_sup_0, Ta_sup_0, Ta_re_0)
tsd['Ths_sys_sup_aru'] = Ths_sup # in C
tsd['Ths_sys_re_aru'] = Ths_re # in C
tsd['mcphs_sys_aru'] = mcphs
# SHU
tsd['Ths_sup_shu'] = np.zeros(
HOURS_IN_YEAR
) * np.nan # in C #FIXME: I don't like that non-existing temperatures are 0
tsd['Ths_sys_re_shu'] = np.zeros(
HOURS_IN_YEAR
) * np.nan # in C #FIXME: I don't like that non-existing temperatures are 0
tsd['mcphs_sys_shu'] = np.zeros(HOURS_IN_YEAR)
elif control_heating_cooling_systems.has_floor_heating_system(bpr):
Ta_heating_0 = np.nanmax(tsd['ta_hs_set'])
Qhs_sys_0 = np.nanmax(tsd['Qhs_sys']) # in W
tsd['Ths_sys_sup_ahu'] = np.zeros(
HOURS_IN_YEAR
) * np.nan # in C #FIXME: I don't like that non-existing temperatures are 0
tsd['Ths_sys_re_ahu'] = np.zeros(
HOURS_IN_YEAR
) * np.nan # in C #FIXME: I don't like that non-existing temperatures are 0
tsd['mcphs_sys_ahu'] = np.zeros(HOURS_IN_YEAR)
tsd['Ths_sys_sup_aru'] = np.zeros(
HOURS_IN_YEAR
) * np.nan # in C #FIXME: I don't like that non-existing temperatures are 0
tsd['Ths_sys_re_aru'] = np.zeros(
HOURS_IN_YEAR
) * np.nan # in C #FIXME: I don't like that non-existing temperatures are 0
tsd['mcphs_sys_aru'] = np.zeros(HOURS_IN_YEAR)
Ths_sup, Ths_re, mcphs = np.vectorize(radiators.calc_radiator)(
tsd['Qhs_sys'], tsd['T_int'], Qhs_sys_0, Ta_heating_0,
bpr.building_systems['Ths_sup_shu_0'],
bpr.building_systems['Ths_re_shu_0'])
tsd['Ths_sys_sup_shu'] = Ths_sup
tsd['Ths_sys_re_shu'] = Ths_re
tsd['mcphs_sys_shu'] = mcphs
else:
raise Exception(
'Heating system not defined in function: "calc_temperatures_emission_systems"'
)
#
# TEMPERATURES COOLING SYSTEMS
#
if not control_heating_cooling_systems.has_cooling_system(
bpr.hvac["class_cs"]):
# if no cooling system
tsd['Tcs_sys_sup_ahu'] = np.zeros(
HOURS_IN_YEAR
) * np.nan # in C #FIXME: I don't like that non-existing temperatures are 0
tsd['Tcs_sys_re_ahu'] = np.zeros(
HOURS_IN_YEAR
) * np.nan # in C #FIXME: I don't like that non-existing temperatures are 0
tsd['mcpcs_sys_ahu'] = np.zeros(HOURS_IN_YEAR)
tsd['Tcs_sys_sup_aru'] = np.zeros(
HOURS_IN_YEAR
) * np.nan # in C #FIXME: I don't like that non-existing temperatures are 0
tsd['Tcs_sys_re_aru'] = np.zeros(
HOURS_IN_YEAR
) * np.nan # in C #FIXME: I don't like that non-existing temperatures are 0
tsd['mcpcs_sys_aru'] = np.zeros(HOURS_IN_YEAR)
tsd['Tcs_sys_sup_scu'] = np.zeros(
HOURS_IN_YEAR
) * np.nan # in C #FIXME: I don't like that non-existing temperatures are 0
tsd['Tcs_sys_re_scu'] = np.zeros(
HOURS_IN_YEAR
) * np.nan # in C #FIXME: I don't like that non-existing temperatures are 0
tsd['mcpcs_sys_scu'] = np.zeros(HOURS_IN_YEAR)
elif control_heating_cooling_systems.has_central_ac_cooling_system(bpr):
# AHU
# consider losses according to loads of systems
frac_ahu = [
ahu / sys if sys < 0 else 0
for ahu, sys in zip(tsd['Qcs_sen_ahu'], tsd['Qcs_sen_sys'])
]
qcs_sys_ahu = tsd['Qcs_sen_ahu'] + tsd['Qcs_lat_ahu'] + (
tsd['Qcs_em_ls'] + tsd['Qcs_dis_ls']) * frac_ahu
Qcs_sys_ahu_0 = np.nanmin(qcs_sys_ahu) # in W
index = np.where(qcs_sys_ahu == Qcs_sys_ahu_0)
ma_sup_0 = tsd['ma_sup_cs_ahu'][index[0][0]]
Ta_sup_0 = tsd['ta_sup_cs_ahu'][index[0][0]] + KELVIN_OFFSET
Ta_re_0 = tsd['ta_re_cs_ahu'][index[0][0]] + KELVIN_OFFSET
Tcs_sup, Tcs_re, mcpcs = np.vectorize(heating_coils.calc_cooling_coil)(
qcs_sys_ahu, Qcs_sys_ahu_0, tsd['ta_sup_cs_ahu'],
tsd['ta_re_cs_ahu'], bpr.building_systems['Tcs_sup_ahu_0'],
bpr.building_systems['Tcs_re_ahu_0'], tsd['ma_sup_cs_ahu'],
ma_sup_0, Ta_sup_0, Ta_re_0)
tsd['Tcs_sys_sup_ahu'] = Tcs_sup # in C
tsd['Tcs_sys_re_ahu'] = Tcs_re # in C
tsd['mcpcs_sys_ahu'] = mcpcs
# ARU
# consider losses according to loads of systems
frac_aru = [
aru / sys if sys < 0 else 0
for aru, sys in zip(tsd['Qcs_sen_aru'], tsd['Qcs_sen_sys'])
]
qcs_sys_aru = tsd['Qcs_sen_aru'] + tsd['Qcs_lat_aru'] + (
tsd['Qcs_em_ls'] + tsd['Qcs_dis_ls']) * frac_aru
Qcs_sys_aru_0 = np.nanmin(qcs_sys_aru) # in W
index = np.where(qcs_sys_aru == Qcs_sys_aru_0)
ma_sup_0 = tsd['ma_sup_cs_aru'][index[0][0]]
Ta_sup_0 = tsd['ta_sup_cs_aru'][index[0][0]] + KELVIN_OFFSET
Ta_re_0 = tsd['ta_re_cs_aru'][index[0][0]] + KELVIN_OFFSET
Tcs_sup, Tcs_re, mcpcs = np.vectorize(heating_coils.calc_cooling_coil)(
qcs_sys_aru, Qcs_sys_aru_0, tsd['ta_sup_cs_aru'],
tsd['ta_re_cs_aru'], bpr.building_systems['Tcs_sup_aru_0'],
bpr.building_systems['Tcs_re_aru_0'], tsd['ma_sup_cs_aru'],
ma_sup_0, Ta_sup_0, Ta_re_0)
tsd['Tcs_sys_sup_aru'] = Tcs_sup # in C
tsd['Tcs_sys_re_aru'] = Tcs_re # in C
tsd['mcpcs_sys_aru'] = mcpcs
# SCU
tsd['Tcs_sys_sup_scu'] = np.zeros(
HOURS_IN_YEAR
) * np.nan # in C #FIXME: I don't like that non-existing temperatures are 0
tsd['Tcs_sys_re_scu'] = np.zeros(
HOURS_IN_YEAR
) * np.nan # in C #FIXME: I don't like that non-existing temperatures are 0
tsd['mcpcs_sys_scu'] = np.zeros(HOURS_IN_YEAR)
elif control_heating_cooling_systems.has_local_ac_cooling_system(bpr):
# AHU
tsd['Tcs_sys_sup_ahu'] = np.zeros(
HOURS_IN_YEAR
) * np.nan # in C #FIXME: I don't like that non-existing temperatures are 0
tsd['Tcs_sys_re_ahu'] = np.zeros(
HOURS_IN_YEAR
) * np.nan # in C #FIXME: I don't like that non-existing temperatures are 0
tsd['mcpcs_sys_ahu'] = np.zeros(HOURS_IN_YEAR)
# ARU
# consider losses according to loads of systems
qcs_sys_aru = tsd['Qcs_sen_aru'] + tsd['Qcs_lat_aru'] + (
tsd['Qcs_em_ls'] + tsd['Qcs_dis_ls'])
qcs_sys_aru = np.nan_to_num(qcs_sys_aru)
# Calc nominal temperatures of systems
Qcs_sys_aru_0 = np.nanmin(qcs_sys_aru) # in W
index = np.where(qcs_sys_aru == Qcs_sys_aru_0)
ma_sup_0 = tsd['ma_sup_cs_aru'][index[0][0]]
Ta_sup_0 = tsd['ta_sup_cs_aru'][index[0][0]] + KELVIN_OFFSET
Ta_re_0 = tsd['ta_re_cs_aru'][index[0][0]] + KELVIN_OFFSET
Tcs_sup, Tcs_re, mcpcs = np.vectorize(heating_coils.calc_cooling_coil)(
qcs_sys_aru, Qcs_sys_aru_0, tsd['ta_sup_cs_aru'],
tsd['ta_re_cs_aru'], bpr.building_systems['Tcs_sup_aru_0'],
bpr.building_systems['Tcs_re_aru_0'], tsd['ma_sup_cs_aru'],
ma_sup_0, Ta_sup_0, Ta_re_0)
tsd['Tcs_sys_sup_aru'] = Tcs_sup # in C
tsd['Tcs_sys_re_aru'] = Tcs_re # in C
tsd['mcpcs_sys_aru'] = mcpcs
# SCU
tsd['Tcs_sys_sup_scu'] = np.zeros(
HOURS_IN_YEAR
) * np.nan # in C #FIXME: I don't like that non-existing temperatures are 0
tsd['Tcs_sys_re_scu'] = np.zeros(
HOURS_IN_YEAR
) * np.nan # in C #FIXME: I don't like that non-existing temperatures are 0
tsd['mcpcs_sys_scu'] = np.zeros(HOURS_IN_YEAR)
elif control_heating_cooling_systems.has_3for2_cooling_system(bpr):
# AHU
# consider losses according to loads of systems
frac_ahu = [
ahu / sys if sys < 0 else 0
for ahu, sys in zip(tsd['Qcs_sen_ahu'], tsd['Qcs_sen_sys'])
]
qcs_sys_ahu = tsd['Qcs_sen_ahu'] + tsd['Qcs_lat_ahu'] + (
tsd['Qcs_em_ls'] + tsd['Qcs_dis_ls']) * frac_ahu
qcs_sys_ahu = np.nan_to_num(qcs_sys_ahu)
Qcs_sys_ahu_0 = np.nanmin(qcs_sys_ahu) # in W
index = np.where(qcs_sys_ahu == Qcs_sys_ahu_0)
ma_sup_0 = tsd['ma_sup_cs_ahu'][index[0][0]]
Ta_sup_0 = tsd['ta_sup_cs_ahu'][index[0][0]] + KELVIN_OFFSET
Ta_re_0 = tsd['ta_re_cs_ahu'][index[0][0]] + KELVIN_OFFSET
Tcs_sup, Tcs_re, mcpcs = np.vectorize(heating_coils.calc_cooling_coil)(
qcs_sys_ahu, Qcs_sys_ahu_0, tsd['ta_sup_cs_ahu'],
tsd['ta_re_cs_ahu'], bpr.building_systems['Tcs_sup_ahu_0'],
bpr.building_systems['Tcs_re_ahu_0'], tsd['ma_sup_cs_ahu'],
ma_sup_0, Ta_sup_0, Ta_re_0)
tsd['Tcs_sys_sup_ahu'] = Tcs_sup # in C
tsd['Tcs_sys_re_ahu'] = Tcs_re # in C
tsd['mcpcs_sys_ahu'] = mcpcs
# ARU
# consider losses according to loads of systems
frac_aru = [
aru / sys if sys < 0 else 0
for aru, sys in zip(tsd['Qcs_sen_aru'], tsd['Qcs_sen_sys'])
]
qcs_sys_aru = tsd['Qcs_sen_aru'] + tsd['Qcs_lat_aru'] + (
tsd['Qcs_em_ls'] + tsd['Qcs_dis_ls']) * frac_aru
qcs_sys_aru = np.nan_to_num(qcs_sys_aru)
# Calc nominal temperatures of systems
Qcs_sys_aru_0 = np.nanmin(qcs_sys_aru) # in W
index = np.where(qcs_sys_aru == Qcs_sys_aru_0)
ma_sup_0 = tsd['ma_sup_cs_aru'][index[0][0]]
Ta_sup_0 = tsd['ta_sup_cs_aru'][index[0][0]] + KELVIN_OFFSET
Ta_re_0 = tsd['ta_re_cs_aru'][index[0][0]] + KELVIN_OFFSET
Tcs_sup, Tcs_re, mcpcs = np.vectorize(heating_coils.calc_cooling_coil)(
qcs_sys_aru, Qcs_sys_aru_0, tsd['ta_sup_cs_aru'],
tsd['ta_re_cs_aru'], bpr.building_systems['Tcs_sup_aru_0'],
bpr.building_systems['Tcs_re_aru_0'], tsd['ma_sup_cs_aru'],
ma_sup_0, Ta_sup_0, Ta_re_0)
tsd['Tcs_sys_sup_aru'] = Tcs_sup # in C
tsd['Tcs_sys_re_aru'] = Tcs_re # in C
tsd['mcpcs_sys_aru'] = mcpcs
# SCU
# consider losses according to loads of systems
frac_scu = [
scu / sys if sys < 0 else 0
for scu, sys in zip(tsd['Qcs_sen_scu'], tsd['Qcs_sen_sys'])
]
qcs_sys_scu = tsd['Qcs_sen_scu'] + (tsd['Qcs_em_ls'] +
tsd['Qcs_dis_ls']) * frac_scu
qcs_sys_scu = np.nan_to_num(qcs_sys_scu)
Qcs_sys_scu_0 = np.nanmin(qcs_sys_scu) # in W
Ta_cooling_0 = np.nanmin(tsd['ta_cs_set'])
Tcs_sup, Tcs_re, mcpcs = np.vectorize(radiators.calc_radiator)(
qcs_sys_scu, tsd['T_int'], Qcs_sys_scu_0, Ta_cooling_0,
bpr.building_systems['Tcs_sup_scu_0'],
bpr.building_systems['Tcs_re_scu_0'])
tsd['Tcs_sys_sup_scu'] = Tcs_sup # in C
tsd['Tcs_sys_re_scu'] = Tcs_re # in C
tsd['mcpcs_sys_scu'] = mcpcs
elif control_heating_cooling_systems.has_ceiling_cooling_system(bpr) or \
control_heating_cooling_systems.has_floor_cooling_system(bpr):
# SCU
# consider losses according to loads of systems
qcs_sys_scu = tsd['Qcs_sen_scu'] + (tsd['Qcs_em_ls'] +
tsd['Qcs_dis_ls'])
qcs_sys_scu = np.nan_to_num(qcs_sys_scu)
Qcs_sys_scu_0 = np.nanmin(qcs_sys_scu) # in W
Ta_cooling_0 = np.nanmin(tsd['ta_cs_set'])
# use radiator for ceiling cooling calculation
Tcs_sup, Tcs_re, mcpcs = np.vectorize(radiators.calc_radiator)(
qcs_sys_scu, tsd['T_int'], Qcs_sys_scu_0, Ta_cooling_0,
bpr.building_systems['Tcs_sup_scu_0'],
bpr.building_systems['Tcs_re_scu_0'])
tsd['Tcs_sys_sup_scu'] = Tcs_sup # in C
tsd['Tcs_sys_re_scu'] = Tcs_re # in C
tsd['mcpcs_sys_scu'] = mcpcs
# AHU
tsd['Tcs_sys_sup_ahu'] = np.zeros(
HOURS_IN_YEAR
) * np.nan # in C #FIXME: I don't like that non-existing temperatures are 0
tsd['Tcs_sys_re_ahu'] = np.zeros(
HOURS_IN_YEAR
) * np.nan # in C #FIXME: I don't like that non-existing temperatures are 0
tsd['mcpcs_sys_ahu'] = np.zeros(HOURS_IN_YEAR)
# ARU
tsd['Tcs_sys_sup_aru'] = np.zeros(
HOURS_IN_YEAR
) * np.nan # in C #FIXME: I don't like that non-existing temperatures are 0
tsd['Tcs_sys_re_aru'] = np.zeros(
HOURS_IN_YEAR
) * np.nan # in C #FIXME: I don't like that non-existing temperatures are 0
tsd['mcpcs_sys_aru'] = np.zeros(HOURS_IN_YEAR)
else:
raise Exception(
'Cooling system not defined in function: "calc_temperatures_emission_systems"'
)
return tsd
def calc_heating_cooling_loads(bpr, tsd, t):
"""
:param bpr:
:param tsd:
:param t:
:return:
"""
# first check for season
if control_heating_cooling_systems.is_heating_season(t, bpr)\
and not control_heating_cooling_systems.is_cooling_season(t, bpr):
# +++++++++++++++++++++++++++++++++++++++++++
# HEATING
# +++++++++++++++++++++++++++++++++++++++++++
# check system
if not control_heating_cooling_systems.has_heating_system(bpr) \
or not control_heating_cooling_systems.heating_system_is_active(tsd, t):
# no system = no loads
rc_model_temperatures = calc_rc_no_loads(bpr, tsd, t)
elif control_heating_cooling_systems.has_radiator_heating_system(bpr)\
or control_heating_cooling_systems.has_floor_heating_system(bpr):
# radiator or floor heating
rc_model_temperatures = calc_heat_loads_radiator(bpr, t, tsd)
tsd['Ehs_lat_aux'][t] = 0 # TODO
# elif has_local_ac_heating_system:
# TODO: here could be a heating system using the mini-split unit ("T5")
elif control_heating_cooling_systems.has_central_ac_heating_system(
bpr):
rc_model_temperatures = calc_heat_loads_central_ac(bpr, t, tsd)
else:
# message and no heating system
warnings.warn(
'Unknown heating system. Calculation without system.')
# no system = no loads
rc_model_temperatures = calc_rc_no_loads(bpr, tsd, t)
# update tsd
update_tsd_no_cooling(tsd, t)
# for dashboard
detailed_thermal_balance_to_tsd(tsd, bpr, t, rc_model_temperatures)
elif control_heating_cooling_systems.is_cooling_season(t, bpr) \
and not control_heating_cooling_systems.is_heating_season(t, bpr):
# +++++++++++++++++++++++++++++++++++++++++++
# COOLING
# +++++++++++++++++++++++++++++++++++++++++++
# check system
if not control_heating_cooling_systems.has_cooling_system(bpr)\
or not control_heating_cooling_systems.cooling_system_is_active(bpr, tsd, t):
# no system = no loads
rc_model_temperatures = calc_rc_no_loads(bpr, tsd, t)
elif control_heating_cooling_systems.has_local_ac_cooling_system(bpr):
rc_model_temperatures = calc_cool_loads_mini_split_ac(bpr, t, tsd)
elif control_heating_cooling_systems.has_central_ac_cooling_system(
bpr):
rc_model_temperatures = calc_cool_loads_central_ac(bpr, t, tsd)
elif control_heating_cooling_systems.has_3for2_cooling_system(bpr):
rc_model_temperatures = calc_cool_loads_3for2(bpr, t, tsd)
elif control_heating_cooling_systems.has_ceiling_cooling_system(bpr) or \
control_heating_cooling_systems.has_floor_cooling_system(bpr):
rc_model_temperatures = calc_cool_loads_radiator(bpr, t, tsd)
else:
# message and no cooling system
warnings.warn(
'Unknown cooling system. Calculation without system.')
# no system = no loads
rc_model_temperatures = calc_rc_no_loads(bpr, tsd, t)
# update tsd
update_tsd_no_heating(tsd, t)
# for dashboard
detailed_thermal_balance_to_tsd(tsd, bpr, t, rc_model_temperatures)
else:
warnings.warn('Timestep %s not in heating season nor cooling season' %
t)
calc_rc_no_loads(bpr, tsd, t)
return
