OpenSimula 0.5.1__py3-none-any.whl

opensimula/components/Surface.py

@@ -0,0 +1,129 @@
+import math
+import numpy as np
+from opensimula.Component import Component
+from opensimula.Message import Message
+from opensimula.Parameters import Parameter_options, Parameter_float, Parameter_float_list
+from shapely.geometry import Polygon
+from opensimula.Variable import Variable
+
+
+class Surface(Component):
+    def __init__(self, name, project):
+        Component.__init__(self, name, project)
+        # Parameters
+        self.parameter("type").value = "Surface"
+        self.add_parameter(Parameter_float("azimuth", 0, "°", min=-180, max=180))  # Surface x vs Building x -> S: 0º, E: 90º, W: -90º, N: 180º
+        self.add_parameter(Parameter_float("altitude", 0, "°", min=-90, max=90))  # Surface y vs Building y -> vertical: 0º, facing up: 90º, facing down: -90º
+        self.add_parameter(Parameter_options(
+            "shape", "RECTANGLE", ["RECTANGLE", "POLYGON"]))
+        self.add_parameter(Parameter_float("width", 1, "m", min=0.0))
+        self.add_parameter(Parameter_float("height", 1, "m", min=0.0))
+        # Building Coordinate system
+        self.add_parameter(Parameter_float_list(
+            "ref_point", [0, 0, 0], "m", min=float("-inf")))
+        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")))
+        
+        # Variables
+        self.add_variable(Variable("E_dir_sunny", "W/m²"))  # Without shadows
+        self.add_variable(Variable("E_dir", "W/m²"))
+        self.add_variable(Variable("E_dif_sunny", "W/m²"))  # Without shadows
+        self.add_variable(Variable("E_dif", "W/m²"))
+
+    def check(self):
+        errors = super().check()
+        # 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 pre_simulation(self, n_time_steps, delta_t):
+        super().pre_simulation(n_time_steps, delta_t)
+
+    @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
+
+    # exterior normal vector
+    def orientation_angle(self, angle, side, coordinate_system="global"):
+        if angle == "azimuth":
+            az = self.parameter("azimuth").value
+            if self.get_building() is not None and coordinate_system == "global":
+                    azi_building = self.get_building().parameter("azimuth").value
+                    az = az + azi_building
+            if side == 0:
+                return az
+            elif side == 1:
+                if az > 0:
+                    return az-180
+                else:
+                    return az+180
+        elif angle == "altitude":
+            alt = self.parameter("altitude").value
+            if side == 0:
+                return alt
+            elif side == 1:
+                return -alt
+
+    def get_building(self): # Default no building
+        return None
+    
+    def radiant_property(self, prop, radiation_type, side, theta=0):
+        """It must be redefined by child classes
+
+        Args:
+            prop (_type_): _description_
+            radiation_type (_type_): _description_
+            side (_type_): _description_
+
+        Returns:
+            _type_: _description_
+        """
+        return 0
+
+    def get_origin(self, coordinate_system="global"):
+        if self.get_building() is not None:
+            if coordinate_system == "global":
+                az_b = math.radians(self.get_building().parameter("azimuth").value)
+                local_origin = self.parameter("ref_point").value
+                global_origin = [local_origin[0]*math.cos(az_b)-local_origin[1]*math.sin(az_b),
+                             local_origin[0]*math.sin(az_b) +
+                             local_origin[1]*math.cos(az_b),
+                             local_origin[2]]
+                return global_origin
+            elif coordinate_system == "building":
+                return np.array(self.parameter("ref_point").value)+ np.array(self.get_building().parameter("ref_point").value)
+            else:
+                return self.parameter("ref_point").value
+        else:
+            return self.parameter("ref_point").value
+
+    def get_polygon_2D(self):  # Get polygon_2D
+        if (self.parameter("shape").value == "RECTANGLE"):
+            w = self.parameter("width").value
+            h = self.parameter("height").value
+            return [[0, 0], [w, 0], [w, h], [0, 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],
+                                  self.parameter("y_polygon").value[i]])
+            return polygon2D
+        
+    def get_polygon_3D(self): # Global coordenates
+        return None
+
+    

