OpenSimula 0.5.1__py3-none-any.whl

opensimula/components/Frame.py

@@ -0,0 +1,35 @@
+from opensimula.Component import Component
+from opensimula.Parameters import Parameter_float, Parameter_float_list, Parameter_math_exp_list
+
+
+class Frame(Component):
+    def __init__(self, name, project):
+        Component.__init__(self, name, project)
+        self.parameter("type").value = "Frame"
+        self.parameter(
+            "description").value = "Opening frame"
+
+        self.add_parameter(Parameter_float_list(
+            "solar_alpha", [0.85, 0.85], "frac", min=0, max=1))
+        self.add_parameter(Parameter_float_list(
+            "lw_epsilon", [0.9, 0.9], "frac", min=0, max=1))
+        self.add_parameter(Parameter_float(
+            "thermal_resistance", 0.2, "m²K/W", min=0))
+
+    def radiant_property(self, prop, radiation_type, side, theta=0):
+        if (radiation_type == "solar_diffuse" or radiation_type == "solar_direct"):
+            if (prop == "rho"):
+                return 1-self.parameter("solar_alpha").value[side]
+            elif (prop == "tau"):
+                return 0
+            elif (prop == "alpha"):
+                return self.parameter("solar_alpha").value[side]
+            elif (prop == "alpha_other_side"):
+                return 0
+        elif (radiation_type == "long_wave"):
+            if (prop == "rho"):
+                return 1-self.parameter("lw_epsilon").value[side]
+            elif (prop == "tau"):
+                return 0
+            elif (prop == "alpha"):
+                return self.parameter("lw_epsilon").value[side]

opensimula/components/Glazing.py

