OpenSimula 0.6.1__tar.gz → 0.7.1__tar.gz

{opensimula-0.6.1 → opensimula-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opensimula
-Version: 0.6.1
+Version: 0.7.1
 Summary: Component-based time simulation environment in Python
 Author-email: "Juan F. Coronel" <jfc@us.es>
 Requires-Python: >=3.12
@@ -18,7 +18,6 @@ Requires-Dist: psychrolib>=2.5.0
 Requires-Dist: scipy>=1.16.2
 Requires-Dist: shapely>=2.1.1
 Requires-Dist: tqdm>=4.67.1
-Requires-Dist: triangle>=20250106
 Requires-Dist: vedo>=2025.5.4
 Dynamic: license-file
 

{opensimula-0.6.1 → opensimula-0.7.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "opensimula"
-version = "0.6.1"
+version = "0.7.1"
 requires-python = ">=3.12"
 authors = [
   { name="Juan F. Coronel", email="jfc@us.es" },
@@ -20,8 +20,7 @@ dependencies = [
     "scipy>=1.16.2",
     "shapely>=2.1.1",
     "tqdm>=4.67.1",
-    "triangle>=20250106",
-    "vedo>=2025.5.4",
+"vedo>=2025.5.4",
 ]
 
 [dependency-groups]

{opensimula-0.6.1 → opensimula-0.7.1}/src/opensimula/Project.py

@@ -676,23 +676,23 @@ class Project(Parameter_container):
             if hasattr(component, "get_polygon_3D"):
                 env_3D.add_polygon_3D(component.get_polygon_3D())
            
-    def show_3D(self):
+    def show_3D(self, jupyter=False):
         env_3D = Environment_3D()
         self.create_3D_environment(env_3D)
-        env_3D.show(polygons_type="initial")
-    
-    def show_3D_shadows(self, date):
+        env_3D.show(polygons_type="initial", jupyter=jupyter)
+
+    def show_3D_shadows(self, date, jupyter=False):
         env_3D = Environment_3D()
         self.create_3D_environment(env_3D)
         file_met = self.parameter("simulation_file_met").component
         cos = file_met.sun_cosines(date)
         if len(cos) == 3:
             env_3D.calculate_shadows(cos)
-            env_3D.show(polygons_type="Building_shadows")
+            env_3D.show(polygons_type="Building_shadows", jupyter=jupyter)
         else:
             self._sim_.message(Message(date.strftime("%H:%M,  %d/%m/%Y") + " is night", "WARNING"))
 
-    def show_3D_shadows_animation(self, date):
+    def show_3D_shadows_animation(self, date, jupyter=False):
         env_3D = Environment_3D()
         self.create_3D_environment(env_3D)
         file_met = self.parameter("simulation_file_met").component
@@ -701,9 +701,9 @@ class Project(Parameter_container):
         for hour in range(24):
             new_date = date.replace(hour=hour, minute=0, second=0)
             cos = file_met.sun_cosines(new_date)
-            if len(cos) == 3: # Day time
+            if len(cos) == 3:  # Day time
                 texts.append(new_date.strftime("%H:%M,  %d/%m/%Y"))
                 cosines.append(cos)
-        env_3D.show_animation(texts, cosines, polygons_type="Building_shadows")
+        env_3D.show_animation(texts, cosines, polygons_type="Building_shadows", jupyter=jupyter)
 
             

{opensimula-0.6.1 → opensimula-0.7.1}/src/opensimula/__init__.py

@@ -5,4 +5,4 @@ opensimula is a Python Package for perform time simulations
 """
 from opensimula.Simulation import Simulation
 from opensimula.Iterative_process import Iterative_process
-VERSION = "0.6.1"
+VERSION = "0.7.1"

opensimula-0.6.1/src/opensimula/components/HVAC_DX_equipment.py → opensimula-0.7.1/src/opensimula/components/DX_unit.py

@@ -3,11 +3,11 @@ from opensimula.Parameters import Parameter_float, Parameter_float_list, Paramet
 from opensimula.Component import Component
 from scipy.optimize import fsolve
 
-class HVAC_DX_equipment(Component):
+class DX_unit(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.parameter("type").value = "DX_unit"
+        self.parameter("description").value = "Direct Expansion unit 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))

opensimula-0.6.1/src/opensimula/components/HVAC_fan_equipment.py → opensimula-0.7.1/src/opensimula/components/Fan.py

@@ -1,11 +1,11 @@
 from opensimula.Parameters import Parameter_float, Parameter_math_exp
 from opensimula.Component import Component
 
-class HVAC_fan_equipment(Component):
+class Fan(Component):
     def __init__(self, name, project):
         Component.__init__(self, name, project)
-        self.parameter("type").value = "HVAC_fan_equipment"
-        self.parameter("description").value = "HVAC Fan equipment manufacturer information"
+        self.parameter("type").value = "Fan"
+        self.parameter("description").value = "Fan equipment manufacturer information"
         self.add_parameter(Parameter_float("nominal_air_flow", 1, "m³/s", min=0))
         self.add_parameter(Parameter_float("nominal_pressure", 1, "Pa", min=0))
         self.add_parameter(Parameter_float("nominal_power", 1, "W", min=0))

{opensimula-0.6.1 → opensimula-0.7.1}/src/opensimula/components/HVAC_DX_system.py

@@ -10,7 +10,7 @@ class HVAC_DX_system(Component):
         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("equipment", "not_defined", ["DX_unit"]))
         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"))

{opensimula-0.6.1 → opensimula-0.7.1}/src/opensimula/components/HVAC_MZW_system.py

@@ -32,16 +32,16 @@ class HVAC_MZW_system(Component):  # HVAC Multizone Water system
             )
         )
         self.add_parameter(
-            Parameter_component("cooling_coil", "not_defined", ["HVAC_coil_equipment"])
+            Parameter_component("cooling_coil", "not_defined", ["Water_coil"])
         )
         self.add_parameter(
-            Parameter_component("heating_coil", "not_defined", ["HVAC_coil_equipment"])
+            Parameter_component("heating_coil", "not_defined", ["Water_coil"])
         )
         self.add_parameter(
-            Parameter_component("supply_fan", "not_defined", ["HVAC_fan_equipment"])
+            Parameter_component("supply_fan", "not_defined", ["Fan"])
         )
         self.add_parameter(
-            Parameter_component("return_fan", "not_defined", ["HVAC_fan_equipment"])
+            Parameter_component("return_fan", "not_defined", ["Fan"])
         )
         self.add_parameter(Parameter_float("air_flow", 1, "m³/s", min=0))
         self.add_parameter(
@@ -108,7 +108,7 @@ class HVAC_MZW_system(Component):  # HVAC Multizone Water system
         self.add_parameter(Parameter_boolean("vav", False))
         self.add_parameter(
             Parameter_component_list(
-                "reheat_coils", ["not_defined", "not_defined"], ["HVAC_coil_equipment"]
+                "reheat_coils", ["not_defined", "not_defined"], ["Water_coil"]
             )
         )
 

{opensimula-0.6.1 → opensimula-0.7.1}/src/opensimula/components/HVAC_SZW_system.py

@@ -20,16 +20,16 @@ class HVAC_SZW_system(Component):  # HVAC Single Zone Water system
             Parameter_component("space", "not_defined", ["Space"])
         )  # Space
         self.add_parameter(
-            Parameter_component("cooling_coil", "not_defined", ["HVAC_coil_equipment"])
+            Parameter_component("cooling_coil", "not_defined", ["Water_coil"])
         )
         self.add_parameter(
-            Parameter_component("heating_coil", "not_defined", ["HVAC_coil_equipment"])
+            Parameter_component("heating_coil", "not_defined", ["Water_coil"])
         )
         self.add_parameter(
-            Parameter_component("supply_fan", "not_defined", ["HVAC_fan_equipment"])
+            Parameter_component("supply_fan", "not_defined", ["Fan"])
         )
         self.add_parameter(
-            Parameter_component("return_fan", "not_defined", ["HVAC_fan_equipment"])
+            Parameter_component("return_fan", "not_defined", ["Fan"])
         )
         self.add_parameter(Parameter_float("air_flow", 1, "m³/s", min=0))
         self.add_parameter(Parameter_float("return_air_flow", 1, "m³/s", min=0))

{opensimula-0.6.1 → opensimula-0.7.1}/src/opensimula/components/Surface.py

@@ -12,7 +12,7 @@ class Surface(Component):
         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("azimuth", 0, "°", min=-180, max=180))  # Angle from building -Y axis to horizontal projection of exterior normal -> 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"]))

opensimula-0.6.1/src/opensimula/components/HVAC_coil_equipment.py → opensimula-0.7.1/src/opensimula/components/Water_coil.py

@@ -4,11 +4,11 @@ from opensimula.Component import Component
 from scipy.optimize import fsolve
 import psychrolib as sicro
 
-class HVAC_coil_equipment(Component):
+class Water_coil(Component):
     def __init__(self, name, project):
         Component.__init__(self, name, project)
-        self.parameter("type").value = "HVAC_coil_equipment"
-        self.parameter("description").value = "HVAC coil equipment manufacturer information"
+        self.parameter("type").value = "Water_coil"
+        self.parameter("description").value = "Water coil equipment manufacturer information"
         self.add_parameter(Parameter_float("nominal_air_flow", 1, "m³/s", min=0))
         self.add_parameter(Parameter_float("nominal_cooling_water_flow", 1, "m³/s", min=0))
         self.add_parameter(Parameter_float("nominal_total_cooling_capacity", 0, "W", min=0))

{opensimula-0.6.1 → opensimula-0.7.1}/src/opensimula/components/__init__.py

@@ -16,9 +16,9 @@ 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.DX_unit import DX_unit
+from opensimula.components.Water_coil import Water_coil
+from opensimula.components.Fan import Fan
 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

opensimula-0.7.1/src/opensimula/visual_3D/Environment_3D.py

@@ -0,0 +1,492 @@
+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
+
+    # ── Plotly helpers (jupyter mode) ──────────────────────────────────────
+
+    def _rgb_str_(self, color_name):
+        rgb = vedo.colors.get_color(color_name)
+        return f"rgb({int(rgb[0]*255)},{int(rgb[1]*255)},{int(rgb[2]*255)})"
+
+    def _polygon_to_plotly_(self, polygon_3D):
+        """Returns (go.Mesh3d, go.Scatter3d outline) for a single Polygon_3D."""
+        import plotly.graph_objects as go
+        points, faces = polygon_3D._triangulate_()
+        pts = np.array(points)
+        fcs = np.array(faces)
+        color = self._rgb_str_(polygon_3D.color)
+        mesh = go.Mesh3d(
+            x=pts[:, 0], y=pts[:, 1], z=pts[:, 2],
+            i=fcs[:, 0], j=fcs[:, 1], k=fcs[:, 2],
+            color=color, opacity=polygon_3D.opacity,
+            name=polygon_3D.name,
+            hovertemplate=f"<b>{polygon_3D.name}</b><extra></extra>",
+            flatshading=True,
+            lighting=dict(ambient=0.85, diffuse=0.5, specular=0.05),
+        )
+        boundary = np.array(polygon_3D.polygon3D)
+        xs = list(boundary[:, 0]) + [boundary[0, 0], None]
+        ys = list(boundary[:, 1]) + [boundary[0, 1], None]
+        zs = list(boundary[:, 2]) + [boundary[0, 2], None]
+        outline = go.Scatter3d(
+            x=xs, y=ys, z=zs,
+            mode="lines",
+            line=dict(color="black", width=2),
+            showlegend=False, hoverinfo="skip",
+        )
+        return mesh, outline
+
+    def _merge_to_plotly_(self, polygon_list, name=""):
+        """Merge multiple Polygon_3D into a single go.Mesh3d (for animation frames)."""
+        import plotly.graph_objects as go
+        if not polygon_list:
+            return go.Mesh3d(x=[0], y=[0], z=[0], i=[], j=[], k=[],
+                             visible=False, showlegend=False, hoverinfo="skip")
+        all_pts, all_i, all_j, all_k, all_colors = [], [], [], [], []
+        offset = 0
+        for pol in polygon_list:
+            points, faces = pol._triangulate_()
+            pts = np.array(points)
+            fcs = np.array(faces)
+            all_pts.append(pts)
+            all_i.extend((fcs[:, 0] + offset).tolist())
+            all_j.extend((fcs[:, 1] + offset).tolist())
+            all_k.extend((fcs[:, 2] + offset).tolist())
+            c = self._rgb_str_(pol.color)
+            all_colors.extend([c] * len(fcs))
+            offset += len(pts)
+        pts_arr = np.concatenate(all_pts, axis=0)
+        return go.Mesh3d(
+            x=pts_arr[:, 0], y=pts_arr[:, 1], z=pts_arr[:, 2],
+            i=all_i, j=all_j, k=all_k,
+            facecolor=all_colors,
+            flatshading=True, name=name,
+            hoverinfo="skip",
+            lighting=dict(ambient=0.85, diffuse=0.5, specular=0.05),
+        )
+
+    def _merge_outlines_to_plotly_(self, polygon_list):
+        """Merge outlines of multiple Polygon_3D into a single go.Scatter3d."""
+        import plotly.graph_objects as go
+        xs, ys, zs = [], [], []
+        for pol in polygon_list:
+            boundary = np.array(pol.polygon3D)
+            if len(boundary) == 0:
+                continue
+            xs.extend(list(boundary[:, 0]) + [boundary[0, 0], None])
+            ys.extend(list(boundary[:, 1]) + [boundary[0, 1], None])
+            zs.extend(list(boundary[:, 2]) + [boundary[0, 2], None])
+        return go.Scatter3d(
+            x=xs, y=ys, z=zs,
+            mode="lines",
+            line=dict(color="black", width=2),
+            showlegend=False, hoverinfo="skip",
+        )
+
+    def _scene_bounds_(self, pols):
+        """Return (xmin, xmax, ymin, ymax, zmin, zmax) for a list of Polygon_3D."""
+        all_pts = np.concatenate([np.array(p.polygon3D) for p in pols if len(p.polygon3D) > 0], axis=0)
+        return (all_pts[:, 0].min(), all_pts[:, 0].max(),
+                all_pts[:, 1].min(), all_pts[:, 1].max(),
+                all_pts[:, 2].min(), all_pts[:, 2].max())
+
+    def _zero_plane_traces_(self, pols):
+        """Return thin-line Scatter3d outlines for the x=0, y=0, z=0 planes."""
+        import plotly.graph_objects as go
+        if not pols:
+            return []
+        xmin, xmax, ymin, ymax, zmin, zmax = self._scene_bounds_(pols)
+        style = dict(color="rgba(100,100,100,0.5)", width=1)
+        traces = []
+
+        def rect_trace(xs, ys, zs):
+            return go.Scatter3d(
+                x=xs, y=ys, z=zs,
+                mode="lines",
+                line=style,
+                showlegend=False, hoverinfo="skip",
+            )
+
+        # z=0 plane outline (only if 0 is within z range)
+        if zmin <= 0 <= zmax:
+            traces.append(rect_trace(
+                [xmin, xmax, xmax, xmin, xmin],
+                [ymin, ymin, ymax, ymax, ymin],
+                [0, 0, 0, 0, 0],
+            ))
+        # x=0 plane outline
+        if xmin <= 0 <= xmax:
+            traces.append(rect_trace(
+                [0, 0, 0, 0, 0],
+                [ymin, ymax, ymax, ymin, ymin],
+                [zmin, zmin, zmax, zmax, zmin],
+            ))
+        # y=0 plane outline
+        if ymin <= 0 <= ymax:
+            traces.append(rect_trace(
+                [xmin, xmax, xmax, xmin, xmin],
+                [0, 0, 0, 0, 0],
+                [zmin, zmin, zmax, zmax, zmin],
+            ))
+        return traces
+
+    def _plotly_scene_layout_(self):
+        import plotly.graph_objects as go
+        axis_style = dict(
+            showbackground=True,
+            backgroundcolor="rgb(220, 220, 220)",
+            tickfont=dict(size=9, color="gray"),
+            title_font=dict(size=10, color="gray"),
+        )
+        return go.Layout(
+            paper_bgcolor="rgb(235, 235, 235)",
+            scene=dict(
+                xaxis=dict(title="X [m]", **axis_style),
+                yaxis=dict(title="Y [m]", **axis_style),
+                zaxis=dict(title="Z [m]", **axis_style),
+                aspectmode="data",
+                bgcolor="rgb(235, 235, 235)",
+            ),
+            margin=dict(l=0, r=0, t=0, b=0),
+            showlegend=False,
+        )
+
+    # ── Public show methods ─────────────────────────────────────────────────
+
+    def show(self, polygons_type="initial", jupyter=False):
+        if jupyter:
+            import plotly.graph_objects as go
+            if polygons_type == "initial":
+                pols = [p for p in self.pol_3D if p.visible]
+            elif polygons_type == "Building_shadows":
+                pols = (list(self.pol_sunny) + list(self.pol_shadows) +
+                        [p for p in self.pol_3D if p.visible and not p.calculate_shadows])
+            elif polygons_type == "sunny":
+                pols = list(self.pol_sunny)
+            elif polygons_type == "shadows":
+                pols = list(self.pol_shadows)
+            else:
+                pols = list(self.pol_sunny) + list(self.pol_shadows)
+            traces = []
+            for pol in pols:
+                mesh, outline = self._polygon_to_plotly_(pol)
+                traces.extend([mesh, outline])
+            traces.extend(self._zero_plane_traces_(pols))
+            go.Figure(data=traces, layout=self._plotly_scene_layout_()).show()
+        else:
+            vedo.settings.default_backend = "vtk"
+            meshes = self.get_vedo_meshes(polygons_type)
+            text_obj = [None]
+
+            def on_left_click(evt):
+                if text_obj[0] is not None:
+                    vp.remove(text_obj[0])
+                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')
+                vp.add(text_obj[0])
+                vp.render()
+
+            vp = vedo.Plotter(title="opensimula")
+            vp.add_callback('mouse click', on_left_click)
+            vp.show(*meshes, axes=1, viewup="z").close()
+
+    def show_animation(self, texts, cosines, polygons_type="initial", jupyter=False):
+        if jupyter:
+            import plotly.graph_objects as go
+
+            # Static traces: surfaces that don't participate in shadow calculation
+            static_pols = [p for p in self.pol_3D if p.visible and not p.calculate_shadows]
+            static_traces = []
+            for pol in static_pols:
+                mesh, outline = self._polygon_to_plotly_(pol)
+                static_traces.extend([mesh, outline])
+            all_pols = list(self.pol_3D) + list(self.pol_sunny) + list(self.pol_shadows)
+            static_traces.extend(self._zero_plane_traces_([p for p in all_pols if len(p.polygon3D) > 0]))
+            n_static = len(static_traces)
+
+            # Build frames (sunny + shadow merged meshes update per frame)
+            self.calculate_shadows(cosines[0], create_polygons=True)
+            init_sunny = self._merge_to_plotly_(self.pol_sunny, "sunny")
+            init_sunny_outline = self._merge_outlines_to_plotly_(self.pol_sunny)
+            init_shadow = self._merge_to_plotly_(self.pol_shadows, "shadow")
+            init_shadow_outline = self._merge_outlines_to_plotly_(self.pol_shadows)
+
+            frames = []
+            for i, (cos, text) in enumerate(zip(cosines, texts)):
+                self.calculate_shadows(cos, create_polygons=True)
+                frames.append(go.Frame(
+                    data=[self._merge_to_plotly_(self.pol_sunny, "sunny"),
+                          self._merge_outlines_to_plotly_(self.pol_sunny),
+                          self._merge_to_plotly_(self.pol_shadows, "shadow"),
+                          self._merge_outlines_to_plotly_(self.pol_shadows)],
+                    traces=[n_static, n_static + 1, n_static + 2, n_static + 3],
+                    name=str(i),
+                    layout=go.Layout(title_text=text),
+                ))
+
+            layout = self._plotly_scene_layout_()
+            layout.update(
+                title_text=texts[0],
+                margin=dict(l=0, r=0, t=30, b=80),
+                updatemenus=[dict(
+                    type="buttons", direction="left",
+                    pad={"r": 10, "t": 20}, x=0.1, y=0,
+                    buttons=[
+                        dict(label="▶ Play", method="animate",
+                             args=[None, {"frame": {"duration": 800, "redraw": True},
+                                          "fromcurrent": True}]),
+                        dict(label="⏸ Pause", method="animate",
+                             args=[[None], {"frame": {"duration": 0}, "mode": "immediate"}]),
+                    ],
+                )],
+                sliders=[dict(
+                    active=0,
+                    steps=[dict(
+                        method="animate",
+                        args=[[str(i)], {"frame": {"duration": 0, "redraw": True},
+                                         "mode": "immediate"}],
+                        label=texts[i],
+                    ) for i in range(len(texts))],
+                    x=0, y=0, len=1.0, pad={"b": 10, "t": 30},
+                )],
+            )
+            go.Figure(
+                data=static_traces + [init_sunny, init_sunny_outline, init_shadow, init_shadow_outline],
+                layout=layout,
+                frames=frames,
+            ).show()
+        else:
+            vedo.settings.default_backend = "vtk"
+            meshes = []
+
+            def slider_func(widget, event):
+                idx = int(widget.value)
+                widget.title = texts[idx]
+                vp.remove(meshes.pop(0))
+                cos = cosines[idx]
+                self.calculate_shadows(cos, create_polygons=True)
+                meshes.append(self.get_vedo_meshes(polygons_type))
+                vp.add(meshes[0])
+
+            self.calculate_shadows(cosines[0], create_polygons=True)
+            meshes.append(self.get_vedo_meshes(polygons_type))
+            vp = vedo.Plotter(title="opensimula", axes=1)
+            vp.add(meshes[0])
+            vp.add_slider(
+                slider_func,
+                0, len(cosines) - 1,
+                value=0,
+                pos="bottom-right",
+                title=texts[0],
+            )
+            vp.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()
+
+

{opensimula-0.6.1 → opensimula-0.7.1}/src/opensimula/visual_3D/Polygon_3D.py

@@ -1,8 +1,8 @@
 import math
 import numpy as np
-from shapely.geometry import Polygon
+from shapely.geometry import Polygon, MultiPoint
+from shapely.ops import triangulate as shapely_triangulate
 import vedo
-from triangle import triangulate
 
 class Polygon_3D():
     def __init__(self, name, origin, azimuth, altitude, polygon2D, holes2D=[], color="white", opacity=1.0, visible=True,shading=True,calculate_shadows=True):
@@ -74,32 +74,27 @@ class Polygon_3D():
         return mesh
 
     def _triangulate_(self):
-        def edge_idxs(nv):
-            i = np.append(np.arange(nv), 0)
-            return np.stack([i[:-1], i[1:]], axis=1)
+        all_verts = list(self.polygon2D)
+        for hole in self.holes2D:
+            all_verts.extend(hole)
 
-        nv = 0
-        verts, edges = [], []
-        for loop in (self.polygon2D, *self.holes2D):
-            verts.append(loop)
-            edges.append(nv + edge_idxs(len(loop)))
-            nv += len(loop)
+        tris = [t for t in shapely_triangulate(MultiPoint(all_verts))
+                if self.shapely_polygon.contains(t.centroid)]
 
-        verts, edges = np.concatenate(verts), np.concatenate(edges)
-        # Triangulate needs to know a single interior point for each hole
-        holes = np.array([np.mean(h, axis=0) for h in self.holes2D])
-        # Because triangulate is a wrapper around a C library the syntax is a little weird, 'p' here means planar straight line graph
-        if self.has_holes():
-            d = triangulate(dict(vertices=verts, segments=edges, holes=holes), opts='p')
-        else:
-            d = triangulate(dict(vertices=verts, segments=edges), opts='p')
-        # Convert back 
-        v, f = d['vertices'], d['triangles']
-        nv, nf = len(v), len(f)
-        points = np.concatenate([v, np.zeros((nv, 1))], axis=1)
-        # Creo que lo tengo que hacer en 2D y luego pasarlo a 3D
-        #faces = np.concatenate([np.full((nf, 1), 3), f], axis=1).reshape(-1)
-        return (self._convert_2D_to_3D_(points), f)
+        vert_map = {}
+        verts = []
+        faces = []
+        for tri in tris:
+            face = []
+            for c in list(tri.exterior.coords)[:-1]:
+                key = (round(c[0], 10), round(c[1], 10))
+                if key not in vert_map:
+                    vert_map[key] = len(verts)
+                    verts.append(c)
+                face.append(vert_map[key])
+            faces.append(face)
+
+        return (self._convert_2D_to_3D_(np.array(verts)), np.array(faces))
 
     def _are_vertices_counterclockwise_(self,puntos):
         # Se suma el primer punto al final para cerrar el polígono.

{opensimula-0.6.1 → opensimula-0.7.1}/src/opensimula.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opensimula
-Version: 0.6.1
+Version: 0.7.1
 Summary: Component-based time simulation environment in Python
 Author-email: "Juan F. Coronel" <jfc@us.es>
 Requires-Python: >=3.12
@@ -18,7 +18,6 @@ Requires-Dist: psychrolib>=2.5.0
 Requires-Dist: scipy>=1.16.2
 Requires-Dist: shapely>=2.1.1
 Requires-Dist: tqdm>=4.67.1
-Requires-Dist: triangle>=20250106
 Requires-Dist: vedo>=2025.5.4
 Dynamic: license-file
 

{opensimula-0.6.1 → opensimula-0.7.1}/src/opensimula.egg-info/SOURCES.txt

@@ -20,17 +20,16 @@ src/opensimula/components/Building.py
 src/opensimula/components/Building_surface.py
 src/opensimula/components/Calculator.py
 src/opensimula/components/Construction.py
+src/opensimula/components/DX_unit.py
 src/opensimula/components/Day_schedule.py
+src/opensimula/components/Fan.py
 src/opensimula/components/File_data.py
 src/opensimula/components/File_met.py
 src/opensimula/components/Frame.py
 src/opensimula/components/Glazing.py
-src/opensimula/components/HVAC_DX_equipment.py
 src/opensimula/components/HVAC_DX_system.py
 src/opensimula/components/HVAC_MZW_system.py
 src/opensimula/components/HVAC_SZW_system.py
-src/opensimula/components/HVAC_coil_equipment.py
-src/opensimula/components/HVAC_fan_equipment.py
 src/opensimula/components/HVAC_perfect_system.py
 src/opensimula/components/Material.py
 src/opensimula/components/Opening.py
@@ -40,6 +39,7 @@ src/opensimula/components/Space.py
 src/opensimula/components/Space_type.py
 src/opensimula/components/Surface.py
 src/opensimula/components/Test_component.py
+src/opensimula/components/Water_coil.py
 src/opensimula/components/Week_schedule.py
 src/opensimula/components/Year_schedule.py
 src/opensimula/components/__init__.py

{opensimula-0.6.1 → opensimula-0.7.1}/src/opensimula.egg-info/requires.txt

@@ -10,5 +10,4 @@ psychrolib>=2.5.0
 scipy>=1.16.2
 shapely>=2.1.1
 tqdm>=4.67.1
-triangle>=20250106
 vedo>=2025.5.4

{opensimula-0.6.1 → opensimula-0.7.1}/test/test_HVAC_DX_Equipment.py

@@ -2,10 +2,10 @@ import opensimula as osim
 import pytest
 
 case_dict = {
-    "name": "Test_HVAC_DX_equipment",
+    "name": "Test_DX_unit",
     "components": [
         {
-            "type": "HVAC_DX_equipment",
+            "type": "DX_unit",
             "name": "HVAC_equipment",
             "nominal_air_flow": 0.4248,
             "nominal_total_cooling_capacity": 7951,

{opensimula-0.6.1 → opensimula-0.7.1}/test/test_HVAC_DX_system.py

@@ -323,7 +323,7 @@ case610_dict = {
             "altitude": 90
         },
         {
-            "type": "HVAC_DX_equipment",
+            "type": "DX_unit",
             "name": "HVAC_equipment",
             "nominal_air_flow": 0.417,
             "nominal_total_cooling_capacity": 6900,

opensimula-0.6.1/src/opensimula/visual_3D/Environment_3D.py

@@ -1,257 +0,0 @@
-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()
-
-