opensimula/components/Test_component.py

@@ -0,0 +1,76 @@
+from opensimula.Parameters import (
+    Parameter_boolean,
+    Parameter_float,
+    Parameter_int,
+    Parameter_string,
+    Parameter_options,
+    Parameter_component,
+    Parameter_boolean_list,
+    Parameter_string_list,
+    Parameter_int_list,
+    Parameter_float_list,
+    Parameter_options_list,
+    Parameter_component_list,
+    Parameter_variable,
+    Parameter_variable_list,
+    Parameter_math_exp,
+    Parameter_math_exp_list
+)
+from opensimula.Component import Component
+from opensimula.Variable import Variable
+
+
+class Test_component(Component):
+    """Component for development testing"""
+
+    def __init__(self, name, project):
+        Component.__init__(self, name, project)
+        self.parameter("type").value = "Test_component"
+        self.parameter("description").value = "Dummy component for testing"
+
+        self.add_parameter(Parameter_boolean("boolean", False))
+        self.add_parameter(Parameter_string("string", "Hello World"))
+        self.add_parameter(Parameter_int("int", 100, "h"))
+        self.add_parameter(Parameter_float("float", 0.1, "m"))
+        self.add_parameter(Parameter_options(
+            "options", "One", ["One", "Two", "Three"]))
+        self.add_parameter(Parameter_component("component", "not_defined"))
+        self.add_parameter(Parameter_variable("variable"))
+        self.add_parameter(Parameter_math_exp("math_exp"))
+        self.add_parameter(Parameter_boolean_list(
+            "boolean_list", [True, False]))
+        self.add_parameter(Parameter_string_list(
+            "string_list", ["Hello World 1", "Hello World 2"]))
+        self.add_parameter(Parameter_int_list("int_list", [50, 100], "h"))
+        self.add_parameter(Parameter_float_list("float_list", [0.1, 0.2], "m"))
+        self.add_parameter(Parameter_options_list(
+            "options_list", ["One", "Two"], ["One", "Two", "Three"]))
+        self.add_parameter(Parameter_component_list(
+            "component_list", ["not_defined", "not_defined"]))
+        self.add_parameter(Parameter_variable_list("variable_list"))
+        self.add_parameter(Parameter_math_exp_list("math_exp_list"))
+
+        # Variable
+        self.add_variable(Variable("t", unit="s"))
+        self.add_variable(Variable("exp_1"))
+        self.add_variable(Variable("exp_2"))
+        self.add_variable(Variable("exp_3"))
+
+        self._initial_date_ = None
+
+    def pre_simulation(self, n_time_steps, delta_t):
+        super().pre_simulation(n_time_steps, delta_t)
+
+    def pre_iteration(self, time_index, date, daylight_saving):
+        super().pre_iteration(time_index, date, daylight_saving)
+        if time_index == 0:
+            self._initial_date_ = date
+        self.variable("t").values[time_index] = (
+            date - self._initial_date_).total_seconds()
+
+        variables_dic = {}
+        for key, var in self._variables_.items():
+            variables_dic[key] = var.values[time_index]
+
+        self.variable("exp_1").values[time_index] = self.parameter(
+            "math_exp").evaluate(variables_dic)

opensimula/components/Week_schedule.py

