def calc_m_ve_required(bpr, tsd):
"""
Calculate required outdoor air ventilation rate according to occupancy
Author: Legacy
Date: old
:param tsd: Timestep data
:type tsd: Dict[str, numpy.ndarray]
:return: updates tsd
"""
m_ve_required_people = (tsd['ve']/3.6) * physics.calc_rho_air(tsd['T_ext'][:]) * 0.001 # kg/s
if control_heating_cooling_systems.has_3for2_cooling_system(bpr) \
or control_heating_cooling_systems.has_central_ac_cooling_system(bpr):
# 0.6 l/s/m2 minimum ventilation rate according to Singapore standard SS 553
# air conditioning systems supply the higher rate between minimum flow per area and required ventilation for
# people during occupied hours. The minimum flow rate ensures dilution of pollutants inside the building
# This applies to buildings with air-conditioning systems for cooling
# [https://escholarship.org/content/qt7k1796zv/qt7k1796zv.pdf]
m_ve_required_min = constants.MIN_VENTILATION_RATE * bpr.rc_model['Af'] * physics.calc_rho_air(tsd['T_ext'][:]) * 0.001 # kg/s
# we want this not to affect the air flows during the heating season
m_ve_required = []
for t in range(0, HOURS_IN_YEAR):
if 0.0 < m_ve_required_people[t] < m_ve_required_min[t] and \
control_heating_cooling_systems.is_cooling_season(t, bpr):
m_ve_required.append(m_ve_required_min[t])
else:
m_ve_required.append(m_ve_required_people[t])
#m_ve_required = [req_min if 0.0 < req_peop < req_min else req_peop for req_min, req_peop in zip(m_ve_required_min, m_ve_required_people)]
m_ve_required = np.asarray(m_ve_required) # convert list to array
else:
m_ve_required = m_ve_required_people
tsd['m_ve_required'] = m_ve_required
return
def central_air_handling_unit_cooling(m_ve_mech, t_ve_mech_after_hex, x_ve_mech, bpr):
"""
the central air handling unit acts on the mechanical ventilation air stream
it has a fixed coil and fixed supply temperature
the input is the cooling load that should be achieved, however over-cooling is possible
dehumidification/latent cooling is a by product as the ventilation air is supplied at the coil temperature dew point
Gabriel Happle, Feb. 2018
:param m_ve_mech:
:param t_ve_mech_after_hex:
:param x_ve_mech:
:param bpr:
:return:
"""
# look up supply and coil temperatures according to system
if control_heating_cooling_systems.has_3for2_cooling_system(bpr) \
or control_heating_cooling_systems.has_central_ac_cooling_system(bpr):
t_sup_c_ahu = bpr.hvac['Tc_sup_air_ahu_C'] # (C) supply temperature of central ahu
t_coil_c_ahu = bpr.hvac['Tscs0_ahu_C'] # (C) coil temperature of central ahu
else:
raise Exception('Not enough parameters specified for cooling system: %s' % bpr.hvac['type_cs'])
# check if system is operated or bypassed
if t_ve_mech_after_hex <= t_sup_c_ahu: # no operation if incoming air temperature is lower than supply
qc_sen_ahu = 0.0 # no load because no operation
qc_lat_ahu = 0.0 # no load because no operation
x_sup_c_ahu = x_ve_mech
# temperatures and mass flows
ma_sup_cs_ahu = 0.0
ta_sup_cs_ahu = np.nan
ta_re_cs_ahu = np.nan
# TODO: check potential 3for2 operation in non-humid climates. According to Lukas...
# AHU might only be operated when dehumidification is necessary
# i.e., it could even be possible to bypass the system with 30C hot outdoor air
else:
# calculate the max moisture content at the coil temperature
x_sup_c_ahu_max = convert_rh_to_moisture_content(100.0, t_coil_c_ahu)
# calculate the system sensible cooling power
qc_sen_ahu = m_ve_mech * C_A * (t_sup_c_ahu - t_ve_mech_after_hex)
# calculate the supply moisture content
x_sup_c_ahu = np.min([x_ve_mech, x_sup_c_ahu_max])
# calculate the latent load in terms of water removed
g_dhu_ahu = m_ve_mech * (x_sup_c_ahu - x_ve_mech)
# calculate the latent load in terms of energy
qc_lat_ahu = g_dhu_ahu * H_WE
# temperatures and mass flows
ma_sup_cs_ahu = m_ve_mech
ta_sup_cs_ahu = t_sup_c_ahu
ta_re_cs_ahu = t_ve_mech_after_hex
# construct return dict
return {'qc_sen_ahu': qc_sen_ahu, 'qc_lat_ahu': qc_lat_ahu, 'x_sup_c_ahu': x_sup_c_ahu,
'ma_sup_cs_ahu': ma_sup_cs_ahu, 'ta_sup_cs_ahu': ta_sup_cs_ahu, 'ta_re_cs_ahu': ta_re_cs_ahu}
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
