OpenSimula 0.8.9__tar.gz → 0.8.10__tar.gz

{opensimula-0.8.9/src/opensimula.egg-info → opensimula-0.8.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opensimula
-Version: 0.8.9
+Version: 0.8.10
 Summary: Component-based time simulation environment in Python
 Author: Luis Pérez-Lombard, Ismael R. Maestre
 Author-email: "Juan F. Coronel" <jfc@us.es>

{opensimula-0.8.9 → opensimula-0.8.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "opensimula"
-version = "0.8.9"
+version = "0.8.10"
 requires-python = ">=3.12"
 authors = [
   { name="Juan F. Coronel", email="jfc@us.es" },

{opensimula-0.8.9 → opensimula-0.8.10}/src/opensimula/components/Building_surface.py

@@ -12,6 +12,8 @@ from opensimula.Parameters import (
 from opensimula.Variable import Variable
 from opensimula.visual_3D.Polygon_3D import Polygon_3D
 
+SIGMA = 5.670374419e-8  # Stefan-Boltzmann constant, W/m²K⁴
+
 
 class Building_surface(Surface):
     def __init__(self, name, project):
@@ -266,8 +268,10 @@ class Building_surface(Surface):
             self.parameter("ground_material").component.parameter("specific_heat").value
         )
         d_p = math.sqrt((self._k_g_ * periodo_segundos) / (math.pi * rho_g * c_p_g))
-        self._U_hat_ext_ = self._G_w_ * self._k_g_ / math.sqrt(
-            (0.457 * self._B_prime_ + self._d_t_) ** 2 + d_p**2
+        # Periodic external heat transfer coefficient, UNE-EN ISO 13370:2017 (H_pe), per m²
+        P = self.perimeter * self.parameter("exterior_perimeter_fraction").value
+        self._U_hat_ext_ = (
+            self._G_w_ * 0.37 * P * self._k_g_ * math.log(d_p / self._d_t_ + 1) / self.area
         )
 
     def _create_openings_list_(self):
@@ -331,7 +335,7 @@ class Building_surface(Surface):
         # Meterological data
         hor_sol_dif = self._file_met.variable("sol_diffuse").values[time_i]
         hor_sol_dir = self._file_met.variable("sol_direct").values[time_i]
-        T_sky = self._file_met.variable("sky_temperature").values[time_i]
+        self._T_sky = self._file_met.variable("sky_temperature").values[time_i]
 
         # Diffuse solar radiation
         E_dif_sunny = self._file_met.solar_diffuse_rad(
@@ -360,17 +364,44 @@ class Building_surface(Surface):
         q_sol0 = self.radiant_property("alpha", "solar_diffuse", 0) * (E_dif + E_dir)
         self.variable("q_sol0").values[time_i] = q_sol0
         # Mean radiant temperature
-        T_rm = self._F_sky * T_sky + (1 - self._F_sky) * self._T_ext
+        T_rm = self._F_sky * self._T_sky + (1 - self._F_sky) * self._T_ext
         self.variable("T_rm").values[time_i] = T_rm
-        # f_0
         h_rd = self.H_RD * self.radiant_property("alpha", "long_wave", 0)
+        T_s0 = self.variable("T_s0").values[time_i - 1] if time_i > 0 else self._T_ext
+        self._q_lw_corr = self.long_wave_correction(
+            T_s0, self.radiant_property("alpha", "long_wave", 0)
+        )
+        # f_0
         self.f_0 = self.area * (
             -self._p_0_
             - self.parameter("h_cv").value[0] * self._T_ext
             - h_rd * T_rm
             - q_sol0
+            - self._q_lw_corr
         )
 
+    def long_wave_correction(self, T_s0, epsilon):
+        """Exterior long wave gain (W/m²) not included in the linearized exchange
+
+        The building matrices linearize the long wave exchange with the sky and the ground
+        with H_RD (20 °C); the difference with the exact exchange is added explicitly, with
+        the surface temperature of the previous time step.
+
+        Args:
+            T_s0 (float): exterior surface temperature (°C)
+            epsilon (float): long wave emissivity of the exterior surface
+
+        Returns:
+            float: exact minus linearized long wave gain (W/m²)
+        """
+        T_rm = self._F_sky * self._T_sky + (1 - self._F_sky) * self._T_ext
+        exact = epsilon * SIGMA * (
+            self._F_sky * (self._T_sky + 273.15) ** 4
+            + (1 - self._F_sky) * (self._T_ext + 273.15) ** 4
+            - (T_s0 + 273.15) ** 4
+        )
+        return exact - self.H_RD * epsilon * (T_rm - T_s0)
+
     def _calculate_direct_sunny_fraction_(self, time_i):
         if self.project().parameter("shadow_calculation").value == "INSTANT":
             direct_sunny_fraction = self.project().env_3D.get_direct_sunny_fraction(
@@ -426,7 +457,7 @@ class Building_surface(Surface):
             self.variable("q_lwt0").values[time_i] = h_rd * (
                 self.variable("T_rm").values[time_i]
                 - self.variable("T_s0").values[time_i]
-            )
+            ) + self._q_lw_corr
             self.variable("q_lwt1").values[time_i] = (
                 -self.variable("q_cd1").values[time_i]
                 - self.variable("q_cv1").values[time_i]

{opensimula-0.8.9 → opensimula-0.8.10}/src/opensimula/components/DX_unit.py

@@ -1,7 +1,9 @@
 from opensimula.Message import Message
 from opensimula.Parameters import Parameter_float, Parameter_float_list, Parameter_math_exp, Parameter_options, Parameter_boolean
 from opensimula.Component import Component
-from scipy.optimize import fsolve
+from scipy.optimize import fsolve, brentq
+import math
+import psychrolib as sicro
 
 class DX_unit(Component):
     def __init__(self, name, project):
@@ -24,7 +26,7 @@ class DX_unit(Component):
         self.add_parameter(Parameter_math_exp("heating_capacity_expression", "1", "frac"))
         self.add_parameter(Parameter_math_exp("heating_power_expression", "1", "frac"))
         self.add_parameter(Parameter_math_exp("COP_expression", "1", "frac"))
-        self.add_parameter(Parameter_options("dry_coil_model", "SENSIBLE", ["TOTAL", "SENSIBLE"]))
+        self.add_parameter(Parameter_options("dry_coil_model", "SENSIBLE", ["TOTAL", "SENSIBLE", "ADP"]))
         self.add_parameter(Parameter_options("indoor_fan_operation", "CONTINUOUS", ["CONTINUOUS", "CYCLING"]))
         self.add_parameter(Parameter_boolean("power_dry_coil_correction", True))
         self.add_parameter(Parameter_float_list("expression_max_values", [60,30,60,30,1.5,1], "-"))
@@ -41,6 +43,11 @@ class DX_unit(Component):
             errors.append(Message(msg, "ERROR"))
         return errors
         
+    def pre_simulation(self, n_time_steps, delta_t):
+        super().pre_simulation(n_time_steps, delta_t)
+        self._A_0 = None  # Bypass factor constant, calculated at the first cooling call
+        self._T_iwb_dry = None
+
     def get_heating_load(self,T_idb,T_iwb,T_odb,T_owb,F_air,Q_required):
         """
         Q_required: Required heating load
@@ -118,7 +125,11 @@ class DX_unit(Component):
             sensible_capacity = self.parameter("nominal_sensible_cooling_capacity").value
             f = self.parameter("sensible_cooling_capacity_expression").evaluate(var_dic)
             sensible_capacity = sensible_capacity * f
-            if (sensible_capacity > total_capacity):
+            self._T_iwb_dry = None
+            if self.parameter("dry_coil_model").value == "ADP":
+                total_capacity, sensible_capacity = self._adp_capacities(
+                    T_idb, T_iwb, T_odb, T_owb, F_air, total_capacity, sensible_capacity)
+            elif (sensible_capacity > total_capacity):
                 if self.parameter("dry_coil_model").value == "SENSIBLE":
                     total_capacity = sensible_capacity
                 elif self.parameter("dry_coil_model").value == "TOTAL":
@@ -164,7 +175,10 @@ class DX_unit(Component):
         
     def _get_correct_cooling_power(self,total_capacity, sensible_capacity, var_dic):
         power = self.parameter("nominal_cooling_power").value
-        if (sensible_capacity == total_capacity and self.parameter("power_dry_coil_correction").value):
+        if self.parameter("dry_coil_model").value == "ADP":
+            if self._T_iwb_dry is not None and self.parameter("power_dry_coil_correction").value:
+                var_dic["T_iwb"] = self._T_iwb_dry
+        elif (sensible_capacity == total_capacity and self.parameter("power_dry_coil_correction").value):
             T_iwb_min = self._get_min_T_iwb(var_dic)
             var_dic["T_iwb"] = T_iwb_min
         f = self.parameter("cooling_power_expression").evaluate(var_dic)
@@ -180,6 +194,78 @@ class DX_unit(Component):
         root = fsolve(func, var_dic["T_iwb"],xtol=1e-3)
         return root[0]
     
+    # Apparatus dew point (ADP) / bypass factor (BF) dry coil model:
+    # BF = exp(-A_0/m), A_0 from the nominal capacities; the coil is dry when the humidity
+    # ratio of the ADP is not below the inlet one.
+    def _adp_capacities(self, T_idb, T_iwb, T_odb, T_owb, F_air, total_capacity, sensible_capacity):
+        p = self._sim_.props["ATM_PRESSURE"]
+        if getattr(self, "_A_0", None) is None:  # also used outside a simulation
+            self._A_0 = self._get_A_0(p)
+        w_in = sicro.GetHumRatioFromTWetBulb(T_idb, min(T_iwb, T_idb), p)
+        m_air = self._air_mass_flow(T_idb, w_in, F_air, p)
+        w_adp, SHR = self._adp_state(T_idb, w_in, m_air, total_capacity, p)
+        if w_adp >= w_in:  # Dry coil: capacity at the wet bulb of the dry/wet boundary
+            T_iwb_dry = self._get_dry_T_iwb(T_idb, T_iwb, T_odb, T_owb, F_air, m_air, p)
+            var_dic = self._var_state_dic([T_idb, T_iwb_dry, T_odb, T_owb, F_air, 1])
+            total_capacity = (self.parameter("nominal_total_cooling_capacity").value
+                              * self.parameter("total_cooling_capacity_expression").evaluate(var_dic))
+            self._T_iwb_dry = T_iwb_dry
+            return (total_capacity, total_capacity)
+        # Wet coil: the latent capacity cannot exceed that of the ADP model
+        sensible_capacity = max(sensible_capacity, total_capacity * SHR)
+        if sensible_capacity > total_capacity:
+            total_capacity = sensible_capacity
+        return (total_capacity, sensible_capacity)
+
+    def _get_A_0(self, p):
+        T_idb, T_iwb, _ = self.parameter("nominal_cooling_conditions").value
+        Q_tot = self.parameter("nominal_total_cooling_capacity").value
+        Q_sen = self.parameter("nominal_sensible_cooling_capacity").value
+        w_in = sicro.GetHumRatioFromTWetBulb(T_idb, T_iwb, p)
+        m_air = self._air_mass_flow(T_idb, w_in, 1, p)
+        h_in = sicro.GetMoistAirEnthalpy(T_idb, w_in)
+        h_out = h_in - Q_tot / m_air
+        c_p = sicro.GetMoistAirEnthalpy(1, w_in) - sicro.GetMoistAirEnthalpy(0, w_in)
+        T_out = T_idb - Q_sen / (m_air * c_p)
+        w_out = sicro.GetHumRatioFromEnthalpyAndTDryBulb(h_out, T_out)
+        # ADP: the line through inlet and outlet states meets the saturation curve
+        def func(T):
+            return sicro.GetSatHumRatio(T, p) - (w_in + (w_out - w_in) * (T - T_idb) / (T_out - T_idb))
+        T_adp = brentq(func, -40, T_out)
+        BF = (T_out - T_adp) / (T_idb - T_adp)
+        return -math.log(BF) * m_air
+
+    def _air_mass_flow(self, T_idb, w_in, F_air, p):
+        return self.parameter("nominal_air_flow").value * F_air / sicro.GetMoistAirVolume(T_idb, w_in, p)
+
+    def _adp_state(self, T_idb, w_in, m_air, total_capacity, p):
+        """Humidity ratio of the ADP and sensible heat ratio for the given total capacity"""
+        BF = math.exp(-self._A_0 / m_air)
+        h_in = sicro.GetMoistAirEnthalpy(T_idb, w_in)
+        h_adp = h_in - total_capacity / m_air / (1 - BF)
+        if h_adp >= sicro.GetSatAirEnthalpy(T_idb, p):  # No capacity: dry
+            return (sicro.GetSatHumRatio(T_idb, p), 1)
+        if h_adp <= sicro.GetSatAirEnthalpy(-60, p):
+            return (0, 0)
+        T_adp = brentq(lambda T: sicro.GetSatAirEnthalpy(T, p) - h_adp, -60, T_idb)
+        w_adp = sicro.GetSatHumRatio(T_adp, p)
+        h_tin_wadp = sicro.GetMoistAirEnthalpy(T_idb, w_adp)
+        SHR = min((h_tin_wadp - h_adp) / (h_in - h_adp), 1)
+        return (w_adp, SHR)
+
+    def _get_dry_T_iwb(self, T_idb, T_iwb, T_odb, T_owb, F_air, m_air, p):
+        """Inlet wet bulb temperature at which the coil starts to be wet"""
+        def func(T_wb):
+            var_dic = self._var_state_dic([T_idb, T_wb, T_odb, T_owb, F_air, 1])
+            total = (self.parameter("nominal_total_cooling_capacity").value
+                     * self.parameter("total_cooling_capacity_expression").evaluate(var_dic))
+            w = sicro.GetHumRatioFromTWetBulb(T_idb, T_wb, p)
+            return self._adp_state(T_idb, w, m_air, total, p)[0] - w
+        T_wb_min = min(T_iwb, T_idb)
+        if func(T_idb) >= 0:  # Dry even at saturation
+            return T_idb
+        return brentq(func, T_wb_min, T_idb, xtol=1e-3)
+
     def get_fan_power(self, f_load):
         if self.parameter("indoor_fan_operation").value == "CONTINUOUS":
             return self.parameter("indoor_fan_power").value

{opensimula-0.8.9 → opensimula-0.8.10}/src/opensimula/components/HVAC_MZW_system.py

@@ -58,6 +58,7 @@ class HVAC_MZW_system(Component):  # HVAC Multizone Water system
             )
         )
         self.add_parameter(Parameter_math_exp("outdoor_air_fraction", "0", "frac"))
+        self.add_parameter(Parameter_math_exp("outdoor_air_flow", "0", "m³/s"))
         self.add_parameter(Parameter_variable_list("input_variables", []))
         self.add_parameter(Parameter_math_exp("supply_heating_setpoint", "10", "°C"))
         self.add_parameter(Parameter_math_exp("supply_cooling_setpoint", "15", "°C"))
@@ -214,6 +215,16 @@ class HVAC_MZW_system(Component):  # HVAC Multizone Water system
                 f"{self.parameter('name').value}, must define its reheat water system."
             )
             errors.append(Message(msg, "ERROR"))
+        # Test minimum outdoor air given only once
+        if _not_zero(self.parameter("outdoor_air_fraction").value) and _not_zero(
+            self.parameter("outdoor_air_flow").value
+        ):
+            msg = f"{self.parameter('name').value}, outdoor_air_fraction and outdoor_air_flow cannot be used at the same time."
+            errors.append(Message(msg, "ERROR"))
+        # VAV systems get the outdoor air from the return air flow
+        if self.parameter("vav").value and _not_zero(self.parameter("outdoor_air_flow").value):
+            msg = f"{self.parameter('name').value}, outdoor_air_flow cannot be used in VAV systems."
+            errors.append(Message(msg, "ERROR"))
         # Test file_met defined
         if self.project().parameter("simulation_file_met").value == "not_defined":
             msg = f"{self.parameter('name').value}, file_met must be defined in the project 'simulation_file_met'."
@@ -286,6 +297,7 @@ class HVAC_MZW_system(Component):  # HVAC Multizone Water system
         # outdoor air fraction
         self.F_OA_min = self.parameter("outdoor_air_fraction").evaluate(var_dic)
         self.F_OA = self.F_OA_min
+        self.V_OA = self.parameter("outdoor_air_flow").evaluate(var_dic)
         # setpoints
         self.T_heat_sp = self.parameter("supply_heating_setpoint").evaluate(var_dic)
         self.variable("supply_heating_setpoint").values[time_index] = self.T_heat_sp
@@ -350,20 +362,26 @@ class HVAC_MZW_system(Component):  # HVAC Multizone Water system
         # Calculate F_OA based on return air flow
         if self.is_vav:
             self.F_OA = (self.air_flow * self.F_flow_total - v_return) / (self.air_flow* self.F_flow_total)
+        elif self.V_OA > 0:
+            self._set_outdoor_air_from_flow(rho_ZA)
 
-        # Return fan
-        if self.return_fan is None:  # No return fan
-            self.m_return = self.air_flow * (1 - self.F_OA) * rho_ZA
+        # Zone mass balance: the minimum outdoor air is exhausted from the zones
+        self.m_return = self.m_air_supply * (1 - self.F_OA)
+        if self.return_fan is None or self.m_return <= 0:  # No return fan
             self.T_RA = self.T_ZA
         else:
             # Calculate flow fraction in return fan
-            self.m_return = v_return * rho_ZA
             Q_return_fan = self._get_fan_power(
                 "return", self.F_load, v_return/self.return_air_flow
             )
             self.T_RA = Q_return_fan / (self.m_return * self.props["C_PA"]) + self.T_ZA
           
 
+    def _set_outdoor_air_from_flow(self, rho_ZA):
+        # Outdoor air flow given at zone air conditions (the air exhausted from the zones)
+        self.F_OA_min = min(self.V_OA * rho_ZA / self.m_air_supply, 1)
+        self.F_OA = self.F_OA_min
+
     def _calculate_mixed_air(self, f_oa):
         # Mixed air
         self.T_MA, self.w_MA, self.T_MAwb = self._mix_air(f_oa, self.T_OA, self.w_OA, self.T_RA, self.w_RA)
@@ -717,3 +735,10 @@ class HVAC_MZW_system(Component):  # HVAC Multizone Water system
                 self.variable("T_ADP").values[time_index] = self.T_ADP
                 self.variable("epsilon").values[time_index] = self.epsilon
                 self.variable("epsilon_adp").values[time_index] = self.epsilon_adp
+
+
+def _not_zero(expression):
+    try:
+        return float(expression) != 0
+    except ValueError:  # Expression with variables
+        return True

{opensimula-0.8.9 → opensimula-0.8.10}/src/opensimula/components/HVAC_SZW_system.py

@@ -30,6 +30,7 @@ class HVAC_SZW_system(Component):  # HVAC Single Zone Water system
         self.add_parameter(Parameter_float("air_flow", 1, "m³/s", min=0))
         self.add_parameter(Parameter_float("return_air_flow", 1, "m³/s", min=0))
         self.add_parameter(Parameter_math_exp("outdoor_air_fraction", "0", "frac"))
+        self.add_parameter(Parameter_math_exp("outdoor_air_flow", "0", "m³/s"))
         self.add_parameter(Parameter_variable_list("input_variables", []))
         self.add_parameter(Parameter_math_exp("heating_setpoint", "20", "°C"))
         self.add_parameter(Parameter_math_exp("cooling_setpoint", "25", "°C"))
@@ -146,6 +147,12 @@ class HVAC_SZW_system(Component):  # HVAC Single Zone Water system
                 f"{self.parameter('name').value}, must define its heating water system."
             )
             errors.append(Message(msg, "ERROR"))
+        # Test minimum outdoor air given only once
+        if _not_zero(self.parameter("outdoor_air_fraction").value) and _not_zero(
+            self.parameter("outdoor_air_flow").value
+        ):
+            msg = f"{self.parameter('name').value}, outdoor_air_fraction and outdoor_air_flow cannot be used at the same time."
+            errors.append(Message(msg, "ERROR"))
         # Test file_met defined
         if self.project().parameter("simulation_file_met").value == "not_defined":
             msg = f"{self.parameter('name').value}, file_met must be defined in the project 'simulation_file_met'."
@@ -199,6 +206,7 @@ class HVAC_SZW_system(Component):  # HVAC Single Zone Water system
         # outdoor air fraction
         self.F_OA_min = self.parameter("outdoor_air_fraction").evaluate(var_dic)
         self.F_OA = self.F_OA_min
+        self.V_OA = self.parameter("outdoor_air_flow").evaluate(var_dic)
         # setpoints
         self.T_heat_sp = self.parameter("heating_setpoint").evaluate(var_dic)
         self.variable("heating_setpoint").values[time_index] = self.T_heat_sp
@@ -218,10 +226,6 @@ class HVAC_SZW_system(Component):  # HVAC Single Zone Water system
         self.epsilon_adp = 0
         # Initial mass flows
         self.m_air_supply = self.air_flow * self.props["RHO_A"]
-        if self.return_fan is None:  # No return fan
-            self.v_air_return = self.air_flow * (1 - self.F_OA)
-        else:  # Return fan
-            self.v_air_return = self.return_air_flow
 
     def iteration(self, time_index, date, daylight_saving, n_iter):
         super().iteration(time_index, date, daylight_saving, n_iter)
@@ -245,8 +249,11 @@ class HVAC_SZW_system(Component):  # HVAC Single Zone Water system
             self.T_ZA, self.w_ZA / 1000, self.props["ATM_PRESSURE"]
         )
         self.w_RA = self.w_ZA
-        self.m_air_return = self.v_air_return * rho_ZA
-        if self.return_fan is None:  # No return fan
+        if self.V_OA > 0:
+            self._set_outdoor_air_from_flow(rho_ZA)
+        # Zone mass balance: the minimum outdoor air is exhausted from the zone
+        self.m_air_return = self.m_air_supply * (1 - self.F_OA_min)
+        if self.return_fan is None or self.m_air_return <= 0:  # No return fan
             self.Q_return_fan_required = 0
             self.T_RA = self.T_ZA
         else:
@@ -258,6 +265,12 @@ class HVAC_SZW_system(Component):  # HVAC Single Zone Water system
                 self.m_air_return * self.props["C_PA"]
             )
 
+    def _set_outdoor_air_from_flow(self, rho_ZA):
+        # Outdoor air flow given at zone air conditions (the air exhausted from the zone)
+        self.F_OA_min = min(self.V_OA * rho_ZA / self.m_air_supply, 1)
+        if self.parameter("economizer").value == "NO" or self.F_OA < self.F_OA_min:
+            self.F_OA = self.F_OA_min
+
     def _calculate_required_Q(self):
         K_t, F_t = self.space.get_thermal_equation(False)
         Q_supply_fan = self._get_fan_power("supply", self.F_load)
@@ -583,3 +596,10 @@ class HVAC_SZW_system(Component):  # HVAC Single Zone Water system
                 self.variable("T_ADP").values[time_index] = self.T_ADP
                 self.variable("epsilon").values[time_index] = self.epsilon
                 self.variable("epsilon_adp").values[time_index] = self.epsilon_adp
+
+
+def _not_zero(expression):
+    try:
+        return float(expression) != 0
+    except ValueError:  # Expression with variables
+        return True

{opensimula-0.8.9 → opensimula-0.8.10}/src/opensimula/components/Opening.py

@@ -228,8 +228,12 @@ class Opening(Component):
         T_rm = surface.variable("T_rm").values[time_i]
         self.variable("T_rm").values[time_i] = T_rm
         h_rd = self.H_RD * self.radiant_property("alpha", "long_wave", 0)
+        T_s0 = self.variable("T_s0").values[time_i - 1] if time_i > 0 else self._T_ext
+        self._q_lw_corr = surface.long_wave_correction(
+            T_s0, self.radiant_property("alpha", "long_wave", 0)
+        )
         self.f_0 = self.area * (
-            -self.parameter("h_cv").value[0] * self._T_ext - h_rd * T_rm
+            -self.parameter("h_cv").value[0] * self._T_ext - h_rd * T_rm - self._q_lw_corr
         )
         # q_sol0 will be corrected by the building
 
@@ -312,7 +316,7 @@ class Opening(Component):
             self.variable("q_lwt0").values[time_i] = h_rd * (
                 self.variable("T_rm").values[time_i]
                 - self.variable("T_s0").values[time_i]
-            )
+            ) + self._q_lw_corr
             self.variable("q_lwt1").values[time_i] = (
                 +self.variable("q_cd").values[time_i]
                 - self.variable("q_cv1").values[time_i]

{opensimula-0.8.9 → opensimula-0.8.10/src/opensimula.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opensimula
-Version: 0.8.9
+Version: 0.8.10
 Summary: Component-based time simulation environment in Python
 Author: Luis Pérez-Lombard, Ismael R. Maestre
 Author-email: "Juan F. Coronel" <jfc@us.es>

{opensimula-0.8.9 → opensimula-0.8.10}/test/test_Case_600FF.py

@@ -319,6 +319,6 @@ def test_ff_temperature():
 
     T = pro.component("spaces_1").variable("temperature").values
 
-    assert T.mean() == pytest.approx(25.161302336706985)
-    assert T.max() == pytest.approx(65.67212712041555)
-    assert T.min() == pytest.approx(-13.387879316775047)
+    assert T.mean() == pytest.approx(25.393174594921604)
+    assert T.max() == pytest.approx(65.59282242450941)
+    assert T.min() == pytest.approx(-12.419790814021622)

{opensimula-0.8.9 → opensimula-0.8.10}/test/test_Case_610.py

@@ -349,10 +349,10 @@ def test_HVAC_perfect_system():
     peak_heating = load.max()/1000
     peak_cooling = -load.min()/1000
 
-    assert annual_heating == pytest.approx(4.600215347025868)
-    assert annual_cooling == pytest.approx(4.1577184451246785)
-    assert peak_heating == pytest.approx(3.253717666525836)
-    assert peak_cooling == pytest.approx(5.451313222438749)
+    assert annual_heating == pytest.approx(4.463690912071373)
+    assert annual_cooling == pytest.approx(4.184622421932999)
+    assert peak_heating == pytest.approx(3.1410488100839884)
+    assert peak_cooling == pytest.approx(5.470013279897169)
 
 
 def test_interpolated_sunny_fraction():

{opensimula-0.8.9 → opensimula-0.8.10}/test/test_HVAC_DX_Equipment.py

@@ -47,3 +47,24 @@ def test_points():
     assert dry_coil_Q[2] == pytest.approx(0,rel=1e-2)
 
 
+
+
+def test_adp_dry_coil_model():
+    sim = osim.Simulation()
+    pro = sim.new_project("pro")
+    pro.read_dict(case_dict)
+    dx = pro.component("HVAC_equipment")
+    dx.parameter("dry_coil_model").value = "ADP"
+
+    # Nominal conditions: the bypass factor reproduces the nominal sensible heat ratio
+    Q_eq, Q_sen, Q_lat, F_load = dx.get_cooling_load(26.7, 19.4, 35, 25, 1, -6136)
+    assert Q_sen / (Q_sen + Q_lat) == pytest.approx(6136 / 7951, rel=2e-2)
+    # Dry inlet air (26.7 °C, 13 °C wet bulb): dry coil, no latent load
+    Q_eq, Q_sen, Q_lat, F_load = dx.get_cooling_load(26.7, 13, 35, 25, 1, -3000)
+    assert Q_lat == 0
+    assert dx._T_iwb_dry > 13
+    # The latent capacity goes to 0 continuously approaching the dry/wet boundary
+    T_wb = dx._T_iwb_dry
+    lat = [dx.get_cooling_load(26.7, T_wb + dT, 35, 25, 1, -3000)[2] for dT in (0.05, 0.5, 1)]
+    assert 0 <= lat[0] < lat[1] < lat[2]
+    assert lat[0] < 0.1 * lat[2]

{opensimula-0.8.9 → opensimula-0.8.10}/test/test_HVAC_DX_system.py

@@ -373,12 +373,12 @@ def test_HVAC_DX_system_without_vent():
     power = pro.component("system").variable("power").values.sum()/1e6
     annual_latent = pro.component("system").variable("Q_latent").values.sum()/1e6
 
-    assert annual_heating == pytest.approx(3.6308525834349497)
-    assert annual_cooling == pytest.approx(4.979106872785461)
+    assert annual_heating == pytest.approx(3.505853012164859)
+    assert annual_cooling == pytest.approx(5.011342208430301)
     assert peak_heating == pytest.approx(2.749886298191046)
-    assert peak_cooling == pytest.approx(5.697679866477179)
-    assert power == pytest.approx(14.566525249640708)
-    assert annual_latent == pytest.approx(0.05448532861090071)
+    assert peak_cooling == pytest.approx(5.716379241482701)
+    assert power == pytest.approx(14.432399666361574)
+    assert annual_latent == pytest.approx(0.054370526548591265)
     
 
 def test_HVAC_DX_system_with_vent():
@@ -400,10 +400,10 @@ def test_HVAC_DX_system_with_vent():
     annual_latent = pro.component("system").variable("Q_latent").values.sum()/1e6
     print(annual_heating,annual_cooling,peak_heating,peak_cooling,power,annual_latent)
 
-    assert annual_heating == pytest.approx(6.546162001592287)
-    assert annual_cooling == pytest.approx(4.064545377360391)
-    assert peak_heating == pytest.approx(4.013157255693249)
-    assert peak_cooling == pytest.approx(5.378485230257034)
-    assert power == pytest.approx(16.706104000254026)
-    assert annual_latent == pytest.approx(0.07588788128726585)
+    assert annual_heating == pytest.approx(6.413918255026011)
+    assert annual_cooling == pytest.approx(4.0843062420685365)
+    assert peak_heating == pytest.approx(3.9487898560161283)
+    assert peak_cooling == pytest.approx(5.397096853455196)
+    assert power == pytest.approx(16.614980023519852)
+    assert annual_latent == pytest.approx(0.0753997559884013)
 

{opensimula-0.8.9 → opensimula-0.8.10}/test/test_HVAC_FAN_COIL_water_system.py

@@ -376,12 +376,12 @@ def test_HVAC_FAN_COIL_water_system():
     peak_heating = Q_sens.max() / 1000
     peak_cooling = -Q_sens.min() / 1000
 
-    assert annual_heating == pytest.approx(0.06385026130900037, rel=1e-5)
-    assert annual_cooling == pytest.approx(4.84214845930499, rel=1e-5)
-    assert annual_humidification == pytest.approx(0.5802388327831097, rel=1e-5)
+    assert annual_heating == pytest.approx(0.05794164810570399, rel=1e-5)
+    assert annual_cooling == pytest.approx(4.841634385823313, rel=1e-5)
+    assert annual_humidification == pytest.approx(0.5815140376898394, rel=1e-5)
     assert annual_dehumidification == pytest.approx(0.0)
-    assert peak_heating == pytest.approx(2.52316442850628, rel=1e-5)
-    assert peak_cooling == pytest.approx(5.531297059385839, rel=1e-5)
+    assert peak_heating == pytest.approx(2.4139930539173866, rel=1e-5)
+    assert peak_cooling == pytest.approx(5.52532910869739, rel=1e-5)
 
     yearly_df = water.variable_dataframe(
         frequency="yearly", value="sum", pos_neg_columns=["Q_gen"]
@@ -389,13 +389,13 @@ def test_HVAC_FAN_COIL_water_system():
     heating_generation = yearly_df["Q_gen_pos"].values[0] / 1e6
     cooling_generation = yearly_df["Q_gen_neg"].values[0] / 1e6
 
-    assert heating_generation == pytest.approx(0.06564630834915086, rel=1e-5)
-    assert cooling_generation == pytest.approx(-4.935146136630207, rel=1e-5)
+    assert heating_generation == pytest.approx(0.05987756110752762, rel=1e-5)
+    assert cooling_generation == pytest.approx(-4.934717594594343, rel=1e-5)
 
     T_WGO = water.variable("T_WGO").values
     T_WGI = water.variable("T_WGI").values
 
-    assert T_WGO.max() == pytest.approx(50.53477212415523, rel=1e-5)
+    assert T_WGO.max() == pytest.approx(50.848459465012894, rel=1e-5)
     assert T_WGO.min() == pytest.approx(7.0)
-    assert T_WGI.max() == pytest.approx(50.57068717973014, rel=1e-5)
-    assert T_WGI.min() == pytest.approx(7.041926599097343, rel=1e-5)
+    assert T_WGI.max() == pytest.approx(50.876345651587265, rel=1e-5)
+    assert T_WGI.min() == pytest.approx(7.041357495923282, rel=1e-5)

{opensimula-0.8.9 → opensimula-0.8.10}/test/test_Project.py

@@ -1,3 +1,4 @@
+import pytest
 import opensimula as osim
 
 p1_dic = {
@@ -220,3 +221,41 @@ def test_opening_surface_type():
     assert surface_type_errors() == []
     wall.parameter("surface_type").value = "UNDERGROUND"
     assert len(surface_type_errors()) == 1
+
+
+def test_outdoor_air_flow_or_fraction():
+    sim = osim.Simulation()
+    sim.console_print = False
+    p1 = sim.new_project("Project 1")
+    szw = p1.new_component("HVAC_SZW_system", "szw")
+    mzw = p1.new_component("HVAC_MZW_system", "mzw")
+
+    def outdoor_air_errors():
+        return [e for e in p1.check() if "outdoor_air" in e.text]
+
+    assert outdoor_air_errors() == []
+    for system in (szw, mzw):
+        system.parameter("outdoor_air_fraction").value = "0.3"
+        system.parameter("outdoor_air_flow").value = 0.1
+    assert len(outdoor_air_errors()) == 2
+    for system in (szw, mzw):
+        system.parameter("outdoor_air_fraction").value = 0
+    mzw.parameter("vav").value = True
+    assert len(outdoor_air_errors()) == 1
+
+
+def test_long_wave_correction():
+    sim = osim.Simulation()
+    p1 = sim.new_project("Project 1")
+    wall = p1.new_component("Building_surface", "wall")
+    wall._F_sky = 0.5
+    # Around 20 °C the linearized exchange is exact
+    wall._T_sky, wall._T_ext = 19.0, 20.0
+    assert abs(wall.long_wave_correction(20.5, 0.9)) < 0.01
+    # In winter the linearized exchange (H_RD at 20 °C) overestimates the loss to the sky
+    wall._T_sky, wall._T_ext = -20.0, 0.0
+    T_s0 = -2.0
+    T_rm = 0.5 * -20.0 + 0.5 * 0.0
+    linear = wall.H_RD * 0.9 * (T_rm - T_s0)
+    assert wall.long_wave_correction(T_s0, 0.9) > 0
+    assert wall.long_wave_correction(T_s0, 0.9) / -linear == pytest.approx(0.29, abs=0.02)