def calc_set_points(bpr, date, tsd, building_name, config, locator, schedules): # get internal comfort properties tsd = control_heating_cooling_systems.get_temperature_setpoints_incl_seasonality( tsd, bpr, schedules) t_prev = next(get_hours(bpr)) - 1 tsd['T_int'][t_prev] = tsd['T_ext'][t_prev] tsd['x_int'][t_prev] = latent_loads.convert_rh_to_moisture_content( tsd['rh_ext'][t_prev], tsd['T_ext'][t_prev]) return tsd
def central_air_handling_unit_heating(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 heating load that should be achieved, however over-heating is possible Gabriel Happle, Feb. 2018 :param m_ve_mech: :param t_ve_mech_after_hex: :param x_ve_mech: :param bpr: :return: """ # TODO: humidification and its electricity demand # get supply air temperature from system properties t_sup_h_ahu = bpr.hvac['Th_sup_air_ahu_C'] # (C) supply temperature of central ahu t_coil_h_ahu = bpr.hvac['Tshs0_ahu_C'] # (C) coil temperature of central ahu # check if system is operated or bypassed if t_ve_mech_after_hex >= t_sup_h_ahu: # no operation if incoming air temperature is higher than supply qh_sen_ahu = 0.0 # no load because no operation qh_lat_ahu = 0.0 # no load because no operation x_sup_h_ahu = x_ve_mech ma_sup_hs_ahu = 0.0 ta_re_hs_ahu = np.nan ta_sup_hs_ahu = np.nan else: # calculate the max moisture content at the coil temperature x_sup_h_ahu_max = convert_rh_to_moisture_content(100.0, t_coil_h_ahu) # calculate the system sensible cooling power qh_sen_ahu = m_ve_mech * C_A * (t_sup_h_ahu - t_ve_mech_after_hex) # calculate the supply moisture content x_sup_h_ahu = np.min([x_ve_mech, x_sup_h_ahu_max]) # calculate the latent load in terms of water removed g_hu_ahu = m_ve_mech * (x_sup_h_ahu - x_ve_mech) # calculate the latent load in terms of energy qh_lat_ahu = g_hu_ahu * H_WE # temperatures and mass flows ma_sup_hs_ahu = m_ve_mech ta_sup_hs_ahu = t_sup_h_ahu ta_re_hs_ahu = t_ve_mech_after_hex # construct return dict return {'qh_sen_ahu': qh_sen_ahu, 'qh_lat_ahu': qh_lat_ahu, 'x_sup_h_ahu': x_sup_h_ahu, 'ma_sup_hs_ahu' : ma_sup_hs_ahu, 'ta_sup_hs_ahu' : ta_sup_hs_ahu, 'ta_re_hs_ahu' : ta_re_hs_ahu}
def calc_set_points(bpr, date, tsd, building_name, config, locator, schedules): # get internal comfort properties # predefined set points for every given hour can be used to calculate the demand profile for a building # a config flag is used for this, it is present in the config.demand section if config.demand.predefined_hourly_setpoints: tsd = calc_set_point_from_predefined_file(tsd, bpr, date.dayofweek, building_name, locator) else: tsd = control_heating_cooling_systems.get_temperature_setpoints_incl_seasonality(tsd, bpr, schedules) t_prev = get_hours(bpr).next() - 1 tsd['T_int'][t_prev] = tsd['T_ext'][t_prev] tsd['x_int'][t_prev] = latent_loads.convert_rh_to_moisture_content(tsd['rh_ext'][t_prev], tsd['T_ext'][t_prev]) return tsd
def calc_Qhs_Qcs(bpr, date, tsd, use_dynamic_infiltration_calculation, region): # get ventilation flows ventilation_air_flows_simple.calc_m_ve_required(bpr, tsd, region) ventilation_air_flows_simple.calc_m_ve_leakage_simple(bpr, tsd) # get internal comfort properties tsd = control_heating_cooling_systems.calc_simple_temp_control( tsd, bpr, date.dayofweek) # initialize first previous time step t_prev = get_hours(bpr).next() - 1 tsd['T_int'][t_prev] = tsd['T_ext'][t_prev] tsd['x_int'][t_prev] = latent_loads.convert_rh_to_moisture_content( tsd['rh_ext'][t_prev], tsd['T_ext'][t_prev]) # end-use demand calculation for t in get_hours(bpr): # heat flows in [W] tsd = sensible_loads.calc_Qgain_sen(t, tsd, bpr) if use_dynamic_infiltration_calculation: # OVERWRITE STATIC INFILTRATION WITH DYNAMIC INFILTRATION RATE dict_props_nat_vent = ventilation_air_flows_detailed.get_properties_natural_ventilation( bpr) qm_sum_in, qm_sum_out = ventilation_air_flows_detailed.calc_air_flows( tsd['T_int'][t - 1], tsd['u_wind'][t], tsd['T_ext'][t], dict_props_nat_vent) # INFILTRATION IS FORCED NOT TO REACH ZERO IN ORDER TO AVOID THE RC MODEL TO FAIL tsd['m_ve_inf'][t] = max(qm_sum_in / 3600, 1 / 3600) # ventilation air flows [kg/s] ventilation_air_flows_simple.calc_air_mass_flow_mechanical_ventilation( bpr, tsd, t) ventilation_air_flows_simple.calc_air_mass_flow_window_ventilation( bpr, tsd, t) # ventilation air temperature and humidity ventilation_air_flows_simple.calc_theta_ve_mech(bpr, tsd, t) latent_loads.calc_moisture_content_airflows(tsd, t) # heating / cooling demand of building hourly_procedure_heating_cooling_system_load.calc_heating_cooling_loads( bpr, tsd, t) # END OF FOR LOOP return tsd
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 local_air_recirculation_unit_cooling(qc_sen_demand_aru, g_dhu_demand_aru, t_int_prev, x_int_prev, bpr, t_control, x_control): """ the local air recirculation unit recirculates internal air it determines the mass flow of air according to the demand of sensible or latent cooling the air flow can be controlled by sensible OR latent load it has a fixed coil and fixed supply temperature dehumidification/latent cooling is a by product as the ventilation air is supplied at the coil temperature dew point Gabriel Happle, Feb. 2018 :param qc_sen_demand_aru: :param g_dhu_demand_aru: :param t_int_prev: :param x_int_prev: :param bpr: :param t_control: :param x_control: :return: """ # get supply air temperature from system properties t_sup_c_aru = bpr.hvac['Tc_sup_air_aru_C'] # (C) supply temperature of central ahu t_coil_c_aru = bpr.hvac['Tscs0_aru_C'] # (C) coil temperature of central ahu # calculate air mass flow to attain sensible demand m_ve_rec_req_sen = qc_sen_demand_aru / (C_A * (t_sup_c_aru - t_int_prev)) # TODO: take zone temp of t ???? how? # calculate the max moisture content at the coil temperature x_sup_c_aru_max = convert_rh_to_moisture_content(100.0, t_coil_c_aru) # calculate air mass flow to attain latent load m_ve_rec_req_lat = -g_dhu_demand_aru / (x_sup_c_aru_max - x_int_prev) # TODO: take zone x of t ??? how? # determine recirculation air mass flow according to control type if t_control and not x_control: m_ve_rec = m_ve_rec_req_sen elif x_control and not t_control: m_ve_rec = m_ve_rec_req_lat elif t_control and x_control: m_ve_rec = np.max([m_ve_rec_req_sen, m_ve_rec_req_lat]) else: raise Exception('at least one control parameter has to be "True"') # check maximum extractable moisture, prevent value from turning positive for the case of low internal humidity g_dhu_aru_max = np.min( [(total_moisture_in_zone(bpr, x_sup_c_aru_max) - total_moisture_in_zone(bpr, x_int_prev)) / 3600.0, 0.0]) # # determine and return actual behavior qc_sen_aru = m_ve_rec * C_A * (t_sup_c_aru - t_int_prev) x_sup_c_aru = np.min([x_sup_c_aru_max, x_int_prev]) g_dhu_aru_theor = np.min( [m_ve_rec * (x_sup_c_aru - x_int_prev), 0.0]) # TODO: this has to be checked against the kg of water in the room, min. room volume * x_sup_c_aru moisture is possible. g_dhu_aru = np.max([g_dhu_aru_max, g_dhu_aru_theor]) qc_lat_aru = g_dhu_aru * H_WE # temperatures and mass flows ma_sup_cs_aru = m_ve_rec ta_sup_cs_aru = t_sup_c_aru ta_re_cs_aru = t_int_prev return {'qc_sen_aru': qc_sen_aru, 'qc_lat_aru': qc_lat_aru, 'g_dhu_aru': g_dhu_aru, 'ma_sup_cs_aru': ma_sup_cs_aru, 'ta_sup_cs_aru': ta_sup_cs_aru, 'ta_re_cs_aru': ta_re_cs_aru}