OpenSimula 0.5.1__py3-none-any.whl

opensimula/components/HVAC_perfect_system.py

@@ -0,0 +1,137 @@
+from opensimula.Message import Message
+from opensimula.Parameters import Parameter_component, Parameter_float, Parameter_variable_list, Parameter_math_exp
+from opensimula.Component import Component
+from opensimula.Variable import Variable
+import psychrolib as sicro
+
+
+class HVAC_perfect_system(Component):
+    def __init__(self, name, project):
+        Component.__init__(self, name, project)
+        self.parameter("type").value = "HVAC_perfect_system"
+        self.parameter("description").value = "HVAC Perfect system for cooling and heating load"
+        self.add_parameter(Parameter_component("spaces", "not_defined", ["Space"])) 
+        self.add_parameter(Parameter_variable_list("input_variables", []))
+        self.add_parameter(Parameter_math_exp("outdoor_air_flow", "0", "m³/s"))
+        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("humidifying_setpoint", "0", "%"))
+        self.add_parameter(Parameter_math_exp("dehumidifying_setpoint", "100", "%"))
+        self.add_parameter(Parameter_math_exp("system_on_off", "1", "on/off"))
+        # Variables
+        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("outdoor_air_flow", unit="m³/s"))
+        self.add_variable(Variable("heating_setpoint", unit="°C"))
+        self.add_variable(Variable("cooling_setpoint", unit="°C"))
+        self.add_variable(Variable("humidifying_setpoint", unit="%"))
+        self.add_variable(Variable("dehumidifying_setpoint", unit="%"))
+        self.add_variable(Variable("state", unit="flag")) # 0: 0ff, 1: Heating, -1: Cooling, 3: Venting 
+    
+    def check(self):
+        errors = super().check()
+        # 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._space = self.parameter("spaces").component
+        self._file_met = self.project().parameter("simulation_file_met").component
+        self.props = self._sim_.props
+
+    def pre_iteration(self, time_index, date, daylight_saving):
+        super().pre_iteration(time_index, date, daylight_saving)
+        # variables dictonary
+        var_dic = self.get_parameter_variable_dictionary(time_index)
+
+        # outdoor air flow
+        self._outdoor_air_flow = self.parameter("outdoor_air_flow").evaluate(var_dic)
+        self.variable("outdoor_air_flow").values[time_index] = self._outdoor_air_flow
+        # setpoints
+        self.variable("heating_setpoint").values[time_index] = self.parameter("heating_setpoint").evaluate(var_dic)
+        self.variable("cooling_setpoint").values[time_index] = self.parameter("cooling_setpoint").evaluate(var_dic)
+        self.variable("humidifying_setpoint").values[time_index] = self.parameter("humidifying_setpoint").evaluate(var_dic)
+        self.variable("dehumidifying_setpoint").values[time_index] = self.parameter("dehumidifying_setpoint").evaluate(var_dic)
+         # on/off
+        self._on_off = self.parameter("system_on_off").evaluate(var_dic)
+        if self._on_off == 0:
+            self.variable("state").values[time_index] = 0
+            self._on_off = False
+        else:
+            self._on_off = True
+
+        self._T_odb = self._file_met.variable("temperature").values[time_index]
+        self._w_o = self._file_met.variable("abs_humidity").values[time_index]
+        self._outdoor_rho = 1/sicro.GetMoistAirVolume(self._T_odb,self._w_o/1000,self.props["ATM_PRESSURE"])
+        self._T_cool_sp = self.variable("cooling_setpoint").values[time_index]
+        self._T_heat_sp = self.variable("heating_setpoint").values[time_index]
+        self._HR_min = self.variable("humidifying_setpoint").values[time_index] 
+        self._HR_max = self.variable("dehumidifying_setpoint").values[time_index] 
+
+    def iteration(self, time_index, date, daylight_saving, n_iter):
+        super().iteration(time_index, date, daylight_saving, n_iter)
+        self._control_system = {"M_a": 0, "T_a": 0, "w_a":0, "Q_s":0, "M_w":0 }      
+        if self._on_off:
+            self._calculate_required_Q()
+            self._calculate_required_M()
+            self._control_system["Q_s"] = self._Q_spa
+            self._control_system["M_w"] = self._M_spa
+        self._space.set_control_system(self._control_system)
+        return True
+    
+    def _calculate_required_Q(self):
+        K_t,F_t = self._space.get_thermal_equation(False)
+        K_ts = K_t + self._outdoor_air_flow * self._outdoor_rho * self.props["C_PA"]
+        F_ts = F_t + self._outdoor_air_flow * self._outdoor_rho * self.props["C_PA"] * self._T_odb
+        self._T_space = F_ts/K_ts
+        if self._T_space > self._T_cool_sp:
+            self._T_space = self._T_cool_sp
+            self._Q_sys =  K_ts * self._T_space - F_ts
+        elif self._T_space < self._T_heat_sp:
+            self._T_space = self._T_heat_sp
+            self._Q_sys =  K_ts * self._T_space - F_ts
+        else: 
+            self._Q_sys = 0
+        self._Q_spa = K_t * self._T_space - F_t
+    
+    def _calculate_required_M(self):
+        K_h,F_h = self._space.get_humidity_equation(False)
+        K_hs = K_h + self._outdoor_air_flow * self._outdoor_rho
+        F_hs = F_h + self._outdoor_air_flow * self._outdoor_rho * self._w_o 
+        self._w_space = F_hs/K_hs
+        if self._w_space < 0:
+            self._w_space = 0
+        hr_space = sicro.GetRelHumFromHumRatio(self._T_space, self._w_space/1000, self.props["ATM_PRESSURE"])*100
+        if hr_space < self._HR_min:
+            self._w_space = sicro.GetHumRatioFromRelHum(self._T_space, self._HR_min/100, self.props["ATM_PRESSURE"])*1000
+            self._M_sys =  K_hs * self._w_space - F_hs
+        elif hr_space > self._HR_max:
+            self._w_space = sicro.GetHumRatioFromRelHum(self._T_space, self._HR_max/100, self.props["ATM_PRESSURE"])*1000
+            self._M_sys =  K_hs * self._w_space - F_hs
+        else:
+            self._M_sys = 0
+        self._M_spa = K_h * self._w_space - F_h
+
+
+    def post_iteration(self, time_index, date, daylight_saving, converged):
+        super().post_iteration(time_index, date, daylight_saving, converged)
+        if self._on_off:
+            self.variable("Q_sensible").values[time_index] = self._Q_sys  
+            self.variable("Q_latent").values[time_index] = self._M_sys * self.props["LAMBDA"]
+            self.variable("Q_total").values[time_index] = self._Q_sys + self._M_sys * self.props["LAMBDA"]
+            if self._Q_sys > 0: # Heating, Cooling or Venting
+                self.variable("state").values[time_index] = 1
+            elif self._Q_sys < 0:
+                self.variable("state").values[time_index] = -1
+            else:
+                self.variable("state").values[time_index] = 3
+
+