@@ -0,0 +1,122 @@
+import math
+from scipy.integrate import quad
+from opensimula.Component import Component
+from opensimula.Parameters import Parameter_float, Parameter_float_list, Parameter_math_exp, Parameter_math_exp_list
+
+
+class Glazing(Component):
+    def __init__(self, name, project):
+        Component.__init__(self, name, project)
+        self.parameter("type").value = "Glazing"
+        self.parameter("description").value = "Glazing material."
+        self.add_parameter(Parameter_float(
+            "solar_tau", 0.849, "frac", min=0, max=1))
+        self.add_parameter(Parameter_float_list(
+            "solar_rho", [0.077, 0.077], "frac", min=0, max=1))
+        self.add_parameter(Parameter_float_list(
+            "g", [0.867093, 0.867093], "frac", min=0, max=1))
+        self.add_parameter(Parameter_float_list(
+            "lw_epsilon", [0.837, 0.837], "frac", min=0, max=1))
+        self.add_parameter(Parameter_float(
+            "U", 5.686, "W/m²K", min=0))
+        self.add_parameter(Parameter_math_exp(
+            "f_tau_nor", "1.3186 * cos_theta**3 - 3.5251 * cos_theta**2 + 3.2065 * cos_theta", "frac"))
+        f_rho = "1.8562 * cos_theta**3 - 4.4739 * cos_theta**2 + 3.6177 * cos_theta"
+        self.add_parameter(Parameter_math_exp_list(
+            "f_1_minus_rho_nor", [f_rho, f_rho], "frac"))
+
+    def pre_simulation(self, n_time_steps, delta_t):
+        super().pre_simulation(n_time_steps, delta_t)
+        self._calc_diffuse_properties()
+        self._calc_alpha_fractions()
+
+    def _calc_diffuse_properties(self):
+        def tau_integrand(theta):
+            tau_n = self.parameter("solar_tau").value
+            # variables dictonary
+            var_dic = {"cos_theta": math.cos(theta)}
+            f_tau = self.parameter("f_tau_nor").evaluate(var_dic)
+            tau = tau_n*f_tau
+            return 2*tau * math.sin(theta) * math.cos(theta)
+
+        def rho_0_integrand(theta):
+            rho_n = self.parameter("solar_rho").value[0]
+            # variables dictonary
+            var_dic = {"cos_theta": math.cos(theta)}
+            f_rho = self.parameter("f_1_minus_rho_nor").evaluate(0, var_dic)
+            rho = 1-(1-rho_n)*f_rho
+            return 2*rho * math.sin(theta) * math.cos(theta)
+
+        def rho_1_integrand(theta):
+            rho_n = self.parameter("solar_rho").value[1]
+            # variables dictonary
+            var_dic = {"cos_theta": math.cos(theta)}
+            f_rho = self.parameter("f_1_minus_rho_nor").evaluate(1, var_dic)
+            rho = 1-(1-rho_n)*f_rho
+            return 2*rho * math.sin(theta) * math.cos(theta)
+
+        tau = quad(tau_integrand, 0, math.pi/2)[0]
+        rho_0 = quad(rho_0_integrand, 0, math.pi/2)[0]
+        rho_1 = quad(rho_1_integrand, 0, math.pi/2)[0]
+        self.tau_solar_diffuse = tau
+        self.rho_solar_diffuse = [rho_0, rho_1]
+        self.alpha_solar_diffuse = [1-rho_0-tau, 1-rho_1-tau]
+
+    def _calc_alpha_fractions(self):
+        h_CR0 = 25
+        h_CR1 = 3.6 + 4.1/0.837 * \
+            self.parameter("lw_epsilon").value[1]  # UNE-EN 410:2011
+        tau = self.parameter("solar_tau").value
+        U = self.parameter("U").value
+        if (U > 5):  # simple glazing calculations are inestable
+            self.alpha_own_side_fraction = [0.5, 0.5]
+        else:
+            alpha_1 = 1 - tau - self.parameter("solar_rho").value[0]
+            g_1 = self.parameter("g").value[0]
+            alpha_11 = (g_1+alpha_1*U/h_CR1-alpha_1-tau)/(U/h_CR0+U/h_CR1-1)
+            alpha_2 = 1 - tau - self.parameter("solar_rho").value[1]
+            g_2 = self.parameter("g").value[1]
+            alpha_22 = (g_2+alpha_2*U/h_CR1-alpha_2-tau)/(U/h_CR0+U/h_CR1-1)
+            self.alpha_own_side_fraction = [alpha_11/alpha_1, alpha_22/alpha_2]
+
+    def thermal_resistance(self):
+        return (1/self.parameter("U").value - 1/25 - 1/(3.6 + 4.1/0.837 *
+                                                        self.parameter("lw_epsilon").value[1]))  # UNE-EN 673:2011
+
+    def radiant_property(self, prop, radiation_type, side, theta=0):
+        if (radiation_type == "solar_diffuse"):
+            if (prop == "rho"):
+                return self.rho_solar_diffuse[side]
+            elif (prop == "tau"):
+                return self.tau_solar_diffuse
+            elif (prop == "alpha"):
+                return self.alpha_solar_diffuse[side]*self.alpha_own_side_fraction[side]
+            elif (prop == "alpha_other_side"):
+                return self.alpha_solar_diffuse[side]*(1-self.alpha_own_side_fraction[side])
+        elif (radiation_type == "solar_direct"):
+            # variables dictonary
+            var_dic = {"cos_theta": math.cos(theta)}
+            if (prop == "rho"):
+                rho_n = self.parameter("solar_rho").value[side]
+                f_rho = self.parameter(
+                    "f_1_minus_rho_nor").evaluate(side, var_dic)
+                return 1-(1-rho_n)*f_rho
+            elif (prop == "tau"):
+                return self.parameter("solar_tau").value * self.parameter("f_tau_nor").evaluate(var_dic)
+            elif (prop == "alpha"):
+                alpha = 1 - self.radiant_property("tau", radiation_type, side, theta) - \
+                    self.radiant_property("rho", radiation_type, side, theta)
+                return alpha * self.alpha_own_side_fraction[side]
+            elif (prop == "alpha_other_side"):
+                alpha = 1 - self.radiant_property("tau", radiation_type, side, theta) - \
+                    self.radiant_property("rho", radiation_type, side, theta)
+                return alpha * (1-self.alpha_own_side_fraction[side])
+        elif (radiation_type == "long_wave"):
+            if (prop == "rho"):
+                return 1-self.parameter("lw_epsilon").value[side]
+            elif (prop == "tau"):
+                return 0
+            elif (prop == "alpha"):
+                return self.parameter("lw_epsilon").value[side]
+        else:
+            pass

opensimula/components/HVAC_DX_equipment.py

