OpenSimula 0.3.2__tar.gz → 0.4.1__tar.gz

{opensimula-0.3.2 → opensimula-0.4.1}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 Juan F. Coronel
+Copyright (c) 2025 Juan F. Coronel
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{opensimula-0.3.2 → opensimula-0.4.1}/OpenSimula.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: OpenSimula
-Version: 0.3.2
+Version: 0.4.1
 Summary: Component-based time simulation environment in Python
 Author-email: "Juan F. Coronel" <jfc@us.es>
 Project-URL: Homepage, http://opensimula.org

{opensimula-0.3.2 → opensimula-0.4.1}/OpenSimula.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ docs/cinder/__init__.py
 mkdocs/cinder/__init__.py
 src/OpenSimula/Child.py
 src/OpenSimula/Component.py
+src/OpenSimula/Iterative_process.py
 src/OpenSimula/Parameter_container.py
 src/OpenSimula/Parameters.py
 src/OpenSimula/Project.py
@@ -52,5 +53,6 @@ test/test_File_data.py
 test/test_File_met.py
 test/test_HVAC_DX_Equipment.py
 test/test_HVAC_DX_system.py
+test/test_Iterative_process.py
 test/test_Project.py
 test/test_Schedules.py

{opensimula-0.3.2 → opensimula-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: OpenSimula
-Version: 0.3.2
+Version: 0.4.1
 Summary: Component-based time simulation environment in Python
 Author-email: "Juan F. Coronel" <jfc@us.es>
 Project-URL: Homepage, http://opensimula.org

{opensimula-0.3.2 → opensimula-0.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ requires = ["setuptools>=61.2", "wheel"]
 
 [project]
 name = "OpenSimula"
-version = "0.3.2"
+version = "0.4.1"
 authors = [
   { name="Juan F. Coronel", email="jfc@us.es" },
 ]

opensimula-0.4.1/src/OpenSimula/Iterative_process.py

@@ -0,0 +1,43 @@
+import math
+
+class Iterative_process:
+    def __init__(self, x_0, tol = 1e-5, lambda_min=0.1, lambda_max=1.0, n_ini_relax=2,rel_vel = 0.9):
+        """
+        Iterative process using the fixed-point method with adaptive relaxation coefficient
+    
+        Parameters:
+        x_0: Initial value
+        tol: convergence tolerance
+        lambda_min, lambda_max: relaxation coefficient range
+        n_ini_relax: Number of iterations in which adaptive relaxation is initiated, must be greater than 1
+        """
+        self.x = [x_0]
+        self.tol = tol
+        self.lambda_min = lambda_min
+        self.lambda_max = lambda_max
+        self.lambda_i = lambda_max
+        self.n_ini_relax = n_ini_relax
+        self.rel_vel = rel_vel
+
+        
+    def converged(self):
+        if len(self.x) == 1:
+            return False
+        else:
+            if abs(self.x[-1]-self.x[-2]) < self.tol:
+                return True
+            else:
+                return False
+
+    def x_next(self, proposed_x):
+        x_next = (1 - self.lambda_i) * self.x[-1] + self.lambda_i * proposed_x
+        
+        # Ajuste dinámico de lambda (reduce si hay oscilaciones)
+        if len(self.x)>self.n_ini_relax:
+            #if abs(x_next - self.x[-1]) > abs(self.x[-1]- self.x[-2]):
+                self.lambda_i = max(self.lambda_min, self.lambda_i * self.rel_vel)  # Reducimos lambda
+            #else:
+                #self.lambda_i = min(self.lambda_max, self.lambda_i * 1/self.rel_vel)  # Aumentamos lambda
+
+        self.x.append(x_next)
+        return x_next

{opensimula-0.3.2 → opensimula-0.4.1}/src/OpenSimula/Project.py

@@ -360,6 +360,7 @@ class Project(Parameter_container):
         self._sim_df = pd.DataFrame({"dates":self.dates()})
         self._sim_df["n_iterations"] = 0
         self._sim_df["last_component"] = "None"
+        self._sim_df["converged"] = True
 
         self._sim_.print(f"Simulating {self.parameter('name').value}: ...")
 
@@ -383,11 +384,15 @@ class Project(Parameter_container):
                     converge = True
                 n_iter += 1
             self._sim_df.at[i, "n_iterations"] = n_iter
+            self._sim_df.at[i, "converged"] = converge
             n_iter_acum += n_iter
             self._post_iteration_(i, date, daylight_saving, converge)
             date = date + dt.timedelta(0, delta_t)
 
         self._sim_.print("Simulation completed.")
+        n_not_converged = len(self._sim_df["converged"]) - self._sim_df["converged"].sum()
+        if n_not_converged > 0:
+            self._sim_.print(f"Warning: {n_not_converged} time steps did not converge.")
         self._post_simulation_()
 
     def _pre_simulation_(self, n_time_steps, delta_t):

{opensimula-0.3.2 → opensimula-0.4.1}/src/OpenSimula/__init__.py

@@ -4,4 +4,5 @@ OpenSimula is a Python Package for perform time simulations
 
 """
 from OpenSimula.Simulation import Simulation
-VERSION = "0.3.2"
+from OpenSimula.Iterative_process import Iterative_process
+VERSION = "0.4.1"

{opensimula-0.3.2 → opensimula-0.4.1}/src/OpenSimula/components/File_met.py

@@ -239,17 +239,21 @@ class File_met(Component):
             variable).values[time_i] = array[i] * (1 - f) + array[j] * f
 
     def _get_solar_interpolation_tuple_(self, datetime, solar_hour):
-        day = datetime.timetuple().tm_yday  # Día del año
+        day = datetime.timetuple().tm_yday  # Day of the year
+        if (solar_hour - datetime.hour > 10): # solar hour from previous day
+            day = day - 1
+        elif (solar_hour - datetime.hour < -10): # solar hour next day
+            day = day + 1
         # El primer valor es a las 00:30
         index = solar_hour + (day-1)*24
         if index < 0:
-            index = index + 8760
+            index = 0
         elif index >= 8760:
-            index = index - 8760
+            index = 8760
         i = math.floor(index)
         j = i + 1
         if j >= 8760:
-            j = 0
+            j = 8760
         f = index - i
         return (i, j, f)
 

{opensimula-0.3.2 → opensimula-0.4.1}/src/OpenSimula/components/HVAC_DX_equipment.py

@@ -11,8 +11,7 @@ class HVAC_DX_equipment(Component):
         self.add_parameter(Parameter_float("nominal_total_cooling_capacity", 0, "W", min=0))
         self.add_parameter(Parameter_float("nominal_sensible_cooling_capacity", 0, "W", min=0))
         self.add_parameter(Parameter_float("nominal_cooling_power", 0, "W", min=0))
-        self.add_parameter(Parameter_float("no_load_power", 0, "W", min=0))
-        self.add_parameter(Parameter_float("no_load_heat", 0, "W", min=0))
+        self.add_parameter(Parameter_float("indoor_fan_power", 0, "W", min=0))
         self.add_parameter(Parameter_float_list("nominal_cooling_conditions", [27, 19, 35], "ºC"))
         self.add_parameter(Parameter_math_exp("total_cooling_capacity_expression", "1", "frac"))
         self.add_parameter(Parameter_math_exp("sensible_cooling_capacity_expression", "1", "frac"))
@@ -25,6 +24,7 @@ class HVAC_DX_equipment(Component):
         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("indoor_fan_operation", "CONTINUOUS", ["CONTINUOUS", "CICLING"]))
         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], "-"))
         self.add_parameter(Parameter_float_list("expression_min_values", [0,0,-30,-30,0,0], "-"))
@@ -39,6 +39,11 @@ class HVAC_DX_equipment(Component):
         return errors
     
     def get_cooling_capacity(self,T_idb,T_iwb,T_odb,T_owb,F_air):
+        """
+        Returns (Q_tot,Q_sen) capacities. 
+        If indoor_fan_operation is CONTINUOUS: It returns the values from the expressions (Gross capacity = Coil capacity)
+        If indoor_fan_operation is CICLING: It returns the expressions minus the indoor fan power (Net capacity = Gross capacity - indoor fan)  
+        """
         total_capacity = self.parameter("nominal_total_cooling_capacity").value
         if total_capacity > 0:
             # variables dictonary
@@ -55,24 +60,39 @@ class HVAC_DX_equipment(Component):
                     total_capacity = sensible_capacity
                 elif self.parameter("dry_coil_model").value == "TOTAL":
                     sensible_capacity = total_capacity
+            if self.parameter("indoor_fan_operation").value == "CICLING":
+                sensible_capacity = sensible_capacity - self.parameter("indoor_fan_power").value
+                total_capacity = total_capacity - self.parameter("indoor_fan_power").value
             return (total_capacity, sensible_capacity)
         else:
             return (0,0)
     
     def get_heating_capacity(self,T_idb,T_iwb,T_odb,T_owb,F_air):
+        """
+        Returns heat sensible capacity. 
+        If indoor_fan_operation is CONTINUOUS: It returns the values from the expressions (Gross capacity = Coil capacity)
+        If indoor_fan_operation is CICLING: It returns the expressions plus the indoor fan power (Net capacity = Gross capacity + indoor fan)  """
         capacity = self.parameter("nominal_heating_capacity").value
         if capacity > 0:
             # variables dictonary
             var_dic = self._var_state_dic([T_idb, T_iwb,T_odb,T_owb,F_air,0])
             # Capacity
             capacity = capacity * self.parameter("heating_capacity_expression").evaluate(var_dic)
+            if self.parameter("indoor_fan_operation").value == "CICLING":
+                capacity = capacity + self.parameter("indoor_fan_power").value
             return capacity
         else:
             return 0
     
     def get_cooling_state(self,T_idb,T_iwb,T_odb,T_owb,F_air,F_load):
+        """
+        Returns (Q_tot,Q_sen,Power,F_EER).
+        """
         total_capacity, sensible_capacity = self.get_cooling_capacity(T_idb,T_iwb,T_odb,T_owb,F_air)
         if total_capacity > 0:
+            if self.parameter("indoor_fan_operation").value == "CICLING": # Get gross capacities
+                total_capacity= total_capacity + self.parameter("indoor_fan_power").value
+                sensible_capacity= sensible_capacity + self.parameter("indoor_fan_power").value
             if (F_load > 0):
                 # variables dictonary
                 var_dic = self._var_state_dic([T_idb, T_iwb,T_odb,T_owb,F_air,F_load])
@@ -82,10 +102,16 @@ class HVAC_DX_equipment(Component):
                 EER_full = total_capacity/power_full
                 F_EER = self.parameter("EER_expression").evaluate(var_dic) 
                 EER = EER_full * F_EER 
-                power = total_capacity*F_load/EER + self.parameter("no_load_power").value
+                if self.parameter("indoor_fan_operation").value == "CONTINUOUS":
+                    power = total_capacity*F_load/EER + self.parameter("indoor_fan_power").value
+                elif self.parameter("indoor_fan_operation").value == "CICLING":
+                    power = total_capacity*F_load/EER + self.parameter("indoor_fan_power").value*F_load/F_EER 
                 return (total_capacity*F_load, sensible_capacity*F_load, power, F_EER)
             else:
-                return ( 0 , 0 , self.parameter("no_load_power").value, 0 )
+                if self.parameter("indoor_fan_operation").value == "CONTINUOUS":
+                    return ( 0 , 0 , self.parameter("indoor_fan_power").value, 0 )
+                elif self.parameter("indoor_fan_operation").value == "CICLING":
+                    return ( 0 , 0 , 0, 0 )
         else:
             return (0,0,0,0)
         
@@ -110,6 +136,8 @@ class HVAC_DX_equipment(Component):
     def get_heating_state(self,T_idb, T_iwb,T_odb,T_owb,F_air,F_load):
         capacity = self.get_heating_capacity(T_idb, T_iwb, T_odb,T_owb,F_air)
         if capacity > 0:
+            if self.parameter("indoor_fan_operation").value == "CICLING": # Get gross capacities
+                capacity= capacity - self.parameter("indoor_fan_power").value
             if (F_load > 0):
                 # variables dictonary
                 var_dic = self._var_state_dic([T_idb, T_iwb,T_odb,T_owb,F_air,F_load])
@@ -119,12 +147,24 @@ class HVAC_DX_equipment(Component):
                 COP_full = capacity/power_full
                 F_COP = self.parameter("COP_expression").evaluate(var_dic) 
                 COP = COP_full * F_COP
-                power = capacity*F_load/COP + + self.parameter("no_load_power").value
+                if self.parameter("indoor_fan_operation").value == "CONTINUOUS":
+                    power = capacity*F_load/COP + self.parameter("indoor_fan_power").value
+                elif self.parameter("indoor_fan_operation").value == "CICLING":
+                    power = capacity*F_load/COP + self.parameter("indoor_fan_power").value*F_load/F_COP
                 return (capacity*F_load, power, F_COP)
             else:
-                return (0,self.parameter("no_load_power").value, 0)
+                if self.parameter("indoor_fan_operation").value == "CONTINUOUS":
+                    return ( 0 , 0 , self.parameter("indoor_fan_power").value, 0 )
+                elif self.parameter("indoor_fan_operation").value == "CICLING":
+                    return ( 0 , 0 , 0, 0 )
         else:
             return (0,0,0)
+        
+    def get_no_load_power(self):
+        if self.parameter("indoor_fan_operation").value == "CONTINUOUS":
+            return self.parameter("indoor_fan_power").value
+        elif self.parameter("indoor_fan_operation").value == "CICLING":
+            return 0
     
     def _var_state_dic(self, values):
         max = self.parameter("expression_max_values").value

{opensimula-0.3.2 → opensimula-0.4.1}/src/OpenSimula/components/HVAC_DX_system.py

@@ -1,6 +1,7 @@
 from OpenSimula.Parameters import Parameter_component, Parameter_float, Parameter_variable_list, Parameter_math_exp, Parameter_options
 from OpenSimula.Component import Component
 from OpenSimula.Variable import Variable
+from OpenSimula.Iterative_process import Iterative_process
 import psychrolib as sicro
 
 
@@ -21,8 +22,10 @@ class HVAC_DX_system(Component):
         self.add_parameter(Parameter_options("control_type", "PERFECT", ["PERFECT", "TEMPERATURE"]))
         self.add_parameter(Parameter_float("cooling_bandwidth", 1, "ºC", min=0))
         self.add_parameter(Parameter_float("heating_bandwidth", 1, "ºC", min=0))
-        self.add_parameter(Parameter_float("relaxing_coefficient", 1, "frac", min=0, max=1))
-
+        self.add_parameter(Parameter_options("economizer", "NO", ["NO", "TEMPERATURE","TEMPERATURE_NOT_INTEGRATED","ENTHALPY","ENTHALPY_LIMITED"]))
+        self.add_parameter(Parameter_float("economizer_DT", 0, "ºC", min=0))
+        self.add_parameter(Parameter_float("economizer_enthalpy_limit", 0, "kJ/kg", min=0))
+        
         # Variables
         self.add_variable(Variable("state", unit="flag")) # 0: 0ff, 1: Heating, 2: Heating max cap, -1:Cooling, -2:Cooling max cap, 3: Venting 
         self.add_variable(Variable("T_odb", unit="°C"))
@@ -63,6 +66,11 @@ class HVAC_DX_system(Component):
         if self.parameter("file_met").value == "not_defined":
             errors.append(
                 f"Error: {self.parameter('name').value}, file_met must be defined.")
+        # Test enthalpy economizer not compatible with temperature control type
+        if (self.parameter("economizer").value == "ENTHALPY" or self.parameter("economizer").value == "ENTHALPY_LIMITED") and self.parameter("control_type").value == "TEMPERATURE":
+            errors.append(
+                f"Error: {self.parameter('name').value}, enthalpy economizer not compatible with temperature control type. control typed changed to PERFECT.")
+            self.parameter("control_type").value = "PERFECT"
         return errors
 
     def pre_simulation(self, n_time_steps, delta_t):
@@ -88,10 +96,10 @@ class HVAC_DX_system(Component):
             self.input_var_variable.append(
                 self.parameter("input_variables").variable[i])
         self._f_load = 0
-        self._r_coef = self.parameter("relaxing_coefficient").value
-        self._n_max_iter = self.project().parameter("n_max_iteration").value
-        self._no_load_heat = self._equipment.parameter("no_load_heat").value
-        self._no_load_power = self._equipment.parameter("no_load_power").value
+        
+        self._no_load_power = self._equipment.get_no_load_power()
+        self._economizer = self.parameter("economizer").value != "NO"
+        self._economizer_DT = self.parameter("economizer_DT").value
 
     def pre_iteration(self, time_index, date, daylight_saving):
         super().pre_iteration(time_index, date, daylight_saving)
@@ -125,7 +133,7 @@ class HVAC_DX_system(Component):
             self._on_off = False
         else:
             self._on_off = True
-        self._f_load_pre = self._f_load
+        #self._f_load_pre = self._f_load
 
         # Add uncontrolled ventilation to the space
         if self._on_off:
@@ -133,12 +141,12 @@ class HVAC_DX_system(Component):
                           "V": self._outdoor_air_flow, 
                           "T":self._T_odb, 
                           "w": self._w_o, 
-                          "Q":self._no_load_heat,
+                          "Q":self._no_load_power,
                           "M": 0}
             self._space.add_uncontrol_system(system_dic)
-            self._M_w_pre = 0
-            self._Q_sen_pre = 0
-            self._f_load_pre = 0
+            # Iterative Process for outdoor air fraction with economizer
+            self.itera_Foa = Iterative_process(self._outdoor_air_flow/self._supply_air_flow,tol=0.01,n_ini_relax=3,rel_vel=0.8)
+
     
     def iteration(self, time_index, date, daylight_saving, n_iter):
         super().iteration(time_index, date, daylight_saving, n_iter)
@@ -146,14 +154,17 @@ class HVAC_DX_system(Component):
         if self._on_off:
             self._T_space = self._space.variable("temperature").values[time_index]
             self._w_space = self._space.variable("abs_humidity").values[time_index]
-            # Mix air
-            self._T_idb, self._w_i, self._T_iwb = self._mix_air(self._f_oa, self._T_odb, self._w_o, self._T_space, self._w_space)
             if self.parameter("control_type").value == "PERFECT":
                 control= self._perfect_control(n_iter)    
             elif self.parameter("control_type").value == "TEMPERATURE":
                 control = self._air_temperature_control(n_iter)
         self._space.set_control_system(control)
-        return True
+        
+         # Test convergence
+        if self._on_off and self.parameter("control_type").value == "TEMPERATURE" and self._economizer:
+            return self.itera_Foa.converged()
+        else:
+            return True
 
     def _mix_air(self, f, T1, w1, T2, w2):
         T = f * T1 + (1-f)*T2
@@ -165,12 +176,18 @@ class HVAC_DX_system(Component):
         return (T,w,T_wb)        
     
     def _perfect_control(self, n_iter):
-        Q_required = self._space.get_Q_required(self._T_cool_sp, self._T_heat_sp)
         # Venting
         state = 3
         f_load = 0
         Q_sen = 0
         M_w = 0
+        
+        # Economizer
+        Q_required = self._economizer_perfect()
+
+        # Mix air
+        self._T_idb, self._w_i, self._T_iwb = self._mix_air(self._f_oa, self._T_odb, self._w_o, self._T_space, self._w_space)
+
         if Q_required > 0: # Heating    
             heat_cap = self._equipment.get_heating_capacity(self._T_idb, self._T_iwb, self._T_odb, self._T_owb,self._f_air)
             if heat_cap > 0:
@@ -197,27 +214,72 @@ class HVAC_DX_system(Component):
                     Q_tot = tot_cool_cap*f_load
                 M_w = (Q_tot - Q_sen) / self.DH_W
         # relaxing coef        
-        r_coef = (0.01-self._r_coef)/self._n_max_iter * n_iter + self._r_coef
-        self._M_w = r_coef * M_w + (1-r_coef)*self._M_w_pre # Always relaxing
-        self._Q_sen = r_coef * Q_sen + (1-r_coef)*self._Q_sen_pre
-        self._f_load = r_coef * f_load + (1-r_coef)*self._f_load_pre
+        #r_coef = (0.01-self._r_coef)/self._n_max_iter * n_iter + self._r_coef
+        #self._M_w = r_coef * M_w + (1-r_coef)*self._M_w_pre # Always relaxing
+        #self._Q_sen = r_coef * Q_sen + (1-r_coef)*self._Q_sen_pre
+        #self._f_load = r_coef * f_load + (1-r_coef)*self._f_load_pre
+        #self._state = state
+        #self._M_w_pre = self._M_w
+        #self._Q_sen_pre = self._Q_sen
+        #self._f_load_pre = self._f_load
+
         self._state = state
-        self._M_w_pre = self._M_w
-        self._Q_sen_pre = self._Q_sen
-        self._f_load_pre = self._f_load
+        self._Q_sen = Q_sen
+        self._M_w = M_w
+        self._f_load = f_load
 
         control = {"V": 0, "T": 0, "w":0, "Q":self._Q_sen, "M":self._M_w }
         return control    
-                        
+    
+    def _economizer_perfect(self): 
+        Q_required = self._space.get_Q_required(self._T_cool_sp, self._T_heat_sp)
+        if (self._economizer):
+            if (self.parameter("economizer").value == "TEMPERATURE" or self.parameter("economizer").value == "TEMPERATURE_NOT_INTEGRATED"):
+                use_economizer = self._T_odb < self._T_space-self._economizer_DT
+            elif (self.parameter("economizer").value == "ENTHALPY"):
+                h_odb = sicro.GetMoistAirEnthalpy(self._T_odb,self._w_o/1000)
+                h_space = sicro.GetMoistAirEnthalpy(self._T_space,self._w_space/1000)
+                use_economizer = h_odb < h_space
+            elif (self.parameter("economizer").value == "ENTHALPY_LIMITED"):
+                h_odb = sicro.GetMoistAirEnthalpy(self._T_odb,self._w_o/1000)
+                use_economizer = h_odb < self.parameter("economizer_enthalpy_limit").value * 1000
+            if (Q_required < 0 and use_economizer):
+                Q_rest_ae = self._mrcp * (1-self._f_oa)*(self._T_odb - self._T_space)
+                if  Q_rest_ae < Q_required:
+                    self._f_oa += Q_required/(self._mrcp*(self._T_odb-self._T_space))
+                    Q_required = 0
+                else:        
+                    if (self.parameter("economizer").value == "TEMPERATURE_NOT_INTEGRATED"):
+                        self._f_oa = self._outdoor_air_flow/self._supply_air_flow
+                    elif (self.parameter("economizer").value == "TEMPERATURE"):
+                        self._f_oa = 1
+            else:
+                self._f_oa = self._outdoor_air_flow/self._supply_air_flow
+            system_dic = {"name": self.parameter("name").value, 
+                                  "V": self._supply_air_flow*self._f_oa, 
+                                "T":self._T_odb, 
+                                "w": self._w_o, 
+                                "Q":self._no_load_power,
+                            "M": 0}
+            self._space.add_uncontrol_system(system_dic)
+            Q_required = self._space.get_Q_required(self._T_cool_sp, self._T_heat_sp)
+        return Q_required
+
+            
     def _air_temperature_control(self, n_iter):
-        K_tot, F_tot =  self._space._calculate_K_F_tot(False) # Space Equation
-        T_flo = F_tot/K_tot
+    
         # Venting
         state = 3
         f_load = 0
         Q_sen = 0
         M_w = 0
 
+        # Economizer
+        T_flo, K_tot, F_tot = self._economizer_temperature()
+
+        # Mix air
+        self._T_idb, self._w_i, self._T_iwb = self._mix_air(self._f_oa, self._T_odb, self._w_o, self._T_space, self._w_space)
+
         if (T_flo >= self._T_cool_sp - self._cool_band/2):
             tot_cool_cap, sen_cool_cap = self._equipment.get_cooling_capacity(self._T_idb, self._T_iwb, self._T_odb,self._T_owb, self._f_air)
             if sen_cool_cap > 0:
@@ -225,7 +287,7 @@ class HVAC_DX_system(Component):
                 if T_max_cap > self._T_cool_sp + self._cool_band/2:
                     state = -2
                     f_load = -1 
-                    Q_sen = sen_cool_cap
+                    Q_sen = -sen_cool_cap
                 else:
                     state = -1
                     T_c = (F_tot+sen_cool_cap*(self._T_cool_sp - self._cool_band/2)/self._cool_band)/(K_tot + sen_cool_cap /self._cool_band)
@@ -249,18 +311,54 @@ class HVAC_DX_system(Component):
                     state = 1
 
         # relaxing coef        
-        r_coef = (0.01-self._r_coef)/self._n_max_iter * n_iter + self._r_coef
-        self._M_w = r_coef * M_w + (1-r_coef)*self._M_w_pre
-        self._Q_sen = r_coef * Q_sen + (1-r_coef)*self._Q_sen_pre
-        self._f_load = r_coef * f_load + (1-r_coef)*self._f_load_pre
-        self._state = state
-        self._M_w_pre = self._M_w
-        self._Q_sen_pre = self._Q_sen
-        self._f_load_pre = self._f_load
+        #r_coef = (0.01-self._r_coef)/self._n_max_iter * n_iter + self._r_coef
+        #self._M_w = r_coef * M_w + (1-r_coef)*self._M_w_pre
+        #self._Q_sen = r_coef * Q_sen + (1-r_coef)*self._Q_sen_pre
+        #self._f_load = r_coef * f_load + (1-r_coef)*self._f_load_pre
+        #self._state = state
+        #self._M_w_pre = self._M_w
+        #self._Q_sen_pre = self._Q_sen
+        #self._f_load_pre = self._f_load
      
+        self._state = state
+        self._Q_sen = Q_sen
+        self._M_w = M_w
+        self._f_load = f_load
+
         control = {"V": 0, "T": 0, "w":0, "Q":self._Q_sen, "M":self._M_w }
         return control    
 
+    def _economizer_temperature(self): 
+        K_tot, F_tot =  self._space._calculate_K_F_tot(False) # Space Equation
+        T_flo = F_tot/K_tot   
+        if (self._economizer):
+            if (self._T_odb < self._T_space - self._economizer_DT):
+                if (T_flo >= self._T_cool_sp - 1.5*self._cool_band and T_flo < self._T_cool_sp - 0.5*self._cool_band ):
+                    f_oa_min = self._outdoor_air_flow/self._supply_air_flow
+                    T_min = self._T_cool_sp - 1.5*self._cool_band
+                    f_oa = (T_flo - T_min)/self._cool_band*(1-f_oa_min) + f_oa_min
+                elif (T_flo >= self._T_cool_sp - 0.5*self._cool_band):
+                    if (self.parameter("economizer").value == "TEMPERATURE_NOT_INTEGRATED"):
+                        f_oa = self._outdoor_air_flow/self._supply_air_flow
+                    elif (self.parameter("economizer").value == "TEMPERATURE"):
+                        f_oa = 1
+                else: 
+                    f_oa = self._outdoor_air_flow/self._supply_air_flow
+            else:
+                f_oa = self._outdoor_air_flow/self._supply_air_flow
+            
+            self._f_oa = self.itera_Foa.x_next(f_oa)
+            system_dic = {"name": self.parameter("name").value, 
+                                  "V": self._supply_air_flow*self._f_oa, 
+                                "T":self._T_odb, 
+                                "w": self._w_o, 
+                                "Q":self._no_load_power,
+                            "M": 0}
+            self._space.add_uncontrol_system(system_dic)
+            K_tot, F_tot =  self._space._calculate_K_F_tot(False) # Space Equation
+            T_flo = F_tot/K_tot                 
+        return T_flo, K_tot, F_tot
+
     def post_iteration(self, time_index, date, daylight_saving, converged):
         super().post_iteration(time_index, date, daylight_saving, converged)
         self.variable("state").values[time_index] = self._state
@@ -274,6 +372,7 @@ class HVAC_DX_system(Component):
             self.variable("F_air").values[time_index] = self._f_air
             self.variable("F_load").values[time_index] = self._f_load
             self.variable("power").values[time_index] = self._no_load_power
+            self.variable("outdoor_air_flow").values[time_index] = self._supply_air_flow * self._f_oa
 
             if self._state == 1 or self._state == 2: # Heating
                 Q,power,F_COP = self._equipment.get_heating_state(self._T_idb,self._T_iwb,self._T_odb,self._T_owb,self._f_air,self._f_load)

{opensimula-0.3.2 → opensimula-0.4.1}/src/OpenSimula/components/Space.py

@@ -1,6 +1,7 @@
 from OpenSimula.Component import Component
-from OpenSimula.Parameters import Parameter_component, Parameter_float, Parameter_boolean
+from OpenSimula.Parameters import Parameter_component, Parameter_float
 from OpenSimula.Variable import Variable
+from OpenSimula.Iterative_process import Iterative_process
 import numpy as np
 import psychrolib as sicro
 import math
@@ -18,7 +19,7 @@ class Space(Component):
         self.add_parameter(Parameter_float("volume", 1, "m³", min=0.0))
         self.add_parameter(Parameter_float("furniture_weight", 10, "kg/m²", min=0.0))
         self.add_parameter(Parameter_float("convergence_DT", 0.01, "°C", min=0.0))
-        self.add_parameter(Parameter_float("convergence_Dw", 0.001, "g/kg", min=0.0))
+        self.add_parameter(Parameter_float("convergence_Dw", 0.01, "g/kg", min=0.0))
 
         # Variables
         self.add_variable(Variable("temperature", unit="°C"))
@@ -226,12 +227,17 @@ class Space(Component):
         self.control_system = {"V": 0, "T": 0, "w":0, "Q": 0, "M": 0} # V (m^3/s), T (°C), w (g/kg), Q (W), M (gr H2O)
         # Initial values
         self._estimate_T_w(time_index)
+        # Iterative Process
+        self.itera_T = Iterative_process(self._T,tol=self.parameter("convergence_DT").value,n_ini_relax=3,rel_vel=0.8)
+        self.itera_w = Iterative_process(self._w,tol=self.parameter("convergence_Dw").value,n_ini_relax=3,rel_vel=0.8)
+
         # Humidity balance
         rho = self.building().RHO
         lam = self.building().LAMBDA
         self._K_hum = rho * (self._volume / self._Dt + V_inf)
         self._F_hum = (self.variable("people_latent").values[time_index] + self.variable("other_gains_latent").values[time_index])/lam
         self._F_hum += rho * self._volume / self._Dt * self._w_pre + rho * V_inf * self._file_met.variable("abs_humidity").values[time_index]
+
        
     def _estimate_T_w(self, time_i):
         if time_i == 0:
@@ -247,12 +253,12 @@ class Space(Component):
 
     def iteration(self, time_index, date, daylight_saving, n_iter):
         super().iteration(time_index, date, daylight_saving, n_iter)
-        force_iteration = False
 
         # Calculate temperature
         K_tot,F_tot = self._calculate_K_F_tot(True)
         T = F_tot/K_tot
-        self.variable("temperature").values[time_index] = T
+        self.variable("temperature").values[time_index] = self.itera_T.x_next(T)
+        
         # Calculate humidity
         K_hum, F_hum = self._calculate_K_F_hum(True)
         w = F_hum/K_hum
@@ -261,18 +267,13 @@ class Space(Component):
         if (T< 100): # Sicro limits
             max_hum = sicro.GetHumRatioFromRelHum(T, 1, self.building().ATM_PRESSURE)*1000
             if (w > max_hum):
-                self.variable("abs_humidity").values[time_index] = max_hum
-                force_iteration = True
-            else:
-                self.variable("abs_humidity").values[time_index] = w
-        else:
-            self.variable("abs_humidity").values[time_index] = w
+                w = max_hum
+
+        self.variable("abs_humidity").values[time_index] = self.itera_w.x_next(w)
+        
         # Test convergence
-        converged = self._converged(time_index)
-        if force_iteration:
-            return False
-        else:
-            return converged
+        converged = self.itera_T.converged() and self.itera_w.converged()
+        return converged
 
     def _calculate_solar_direct(self, time_i):
         solar_gain = 0
@@ -319,16 +320,6 @@ class Space(Component):
             F_hum += self.control_system["V"]*rho*self.control_system["w"]  + self.control_system["M"]
         return (K_hum, F_hum)
 
-    def _converged(self, time_i):
-        converged = True
-        if abs(self._T -self.variable("temperature").values[time_i]) > self.parameter("convergence_DT").value:
-            converged = False
-        if abs(self._w -self.variable("abs_humidity").values[time_i]) > self.parameter("convergence_Dw").value:
-            converged = False
-        self._T = self.variable("temperature").values[time_i]
-        self._w = self.variable("abs_humidity").values[time_i] 
-        return converged
-
     def get_Q_required(self, T_cool_sp, T_heat_sp):
         K_tot, F_tot =  self._calculate_K_F_tot(False)
         T = F_tot/K_tot

{opensimula-0.3.2 → opensimula-0.4.1}/test/test_HVAC_DX_Equipment.py

@@ -11,7 +11,7 @@ case_dict = {
             "nominal_total_cooling_capacity": 7951,
             "nominal_sensible_cooling_capacity": 6136,
             "nominal_cooling_power": 2198,
-            "no_load_cooling_power": 230,
+            "indoor_fan_power": 230,
             "nominal_cooling_conditions": [26.7,19.4,35],
             "total_cooling_capacity_expression": "9.099e-04 * T_odb + 4.351e-02 * T_iwb -3.475e-05 * T_odb**2 + 1.512e-04 * T_iwb**2 -4.703e-04 * T_odb * T_iwb + 4.281e-01",
             "sensible_cooling_capacity_expression": "1.148e-03 * T_odb - 7.886e-02 * T_iwb + 1.044e-01 * T_idb - 4.117e-05 * T_odb**2 - 3.917e-03 * T_iwb**2 - 2.450e-03 * T_idb**2 + 4.042e-04 * T_odb * T_iwb - 4.762e-04 * T_odb * T_idb + 5.503e-03 * T_iwb * T_idb  + 2.903e-01",
@@ -35,17 +35,17 @@ def test_points():
 
     assert nominal[0] == pytest.approx(7951,rel=1e-2)
     assert nominal[1] == pytest.approx(6136,rel=1e-2)
-    assert nominal[2] == pytest.approx(2198,rel=1e-2)
+    assert nominal[2] == pytest.approx(2198+230,rel=1e-2)
 
     assert wet_coil[0] == pytest.approx(7570,rel=1e-2)
     assert wet_coil[1] == pytest.approx(6280,rel=1e-2)
-    assert wet_coil[2] == pytest.approx(2078,rel=1e-2)
+    assert wet_coil[2] == pytest.approx(2078+230,rel=1e-2)
 
     assert dry_coil[0] == pytest.approx(6900,rel=1e-2)
     assert dry_coil[1] == pytest.approx(6900,rel=1e-2)
-    assert dry_coil[2] == pytest.approx(2480,rel=1e-2)
+    assert dry_coil[2] == pytest.approx(2480+230,rel=1e-2)
 
     assert wet_coil_part_load[0] == pytest.approx( wet_coil[0]*.3)
     assert wet_coil_part_load[1] == pytest.approx( wet_coil[1]*.3)
-    assert wet_coil_part_load[2] == pytest.approx( wet_coil[2]*0.3/(1 - 0.229*0.7))
+    assert wet_coil_part_load[2] == pytest.approx( (wet_coil[2]-230)*0.3/(1 - 0.229*0.7) +230)
 

{opensimula-0.3.2 → opensimula-0.4.1}/test/test_HVAC_DX_system.py

@@ -331,8 +331,7 @@ case610_dict = {
             "nominal_total_cooling_capacity": 6900,
             "nominal_sensible_cooling_capacity": 4800,
             "nominal_cooling_power": 2400,
-            "no_load_power": 240,
-            "no_load_heat": 240,
+            "indoor_fan_power": 240,
             "total_cooling_capacity_expression": "0.88078 + 0.014248 * T_iwb + 0.00055436 * T_iwb**2 - 0.0075581 * T_odb +	3.2983E-05 * T_odb**2 - 0.00019171 * T_odb * T_iwb",
             "sensible_cooling_capacity_expression": "0.50060 - 0.046438 * T_iwb - 0.00032472 * T_iwb**2 - 0.013202 * T_odb + 7.9307E-05 * T_odb**2 + 0.069958 * T_idb - 3.4276E-05 * T_idb**2",
             "cooling_power_expression": "0.11178 + 0.028493 * T_iwb - 0.00041116 * T_iwb**2 + 0.021414 * T_odb + 0.00016113 * T_odb**2 - 0.00067910 * T_odb * T_iwb",

opensimula-0.4.1/test/test_Iterative_process.py

@@ -0,0 +1,13 @@
+import OpenSimula as osm
+import math
+import pytest
+
+def test_Iterative_process():
+    def y(x):
+        return math.cos(x)
+    x_i = 0.5
+    itera = osm.Iterative_process(x_i)    
+    while not itera.converged():
+        x_i = itera.x_next(y(x_i))
+
+    assert x_i == pytest.approx(0.73908,abs=1e-4)