@@ -0,0 +1,30 @@
+from opensimula.Message import Message
+from opensimula.Parameters import Parameter_component_list
+from opensimula.Component import Component
+
+
+class Week_schedule(Component):
+    def __init__(self, name, project):
+        Component.__init__(self, name, project)
+        self.parameter("type").value = "Week_schedule"
+        self.parameter("description").value = "Time schedule for a week"
+        self.add_parameter(Parameter_component_list(
+            "days_schedules", ["not_defined"], ["Day_schedule"]))
+
+    def check(self):
+        errors = super().check()
+        # Test if 1 or 7 has been defined
+        if (
+            len(self.parameter("days_schedules").value) != 1
+            and len(self.parameter("days_schedules").value) != 7
+        ):
+            msg = f"{self.parameter('name').value}, days_schedules parameter must contain 1 or 7 Day_schedule components"
+            errors.append(Message(msg, "ERROR"))
+        return errors
+
+    def get_value(self, date):
+        if len(self.parameter("days_schedules").value) == 1:
+            return self.parameter("days_schedules").component[0].get_value(date)
+        else:
+            index = date.weekday()
+            return self.parameter("days_schedules").component[index].get_value(date)

opensimula/components/Year_schedule.py

@@ -0,0 +1,65 @@
+import datetime as dt
+from bisect import bisect
+from opensimula.Message import Message
+from opensimula.Parameters import Parameter_component_list, Parameter_string_list
+from opensimula.Component import Component
+from opensimula.Variable import Variable
+
+
+class Year_schedule(Component):
+    def __init__(self, name, project):
+        Component.__init__(self, name, project)
+        self.parameter("type").value = "Year_schedule"
+        self.parameter("description").value = "Time schedule for a year"
+        self.add_parameter(Parameter_string_list("periods", ["01/06"]))
+        self.add_parameter(
+            Parameter_component_list(
+                "weeks_schedules", ["not_defined",
+                                    "not_defined"], ["Week_schedule"]
+            )
+        )
+        # Create Variable
+        self.add_variable(Variable(
+            "values", "", "Values obtained using year, weeks and days schedules for each of the simulation time steps."))
+
+    def check(self):
+        errors = super().check()
+        if (
+            len(self.parameter("periods").value)
+            != len(self.parameter("weeks_schedules").value) - 1
+        ):
+            msg = f"{self.parameter('name').value}, periods size must be weeks_schedules size minus 1"
+            errors.append(Message(msg, "ERROR"))
+        # Check periods format
+        try:
+            days = []
+            for period in self.parameter("periods").value:
+                datetime = dt.datetime.strptime(period, "%d/%m")
+                days.append(datetime.timetuple().tm_yday)
+            if sorted(days) != days:
+                msg = f"{self.parameter('name').value}, periods are not ordered"
+                errors.append(Message(msg, "ERROR"))
+        except ValueError:
+            msg = f"{self.parameter('name').value}, periods does not match format (dd/mm)"
+            errors.append(Message(msg, "ERROR"))
+        return errors
+
+    def pre_simulation(self, n_time_steps, delta_t):
+        super().pre_simulation(n_time_steps, delta_t)
+
+        # Create array of periods_days
+        self._periods_days_ = []
+        for period in self.parameter("periods").value:
+            datetime = dt.datetime.strptime(period, "%d/%m")
+            self._periods_days_.append(datetime.timetuple().tm_yday)
+
+    def pre_iteration(self, time_index, date, daylight_saving):
+        super().pre_iteration(time_index, date, daylight_saving)
+        if daylight_saving:  # adding 1 h
+            date = date + dt.timedelta(0, 3600)
+        self.variable("values").values[time_index] = self.get_value(date)
+
+    def get_value(self, date):
+        year_day = date.timetuple().tm_yday
+        index = bisect(self._periods_days_, year_day)
+        return self.parameter("weeks_schedules").component[index].get_value(date)

opensimula/components/__init__.py

