OpenSimula 0.7.0__tar.gz → 0.8.0__tar.gz

{opensimula-0.7.0 → opensimula-0.8.0}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Juan F. Coronel
+Copyright (c) 2026 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

{opensimula-0.7.0 → opensimula-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opensimula
-Version: 0.7.0
+Version: 0.8.0
 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
 
@@ -44,5 +43,4 @@ Component-based time simulation environment in Python
 - nbformat
 - openpyxl
 - tqdm
-- triangle
 - vedo

{opensimula-0.7.0 → opensimula-0.8.0}/README.md

@@ -20,5 +20,4 @@ Component-based time simulation environment in Python
 - nbformat
 - openpyxl
 - tqdm
-- triangle
 - vedo

{opensimula-0.7.0 → opensimula-0.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "opensimula"
-version = "0.7.0"
+version = "0.8.0"
 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.7.0/src/opensimula → opensimula-0.8.0/src/OpenSimula}/Component.py

@@ -38,7 +38,7 @@ class Component(Parameter_container):
 
         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.
+            frequency (None or str, optional): frequency of the values: None, "hourly", "daily", "monthly", "yearly". 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 [].
@@ -62,14 +62,19 @@ class Component(Parameter_container):
                 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:
+            freq={"hourly": "h", "daily": "D", "monthly": "ME", "yearly": "YE"}
             if value == "mean":
-                data = data.resample(frequency, on='date').mean()
+                data = data.resample(freq[frequency], on='date').mean()
             elif value == "sum":
-                data = data.resample(frequency, on='date').sum()
+                data = data.resample(freq[frequency], on='date').sum()
+            elif value == "sum_pos":
+                data = data.resample(freq[frequency], on='date').apply(lambda x: x.clip(lower=0).sum())
+            elif value == "sum_neg":
+                data = data.resample(freq[frequency], on='date').apply(lambda x: x.clip(upper=0).sum())
             elif value == "max":
-                data = data.resample(frequency, on='date').max()
+                data = data.resample(freq[frequency], on='date').max()
             elif value == "min":
-                data = data.resample(frequency, on='date').min()
+                data = data.resample(freq[frequency], on='date').min()
         if interval is not None:
             data = data[(data['date'] > interval[0]) &
                         (data['date'] < interval[1])]

{opensimula-0.7.0/src/opensimula → opensimula-0.8.0/src/OpenSimula}/Simulation.py

@@ -96,18 +96,17 @@ class Simulation:
         """Return the list of messages"""
         return self._messages_
 
-    def plot(self, dates, variables, names=[], axis=[], frequency=None, value="mean"):
+    def plot(self, dates, variables, names=[], axis=[], frequency=None, value="mean",interval=None):
         """_summary_
         Draw variables graph (using plotly)
 
         Args:
             variables: List of hourly variables
             axis: list of axis y 1 or 2 to use for each variable, empty all in first axis
-            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", "max" or "min". Defaults to "mean".
-
+            frequency (None or str, optional): frequency of the values: None, "hourly", "daily", "monthly", "yearly". 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.
         """
-
         series = {}
         series["date"] = dates
         for i in range(len(variables)):
@@ -121,15 +120,24 @@ class Simulation:
                     series[variables[i].key] = variables[i].values
         data = pd.DataFrame(series)
         if frequency is not None:
+            freq={"hourly": "h", "daily": "D", "monthly": "ME", "yearly": "YE"}
             if value == "mean":
-                data = data.resample(frequency, on='date').mean()
+                data = data.resample(freq[frequency], on='date').mean()
             elif value == "sum":
-                data = data.resample(frequency, on='date').sum()
+                data = data.resample(freq[frequency], on='date').sum()
+            elif value == "sum_pos":
+                data = data.resample(freq[frequency], on='date').apply(lambda x: x.clip(lower=0).sum())
+            elif value == "sum_neg":
+                data = data.resample(freq[frequency], on='date').apply(lambda x: x.clip(upper=0).sum())
             elif value == "max":
-                data = data.resample(frequency, on='date').max()
+                data = data.resample(freq[frequency], on='date').max()
             elif value == "min":
-                data = data.resample(frequency, on='date').min()
+                data = data.resample(freq[frequency], on='date').min()
             data["date"] = data.index
+        if interval is not None:
+            data = data[(data['date'] > interval[0]) &
+                        (data['date'] < interval[1])]
+
 
         subfig = make_subplots(specs=[[{"secondary_y": True}]])
 

opensimula-0.8.0/src/OpenSimula/components/Chiller_heat_pump.py

@@ -0,0 +1,155 @@
+from opensimula.Message import Message
+from opensimula.Parameters import Parameter_float, Parameter_float_list, Parameter_math_exp, Parameter_options
+from opensimula.Component import Component
+
+class Chiller_heat_pump(Component):
+    def __init__(self, name, project):
+        Component.__init__(self, name, project)
+        self.parameter("type").value = "Chiller"
+        self.parameter("description").value = "Chiller equipment manufacturer information"
+        self.add_parameter(Parameter_options("chiller_type", "CHILLER", ["CHILLER", "HEAT_PUMP", "CHILLER_HEAT_PUMP"]))
+        self.add_parameter(Parameter_options("condensation_type", "AIR_CONDENSED", ["AIR_CONDENSED", "WATER_CONDENSED"]))
+        self.add_parameter(Parameter_float("nominal_water_flow", 1, "dm³/s", min=0))
+        self.add_parameter(Parameter_float("nominal_cooling_capacity", 0, "W", min=0))
+        self.add_parameter(Parameter_float("nominal_cooling_power", 0, "W", min=0))
+        self.add_parameter(Parameter_float_list("nominal_cooling_conditions", [35, 12, 7], "ºC"))
+        default_cooling_capacity_expression = "1.1239+0.0316*T_wo-0.00986*T_ci"       
+        self.add_parameter(Parameter_math_exp("cooling_capacity_expression", default_cooling_capacity_expression, "frac"))
+        default_cooling_power_expression = "(0.7336-0.00923*T_wo+0.00945*T_ci)*(0.0878+1.138*F_load-0.2258*F_load**2)"       
+        self.add_parameter(Parameter_math_exp("cooling_power_expression", default_cooling_power_expression, "frac"))
+        self.add_parameter(Parameter_math_exp("EER_expression", "1", "frac"))
+        self.add_parameter(Parameter_float("nominal_heating_capacity", 0, "W", min=0))
+        self.add_parameter(Parameter_float("nominal_heating_power", 0, "W", min=0))
+        self.add_parameter(Parameter_float_list("nominal_heating_conditions", [7, 6, 40, 45], "ºC"))
+        default_heating_capacity_expression = "1.012+0.028*T_wbci-0.004*T_wo"       
+        self.add_parameter(Parameter_math_exp("heating_capacity_expression", default_heating_capacity_expression, "frac"))
+        default_heating_power_expression = "(0.505-0.0375*T_wbci+0.016*T_wo)*(0.0878+1.138*F_load-0.2258*F_load**2)"       
+        self.add_parameter(Parameter_math_exp("heating_power_expression", default_heating_power_expression, "frac"))
+        self.add_parameter(Parameter_math_exp("COP_expression", "1", "frac"))
+        self.add_parameter(Parameter_float_list("expression_max_values", [80,50,50,1.5,1], "-")) # T_wo, T_ci, T_wbci, F_water, F_load
+        self.add_parameter(Parameter_float_list("expression_min_values", [0,-30,-30,0,0], "-")) # T_wo, T_ci, T_wbci, F_water, F_load
+
+    def check(self):
+        errors = super().check()
+        # Test Cooling and Heating conditions 3 values
+        if len(self.parameter("nominal_cooling_conditions").value)!= 3:
+            msg = f"Error: {self.parameter('name').value}, nominal_cooling_conditions size must be 3"
+            errors.append(Message(msg, "ERROR"))
+        if len(self.parameter("nominal_heating_conditions").value)!= 4:
+            msg = f"Error: {self.parameter('name').value}, nominal_heating_conditions size must be 4"
+            errors.append(Message(msg, "ERROR"))
+        return errors
+        
+    def get_heating_load(self,T_wo,T_ci,T_wbci,water_flow,Q_required):
+        """
+        Q_required: Required heating load
+        Returns (Q_eq,f_load).
+        Q_eq: Heating load given by the equipment
+        f_load: Fraction of load (0-1)
+        """
+        F_water = water_flow/self.parameter("nominal_water_flow").value
+        if self.parameter("chiller_type").value == "CHILLER":
+             return (0, 0)
+        else:
+            if Q_required == 0:
+                return (0,0)
+            # variables dictonary
+            var_dic = self._var_state_dic([T_wo, T_ci,T_wbci,F_water,1]) #Full load
+            # Capacity
+            nom_capacity = self.parameter("nominal_heating_capacity").value
+            capacity = nom_capacity * self.parameter("heating_capacity_expression").evaluate(var_dic)
+            if Q_required > capacity:
+                return (capacity,1)
+            else:
+                f_load = Q_required/capacity
+                return (Q_required, f_load)           
+           
+    def get_heating_power(self,T_wo, T_ci,T_wbci,water_flow,Q_required):
+        """
+        Returns (tot_power,COP).
+        """        
+        if self.parameter("chiller_type").value == "CHILLER":
+            return (0,0)
+        else:
+            if Q_required == 0:
+                return (0,0)
+            Q, F_load = self.get_heating_load(T_wo, T_ci,T_wbci,water_flow,Q_required)
+            # variables dictonary
+            F_water = water_flow/self.parameter("nominal_water_flow").value
+            var_dic = self._var_state_dic([T_wo, T_ci,T_wbci,F_water,F_load])
+            # Total power
+            nom_power = self.parameter("nominal_heating_power").value
+            if (self.parameter("heating_power_expression").value ==  "1"): ## Use COP expression
+                nom_capacity= self.parameter("nominal_heating_capacity").value
+                nom_COP = nom_capacity/nom_power
+                power = Q/ (nom_COP * self.parameter("COP_expression").evaluate(var_dic))
+            else: ## Use  heating power expressions
+                power = nom_power * self.parameter("heating_power_expression").evaluate(var_dic)
+            COP = Q/power
+            return (power, COP)
+            
+    def get_cooling_load(self,T_wo,T_ci,T_wbci,water_flow,Q_required):
+        """
+        Q_required: Required cooling load
+        Returns (Q_eq,f_load).
+        Q_eq: Total cool given by the equipment
+        f_load: Fraction of load (0-1)
+        """
+        F_water = water_flow/self.parameter("nominal_water_flow").value
+        if self.parameter("chiller_type").value == "HEAT_PUMP":
+            return (0,0)
+        else:
+            if Q_required == 0:
+                return (0,0)
+            nom_capacity = self.parameter("nominal_cooling_capacity").value
+            # variables dictonary
+            var_dic = self._var_state_dic([T_wo,T_ci,T_wbci,F_water,1]) #Full load
+            capacity = nom_capacity * self.parameter("cooling_capacity_expression").evaluate(var_dic)
+            if Q_required > capacity:
+                return (capacity,1)
+            else:
+                f_load = Q_required/capacity
+                return (Q_required, f_load)   
+
+    def get_cooling_power(self,T_wo, T_ci,T_wbci,water_flow,Q_required):
+        """
+        Returns (tot_power,EER).
+        """        
+        if self.parameter("chiller_type").value == "HEAT_PUMP":
+            return (0,0)
+        else:
+            if Q_required == 0:
+                return (0,0)
+            Q, F_load = self.get_cooling_load(T_wo, T_ci,T_wbci,water_flow,Q_required)
+            # variables dictonary
+            F_water = water_flow/self.parameter("nominal_water_flow").value
+            var_dic = self._var_state_dic([T_wo, T_ci,T_wbci,F_water,F_load])
+            # Power
+            nom_power = self.parameter("nominal_cooling_power").value
+            if (self.parameter("cooling_power_expression").value ==  "1"): ## Use EER expression
+                nom_capacity= self.parameter("nominal_cooling_capacity").value
+                nom_EER = nom_capacity/nom_power
+                power = Q/ (nom_EER * self.parameter("EER_expression").evaluate(var_dic))
+            else: ## Use cooling power expressions
+                power = nom_power * self.parameter("cooling_power_expression").evaluate(var_dic)
+            COP = Q/power
+            return (power, COP)
+
+    def _var_state_dic(self, values):
+        max = self.parameter("expression_max_values").value
+        min = self.parameter("expression_min_values").value
+        for i in range(len(values)):
+            if (values[i] > max[i]):
+                values[i] = max[i]
+            elif (values[i] < min[i]):
+                values[i] = min[i]
+        return {"T_wo":values[0],
+                "T_ci":values[1],
+                "T_wbci":values[2],
+                "F_water":values[3],
+                "F_load":values[4]}
+
+
+
+
+        

{opensimula-0.7.0/src/opensimula → opensimula-0.8.0/src/OpenSimula}/components/File_data.py

@@ -40,8 +40,9 @@ class File_data(Component):
                 self._df_ = pd.read_excel(self.parameter("file_name").value)
             # Create Variable
             for col in self._df_.columns:
-                self.add_variable(Variable(self._extract_name_(
-                    col), unit=self._extract_unit_(col)))
+                if self._is_numeric_(col):
+                    self.add_variable(Variable(self._extract_name_(
+                        col), unit=self._extract_unit_(col)))
 
         except Exception as ex:
             if type(ex).__name__ == "FileNotFoundError":
@@ -55,7 +56,7 @@ class File_data(Component):
     def pre_simulation(self, n_time_steps, delta_t):
         super().pre_simulation(n_time_steps, delta_t)
 
-        self.data_array = self._df_.to_numpy()
+        self.data_array = self._df_.select_dtypes(include=np.number).to_numpy()
 
         if self.parameter("file_step").value == "SIMULATION":
             i = 0
@@ -100,6 +101,9 @@ class File_data(Component):
             return ""
         else:
             return name[name.rfind("[") + 1: name.rfind("]")].strip()
+    
+    def _is_numeric_(self, name):
+        return pd.api.types.is_numeric_dtype(self._df_[name])
 
     def _get_interpolation_tuple_(self, date):
         seconds = (date-self._initial_date_).total_seconds()

{opensimula-0.7.0/src/opensimula → opensimula-0.8.0/src/OpenSimula}/components/HVAC_MZW_system.py

@@ -76,10 +76,16 @@ class HVAC_MZW_system(Component):  # HVAC Multizone Water system
             Parameter_options("fan_operation", "CONTINUOUS", ["CONTINUOUS", "CYCLING"])
         )
         self.add_parameter(
-            Parameter_options("water_source", "UNKNOWN", ["UNKNOWN", "WATER_LOOP"])
+            Parameter_options("water_source", "UNKNOWN", ["UNKNOWN", "WATER_SYSTEM"])
         )