opensimula/components/Material.py

@@ -0,0 +1,14 @@
+from opensimula.Parameters import Parameter_boolean, Parameter_float
+from opensimula.Component import Component
+
+
+class Material(Component):
+    def __init__(self, name, project):
+        Component.__init__(self, name, project)
+        self.parameter("type").value = "Material"
+        self.parameter("description").value = "Material layer properties"
+        self.add_parameter(Parameter_float("conductivity", 1, "W/(m·K)", min=0))
+        self.add_parameter(Parameter_float("density", 1000, "kg/m³", min=0.001))
+        self.add_parameter(Parameter_float("specific_heat", 1000, "J/(kg·K)", min=0.001))
+        self.add_parameter(Parameter_boolean("use_resistance", False))
+        self.add_parameter(Parameter_float("thermal_resistance", 1, "(m²·K)/W", min=0))

opensimula/components/Opening.py

@@ -0,0 +1,409 @@
+import math
+from opensimula.Component import Component
+from opensimula.Message import Message
+from opensimula.Parameters import (
+    Parameter_component,
+    Parameter_float,
+    Parameter_float_list,
+    Parameter_options,
+)
+from opensimula.Variable import Variable
+from shapely.geometry import Polygon
+from opensimula.visual_3D.Polygon_3D import Polygon_3D
+
+
+class Opening(Component):
+    def __init__(self, name, project):
+        Component.__init__(self, name, project)
+        # Parameters
+        self.parameter("type").value = "Opening"
+        self.parameter("description").value = (
+            "Openings (windows/doors) in building surfaces"
+        )
+        self.add_parameter(
+            Parameter_component("surface", "not_defined", ["Building_surface"])
+        )
+        self.add_parameter(
+            Parameter_component("opening_type", "not_defined", ["Opening_type"])
+        )
+        self.add_parameter(
+            Parameter_options("shape", "RECTANGLE", ["RECTANGLE", "POLYGON"])
+        )
+        self.add_parameter(Parameter_float_list("ref_point", [0, 0], "m"))
+        self.add_parameter(Parameter_float("width", 1, "m", min=0.0))
+        self.add_parameter(Parameter_float("height", 1, "m", min=0.0))
+        self.add_parameter(
+            Parameter_float_list("x_polygon", [0, 10, 10, 0], "m", min=float("-inf"))
+        )
+        self.add_parameter(
+            Parameter_float_list("y_polygon", [0, 0, 10, 10], "m", min=float("-inf"))
+        )
+        self.add_parameter(
+            Parameter_float("setback", 0, "m", min=0.0)
+        )  # Only for rectangular openings
+        self.add_parameter(Parameter_float_list("h_cv", [19.3, 2], "W/m²K", min=0))
+
+        self.H_RD = 5.705  # 4*sigma*(293^3)
+        # Variables
+        self.add_variable(Variable("T_s0", "°C"))
+        self.add_variable(Variable("T_s1", "°C"))
+        self.add_variable(Variable("T_rm", "°C"))
+        self.add_variable(Variable("E_dir_sunny", "W/m²"))
+        self.add_variable(Variable("E_dir", "W/m²"))
+        self.add_variable(Variable("E_dif_sunny", "W/m²"))
+        self.add_variable(Variable("E_dif", "W/m²"))
+        self.add_variable(Variable("E_dir_tra", "W/m²"))
+        self.add_variable(Variable("E_dif_tra", "W/m²"))
+        self.add_variable(Variable("theta_sun", "°"))
+        self.add_variable(Variable("E_ref", "W/m²"))
+        self.add_variable(Variable("E_ref_tra", "W/m²"))
+        self.add_variable(Variable("q_cv0", "W/m²"))
+        self.add_variable(Variable("q_cv1", "W/m²"))
+        self.add_variable(Variable("q_cd", "W/m²"))
+        self.add_variable(Variable("q_sol0", "W/m²"))
+        self.add_variable(Variable("q_sol1", "W/m²"))
+        self.add_variable(Variable("q_swig0", "W/m²"))
+        self.add_variable(Variable("q_swig1", "W/m²"))
+        self.add_variable(Variable("q_lwig0", "W/m²"))
+        self.add_variable(Variable("q_lwig1", "W/m²"))
+        self.add_variable(Variable("q_lwt0", "W/m²"))
+        self.add_variable(Variable("q_lwt1", "W/m²"))
+        self.add_variable(Variable("debug_f", ""))
+
+    def check(self):
+        errors = super().check()
+        # Test surface
+        if self.parameter("surface").value == "not_defined":
+            msg = f"{self.parameter('name').value}, its surface must be defined."
+            errors.append(Message(msg, "ERROR"))
+        # TODO: Test surface_type EXTERIOR or INTERIOR
+        # Test opening_type defined
+        if self.parameter("opening_type").value == "not_defined":
+            msg = (
+                f"{self.parameter('name').value}, opening must define its Opening_type."
+            )
+            errors.append(Message(msg, "ERROR"))
+        # Test if Polygon shape that x_polygon and y_polygon has the same size
+        if self.parameter("shape").value == "POLYGON":
+            if len(self.parameter("x_polygon").value) != len(
+                self.parameter("y_polygon").value
+            ):
+                msg = f"{self.parameter('name').value}, x_polygo and y_polygon must have the same size."
+                errors.append(Message(msg, "ERROR"))
+        return errors
+
+    def get_building(self):
+        return self.get_surface().get_building()
+
+    def get_space(self, side=0):
+        return self.get_surface().get_space(side)
+
+    def get_surface(self):
+        return self.parameter("surface").component
+    
+    def is_exterior(self):
+        return (self.get_surface().parameter("surface_type").value == "EXTERIOR")
+
+    # _______ pre_simulation _______
+    def pre_simulation(self, n_time_steps, delta_t):
+        super().pre_simulation(n_time_steps, delta_t)
+        self._file_met = self.project().parameter("simulation_file_met").component
+        self._calculate_K_()
+        self.f_dif_setback = self._f_diffuse_setback_()
+        if self.is_exterior():
+            self._sunny_index = self.project().env_3D.get_sunny_index(
+                self.parameter("name").value
+            )
+        else:
+            self._sunny_index = None
+
+    def _calculate_K_(self):
+        self.k = [0, 0]
+        self.k[0] = self.area * (
+            -self.parameter("h_cv").value[0]
+            - self.H_RD * self.radiant_property("alpha", "long_wave", 0)
+            - 1 / self.parameter("opening_type").component.thermal_resistance()
+        )
+        self.k[1] = self.area * (
+            -1 / self.parameter("opening_type").component.thermal_resistance()
+            - self.parameter("h_cv").value[1]
+        )
+        self.k_01 = (
+            self.area / self.parameter("opening_type").component.thermal_resistance()
+        )
+
+    def _f_diffuse_setback_(self):
+        if (
+            self.parameter("shape").value == "POLYGON"
+            or self.parameter("setback").value == 0
+        ):
+            return 1
+        else:
+            X = self.parameter("width").value / self.parameter("setback").value
+            Y = self.parameter("height").value / self.parameter("setback").value
+            F = (
+                2
+                / (math.pi * X * Y)
+                * (
+                    math.log(((1 + X**2) * (1 + Y**2) / (1 + X**2 + Y**2)) ** 0.5)
+                    + X * ((1 + Y**2) ** 0.5) * math.atan(X / ((1 + Y**2) ** 0.5))
+                    + Y * ((1 + X**2)) ** 0.5 * math.atan(Y / ((1 + X**2)) ** 0.5)
+                    - X * math.atan(X)
+                    - Y * math.atan(Y)
+                )
+            )
+            return 1 - F
+
+    # _______ pre_iteration _______
+    def pre_iteration(self, time_index, date, daylight_saving):
+        super().pre_iteration(time_index, date, daylight_saving)
+        if self.is_exterior():
+            self._calculate_exterior_variables_pre_iteration_(time_index)
+
+    def _calculate_exterior_variables_pre_iteration_(self, time_i):
+        self._T_ext = self._file_met.variable("temperature").values[time_i]
+        # Solar radiation from the surface where the opening is located
+        surface = self.get_surface()
+        # Diffuse solar radiation
+        E_dif_sunny = surface.variable("E_dif_sunny").values[time_i]
+        self.variable("E_dif_sunny").values[time_i] = E_dif_sunny
+        diffuse_sunny_fraction = self.project().env_3D.get_diffuse_sunny_fraction(
+            self._sunny_index
+        )
+        E_dif = E_dif_sunny * diffuse_sunny_fraction
+        self.variable("E_dif").values[time_i] = E_dif
+
+        # Direct solar radiation
+        E_dir_sunny = surface.variable("E_dir_sunny").values[time_i]
+        self.variable("E_dir_sunny").values[time_i] = E_dir_sunny
+        # Setback shadow
+        theta = self._file_met.solar_surface_angle(
+            time_i,
+            surface.orientation_angle("azimuth", 0),
+            surface.orientation_angle("altitude", 0),
+        )
+        self.variable("theta_sun").values[time_i] = theta
+        if (
+            theta is not None
+            and self.parameter("shape").value == "RECTANGLE"
+            and self.parameter("setback").value > 0
+        ):
+            f_setback = self._f_setback_(
+                time_i,
+                surface.orientation_angle("azimuth", 0),
+                surface.orientation_angle("altitude", 0),
+            )
+        else:
+            f_setback = 1
+        E_dir = E_dir_sunny * self._calculate_direct_sunny_fraction_(time_i) * f_setback
+        self.variable("E_dir").values[time_i] = E_dir
+
+        q_sol0 = self.radiant_property("alpha", "solar_diffuse", 0) * E_dif
+        q_sol1 = self.radiant_property("alpha_other_side", "solar_diffuse", 0) * E_dif
+        E_dif_tra = self.radiant_property("tau", "solar_diffuse", 0) * E_dif
+        if theta is not None:
+            q_sol0 += self.radiant_property("alpha", "solar_direct", 0, theta) * E_dir
+            q_sol1 += (
+                self.radiant_property("alpha_other_side", "solar_direct", 0, theta)
+                * E_dir
+            )
+            E_dir_tra = self.radiant_property("tau", "solar_direct", 0, theta) * E_dir
+        else:
+            E_dir_tra = 0
+
+        self.variable("q_sol0").values[time_i] = q_sol0
+        self.variable("q_sol1").values[time_i] = q_sol1
+        self.variable("E_dif_tra").values[time_i] = E_dif_tra
+        self.variable("E_dir_tra").values[time_i] = E_dir_tra
+
+        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)
+        self.f_0 = self.area * (
+            -self.parameter("h_cv").value[0] * self._T_ext - h_rd * T_rm
+        )
+        # q_sol0 will be corrected by the building
+
+    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(
+                self._sunny_index
+            )
+        elif self.project().parameter("shadow_calculation").value == "INTERPOLATION":
+            azi = self._file_met.variable("sol_azimuth").values[time_i]
+            alt = self._file_met.variable("sol_altitude").values[time_i]
+            if not math.isnan(alt):
+                direct_sunny_fraction = (
+                    self.project().env_3D.get_direct_interpolated_sunny_fraction(
+                        self._sunny_index, azi, alt
+                    )
+                )
+            else:
+                direct_sunny_fraction = 1
+        elif self.project().parameter("shadow_calculation").value == "NO":
+            direct_sunny_fraction = 1
+        return direct_sunny_fraction
+
+    def _f_setback_(self, time_i, azimuth_sur, altitude_sur):
+        theta_h = math.fabs(
+            self._file_met.variable("sol_azimuth").values[time_i] - azimuth_sur
+        )
+        f_shadow_h = (
+            self.parameter("setback").value
+            * math.tan(math.radians(theta_h))
+            / self.parameter("width").value
+        )
+        if f_shadow_h > 1:
+            f_shadow_h = 1
+        theta_v = math.fabs(
+            self._file_met.variable("sol_altitude").values[time_i] - altitude_sur
+        )
+        f_shadow_v = (
+            self.parameter("setback").value
+            * math.tan(math.radians(theta_v))
+            / self.parameter("height").value
+        )
+        if f_shadow_v > 1:
+            f_shadow_v = 1
+        return (1 - f_shadow_h) * (1 - f_shadow_v)
+
+    # _______ post_iteration _______
+    def post_iteration(self, time_index, date, daylight_saving, converged):
+        super().post_iteration(time_index, date, daylight_saving, converged)
+        if self.is_exterior():
+            self._calculate_T_s0_(time_index)
+        self._calculate_heat_fluxes_(time_index)
+
+    def _calculate_T_s0_(self, time_i):
+        T_s0 = (
+            self.f_0
+            - (
+                self.variable("q_sol0").values[time_i]
+                + self.variable("q_swig0").values[time_i]
+            )
+            * self.area
+            - self.k_01 * self.variable("T_s1").values[time_i]
+        ) / self.k[0]
+        self.variable("T_s0").values[time_i] = T_s0
+
+    def _calculate_heat_fluxes_(self, time_i):
+        q_cd0 = (
+            self.variable("T_s1").values[time_i] - self.variable("T_s0").values[time_i]
+        ) / self.parameter("opening_type").component.thermal_resistance()
+        self.variable("q_cd").values[time_i] = q_cd0
+        if self.is_exterior():
+            self.variable("q_cv0").values[time_i] = self.parameter("h_cv").value[0] * (
+                self._T_ext - self.variable("T_s0").values[time_i]
+            )
+            T_z = self.get_surface().get_space().variable("temperature").values[time_i]
+            self.variable("q_cv1").values[time_i] = self.parameter("h_cv").value[1] * (
+                T_z - self.variable("T_s1").values[time_i]
+            )
+            h_rd = self.H_RD * self.radiant_property("alpha", "long_wave", 0)
+            self.variable("q_lwt0").values[time_i] = h_rd * (
+                self.variable("T_rm").values[time_i]
+                - self.variable("T_s0").values[time_i]
+            )
+            self.variable("q_lwt1").values[time_i] = (
+                +self.variable("q_cd").values[time_i]
+                - self.variable("q_cv1").values[time_i]
+                - self.variable("q_sol1").values[time_i]
+                - self.variable("q_swig1").values[time_i]
+                - self.variable("q_lwig1").values[time_i]
+            )
+        else:  # interior
+            self.variable("q_cv0").values[time_i] = self.parameter("h_cv").value[0] * (
+                self.get_space(0).variable("temperature").values[time_i]
+                - self.variable("T_s0").values[time_i]
+            )
+            self.variable("q_cv1").values[time_i] = self.parameter("h_cv").value[1] * (
+                self.get_space(1).variable("temperature").values[time_i]
+                - self.variable("T_s1").values[time_i]
+            )
+            self.variable("q_lwt0").values[time_i] = (
+                -self.variable("q_cd").values[time_i]
+                - self.variable("q_cv0").values[time_i]
+                - self.variable("q_sol0").values[time_i]
+                - self.variable("q_swig0").values[time_i]
+                - self.variable("q_lwig0").values[time_i]
+            )
+            self.variable("q_lwt1").values[time_i] = (
+                + self.variable("q_cd").values[time_i]
+                - self.variable("q_cv1").values[time_i]
+                - self.variable("q_sol1").values[time_i]
+                - self.variable("q_swig1").values[time_i]
+                - self.variable("q_lwig1").values[time_i]
+            )
+
+    @property
+    def area(self):
+        if self.parameter("shape").value == "RECTANGLE":
+            return self.parameter("width").value * self.parameter("height").value
+        elif self.parameter("shape").value == "POLYGON":
+            polygon = []
+            n = len(self.parameter("x_polygon").value)
+            for i in range(0, n):
+                polygon.append(
+                    [
+                        self.parameter("x_polygon").value[i],
+                        self.parameter("y_polygon").value[i],
+                    ]
+                )
+            return Polygon(polygon).area
+
+    def radiant_property(self, prop, radiation_type, side, theta=0):
+        return self.parameter("opening_type").component.radiant_property(
+            prop, radiation_type, side, theta
+        )
+
+    def orientation_angle(self, angle, side, coordinate_system="global"):
+        return self.get_surface().orientation_angle(angle, side, coordinate_system)
+
+    def get_origin(self, coordinate_system="global"):
+        return self.get_surface().get_origin(coordinate_system)
+
+    def get_polygon_2D(self):  # Get polygon_2D
+        ref = self.parameter("ref_point").value
+        if self.parameter("shape").value == "RECTANGLE":
+            w = self.parameter("width").value
+            h = self.parameter("height").value
+            return [
+                [ref[0], ref[1]],
+                [ref[0] + w, ref[1]],
+                [ref[0] + w, ref[1] + h],
+                [ref[0], ref[1] + h],
+            ]
+        elif self.parameter("shape").value == "POLYGON":
+            polygon2D = []
+            n = len(self.parameter("x_polygon").value)
+            for i in range(0, n):
+                polygon2D.append(
+                    [
+                        self.parameter("x_polygon").value[i] + ref[0],
+                        self.parameter("y_polygon").value[i] + ref[1],
+                    ]
+                )
+            return polygon2D
+
+    def get_polygon_3D(self):
+        azimuth = self.orientation_angle("azimuth", 0, "global")
+        altitude = self.orientation_angle("altitude", 0, "global")
+        origin = self.get_origin("global")
+        pol_2D = self.get_polygon_2D()
+        name = self.parameter("name").value
+        if self.is_exterior():
+            return Polygon_3D(
+                name, origin, azimuth, altitude, pol_2D, color="blue", opacity=0.6
+            )
+        else:
+            return Polygon_3D(
+                name,
+                origin,
+                azimuth,
+                altitude,
+                pol_2D,
+                color="blue",
+                opacity=0.6,
+                shading=False,
+                calculate_shadows=False,
+            )

