OpenSimula 0.5.1__tar.gz

opensimula-0.5.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Juan F. Coronel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

opensimula-0.5.1/PKG-INFO

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: opensimula
+Version: 0.5.1
+Summary: Component-based time simulation environment in Python
+Author-email: "Juan F. Coronel" <jfc@us.es>
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: dash>=3.2.0
+Requires-Dist: dash-ag-grid>=32.3.2
+Requires-Dist: dash-bootstrap-components>=2.0.4
+Requires-Dist: nbformat>=5.10.4
+Requires-Dist: numpy>=2.3.3
+Requires-Dist: openpyxl>=3.1.5
+Requires-Dist: pandas>=2.3.2
+Requires-Dist: plotly>=6.3.0
+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
+
+![Logo](https://jfcoronel.github.io/opensimula/img/logo_opensimula.png)
+Component-based time simulation environment in Python
+
+[Documentation page](https://jfcoronel.github.io/opensimula/)
+
+## Main Developers
+
+* [Juan F. Coronel](http://jfc.us.es), Universidad de Sevilla
+
+## Package dependencies
+- numpy
+- pandas
+- scipy
+- shapely
+- psychrolib
+- plotly
+- dash
+- dash_bootstrap_components
+- dash_ag_grid
+- pyvista
+- trame
+- trame-vtk
+- trame-vuetify
+- ipywidgets
+

opensimula-0.5.1/README.md

@@ -0,0 +1,25 @@
+![Logo](https://jfcoronel.github.io/opensimula/img/logo_opensimula.png)
+Component-based time simulation environment in Python
+
+[Documentation page](https://jfcoronel.github.io/opensimula/)
+
+## Main Developers
+
+* [Juan F. Coronel](http://jfc.us.es), Universidad de Sevilla
+
+## Package dependencies
+- numpy
+- pandas
+- scipy
+- shapely
+- psychrolib
+- plotly
+- dash
+- dash_bootstrap_components
+- dash_ag_grid
+- pyvista
+- trame
+- trame-vtk
+- trame-vuetify
+- ipywidgets
+

opensimula-0.5.1/pyproject.toml

@@ -0,0 +1,37 @@
+[project]
+name = "opensimula"
+version = "0.5.1"
+requires-python = ">=3.12"
+authors = [
+  { name="Juan F. Coronel", email="jfc@us.es" },
+]
+description = "Component-based time simulation environment in Python"
+readme = "README.md"
+dependencies = [
+    "dash>=3.2.0",
+    "dash-ag-grid>=32.3.2",
+    "dash-bootstrap-components>=2.0.4",
+    "nbformat>=5.10.4",
+    "numpy>=2.3.3",
+    "openpyxl>=3.1.5",
+    "pandas>=2.3.2",
+    "plotly>=6.3.0",
+    "psychrolib>=2.5.0",
+    "scipy>=1.16.2",
+    "shapely>=2.1.1",
+    "tqdm>=4.67.1",
+    "triangle>=20250106",
+    "vedo>=2025.5.4",
+]
+
+[dependency-groups]
+dev = [
+    "ipykernel>=6.30.1",
+    "mkdocs>=1.6.1",
+    "pytest>=8.4.2",
+]
+
+[build-system]
+requires = ["setuptools>=61.2", "wheel"]
+
+

opensimula-0.5.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

opensimula-0.5.1/src/opensimula/Child.py

@@ -0,0 +1,19 @@
+# ____________ Child ________________________
+
+
+class Child():
+    """Objects with parent
+    
+    Superclass for Paramaters an Variables
+    """
+
+    def __init__(self, parent=None):
+        self._parent_ = parent
+
+    @property
+    def parent(self):
+        return self._parent_
+
+    @parent.setter
+    def parent(self, parent):
+        self._parent_ = parent

opensimula-0.5.1/src/opensimula/Component.py

@@ -0,0 +1,214 @@
+import pandas as pd
+from opensimula.Parameter_container import Parameter_container
+from opensimula.Parameters import Parameter_string
+from opensimula.Variable import Variable
+
+
+class Component(Parameter_container):
+    """Base Class for all the components"""
+
+    def __init__(self, name, proj):
+        Parameter_container.__init__(self, proj._sim_)
+        self._variables_ = {}
+        self.add_parameter(Parameter_string("type", "Component"))
+        self.parameter("name").value = name
+        self.parameter("description").value = "Description of the component"
+        self._project_ = proj
+
+    def project(self):
+        return self._project_
+
+    def add_variable(self, variable):
+        """add new Variable"""
+        variable.parent = self
+        variable._sim_ = self._sim_
+        self._variables_[variable.key] = variable
+
+    def del_variable(self, variable):
+        self._variables_.pop(variable.key,None)
+
+    def variable(self, key):
+        return self._variables_[key]
+
+    def variable_dict(self):
+        return self._variables_
+
+    def variable_dataframe(self, units=False, frequency=None, value="mean", interval=None, pos_neg_columns=[]):
+        """_summary_
+
+        Args:
+            units (bool, optional): Includes unit in the name of the variable. Defaults to True.
+            frequency (None or str, optional): frequency of the values: None, "H" Hour, "D" Day, "M" Month, "Y" Year . Defaults to None.
+            value (str, optional): "mean", "sum", "sum_pos", "sum_neg", "max" or "min". Defaults to "mean".
+            interval (None or list of two dates): List with the start and end dates of the period to be included in the dataframe, if the value is None all values are included.
+            pos_neg_columns (list of str, optional): List of variables that will be included in separate columns positive and negative values. Defaults to [].
+
+        Returns:
+            pandas DataFrame: Returns all the variables 
+        """
+        series = {}
+        series["date"] = self.project().dates()
+        for key, var in self._variables_.items():
+            if var.unit == "":
+                series[key] = var.values
+            else:
+                if units:
+                    series[key + " [" + var.unit + "]"] = var.values
+                else:
+                    series[key] = var.values
+        data = pd.DataFrame(series)
+        if pos_neg_columns != []:
+            for col in pos_neg_columns:
+                data[col + "_pos"] = data[col].apply(lambda x: x if x > 0 else 0)
+                data[col + "_neg"] = data[col].apply(lambda x: x if x < 0 else 0)
+        if frequency is not None:
+            if value == "mean":
+                data = data.resample(frequency, on='date').mean()
+            elif value == "sum":
+                data = data.resample(frequency, on='date').sum()
+            elif value == "max":
+                data = data.resample(frequency, on='date').max()
+            elif value == "min":
+                data = data.resample(frequency, on='date').min()
+        if interval is not None:
+            data = data[(data['date'] > interval[0]) &
+                        (data['date'] < interval[1])]
+        return data
+
+    # ____________ Functions that must be overwriten for time simulation _________________
+
+    def get_all_referenced_components(self):
+        """Get list of all referenced components, first itself. Look recursively at the referenced components
+
+        Returns:
+            component_list (component[])
+        """
+        comp_list = []
+        for key, value in self.parameter_dict().items():
+            if value.type == "Parameter_component":
+                if value.component is not None:
+                    sublist = value.component.get_all_referenced_components()
+                    for subcomp in sublist:
+                        comp_list.append(subcomp)
+            elif value.type == "Parameter_component_list":
+                for comp in value.component:
+                    if comp is not None:
+                        sublist = comp.get_all_referenced_components()
+                        for subcomp in sublist:
+                            comp_list.append(subcomp)
+            if value.type == "Parameter_variable":
+                if value.variable is not None:
+                    sublist = value.variable.parent.get_all_referenced_components()
+                    for subcomp in sublist:
+                        comp_list.append(subcomp)
+            elif value.type == "Parameter_variable_list":
+                for var in value.variable:
+                    if var is not None:
+                        sublist = var.parent.get_all_referenced_components()
+                        for subcomp in sublist:
+                            comp_list.append(subcomp)
+        comp_list.append(self)
+        return comp_list
+
+    def check(self):
+        """Check if all is correct
+
+        Returns:
+            errors (string list): List of errors
+        """
+        errors = []
+        # Parameter errors
+        for key, value in self.parameter_dict().items():
+            param_error = value.check()
+            for e in param_error:
+                errors.append(e)
+            # Create variables in paramater_variable
+            if value.type == "Parameter_variable":
+                if value.variable is not None:
+                    if (value.symbol in self._variables_):  # Delete
+                        self.del_variable(self.variable(value.symbol))
+                    self.add_variable(
+                        Variable(value.symbol, value.variable.unit))
+            if value.type == "Parameter_variable_list":
+                for i in range(len(value.variable)):
+                    if value.variable[i] is not None:
+                        if (value.symbol[i] in self._variables_):  # Delete
+                            self.del_variable(self.variable(value.symbol[i]))
+                        self.add_variable(
+                            Variable(value.symbol[i], value.variable[i].unit))
+
+        return errors
+
+    def get_parameter_variable_dictionary(self,time_index):
+        # variables dictonary
+        var_dic = {}
+        for i in range(len(self._var_from_parameter_symbol)):
+            var_dic[self._var_from_parameter_symbol[i]] = self._var_from_parameter_variable[i].values[time_index]
+        return var_dic
+
+    def pre_simulation(self, n_time_steps, delta_t):
+        # Create variables from paramater "Parameter_variable" and "Parameter_variable_list"
+        self._var_from_parameter_symbol = []
+        self._var_from_parameter_variable = []
+        for param in self.parameter_dict().values():
+            if param.type == "Parameter_variable":
+                self._var_from_parameter_symbol.append(param.symbol)
+                self._var_from_parameter_variable.append(param.variable)
+            elif param.type == "Parameter_variable_list":
+                for i in range(len(param.variable)):
+                    self._var_from_parameter_symbol.append(param.symbol[i])
+                    self._var_from_parameter_variable.append(param.variable[i])
+
+        # Initilise all variables to 0
+        for key, var in self._variables_.items():
+            var.initialise(n_time_steps)
+
+    def post_simulation(self):
+        pass
+
+    def pre_iteration(self, time_index, date, daylight_saving):
+        # Initilise all variables to 0
+        for key, value in self.parameter_dict().items():
+            # Copy variables in paramater_variable
+            if value.type == "Parameter_variable":
+                if value.variable is not None:
+                    self.variable(
+                        value.symbol).values[time_index] = value.variable.values[time_index]
+            if value.type == "Parameter_variable_list":
+                for i in range(len(value.variable)):
+                    if value.variable[i] is not None:
+                        self.variable(
+                            value.symbol[i]).values[time_index] = value.variable[i].values[time_index]
+
+    def iteration(self, time_index, date, daylight_saving, n_iter):
+        return True
+
+    def post_iteration(self, time_index, date, daylight_saving, converged):
+        pass
+
+    def _repr_html_(self):
+        html = f"<h3>Component: {self.parameter('name').value}</h3><p><strong>Desciption: </strong>{self.parameter('description').value}</p>"
+        html += "<strong>Parameters:</strong>"
+        html += self.parameter_dataframe().to_html()
+        if (len(self._variables_) > 0):
+            html += "<br/><strong>Variables:</strong>"
+            html += self.variable_html()
+        return html
+
+    def variable_html(self):
+        keys = []
+        descriptions = []
+        units = []
+        for key, var in self._variables_.items():
+            keys.append(key)
+            descriptions.append(var.description)
+            units.append(var.unit)
+
+        data = pd.DataFrame(
+            {"key": keys, "description": descriptions, "unit": units}
+        )
+        return data.to_html()
+
+    def function_html(self):
+        html = "<p><strong>parameter_dataframe():</strong> Return pandas DataFrame with the component parametes.</p>"
+        html += "<p><strong>variable_dataframe():</strong> Return pandas DataFrame with the component variables.</p>"

opensimula-0.5.1/src/opensimula/Iterative_process.py

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

opensimula-0.5.1/src/opensimula/Message.py

@@ -0,0 +1,19 @@
+class Message:
+    def __init__(self, text, level="ERROR"):
+        self._text_ = text
+        self._level_ = level   # ERROR, WARNING, INFO, CONSOLE
+
+    @property
+    def text(self):
+        return self._text_
+
+    @property
+    def level(self):
+        return self._level_
+    
+    def print(self):
+        if self.level == "CONSOLE":
+            print(self.text)
+        else:
+            print(self.level + ": " + self.text)
+        

opensimula-0.5.1/src/opensimula/Parameter_container.py

@@ -0,0 +1,80 @@
+import pandas as pd
+from opensimula.Parameters import Parameter_string
+from opensimula.Message import Message
+
+class Parameter_container:
+    """Class to manage a list of Paramaters
+
+    Superclass for Projects and Components
+
+    Default parameters included:
+    - name (string)
+    - description (string)
+
+    """
+
+    def __init__(self, sim):
+        self._sim_ = sim
+        self._parameters_ = {}
+        self.add_parameter(Parameter_string("name", "Name"))
+        self.add_parameter(Parameter_string("description", "Description"))
+
+    def add_parameter(self, param):
+        """add Parameter"""
+        param.parent = self
+        param._sim_ = self._sim_
+        self._parameters_[param.key] = param
+
+    def del_parameter(self, param):
+        """Deletet parameter"""
+        self._parameters_.remove(param)
+
+    def parameter(self, key):
+        return self._parameters_[key]
+
+    def parameter_dict(self):
+        return self._parameters_
+
+    def set_parameters(self, dictonary):
+        """Read parameters from dictonary"""
+        for key, value in dictonary.items():
+            if key in self._parameters_:
+                self.parameter(key).value = value
+            else:
+                self._sim_.message(Message("Component parameter " + key + " does not exist","ERROR"))
+
+    def parameter_dataframe(self, string_format=False):
+        keys = []
+        values = []
+        types = []
+        units = []
+        for key, par in self._parameters_.items():
+            keys.append(key)
+            if string_format:
+                values.append(str(par.value))
+            else:
+                values.append(par.value)
+            types.append(par.type)
+            if hasattr(par, "unit"):
+                units.append(par.unit)
+            else:
+                units.append("")
+
+        data = pd.DataFrame(
+            {"key": keys, "type": types, "value": values, "unit": units}
+        )
+        return data
+
+    def check_parameters(self):
+        """Check if all is correct
+
+        Returns:
+            errors (string list): List of errors
+        """
+        errors = []
+        for key, value in self._parameters_.items():
+            param_error = value.check()
+            if len(param_error) > 1:
+                for e in param_error:
+                    errors.append(e)
+        return errors