-        self.add_parameter(Parameter_float("cooling_water_flow", 1, "m³/s", min=0))
-        self.add_parameter(Parameter_float("heating_water_flow", 1, "m³/s", min=0))
+        self.add_parameter(
+            Parameter_component("cooling_water_system", "not_defined", ["HVAC_water_system"])
+        )
+        self.add_parameter(
+            Parameter_component("heating_water_system", "not_defined", ["HVAC_water_system"])
+        )
+        self.add_parameter(Parameter_float("cooling_water_flow", 1, "dm³/s", min=0))
+        self.add_parameter(Parameter_float("heating_water_flow", 1, "dm³/s", min=0))
         self.add_parameter(Parameter_float("inlet_cooling_water_temp", 7, "ºC"))
         self.add_parameter(Parameter_float("inlet_heating_water_temp", 50, "ºC"))
         self.add_parameter(
@@ -111,6 +117,13 @@ class HVAC_MZW_system(Component):  # HVAC Multizone Water system
                 "reheat_coils", ["not_defined", "not_defined"], ["Water_coil"]
             )
         )
+        self.add_parameter(
+            Parameter_options("reheat_water_source", "UNKNOWN", ["UNKNOWN", "WATER_SYSTEM"])
+        )
+        self.add_parameter(
+            Parameter_component("reheat_water_system", "not_defined", ["HVAC_water_system"])
+        )
+
 
         # Variables
         self.add_variable(
@@ -183,6 +196,24 @@ class HVAC_MZW_system(Component):  # HVAC Multizone Water system
                 f"{self.parameter('name').value}, must define its supply fan equipment."
             )
             errors.append(Message(msg, "ERROR"))