opensimula/components/Opening_type.py

@@ -0,0 +1,90 @@
+from opensimula.Component import Component
+from opensimula.Message import Message
+from opensimula.Parameters import Parameter_float, Parameter_component
+
+
+class Opening_type(Component):
+    def __init__(self, name, project):
+        Component.__init__(self, name, project)
+        self.parameter("type").value = "Opening_type"
+        self.parameter(
+            "description").value = "Window or doors with glazing, construction, frame and shading."
+
+        self.add_parameter(Parameter_component(
+            "glazing", "not_defined", "Glazing"))
+        self.add_parameter(Parameter_component(
+            "frame", "not_defined", "Frame"))
+        self.add_parameter(Parameter_component(
+            "construction", "not_defined", "Construction"))
+        self.add_parameter(Parameter_float(
+            "glazing_fraction", 0.9, "frac", min=0, max=1))
+        self.add_parameter(Parameter_float(
+            "frame_fraction", 0.1, "frac", min=0, max=1))
+
+    def check(self):
+        errors = super().check()
+        # Test glazing defined
+        if self.parameter("glazing").value == "not_defined" and self.parameter("glazing_fraction").value > 0:
+            msg = f"{self.parameter('name').value}, glazing must be defined."
+            errors.append(Message(msg, "ERROR"))
+        # Test frame defined
+        if self.parameter("frame").value == "not_defined" and self.parameter("frame_fraction").value > 0:
+            msg = f"{self.parameter('name').value}, frame must be defined."
+            errors.append(Message(msg, "ERROR"))
+        # Test construction defined
+        self.construction_fraction = 1 - \
+            self.parameter("glazing_fraction").value - \
+            self.parameter("frame_fraction").value
+        if self.parameter("construction").value == "not_defined" and self.construction_fraction > 0:
+            msg = f"{self.parameter('name').value}, construction must be defined."
+            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._calc_thermal_resistance()
+
+    def _calc_thermal_resistance(self):
+        f_glazing = self.parameter("glazing_fraction").value
+        f_frame = self.parameter("frame_fraction").value
+        f_construction = 1 - f_glazing - f_frame
+        r_glazing = 0
+        r_frame = 0
+        r_construction = 0
+
+        if (f_glazing > 0):
+            r_glazing = self.parameter(
+                "glazing").component.thermal_resistance()
+        if (f_frame > 0):
+            r_frame = self.parameter("frame").component.parameter(
+                "thermal_resistance").value
+        if (f_construction > 0):
+            r_construction = self.parameter(
+                "construction").component.thermal_resistance()
+
+        self._thermal_resistance = r_glazing*f_glazing + \
+            r_frame*f_frame + r_construction*f_construction
+
+    def thermal_resistance(self):
+        return self._thermal_resistance
+
+    def radiant_property(self, prop, radiation_type, side, theta=0):
+        f_glazing = self.parameter("glazing_fraction").value
+        f_frame = self.parameter("frame_fraction").value
+        f_construction = 1 - f_glazing - f_frame
+
+        value = 0
+        if (f_glazing > 0):
+            value += f_glazing * \
+                self.parameter("glazing").component.radiant_property(
+                    prop, radiation_type, side, theta)
+        if (f_frame > 0):
+            value += f_frame * \
+                self.parameter("frame").component.radiant_property(
+                    prop, radiation_type, side, theta)
+        if (f_construction > 0):
+            value += f_construction * \
+                self.parameter("construction").component.radiant_property(
+                    prop, radiation_type, side, theta)
+
+        return value