OpenSimula 0.5.2__tar.gz → 0.6.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opensimula
-Version: 0.5.2
+Version: 0.6.1
 Summary: Component-based time simulation environment in Python
 Author-email: "Juan F. Coronel" <jfc@us.es>
 Requires-Python: >=3.12
@@ -41,9 +41,8 @@ Component-based time simulation environment in Python
 - dash
 - dash_bootstrap_components
 - dash_ag_grid
-- pyvista
-- trame
-- trame-vtk
-- trame-vuetify
-- ipywidgets
-
+- nbformat
+- openpyxl
+- tqdm
+- triangle
+- vedo

{opensimula-0.5.2 → opensimula-0.6.1}/README.md

@@ -17,9 +17,8 @@ Component-based time simulation environment in Python
 - dash
 - dash_bootstrap_components
 - dash_ag_grid
-- pyvista
-- trame
-- trame-vtk
-- trame-vuetify
-- ipywidgets
-
+- nbformat
+- openpyxl
+- tqdm
+- triangle
+- vedo

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

@@ -1,6 +1,6 @@
 [project]
 name = "opensimula"
-version = "0.5.2"
+version = "0.6.1"
 requires-python = ">=3.12"
 authors = [
   { name="Juan F. Coronel", email="jfc@us.es" },
@@ -29,6 +29,7 @@ dev = [
     "ipykernel>=6.30.1",
     "mkdocs>=1.6.1",
     "pytest>=8.4.2",
+    "marimo>=0.19.0",
 ]
 
 [build-system]

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

@@ -158,6 +158,41 @@ class Project(Parameter_container):
         except KeyError:
             return None
 
+    def duplicate_component(self, component_name, new_name):
+        """Duplicate an existing component with a new name
+
+        Args:
+            component_name (string): name of the component to duplicate
+            new_name (string): name for the new component
+
+        Returns:
+            Component: the new duplicated component, None if error
+        """
+        original = self.component(component_name)
+        if original is None:
+            msg = self._get_error_header_() + f"Component '{component_name}' not found."
+            self._sim_.message(Message(msg, "ERROR"))
+            return None
+
+        # Get parameter dictionary from original component
+        comp_dict = {}
+        for key, param in original.parameter_dict().items():
+            comp_dict[key] = param.value
+
+        # Create new component of the same type
+        new_comp = self.new_component(comp_dict["type"], new_name)
+        if new_comp is None:
+            msg = self._get_error_header_() + f"Could not create component of type '{comp_dict['type']}'."
+            self._sim_.message(Message(msg, "ERROR"))
+            return None
+
+        # Copy parameters (except name and type)
+        for key, value in comp_dict.items():
+            if key != "name" and key != "type":
+                new_comp.parameter(key).value = value
+
+        return new_comp
+
     def _get_error_header_(self):
         return f'Project "{self.parameter("name").value}". '
 

{opensimula-0.5.2 → opensimula-0.6.1}/src/opensimula/Simulation.py

@@ -1,5 +1,4 @@
 from opensimula.Project import Project
-from opensimula.Message import Message
 import pandas as pd
 import plotly.express as px
 from plotly.subplots import make_subplots
@@ -115,8 +114,11 @@ class Simulation:
             if i < len(names):
                 series[names[i]] = variables[i].values
             else:
-                series[variables[i].parent.parameter(
-                    "name").value+":"+variables[i].key] = variables[i].values
+                if variables[i].parent is not None:
+                    series[variables[i].parent.parameter(
+                        "name").value+":"+variables[i].key] = variables[i].values
+                else:
+                    series[variables[i].key] = variables[i].values
         data = pd.DataFrame(series)
         if frequency is not None:
             if value == "mean":
@@ -135,8 +137,11 @@ class Simulation:
             if i < len(names):
                 name = names[i]
             else:
-                name = variables[i].parent.parameter(
-                    "name").value+":"+variables[i].key
+                if variables[i].parent is not None:
+                    name = variables[i].parent.parameter(
+                        "name").value+":"+variables[i].key
+                else:
+                    name = variables[i].key
             fig = px.line(data, x='date', y=name)
             fig.for_each_trace(lambda t: t.update(name=name))
             fig.update_traces(showlegend=True)

{opensimula-0.5.2 → opensimula-0.6.1}/src/opensimula/Variable.py

@@ -25,6 +25,10 @@ class Variable(Child):
     def values(self):
         return self._values_
 
+    @values.setter
+    def values(self, values):
+        self._values_ = values
+
     @property
     def unit(self):
         return self._unit_

{opensimula-0.5.2 → opensimula-0.6.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.5.2"
+VERSION = "0.6.1"

{opensimula-0.5.2 → opensimula-0.6.1}/src/opensimula/components/Building.py

@@ -168,7 +168,7 @@ class Building(Component):
                         if self.spaces[j] == self.surfaces[i].get_space():
                             self.KSZ_matrix[i][j] = (
                                 self.surfaces[i].area
-                                * self.surfaces[i].parameter("h_cv").value[0]
+                                * self.surfaces[i].parameter("h_cv").value[self.sides[i]]
                             )
                 elif surface_type == "INTERIOR":
                     k = self.surfaces[i].k

{opensimula-0.5.2 → opensimula-0.6.1}/src/opensimula/components/Building_surface.py

@@ -1,7 +1,13 @@
 import math
 from opensimula.Message import Message
 from opensimula.components.Surface import Surface
-from opensimula.Parameters import Parameter_component, Parameter_float_list, Parameter_options, Parameter_component_list
+from opensimula.Parameters import (
+    Parameter_component,
+    Parameter_float,
+    Parameter_float_list,
+    Parameter_options,
+    Parameter_component_list,
+)
 from opensimula.Variable import Variable
 from opensimula.visual_3D.Polygon_3D import Polygon_3D
 
@@ -12,10 +18,35 @@ class Building_surface(Surface):
         # Parameters
         self.parameter("type").value = "Building_surface"
         self.parameter("description").value = "Building surface"
-        self.add_parameter(Parameter_component("construction", "not_defined", ["Construction"]))
-        self.add_parameter(Parameter_component_list("spaces", ["not_defined", "not_defined"], ["Space"]))
-        self.add_parameter(Parameter_options("surface_type", "EXTERIOR", ["EXTERIOR", "INTERIOR", "UNDERGROUND", "VIRTUAL"]))
+        self.add_parameter(
+            Parameter_component("construction", "not_defined", ["Construction"])
+        )
+        self.add_parameter(
+            Parameter_component_list(
+                "spaces", ["not_defined", "not_defined"], ["Space"]
+            )
+        )
+        self.add_parameter(
+            Parameter_options(
+                "surface_type",
+                "EXTERIOR",
+                ["EXTERIOR", "INTERIOR", "UNDERGROUND", "VIRTUAL"],
+            )
+        )
         self.add_parameter(Parameter_float_list("h_cv", [19.3, 2], "W/m²K", min=0))
+        # Only for underground surfaces
+        self.add_parameter(
+            Parameter_component("ground_material", "not_defined", ["Material"])
+        )
+        self.add_parameter(
+            Parameter_float("exterior_perimeter_fraction", 1, "frac", min=0, max=1)
+        )
+        self.add_parameter(
+            Parameter_float("exterior_perimeter_wall_thickness", 0.3, "m", min=0)
+        )
+        self.add_parameter(
+            Parameter_float("groundwater_depth", 0, "m", min=0)
+        )
 
         # Constants
         self.H_RD = 5.705  # 4*sigma*(293^3)
@@ -46,12 +77,12 @@ class Building_surface(Surface):
     def check(self):
         errors = super().check()
         # Test space defined
-        surface_type = self.parameter("surface_type").value
-        if surface_type == "EXTERIOR" or surface_type == "UNDERGROUND":
+        self._surface_type_ = self.parameter("surface_type").value
+        if self._surface_type_ == "EXTERIOR" or self._surface_type_ == "UNDERGROUND":
             if self.parameter("spaces").value[0] == "not_defined":
                 msg = f"{self.parameter('name').value}, must define its space."
                 errors.append(Message(msg, "ERROR"))
-        elif surface_type == "INTERIOR" or surface_type == "VIRTUAL":
+        elif self._surface_type_ == "INTERIOR" or self._surface_type_ == "VIRTUAL":
             if (
                 self.parameter("spaces").value[0] == "not_defined"
                 or self.parameter("spaces").value[1] == "not_defined"
@@ -59,10 +90,20 @@ class Building_surface(Surface):
                 msg = f"{self.parameter('name').value}, must define two spaces."
                 errors.append(Message(msg, "ERROR"))
         # Test construction defined for non-virtual surfaces
-        if surface_type != "VIRTUAL" and self.parameter("construction").value == "not_defined":
+        if (
+            self._surface_type_ != "VIRTUAL"
+            and self.parameter("construction").value == "not_defined"
+        ):
             msg = f"{self.parameter('name').value}, Building surfaces must define its construction."
             errors.append(Message(msg, "ERROR"))
-        self._surface_type_ = self.parameter("surface_type").value
+        # Test ground material defined for underground surfaces
+        if (
+            self._surface_type_ == "UNDERGROUND"
+            and self.parameter("ground_material").value == "not_defined"
+        ):
+            msg = f"{self.parameter('name').value}, Underground surfaces must define its ground material."
+            errors.append(Message(msg, "ERROR"))
+        # Create openings list
         if self._surface_type_ == "EXTERIOR" or self._surface_type_ == "INTERIOR":
             self._create_openings_list_()
         return errors
@@ -70,17 +111,19 @@ class Building_surface(Surface):
     def get_building(self):
         return self.parameter("spaces").component[0].get_building()
 
-    def get_space(self,side=0):
+    def get_space(self, side=0):
         return self.parameter("spaces").component[side]
-    
+
     def radiant_property(self, prop, radiation_type, side, theta=0):
-        if self.parameter("surface_type").value == "VIRTUAL":
+        if self._surface_type_ == "VIRTUAL":
             if prop == "tau":
                 return 1
             else:
                 return 0
         else:
-            return self.parameter("construction").component.radiant_property(prop, radiation_type, side, theta)
+            return self.parameter("construction").component.radiant_property(
+                prop, radiation_type, side, theta
+            )
 
     # ____________ pre_simulation ____________
     def pre_simulation(self, n_time_steps, delta_t):
@@ -90,12 +133,102 @@ class Building_surface(Surface):
         self._T_ini = self.get_building().parameter("initial_temperature").value
         self._F_sky = (1 + math.sin(math.radians(self.parameter("altitude").value))) / 2
         self._surface_type_ = self.parameter("surface_type").value
+        self._construction_ = self.parameter("construction").component
         if self._surface_type_ == "EXTERIOR" or self._surface_type_ == "INTERIOR":
             self._create_openings_list_()
-        if self._surface_type_ != "VIRTUAL":
             self._calculate_K_()
         if self._surface_type_ == "EXTERIOR":
-            self._sunny_index_ = self.project().env_3D.get_sunny_index(self.parameter("name").value)
+            self._sunny_index_ = self.project().env_3D.get_sunny_index(
+                self.parameter("name").value
+            )
+        if self._surface_type_ == "UNDERGROUND":
+            self._create_underground_construction_()
+            self._construction_.pre_simulation(
+                n_time_steps, delta_t
+            )  # is not included in list of project components
+            self._calculate_K_()
+            self._calculate_ground_U_hat_()
+
+    def _create_underground_construction_(self):
+        # Test if underground construction already exists and delete it
+        und_cons_name = self.parameter("name").value + "_und_cons"
+        if self.project().component(und_cons_name) is not None:
+            self.project().del_component(self.project().component(und_cons_name))
+        # Test if virtual material already exists and delete it
+        vir_mat_name = self.parameter("name").value + "_vir_mat"
+        if self.project().component(vir_mat_name) is not None:
+            self.project().del_component(self.project().component(vir_mat_name))
+        # create virtual material with zero properties
+        vir_mat = self.project().new_component("Material", vir_mat_name)
+        vir_mat.set_parameters({"density": 1, "specific_heat": 1, "conductivity": 1})
+        # create new construction for underground surfaces
+        self._construction_ = self.project().duplicate_component(
+            self.parameter("construction").component.parameter("name").value,
+            und_cons_name,
+        )
+        # Equivalent thickness UNE-EN ISO 13370:2017
+        self._B_prime_ = (
+            2
+            * self.area
+            / (self.perimeter * self.parameter("exterior_perimeter_fraction").value)
+        )
+        R_cons = self._construction_.thermal_resistance()  # m²K/W
+        self._k_g_ = (
+            self.parameter("ground_material").component.parameter("conductivity").value
+        )
+        w = self.parameter("exterior_perimeter_wall_thickness").value  # Thickness of perimetral walls
+        self._d_t_ = w + self._k_g_ * (
+            1 / self.parameter("h_cv").value[0]
+            + 1 / self.parameter("h_cv").value[1]
+            + R_cons
+        )  # m
+
+        if self._d_t_ < self._B_prime_:
+            self._U_tot_ = (
+                (2 * self._k_g_)
+                / (math.pi * self._B_prime_ + self._d_t_)
+                * math.log((math.pi * self._B_prime_ / self._d_t_) + 1)
+            )
+        else:  # Well insulated
+            self._U_tot_ = self._k_g_ / (self._d_t_ + 0.457 * self._B_prime_)
+        
+        # Gorundwater effect
+        groundwater_depth = self.parameter("groundwater_depth").value
+        self._G_w_ = 1.0
+        if groundwater_depth > 0:
+            self._G_w_ = 1 + math.exp(-2*groundwater_depth / self._B_prime_)
+        self._U_tot_ *= self._G_w_
+
+        # adding 0,5m of ground material t
+        self._ground_thickness_ = 0.5  # fixed 50 cm.
+        self._construction_.add_exterior_layer(
+            self.parameter("ground_material").component.parameter("name").value,
+            self._ground_thickness_,
+        )
+        # Thermal resistanace of the virtual layer
+        R_vi = (
+            1 / self._U_tot_
+            - 1 / self.parameter("h_cv").value[1]
+            - R_cons
+            - 0.5 / self._k_g_
+        )  # m²K/W
+        k_vi = 0.1 / R_vi
+        # Add virtual layer to the construction
+        vir_mat.parameter("conductivity").value = k_vi
+        self._construction_.add_exterior_layer(vir_mat_name, 0.1)
+
+    def _calculate_ground_U_hat_(self):
+        # Exterior temperature from meteorological file
+        # Dinamics transmitance (U_hat and U_hat_ext)
+        periodo_segundos = 31536000  # Un año
+        rho_g = self.parameter("ground_material").component.parameter("density").value
+        c_p_g = (
+            self.parameter("ground_material").component.parameter("specific_heat").value
+        )
+        d_p = math.sqrt((self._k_g_ * periodo_segundos) / (math.pi * rho_g * c_p_g))
+        self._U_hat_ext_ = self._G_w_ * self._k_g_ / math.sqrt(
+            (0.457 * self._B_prime_ + self._d_t_) ** 2 + d_p**2
+        )
 
     def _create_openings_list_(self):
         project_openings_list = self.project().component_list(comp_type="Opening")
@@ -105,46 +238,55 @@ class Building_surface(Surface):
                 self.openings.append(opening)
 
     def _calculate_K_(self):
-        self.a_0, self.a_1, self.a_01 = self.parameter("construction").component.get_A()
+        self.a_0, self.a_1, self.a_01 = self._construction_.get_A()
         self.k_01 = self.area * self.a_01
-        surface_type = self.parameter("surface_type").value
-        if surface_type == "EXTERIOR":
-            self.k[0] = self.area * (self.a_0
+        if self._surface_type_ == "EXTERIOR":
+            self.k[0] = self.area * (
+                self.a_0
                 - self.parameter("h_cv").value[0]
                 - self.H_RD * self.radiant_property("alpha", "long_wave", 0)
             )
             self.k[1] = self.area * (self.a_1 - self.parameter("h_cv").value[1])
-        elif surface_type == "INTERIOR":
-            # interior
+        elif self._surface_type_ == "INTERIOR":
             self.k[0] = self.area * (self.a_0 - self.parameter("h_cv").value[0])
             self.k[1] = self.area * (self.a_1 - self.parameter("h_cv").value[1])
-        elif surface_type == "UNDERGROUND":
-            # Underground
+        elif self._surface_type_ == "UNDERGROUND":
             self.k[0] = 1  # not used
-            self.k[1] = self.area * (self.a_1 - self.parameter("h_cv").value[0]) # only one defined
-    
+            self.k[1] = self.area * (
+                self.a_1 - self.parameter("h_cv").value[1]
+            )  # only one defined
 
-    #________ pre_iteration ____________
+    # ________ pre_iteration ____________
     def pre_iteration(self, time_i, date, daylight_saving):
         super().pre_iteration(time_i, date, daylight_saving)
         # Meterological data
         self._T_ext = self._file_met.variable("temperature").values[time_i]
         if self._surface_type_ != "VIRTUAL":
             # Trasient part
-            self._p_0_, self._p_1_ = self.parameter("construction").component.get_P(
+            self._p_0_, self._p_1_ = self._construction_.get_P(
                 time_i,
                 self.variable("T_s0").values,
                 self.variable("T_s1").values,
                 self.variable("q_cd0").values,
                 self.variable("q_cd1").values,
-                self._T_ini)
+                self._T_ini,
+            )
             self.variable("p_0").values[time_i] = self._p_0_
             self.variable("p_1").values[time_i] = self._p_1_
         if self._surface_type_ == "EXTERIOR":
             self._pre_iteration_exterior_(time_i)
-        elif self._surface_type_ == "UNDERGROUND":
-            self.variable("T_s0").values[time_i] = self._file_met.variable("underground_temperature").values[time_i]
-            
+        if self._surface_type_ == "UNDERGROUND":
+            year_start = date.replace(month=1, day=1, hour=0, minute=0, second=0)
+            seconds_elapsed = (date - year_start).total_seconds()
+            DT = self._file_met.DT_monthly_amplitude/2
+            T_avg = self._file_met.T_average
+            tau = self._file_met.month_min_temp # One month of delay for the minimum temperature, as in UNE-EN ISO 13370:2017
+            m = seconds_elapsed / 2628000
+            self.variable("T_s0").values[time_i] = (
+                T_avg
+                - self._U_hat_ext_ / self._U_tot_ * DT * math.cos(2 * math.pi * (m-tau) / 12)
+                )
+
     def _pre_iteration_exterior_(self, time_i):
         # Meterological data
         hor_sol_dif = self._file_met.variable("sol_diffuse").values[time_i]
@@ -153,33 +295,40 @@ class Building_surface(Surface):
 
         # Diffuse solar radiation
         E_dif_sunny = self._file_met.solar_diffuse_rad(
-                time_i,
-                self.orientation_angle("azimuth", 0),
-                self.orientation_angle("altitude", 0),
-            )
-        E_dif_sunny = E_dif_sunny + (1 - self._F_sky) * self._albedo * (hor_sol_dif + hor_sol_dir)
+            time_i,
+            self.orientation_angle("azimuth", 0),
+            self.orientation_angle("altitude", 0),
+        )
+        E_dif_sunny = E_dif_sunny + (1 - self._F_sky) * self._albedo * (
+            hor_sol_dif + hor_sol_dir
+        )
         self.variable("E_dif_sunny").values[time_i] = E_dif_sunny
-        diffuse_sunny_fraction = self.project().env_3D.get_diffuse_sunny_fraction(self._sunny_index_)
+        diffuse_sunny_fraction = self.project().env_3D.get_diffuse_sunny_fraction(
+            self._sunny_index_
+        )
         E_dif = E_dif_sunny * diffuse_sunny_fraction
         self.variable("E_dif").values[time_i] = E_dif
         # Direct solar radiation
         E_dir_sunny = self._file_met.solar_direct_rad(
-                time_i,
-                self.orientation_angle("azimuth", 0),
-                self.orientation_angle("altitude", 0),
+            time_i,
+            self.orientation_angle("azimuth", 0),
+            self.orientation_angle("altitude", 0),
         )
         self.variable("E_dir_sunny").values[time_i] = E_dir_sunny
         E_dir = E_dir_sunny * self._calculate_direct_sunny_fraction_(time_i)
         self.variable("E_dir").values[time_i] = E_dir
         q_sol0 = self.radiant_property("alpha", "solar_diffuse", 0) * (E_dif + E_dir)
         self.variable("q_sol0").values[time_i] = q_sol0
-                # Mean radiant temperature
+        # Mean radiant temperature
         T_rm = self._F_sky * T_sky + (1 - self._F_sky) * self._T_ext
         self.variable("T_rm").values[time_i] = T_rm
         # f_0
         h_rd = self.H_RD * self.radiant_property("alpha", "long_wave", 0)
         self.f_0 = self.area * (
-            -self._p_0_ - self.parameter("h_cv").value[0] * self._T_ext - h_rd * T_rm - q_sol0
+            -self._p_0_
+            - self.parameter("h_cv").value[0] * self._T_ext
+            - h_rd * T_rm
+            - q_sol0
         )
 
     def _calculate_direct_sunny_fraction_(self, time_i):
@@ -202,8 +351,7 @@ class Building_surface(Surface):
             direct_sunny_fraction = 1
         return direct_sunny_fraction
 
-
-    #________ post_iteration ____________
+    # ________ post_iteration ____________
     def post_iteration(self, time_index, date, daylight_saving, converged):
         super().post_iteration(time_index, date, daylight_saving, converged)
         if self._surface_type_ == "EXTERIOR":
@@ -236,7 +384,8 @@ class Building_surface(Surface):
             )
             h_rd = self.H_RD * self.radiant_property("alpha", "long_wave", 0)
             self.variable("q_lwt0").values[time_i] = h_rd * (
-                self.variable("T_rm").values[time_i] - self.variable("T_s0").values[time_i]
+                self.variable("T_rm").values[time_i]
+                - self.variable("T_s0").values[time_i]
             )
             self.variable("q_lwt1").values[time_i] = (
                 -self.variable("q_cd1").values[time_i]
@@ -269,8 +418,10 @@ class Building_surface(Surface):
                 - self.variable("q_lwig1").values[time_i]
             )
         elif self._surface_type_ == "UNDERGROUND":
-            self.variable("q_cv0").values[time_i] = -self.variable("q_cd0").values[time_i]
-            self.variable("q_cv1").values[time_i] = self.parameter("h_cv").value * (
+            self.variable("q_cv0").values[time_i] = -self.variable("q_cd0").values[
+                time_i
+            ]
+            self.variable("q_cv1").values[time_i] = self.parameter("h_cv").value[1] * (
                 self.get_space().variable("temperature").values[time_i]
                 - self.variable("T_s1").values[time_i]
             )
@@ -306,13 +457,37 @@ class Building_surface(Surface):
             )
         elif self._surface_type_ == "INTERIOR":
             return Polygon_3D(
-                name, origin, azimuth, altitude, pol_2D, holes_2D, color="green", shading=False, calculate_shadows=False
+                name,
+                origin,
+                azimuth,
+                altitude,
+                pol_2D,
+                holes_2D,
+                color="green",
+                shading=False,
+                calculate_shadows=False,
             )
-        elif self._surface_type_ == "UNDERGROUND":         
+        elif self._surface_type_ == "UNDERGROUND":
             return Polygon_3D(
-                name, origin, azimuth, altitude, pol_2D, holes_2D, color="brown", shading=False, calculate_shadows=False
+                name,
+                origin,
+                azimuth,
+                altitude,
+                pol_2D,
+                holes_2D,
+                color="brown",
+                shading=False,
+                calculate_shadows=False,
             )
         elif self._surface_type_ == "VIRTUAL":
             return Polygon_3D(
-                name, origin, azimuth, altitude, pol_2D, color="green", opacity=0.4, shading=False, calculate_shadows=False
+                name,
+                origin,
+                azimuth,
+                altitude,
+                pol_2D,
+                color="green",
+                opacity=0.4,
+                shading=False,
+                calculate_shadows=False,
             )

{opensimula-0.5.2 → opensimula-0.6.1}/src/opensimula/components/Construction.py

@@ -28,6 +28,20 @@ class Construction(Component):
             errors.append(Message(msg, "error"))
         return errors
 
+    def add_exterior_layer(self, material_name, thickness):
+        """Add a new exterior layer (at index 0) to the construction.
+
+        Args:
+            material_name (str): Name of the material component to add
+            thickness (float): Thickness of the layer in meters
+        """
+        materials = self.parameter("materials").value
+        thicknesses = self.parameter("thicknesses").value
+        materials.insert(0, material_name)
+        thicknesses.insert(0, thickness)
+        self.parameter("materials").value = materials
+        self.parameter("thicknesses").value = thicknesses
+
     # Functions for Transfer Function Calculation
 
     def pre_simulation(self, n_time_steps, delta_t):