@@ -0,0 +1,210 @@
+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
+
+class HVAC_DX_equipment(Component):
+    def __init__(self, name, project):
+        Component.__init__(self, name, project)
+        self.parameter("type").value = "HVAC_DX_equipment"
+        self.parameter("description").value = "HVAC Direct Expansion equipment manufacturer information"
+        self.add_parameter(Parameter_float("nominal_air_flow", 1, "m³/s", min=0))
+        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("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"))
+        self.add_parameter(Parameter_math_exp("cooling_power_expression", "1", "frac"))
+        self.add_parameter(Parameter_math_exp("EER_expression", "1", "frac"))
+        self.add_parameter(Parameter_float("nominal_heating_capacity", 0, "W", min=0))
+        self.add_parameter(Parameter_float("nominal_heating_power", 0, "W", min=0))
+        self.add_parameter(Parameter_float_list("nominal_heating_conditions", [20, 7, 6], "ºC"))
+        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("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], "-"))
+        self.add_parameter(Parameter_float_list("expression_min_values", [0,0,-30,-30,0,0], "-"))
+
+    def check(self):
+        errors = super().check()
+        # Test Cooling and Heating conditions 3 values
+        if len(self.parameter("nominal_cooling_conditions").value)!= 3:
+            msg = f"Error: {self.parameter('name').value}, nominal_cooling_conditions size must be 3"
+            errors.append(Message(msg, "ERROR"))
+        if len(self.parameter("nominal_heating_conditions").value)!= 3:
+            msg = f"Error: {self.parameter('name').value}, nominal_heating_conditions size must be 3"
+            errors.append(Message(msg, "ERROR"))
+        return errors
+        
+    def get_heating_load(self,T_idb,T_iwb,T_odb,T_owb,F_air,Q_required):
+        """
+        Q_required: Required heating load
+        Returns (Q_eq,Q_coil,f_load).
+        Q_eq: Net heat given by the equipment
+        Q_coil: Gross heat given by the coil
+        f_load: Fraction of load (0-1)
+        """
+        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,1]) #Full load
+            # Capacity
+            cap_coil = capacity * self.parameter("heating_capacity_expression").evaluate(var_dic)
+            cap_eq = cap_coil + self.get_fan_heat(1)
+            if self.get_fan_heat(0) == 0: # Q_required is equipment load
+                if Q_required > cap_eq:
+                    return (cap_eq,cap_coil,1)
+                else:
+                    f_load = Q_required/cap_eq
+                    return (Q_required, Q_required-self.get_fan_heat(f_load), f_load)
+            else: # Q_required is coil load
+                if Q_required > cap_coil:
+                    return (cap_eq,cap_coil,1)
+                else:
+                    f_load = Q_required/cap_coil
+                    return (Q_required+self.get_fan_heat(f_load), Q_required, f_load)           
+        else:
+            return (self.get_fan_heat(0),0, 0)
+    
+    def get_heating_power(self,T_idb, T_iwb,T_odb,T_owb,F_air,Q_required):
+        """
+        Returns (power,indoor_fan_power,F_COP).
+        """
+        cap_nom = self.parameter("nominal_heating_capacity").value
+        if cap_nom > 0:
+            Q_eq, Q_coil, F_load = self.get_heating_load(T_idb, T_iwb,T_odb,T_owb,F_air,Q_required)
+            # variables dictonary
+            var_dic = self._var_state_dic([T_idb, T_iwb,T_odb,T_owb,F_air,F_load])
+            # Compressor
+            power_full = self.parameter("nominal_heating_power").value
+            power_full = power_full * self.parameter("heating_power_expression").evaluate(var_dic)
+            capacity = Q_coil/F_load 
+            COP_full = capacity/power_full
+            F_COP = self.parameter("COP_expression").evaluate(var_dic) 
+            COP = COP_full * F_COP
+            if self.parameter("indoor_fan_operation").value == "CONTINUOUS":
+                fan_power = self.parameter("indoor_fan_power").value
+            elif self.parameter("indoor_fan_operation").value == "CYCLING":
+                fan_power = self.parameter("indoor_fan_power").value*F_load/F_COP
+            return (capacity*F_load/COP + fan_power, fan_power, F_COP)
+        else:
+            fan_power = self.get_fan_power(0)
+            return (fan_power,fan_power,0)
+
+    
+    def get_cooling_load(self,T_idb,T_iwb,T_odb,T_owb,F_air,Q_required):
+        """
+        Q_required: Required cooling load (negative for cooling)
+        Returns (Q_eq,Q_coil,Q_lat ,f_load).
+        Q_eq: Sensible net heat given by the equipment
+        Q_coil: Sensible gross heat given by the coil
+        Q_lat: Latent heat given by the coil
+        f_load: Fraction of load (0-1)
+        """
+        nom_total_capacity = self.parameter("nominal_total_cooling_capacity").value
+        if nom_total_capacity > 0:
+            Q_required = -Q_required # Positive
+            # variables dictonary
+            var_dic = self._var_state_dic([T_idb, T_iwb,T_odb,T_owb,F_air,1]) #Full load
+            # Total
+            f = self.parameter("total_cooling_capacity_expression").evaluate(var_dic)
+            total_capacity = nom_total_capacity * f
+            # Sensible
+            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):
+                if self.parameter("dry_coil_model").value == "SENSIBLE":
+                    total_capacity = sensible_capacity
+                elif self.parameter("dry_coil_model").value == "TOTAL":
+                    sensible_capacity = total_capacity
+            cap_eq = sensible_capacity - self.get_fan_heat(1)
+            if self.get_fan_heat(0) == 0: # Q_required is equipment load
+                if Q_required > cap_eq:
+                    return (cap_eq,sensible_capacity,total_capacity-sensible_capacity,1)
+                else:
+                    F_load = Q_required/cap_eq
+                    return (Q_required, Q_required+self.get_fan_heat(F_load),(total_capacity-sensible_capacity)*F_load , F_load)
+            else:  # Q_requiered is coil load
+                if Q_required > sensible_capacity:
+                    return (cap_eq,sensible_capacity,total_capacity-sensible_capacity,1)
+                else:
+                    F_load = Q_required/sensible_capacity
+                    return (Q_required-self.get_fan_heat(F_load), Q_required,(total_capacity-sensible_capacity)*F_load , F_load)
+        else:
+            return (-self.get_fan_heat(0), 0, 0, 0)
+
+    def get_cooling_power(self,T_idb,T_iwb,T_odb,T_owb,F_air,Q_required):
+        """
+        Returns (power,indoor_fan_power,F_EER).
+        """
+        Q_eq, Q_sen, Q_lat, F_load = self.get_cooling_load(T_idb,T_iwb,T_odb,T_owb,F_air,Q_required)
+        if Q_sen > 0:
+            # variables dictonary
+            var_dic = self._var_state_dic([T_idb, T_iwb,T_odb,T_owb,F_air,F_load])
+            capacity_tot = (Q_sen+Q_lat)/F_load 
+            capacity_sen = Q_sen/F_load 
+            power_full = self._get_correct_cooling_power(capacity_tot,capacity_sen,var_dic)
+            EER_full = capacity_tot/power_full
+            F_EER = self.parameter("EER_expression").evaluate(var_dic) 
+            EER = EER_full * F_EER 
+            if self.parameter("indoor_fan_operation").value == "CONTINUOUS":
+                fan_power = self.parameter("indoor_fan_power").value
+            elif self.parameter("indoor_fan_operation").value == "CYCLING":
+                fan_power = self.parameter("indoor_fan_power").value*F_load/F_EER
+            return (capacity_tot*F_load/EER + fan_power, fan_power, F_EER)
+        else:
+            fan_power = self.get_fan_power(0)
+            return (fan_power,fan_power,0)
+        
+    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):
+            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)
+        return (power * f)
+                  
+    def _get_min_T_iwb(self,var_dic):
+        total_capacity = self.parameter("nominal_total_cooling_capacity").value
+        sensible_capacity = self.parameter("nominal_sensible_cooling_capacity").value
+        def func(T_iwb):
+            var_dic["T_iwb"] = T_iwb
+            return (sensible_capacity*self.parameter("sensible_cooling_capacity_expression").evaluate(var_dic)-
+                    total_capacity*self.parameter("total_cooling_capacity_expression").evaluate(var_dic))
+        root = fsolve(func, var_dic["T_iwb"],xtol=1e-3)
+        return root[0]
+    
+    def get_fan_power(self, f_load):
+        if self.parameter("indoor_fan_operation").value == "CONTINUOUS":
+            return self.parameter("indoor_fan_power").value
+        elif self.parameter("indoor_fan_operation").value == "CYCLING":
+            return self.parameter("indoor_fan_power").value * f_load
+
+    def get_fan_heat(self, f_load):
+        return self.get_fan_power(f_load)
+
+    def _var_state_dic(self, values):
+        max = self.parameter("expression_max_values").value
+        min = self.parameter("expression_min_values").value
+        for i in range(len(values)):
+            if (values[i] > max[i]):
+                values[i] = max[i]
+            elif (values[i] < min[i]):
+                values[i] = min[i]
+        return {"T_idb":values[0],
+                "T_iwb":values[1],
+                "T_odb":values[2],
+                "T_owb":values[3],
+                "F_air":values[4],
+                "F_load":values[5]}
+
+
+
+
+        