+        # Test cooling water system defined
+        if self.parameter("water_source").value == "WATER_SYSTEM" and self.parameter("cooling_water_system").value == "not_defined":
+            msg = (
+                f"{self.parameter('name').value}, must define its cooling water system."
+            )
+            errors.append(Message(msg, "ERROR"))
+        # Test heating water system defined
+        if self.parameter("water_source").value == "WATER_SYSTEM" and self.parameter("heating_water_system").value == "not_defined":
+            msg = (
+                f"{self.parameter('name').value}, must define its heating water system."
+            )
+            errors.append(Message(msg, "ERROR"))
+        # Test reheat water system defined
+        if self.parameter("reheat_water_source").value == "WATER_SYSTEM" and self.parameter("reheat_water_system").value == "not_defined":
+            msg = (
+                f"{self.parameter('name').value}, must define its reheat water system."
+            )
+            errors.append(Message(msg, "ERROR"))
         # Test file_met defined
         if self.project().parameter("simulation_file_met").value == "not_defined":
             msg = f"{self.parameter('name').value}, file_met must be defined in the project 'simulation_file_met'."
@@ -221,18 +252,8 @@ class HVAC_MZW_system(Component):  # HVAC Multizone Water system
         self.reheat_coils = self.parameter("reheat_coils").component
 
         # Water flows and temperatures