@@ -0,0 +1,40 @@
+from opensimula.components.Test_component import Test_component
+from opensimula.components.Material import Material
+from opensimula.components.Glazing import Glazing
+from opensimula.components.Frame import Frame
+from opensimula.components.Construction import Construction
+from opensimula.components.Opening_type import Opening_type
+from opensimula.components.File_data import File_data
+from opensimula.components.Day_schedule import Day_schedule
+from opensimula.components.Week_schedule import Week_schedule
+from opensimula.components.Year_schedule import Year_schedule
+from opensimula.components.File_met import File_met
+from opensimula.components.Space_type import Space_type
+from opensimula.components.Building import Building
+from opensimula.components.Space import Space
+from opensimula.components.Building_surface import Building_surface
+from opensimula.components.Solar_surface import Solar_surface
+from opensimula.components.Opening import Opening
+from opensimula.components.Calculator import Calculator
+from opensimula.components.HVAC_DX_equipment import HVAC_DX_equipment
+from opensimula.components.HVAC_coil_equipment import HVAC_coil_equipment
+from opensimula.components.HVAC_fan_equipment import HVAC_fan_equipment
+from opensimula.components.HVAC_DX_system import HVAC_DX_system
+from opensimula.components.HVAC_SZW_system import HVAC_SZW_system
+from opensimula.components.HVAC_MZW_system import HVAC_MZW_system
+from opensimula.components.HVAC_perfect_system import HVAC_perfect_system
+
+DEFAULT_COMPONENTS_ORDER = [
+                    "Space_type",
+                    "Building_surface",
+                    "Solar_surface",
+                    "Opening",
+                    "Space",
+                    "Building",
+                    "HVAC_MZW_system",
+                    "HVAC_perfect_system",
+                    "HVAC_DX_system",
+                    "HVAC_SZW_system",
+                    "Calculator"
+                ]
+

opensimula/visual_3D/Environment_3D.py