opensimula/components/HVAC_DX_system.py

@@ -0,0 +1,254 @@
+from opensimula.Message import Message
+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
+import psychrolib as sicro
+
+
+class HVAC_DX_system(Component):
+    def __init__(self, name, project):
+        Component.__init__(self, name, project)
+        self.parameter("type").value = "HVAC_DX_system"
+        self.parameter("description").value = "HVAC Direct Expansion system for time simulation"
+        self.add_parameter(Parameter_component("equipment", "not_defined", ["HVAC_DX_equipment"]))
+        self.add_parameter(Parameter_component("spaces", "not_defined", ["Space"])) # Space, TODO: Add Air_distribution, Energy_load
+        self.add_parameter(Parameter_float("air_flow", 1, "m³/s", min=0))
+        self.add_parameter(Parameter_math_exp("outdoor_air_fraction", "0", "frac"))
+        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"))
+        self.add_parameter(Parameter_math_exp("system_on_off", "1", "on/off"))
+        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_OA", unit="°C"))
+        self.add_variable(Variable("T_OAwb", unit="°C"))
+        self.add_variable(Variable("T_MA", unit="°C"))
+        self.add_variable(Variable("T_MAwb", unit="°C"))
+        self.add_variable(Variable("F_air", unit="frac"))
+        self.add_variable(Variable("F_load", unit="frac"))
+        self.add_variable(Variable("outdoor_air_fraction", unit="frac"))
+        self.add_variable(Variable("m_air_flow", unit="kg/s"))
+        self.add_variable(Variable("T_SA", unit="°C"))
+        self.add_variable(Variable("w_SA", unit="g/kg"))
+        self.add_variable(Variable("Q_total", unit="W"))
+        self.add_variable(Variable("Q_sensible", unit="W"))
+        self.add_variable(Variable("Q_latent", unit="W"))
+        self.add_variable(Variable("power", unit="W"))
+        self.add_variable(Variable("indoor_fan_power", unit="W"))
+        self.add_variable(Variable("heating_setpoint", unit="°C"))
+        self.add_variable(Variable("cooling_setpoint", unit="°C"))
+        self.add_variable(Variable("EER", unit="frac"))
+        self.add_variable(Variable("COP", unit="frac"))
+        self.add_variable(Variable("efficiency_degradation", unit="frac"))
+
+
+    def check(self):
+        errors = super().check()
+        # Test equipment defined
+        if self.parameter("equipment").value == "not_defined":
+            msg = f"{self.parameter('name').value}, must define its equipment."
+            errors.append(Message(msg, "ERROR"))
+        # Test space defined
+        if self.parameter("spaces").value == "not_defined":
+            msg = f"{self.parameter('name').value}, must define its space."
+            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'."
+            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._equipment = self.parameter("equipment").component
+        self._space = self.parameter("spaces").component
+        self._file_met = self.project().parameter("simulation_file_met").component
+        sicro.SetUnitSystem(sicro.SI)
+        self.props = self._sim_.props
+        self._air_flow = self.parameter("air_flow").value
+        self._f_air = self._air_flow / self._equipment.parameter("nominal_air_flow").value
+        self._f_load = 0
+        self._no_load_heat = self._equipment.get_fan_heat(0)
+        self._rho_i = self.props["RHO_A"] 
+        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)
+        # Outdoor air
+        self._T_odb = self._file_met.variable("temperature").values[time_index]
+        self._T_owb = self._file_met.variable("wet_bulb_temp").values[time_index]
+        self._w_o = self._file_met.variable("abs_humidity").values[time_index]
+        self.variable("T_OA").values[time_index] = self._T_odb
+        self.variable("T_OAwb").values[time_index] = self._T_owb
+        self._outdoor_rho = 1/sicro.GetMoistAirVolume(self._T_odb,self._w_o/1000,self.props["ATM_PRESSURE"])
+        # variables dictonary
+        var_dic = self.get_parameter_variable_dictionary(time_index)
+
+        # outdoor air fraction
+        self._outdoor_air_fraction = self.parameter("outdoor_air_fraction").evaluate(var_dic)
+        self._f_oa = self._outdoor_air_fraction
+
+        # setpoints
+        self._T_heat_sp = self.parameter("heating_setpoint").evaluate(var_dic)
+        self.variable("heating_setpoint").values[time_index] = self._T_heat_sp
+        self._T_cool_sp = self.parameter("cooling_setpoint").evaluate(var_dic)
+        self.variable("cooling_setpoint").values[time_index] = self._T_cool_sp
+        # on/off
+        self._on_off = self.parameter("system_on_off").evaluate(var_dic)
+        if self._on_off == 0:
+            self._state = 0
+            self.variable("state").values[time_index] = 0
+            self._on_off = False
+        else:
+            self._on_off = True
+    
+    def iteration(self, time_index, date, daylight_saving, n_iter):
+        super().iteration(time_index, date, daylight_saving, n_iter)
+        space_air = {"M_a": 0, "T_a": 0, "w_a":0, "Q_s":0, "M_w":0 }
+        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]
+            # Calculate Q_required
+            self._calculate_required_Q()
+            if (self._economizer):
+                self._simulate_economizer() # Calculation of new f_oa
+                self._calculate_required_Q()
+            space_air = self._simulate_system()           
+        self._space.set_control_system(space_air)
+        return True
+
+    def _calculate_required_Q(self):
+        K_t,F_t = self._space.get_thermal_equation(False)
+        m_cp_oa = self._air_flow * self._f_oa * self._rho_i * self.props["C_PA"]
+        K_ts = K_t + m_cp_oa
+        F_ts = F_t + m_cp_oa * self._T_odb + self._no_load_heat
+        T_flo = F_ts/K_ts
+        if T_flo > self._T_cool_sp:
+            self._Q_required =  K_ts * self._T_cool_sp - F_ts
+        elif T_flo < self._T_heat_sp:
+            self._Q_required =  K_ts * self._T_heat_sp - F_ts
+        else: 
+            self._Q_required = 0
+        if abs(self._Q_required) < 0.0001: # Problems with convergence
+            self._Q_required = 0
+    
+    def _simulate_economizer(self): 
+        if (self.parameter("economizer").value == "TEMPERATURE" or self.parameter("economizer").value == "TEMPERATURE_NOT_INTEGRATED"):
+            on_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)
+            on_economizer = h_odb < h_space
+        elif (self.parameter("economizer").value == "ENTHALPY_LIMITED"):
+            h_odb = sicro.GetMoistAirEnthalpy(self._T_odb,self._w_o/1000)
+            on_economizer = h_odb < self.parameter("economizer_enthalpy_limit").value * 1000
+            
+        if (on_economizer):
+            if (self._Q_required < 0):
+                mrhocp =  self._air_flow * self.props["C_PA"]* self._outdoor_rho
+                Q_rest_ae = mrhocp * (1-self._f_oa) * (self._T_odb - self._T_space)
+                if  Q_rest_ae < self._Q_required:
+                    self._f_oa += self._Q_required/(mrhocp * (self._T_odb-self._T_space))
+                    self._Q_required = 0
+                else:        
+                    if (self.parameter("economizer").value == "TEMPERATURE_NOT_INTEGRATED"):
+                        self._f_oa = self._outdoor_air_fraction
+                    else:
+                        self._f_oa = 1
+            elif (self._Q_required > 0): # Heating 
+                self._f_oa = self._outdoor_air_fraction
+        else:
+            self._f_oa = self._outdoor_air_fraction
+    
+    def _simulate_system(self):
+        # Venting
+        state = 3
+        f_load = 0
+        Q_coil = 0
+        Q_eq = self._equipment.get_fan_heat(0)
+        M_w = 0
+
+        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)
+        self._rho_i = 1/sicro.GetMoistAirVolume(self._T_idb,self._w_i/1000,self.props["ATM_PRESSURE"])
+
+        if self._Q_required > 0: # Heating    
+            Q_eq,Q_coil,f_load = self._equipment.get_heating_load(self._T_idb, self._T_iwb, self._T_odb, self._T_owb,self._f_air,self._Q_required)
+            if f_load == 1:
+                state = 1
+            else:
+                state = 2
+        elif self._Q_required < 0: # Cooling
+            Q_eq, Q_coil, Q_lat,f_load = self._equipment.get_cooling_load(self._T_idb, self._T_iwb, self._T_odb,self._T_owb,self._f_air,self._Q_required)
+            if f_load == 1:
+                state = -2
+            else:
+                state = -1
+            M_w = -(Q_lat) / self.props["LAMBDA"]
+            Q_coil = -Q_coil
+            Q_eq = -Q_eq
+
+        self._state = state
+        self._Q_coil = Q_coil 
+        self._Q_eq = Q_eq
+        self._M_w = M_w
+        self._f_load = f_load
+
+        air_flow = {"M_a": self._air_flow * self._f_oa * self._rho_i, 
+                    "T_a": self._T_odb, 
+                    "w_a":self._w_o, 
+                    "Q_s": Q_eq, 
+                    "M_w":self._M_w }
+        return air_flow  
+
+    def _mix_air(self, f, T1, w1, T2, w2):
+        T = f * T1 + (1-f)*T2
+        w = f * w1 + (1-f)*w2
+        if (T > 100):
+            T_wb = 50 # Inventado
+        else:
+            T_wb = sicro.GetTWetBulbFromHumRatio(T,w/1000,self.props["ATM_PRESSURE"])
+        return (T,w,T_wb)        
+
+    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
+        if self._state != 0 : # on
+            self.variable("T_MA").values[time_index] = self._T_idb
+            self.variable("T_MAwb").values[time_index] = self._T_iwb
+            m_supply = self._air_flow * self._rho_i
+            self.variable("m_air_flow").values[time_index] = m_supply
+            self.variable("outdoor_air_fraction").values[time_index] = self._f_oa
+            self.variable("T_SA").values[time_index] = self._Q_eq/(m_supply*self.props["C_PA"]) + self._T_idb
+            self.variable("w_SA").values[time_index] = self._M_w/(self._air_flow * self._rho_i) +self._w_i
+            self.variable("F_air").values[time_index] = self._f_air
+            self.variable("F_load").values[time_index] = self._f_load
+            if self._state == 1 or self._state == 2: # Heating
+                power,fan_power, F_COP = self._equipment.get_heating_power(self._T_idb,self._T_iwb,self._T_odb,self._T_owb,self._f_air,self._Q_required)
+                Q_sys = self._Q_coil
+                self.variable("Q_sensible").values[time_index] = Q_sys
+                self.variable("Q_total").values[time_index] = Q_sys
+                self.variable("power").values[time_index] = power
+                self.variable("indoor_fan_power").values[time_index] = fan_power
+                if power>0:
+                    self.variable("COP").values[time_index] = Q_sys/power
+                    self.variable("efficiency_degradation").values[time_index] = F_COP
+            elif self._state == -1 or self._state == -2: #Cooling
+                power,fan_power,F_EER = self._equipment.get_cooling_power(self._T_idb,self._T_iwb,self._T_odb,self._T_owb,self._f_air,self._Q_required)
+                Q_s = -self._Q_coil 
+                Q_l = -self._M_w * self.props["LAMBDA"]
+                self.variable("Q_sensible").values[time_index] = Q_s
+                self.variable("Q_latent").values[time_index] = Q_l
+                self.variable("Q_total").values[time_index] = Q_s + Q_l
+                self.variable("power").values[time_index] = power
+                self.variable("indoor_fan_power").values[time_index] = fan_power
+                if power>0: 
+                    self.variable("EER").values[time_index] = (Q_s+Q_l)/power
+                    self.variable("efficiency_degradation").values[time_index] = F_EER
+            else: # venting
+                self.variable("power").values[time_index] = self._equipment.get_fan_power(0)
+                self.variable("indoor_fan_power").values[time_index] = self._equipment.get_fan_power(0)