-        self.cooling_water_flow = self.parameter("cooling_water_flow").value
-        self.heating_water_flow = self.parameter("heating_water_flow").value
-        if self.c_coil:
-            self._cooling_F_water = (
-                self.cooling_water_flow
-                / self.c_coil.parameter("nominal_cooling_water_flow").value
-            )
-        if self.h_coil:
-            self._heating_F_water = (
-                self.heating_water_flow
-                / self.h_coil.parameter("nominal_heating_water_flow").value
-            )
+        self.cooling_water_flow = self.parameter("cooling_water_flow").value/1000 # Convert to m³/s 
+        self.heating_water_flow = self.parameter("heating_water_flow").value/1000 # Convert to m³/s
         self.cooling_water_temp = self.parameter("inlet_cooling_water_temp").value
         self.heating_water_temp = self.parameter("inlet_heating_water_temp").value
         self.rho_MA = self.props["RHO_A"]
@@ -575,7 +596,7 @@ class HVAC_MZW_system(Component):  # HVAC Multizone Water system
                     # Reheat coil
                     water_flow = reheat_coil.parameter(
                         "nominal_heating_water_flow"
-                    ).value
+                    ).value/1000  # Convert to m³/s
                     capacity, epsilon = reheat_coil.get_heating_capacity(
                         self.T_SA,
                         self.T_SAwb,
@@ -681,11 +702,11 @@ class HVAC_MZW_system(Component):  # HVAC Multizone Water system
                 self.variable("T_ADP").values[time_index] = 0
                 self.variable("epsilon").values[time_index] = self.epsilon
             elif self.state == -1 or self.state == -2:  # Cooling
-                Q_s = -self.Q_coil
+                Q_s = self.Q_coil
                 Q_l = -self.M_w * self.props["LAMBDA"]
                 self.variable("Q_sensible").values[time_index] = Q_s
                 self.variable("Q_latent").values[time_index] = Q_l
-                self.variable("Q_total").values[time_index] = Q_s
+                self.variable("Q_total").values[time_index] = -Q_s + Q_l
                 self.variable("T_iw").values[time_index] = self.cooling_water_temp
                 self.variable("T_ow").values[time_index] = self.cooling_water_temp + (
                     Q_s + Q_l