@@ -0,0 +1,257 @@
+import time
+import numpy as np
+import math
+from scipy.interpolate import RegularGridInterpolator
+import matplotlib.pyplot as plt
+import vedo as vedo
+
+class Environment_3D:
+    def __init__(self):
+        self.pol_3D = []
+        self.pol_sunny = []
+        self.pol_shadows = []
+        self.sunny_fraction = []
+        self.solar_tables_calculated = False
+
+    def add_polygon_3D(self, polygon_3D):
+        self.pol_3D.append(polygon_3D)
+        self.sunny_fraction.append(1.0)
+
+    def get_vedo_meshes(self, polygons_type="initial"):
+        meshes = []
+        if polygons_type == "initial":
+            for polygon_3D in self.pol_3D:
+                if polygon_3D.visible:
+                    mesh = polygon_3D.get_vedo_mesh()
+                    mesh.polygon_name = polygon_3D.name
+                    meshes.append(mesh)
+                    meshes.append(mesh.silhouette("2d").c("black").linewidth(5))
+        elif polygons_type == "sunny":
+            for polygon_3D in self.pol_sunny:
+                mesh = polygon_3D.get_vedo_mesh()
+                mesh.polygon_name = polygon_3D.name
+                meshes.append(mesh)
+                meshes.append(mesh.silhouette("2d").c("black").linewidth(5))
+        elif polygons_type == "shadows":
+            for polygon_3D in self.pol_shadows:
+                mesh = polygon_3D.get_vedo_mesh()
+                mesh.polygon_name = polygon_3D.name
+                meshes.append(mesh)
+                meshes.append(mesh.silhouette("2d").c("black").linewidth(5))
+        elif polygons_type == "sunny+shadows":
+            for polygon_3D in self.pol_sunny:
+                mesh = polygon_3D.get_vedo_mesh()
+                mesh.polygon_name = polygon_3D.name
+                meshes.append(mesh)
+                meshes.append(mesh.silhouette("2d").c("black").linewidth(5))
+            for polygon_3D in self.pol_shadows:
+                mesh = polygon_3D.get_vedo_mesh()
+                mesh.polygon_name = polygon_3D.name
+                meshes.append(mesh)
+                meshes.append(mesh.silhouette("2d").c("black").linewidth(5))
+        elif polygons_type == "Building_shadows":
+            for polygon_3D in self.pol_sunny:
+                mesh = polygon_3D.get_vedo_mesh()
+                mesh.polygon_name = polygon_3D.name
+                meshes.append(mesh)
+                meshes.append(mesh.silhouette("2d").c("black").linewidth(5))
+            for polygon_3D in self.pol_shadows:
+                mesh = polygon_3D.get_vedo_mesh()
+                mesh.polygon_name = polygon_3D.name
+                meshes.append(mesh)
+                meshes.append(mesh.silhouette("2d").c("black").linewidth(5))
+            for polygon_3D in self.pol_3D:
+                if polygon_3D.visible and polygon_3D.calculate_shadows == False:
+                    mesh = polygon_3D.get_vedo_mesh()
+                    mesh.polygon_name = polygon_3D.name
+                    meshes.append(mesh)
+                    meshes.append(mesh.silhouette("2d").c("black").linewidth(5))
+
+        return meshes
+
+    def show(self, polygons_type="initial"):
+        vedo.settings.default_backend = 'vtk'
+        meshes = self.get_vedo_meshes(polygons_type)
+        
+        text_obj = [None]  # Usamos una lista para que sea mutable en el callback
+
+        def on_left_click(evt):
+            if text_obj[0] is not None:
+                plt.remove(text_obj[0])  # Borra el texto anterior
+            msh = evt.object
+            if not msh:
+                text_obj[0] = vedo.Text2D(" ", pos='top-left')
+            else:
+                text_obj[0] = vedo.Text2D(f"{msh.polygon_name}", pos='top-left')
+            plt.add(text_obj[0])
+            plt.render()
+        
+        plt = vedo.Plotter(title="opensimula")
+        plt.add_callback('mouse click', on_left_click)
+        plt.show(*meshes, axes=1, viewup="z").close()
+
+    def show_animation(self, texts, cosines , polygons_type="initial" ):
+        vedo.settings.default_backend = 'vtk'
+        meshes = []
+        def slider_func(widget, event):
+            idx = int(widget.value)
+            widget.title = texts[idx]
+            plt.remove( meshes.pop(0))
+            cos = cosines[idx]
+            self.calculate_shadows(cos, create_polygons=True)
+            meshes.append(self.get_vedo_meshes(polygons_type))
+            plt.add(meshes[0])
+
+        # Show first frame
+        self.calculate_shadows(cosines[0], create_polygons=True)
+        meshes.append(self.get_vedo_meshes(polygons_type))
+        plt = vedo.Plotter(title="opensimula", axes=1)  
+        plt.add(meshes[0])
+        plt.add_slider(
+            slider_func,
+            0, len(cosines)-1,  # slider range
+            value=0,         # initial value
+            pos="bottom-right",  # position of the slider
+            title=texts[0]
+        )
+        plt.show(viewup="z").close()
+        
+    def delete_shadows(self):
+        self.pol_sunny = []
+        self.pol_shadows = []
+        self.sunny_fraction = []
+
+    def calculate_shadows(self, sun_position, create_polygons=True):
+        self.sunny_fraction = []
+        if create_polygons:
+            self.pol_sunny = []
+            self.pol_shadows = []
+
+        for polygon in self.pol_3D:
+            if polygon.calculate_shadows:
+                sunny_polygons, shadow_polygons = polygon.get_sunny_shadow_polygon3D(
+                    self, sun_position
+                )
+                if sunny_polygons is not None:
+                    sunny_area = 0
+                    for sunny_polygon in sunny_polygons:
+                        if create_polygons:
+                            self.pol_sunny.append(sunny_polygon)
+                        sunny_area += sunny_polygon.area
+                    self.sunny_fraction.append(sunny_area / polygon.area)
+                else:
+                    self.sunny_fraction.append(0)  # No sunny area
+                if create_polygons:
+                    if shadow_polygons is not None:
+                        for shadow_polygon in shadow_polygons:
+                            self.pol_shadows.append(shadow_polygon)
+    
+    def get_sunny_polygon_list(self):
+        sunny_polygons = []
+        for polygon in self.pol_3D:
+            if polygon.calculate_shadows:
+                sunny_polygons.append(polygon)
+        return sunny_polygons
+    
+    def get_sunny_index(self, name):
+        sunny_polygons = self.get_sunny_polygon_list()
+        for i in range(len(sunny_polygons)):
+            if sunny_polygons[i].name == name:
+                return i
+        return None
+    
+    def calculate_solar_tables(self):
+        self._calculate_shadow_interpolation_table()
+        self._calculate_diffuse_shadow()
+        self.solar_tables_calculated = True
+
+    def _calculate_shadow_interpolation_table(self):
+        self.shadow_azimuth_grid = np.linspace(0, 350, 36)
+        self.shadow_altitude_grid = np.linspace(-85, 85, 18)
+        sunny_polygons = self.get_sunny_polygon_list()
+        self.sunny_fraction_tables = np.zeros((len(sunny_polygons), 36, 18))
+        j = 0
+        for azimuth in self.shadow_azimuth_grid:
+            azi_rd = math.radians(azimuth)
+            k = 0
+            for altitude in self.shadow_altitude_grid:
+                alt_rd = math.radians(altitude)
+                sun_position = np.array(
+                    [
+                        math.cos(alt_rd) * math.sin(azi_rd),
+                        -math.cos(alt_rd) * math.cos(azi_rd),
+                        math.sin(alt_rd),
+                    ]
+                )
+
+                self.calculate_shadows(sun_position, create_polygons=False)
+                sunny_frac = self.sunny_fraction
+                for i in range(len(sunny_frac)):
+                    self.sunny_fraction_tables[i][j][k] = sunny_frac[i]
+                k = k + 1
+            j = j + 1
+        
+        self.sunny_interpolation_functions = []
+        for i in range(0, len(sunny_polygons)):
+            self.sunny_interpolation_functions.append(
+                RegularGridInterpolator(
+                    (self.shadow_azimuth_grid, self.shadow_altitude_grid),
+                    self.sunny_fraction_tables[i],
+                    bounds_error=False,
+                    fill_value=None,
+                    method="cubic",
+                )
+            )
+    
+    def _calculate_diffuse_shadow(self):
+        def integral(i,polygon_i):
+            sunny_value = 0
+            shadow_value = 0
+            n = 0
+            for j in range(len(self.shadow_azimuth_grid)):
+                for k in range(len(self.shadow_altitude_grid)):
+                    theta = polygon_i.get_angle_with_normal(
+                        self.shadow_azimuth_grid[j], self.shadow_altitude_grid[k]
+                    )
+                    if theta < math.pi / 2:
+                        f = 0.5 * math.sin(2 * theta)
+                        sunny_value = sunny_value + f
+                        shadow_value = (
+                            shadow_value + f * self.sunny_fraction_tables[i][j][k]
+                        )
+                        n = n + 1
+            return shadow_value / sunny_value
+
+        self.shadow_diffuse_fraction = []
+        sunny_polygon_list = self.get_sunny_polygon_list()
+        for i in range(0, len(sunny_polygon_list)):
+            polygon_i = sunny_polygon_list[i]
+            self.shadow_diffuse_fraction.append(integral(i, polygon_i))
+    
+    def get_diffuse_sunny_fraction(self, sunny_i):
+        if self.solar_tables_calculated == True:
+            return self.shadow_diffuse_fraction[sunny_i]
+        else:
+            return 1
+
+    def get_direct_interpolated_sunny_fraction(self, sunny_i, azi, alt):
+        if self.solar_tables_calculated == True:
+            if azi < 0:
+                azi = azi + 360
+            return self.sunny_interpolation_functions[sunny_i]((azi, alt))
+        else:
+            return 1      
+    
+    def get_direct_sunny_fraction(self, sunny_i):
+        if self.sunny_fraction == []:
+            return 1
+        else:
+            return self.sunny_fraction[sunny_i]
+    
+    def show_sunny_fraction(self, sunny_i):
+        fig, ax = plt.subplots()
+        X, Y = np.meshgrid(self.shadow_azimuth_grid, self.shadow_altitude_grid)
+        ax.imshow(self.sunny_fraction_tables[sunny_i], vmin=0, vmax=1)
+        plt.show()
+
+