OpenSimula 0.5.1__py3-none-any.whl

opensimula/components/Building_surface.py

@@ -0,0 +1,318 @@
+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.Variable import Variable
+from opensimula.visual_3D.Polygon_3D import Polygon_3D
+
+
+class Building_surface(Surface):
+    def __init__(self, name, project):
+        Surface.__init__(self, name, project)
+        # 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_float_list("h_cv", [19.3, 2], "W/m²K", min=0))
+
+        # Constants
+        self.H_RD = 5.705  # 4*sigma*(293^3)
+        # Variables
+        self.add_variable(Variable("T_s0", "°C"))
+        self.add_variable(Variable("T_s1", "°C"))
+        self.add_variable(Variable("q_cd0", "W/m²"))
+        self.add_variable(Variable("q_cd1", "W/m²"))
+        self.add_variable(Variable("p_0", "W/m²"))
+        self.add_variable(Variable("p_1", "W/m²"))
+        self.add_variable(Variable("q_cv0", "W/m²"))
+        self.add_variable(Variable("q_cv1", "W/m²"))
+        self.add_variable(Variable("q_sol0", "W/m²"))
+        self.add_variable(Variable("q_sol1", "W/m²"))
+        self.add_variable(Variable("q_swig0", "W/m²"))
+        self.add_variable(Variable("q_swig1", "W/m²"))
+        self.add_variable(Variable("q_lwig0", "W/m²"))
+        self.add_variable(Variable("q_lwig1", "W/m²"))
+        self.add_variable(Variable("q_lwt0", "W/m²"))
+        self.add_variable(Variable("q_lwt1", "W/m²"))
+        # For exterior surface
+        self.add_variable(Variable("T_rm", "°C"))
+
+        # k values must be calculated by each subclass
+        self.k = [1.0, 2.0]
+        self.k_01 = -1
+
+    def check(self):
+        errors = super().check()
+        # Test space defined
+        surface_type = self.parameter("surface_type").value
+        if surface_type == "EXTERIOR" or 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":
+            if (
+                self.parameter("spaces").value[0] == "not_defined"
+                or self.parameter("spaces").value[1] == "not_defined"
+            ):
+                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":
+            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
+        if self._surface_type_ == "EXTERIOR" or self._surface_type_ == "INTERIOR":
+            self._create_openings_list_()
+        return errors
+
+    def get_building(self):
+        return self.parameter("spaces").component[0].get_building()
+
+    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 prop == "tau":
+                return 1
+            else:
+                return 0
+        else:
+            return self.parameter("construction").component.radiant_property(prop, radiation_type, side, theta)
+
+    # ____________ pre_simulation ____________
+    def pre_simulation(self, n_time_steps, delta_t):
+        super().pre_simulation(n_time_steps, delta_t)
+        self._file_met = self.project().parameter("simulation_file_met").component
+        self._albedo = self.project().parameter("albedo").value
+        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
+        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)
+
+    def _create_openings_list_(self):
+        project_openings_list = self.project().component_list(comp_type="Opening")
+        self.openings = []
+        for opening in project_openings_list:
+            if opening.parameter("surface").component == self:
+                self.openings.append(opening)
+
+    def _calculate_K_(self):
+        self.a_0, self.a_1, self.a_01 = self.parameter("construction").component.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
+                - 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
+            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
+            self.k[0] = 1  # not used
+            self.k[1] = self.area * (self.a_1 - self.parameter("h_cv").value[0]) # only one defined
+    
+
+    #________ 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(
+                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.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]
+            
+    def _pre_iteration_exterior_(self, time_i):
+        # Meterological data
+        hor_sol_dif = self._file_met.variable("sol_diffuse").values[time_i]
+        hor_sol_dir = self._file_met.variable("sol_direct").values[time_i]
+        T_sky = self._file_met.variable("sky_temperature").values[time_i]
+
+        # 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)
+        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_)
+        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),
+        )
+        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
+        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
+        )
+
+    def _calculate_direct_sunny_fraction_(self, time_i):
+        if self.project().parameter("shadow_calculation").value == "INSTANT":
+            direct_sunny_fraction = self.project().env_3D.get_direct_sunny_fraction(
+                self._sunny_index_
+            )
+        elif self.project().parameter("shadow_calculation").value == "INTERPOLATION":
+            azi = self._file_met.variable("sol_azimuth").values[time_i]
+            alt = self._file_met.variable("sol_altitude").values[time_i]
+            if not math.isnan(alt):
+                direct_sunny_fraction = (
+                    self.project().env_3D.get_direct_interpolated_sunny_fraction(
+                        self._sunny_index_, azi, alt
+                    )
+                )
+            else:
+                direct_sunny_fraction = 1
+        elif self.project().parameter("shadow_calculation").value == "NO":
+            direct_sunny_fraction = 1
+        return direct_sunny_fraction
+
+
+    #________ 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":
+            self._calculate_exterior_T_s0_(time_index)
+        if self._surface_type_ != "VIRTUAL":
+            self._calculate_heat_fluxes_(time_index)
+
+    def _calculate_exterior_T_s0_(self, time_i):
+        T_s0 = (self.f_0 - self.k_01 * self.variable("T_s1").values[time_i]) / self.k[0]
+        self.variable("T_s0").values[time_i] = T_s0
+
+    def _calculate_heat_fluxes_(self, time_i):
+        self.variable("q_cd0").values[time_i] = (
+            self.a_0 * self.variable("T_s0").values[time_i]
+            + self.a_01 * self.variable("T_s1").values[time_i]
+            + self.variable("p_0").values[time_i]
+        )
+        self.variable("q_cd1").values[time_i] = (
+            self.a_01 * self.variable("T_s0").values[time_i]
+            + self.a_1 * self.variable("T_s1").values[time_i]
+            + self.variable("p_1").values[time_i]
+        )
+        if self._surface_type_ == "EXTERIOR":
+            self.variable("q_cv0").values[time_i] = self.parameter("h_cv").value[0] * (
+                self._T_ext - self.variable("T_s0").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]
+            )
+            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("q_lwt1").values[time_i] = (
+                -self.variable("q_cd1").values[time_i]
+                - self.variable("q_cv1").values[time_i]
+                - self.variable("q_sol1").values[time_i]
+                - self.variable("q_swig1").values[time_i]
+                - self.variable("q_lwig1").values[time_i]
+            )
+        elif self._surface_type_ == "INTERIOR":
+            self.variable("q_cv0").values[time_i] = self.parameter("h_cv").value[0] * (
+                self.get_space(0).variable("temperature").values[time_i]
+                - self.variable("T_s0").values[time_i]
+            )
+            self.variable("q_cv1").values[time_i] = self.parameter("h_cv").value[1] * (
+                self.get_space(1).variable("temperature").values[time_i]
+                - self.variable("T_s1").values[time_i]
+            )
+            self.variable("q_lwt0").values[time_i] = (
+                -self.variable("q_cd0").values[time_i]
+                - self.variable("q_cv0").values[time_i]
+                - self.variable("q_sol0").values[time_i]
+                - self.variable("q_swig0").values[time_i]
+                - self.variable("q_lwig0").values[time_i]
+            )
+            self.variable("q_lwt1").values[time_i] = (
+                -self.variable("q_cd1").values[time_i]
+                - self.variable("q_cv1").values[time_i]
+                - self.variable("q_sol1").values[time_i]
+                - self.variable("q_swig1").values[time_i]
+                - 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.get_space().variable("temperature").values[time_i]
+                - self.variable("T_s1").values[time_i]
+            )
+            self.variable("q_lwt1").values[time_i] = (
+                -self.variable("q_cd1").values[time_i]
+                - self.variable("q_cv1").values[time_i]
+                - self.variable("q_sol1").values[time_i]
+                - self.variable("q_swig1").values[time_i]
+                - self.variable("q_lwig1").values[time_i]
+            )
+
+    @property
+    def area(self):
+        area = super().area
+        if self._surface_type_ == "EXTERIOR" or self._surface_type_ == "INTERIOR":
+            for opening in self.openings:
+                area -= opening.area
+        return area
+
+    def get_polygon_3D(self):
+        azimuth = self.orientation_angle("azimuth", 0, "global")
+        altitude = self.orientation_angle("altitude", 0, "global")
+        origin = self.get_origin("global")
+        pol_2D = self.get_polygon_2D()
+        name = self.parameter("name").value
+        holes_2D = []
+        if self._surface_type_ == "EXTERIOR" or self._surface_type_ == "INTERIOR":
+            for opening in self.openings:
+                holes_2D.append(opening.get_polygon_2D())
+        if self._surface_type_ == "EXTERIOR":
+            return Polygon_3D(
+                name, origin, azimuth, altitude, pol_2D, holes_2D, color="white"
+            )
+        elif self._surface_type_ == "INTERIOR":
+            return Polygon_3D(
+                name, origin, azimuth, altitude, pol_2D, holes_2D, color="green", shading=False, calculate_shadows=False
+            )
+        elif self._surface_type_ == "UNDERGROUND":         
+            return Polygon_3D(
+                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
+            )

opensimula/components/Calculator.py

@@ -0,0 +1,51 @@
+from opensimula.Component import Component
+from opensimula.Message import Message
+from opensimula.Parameters import Parameter_variable_list, Parameter_math_exp_list, Parameter_string_list
+from opensimula.Variable import Variable
+
+class Calculator(Component):
+    def __init__(self, name, project):
+        Component.__init__(self, name, project)
+        self.parameter("type").value = "Calculator"
+        self.parameter(
+            "description").value = "Component to perform calculations with variables from other components."
+        # Parameters
+        self.add_parameter(Parameter_variable_list("input_variables", []))
+        self.add_parameter(Parameter_string_list("output_variables", []))
+        self.add_parameter(Parameter_string_list("output_units", []))
+        self.add_parameter(Parameter_math_exp_list("output_expressions", []))
+
+    def check(self):
+        self._variables_ = {}  # Delete all the variables
+        errors = super().check()
+        if (
+            len(self.parameter("output_variables").value)
+            != len(self.parameter("output_expressions").value) or len(self.parameter("output_variables").value)
+            != len(self.parameter("output_units").value)
+        ):
+            msg = Message(f"Error: {self.parameter('name').value}, output_variables, output_units and output_expressions size must be equal","ERROR")
+            errors.append(msg)
+        else:
+            # Create output variables
+            for i in range(len(self.parameter("output_variables").value)):
+                name = self.parameter("output_variables").value[i]
+                unit = self.parameter("output_units").value[i]
+                desc = self.parameter("output_expressions").value[i]
+                self.add_variable(Variable(name, unit, desc))
+
+        return errors
+
+    def pre_simulation(self, n_time_steps, delta_t):
+        super().pre_simulation(n_time_steps, delta_t)
+
+    def pre_iteration(self, time_index, date, daylight_saving):
+        super().pre_iteration(time_index, date, daylight_saving)
+        # variables dictonary
+        var_dic = self.get_parameter_variable_dictionary(time_index)
+        
+        # Output variables
+        for i in range(len(self.parameter("output_variables").value)):
+            calculated_value = self.parameter(
+                "output_expressions").evaluate(i, var_dic)
+            name = self.parameter("output_variables").value[i]
+            self.variable(name).values[time_index] = calculated_value

opensimula/components/Construction.py

@@ -0,0 +1,309 @@
+import math
+import numpy as np
+from scipy.optimize import brentq
+from opensimula.Message import Message
+from opensimula.Parameters import Parameter_component_list, Parameter_float_list
+from opensimula.Component import Component
+
+class Construction(Component):
+    def __init__(self, name, project):
+        Component.__init__(self, name, project)
+        self.parameter("type").value = "Construction"
+        self.parameter(
+            "description").value = "Construction using layers of material"
+
+        self.add_parameter(Parameter_float_list(
+            "solar_alpha", [0.8, 0.8], "frac", min=0, max=1))
+        self.add_parameter(Parameter_float_list(
+            "lw_epsilon", [0.9, 0.9], "frac", min=0, max=1))
+        self.add_parameter(Parameter_component_list(
+            "materials", [], "Material"))
+        self.add_parameter(Parameter_float_list("thicknesses", [], "m", min=0))
+
+    def check(self):
+        errors = super().check()
+        # Test if materials an thicknesses size are equals
+        if len(self.parameter("materials").value) != len(self.parameter("thicknesses").value):
+            msg =f"Error: {self.parameter('name').value}, material and thicknesses parameters must have same length"
+            errors.append(Message(msg, "error"))
+        return errors
+
+    # Functions for Transfer Function Calculation
+
+    def pre_simulation(self, n_time_steps, delta_t):
+        super().pre_simulation(n_time_steps, delta_t)
+        self._calc_trans_fun_(delta_t)
+
+    def get_T_step_fluxes(self):
+        n_q = len(self._coef_Q)
+        n_t = len(self._coef_T_a)
+        Q_old_1 = np.zeros(n_q)
+        Q_old_2 = np.zeros(n_q)
+        T_old = np.ones(n_t)
+        # T_old[0] = 0
+        q_2 = 1
+        Q_2 = []
+        Q_1 = []
+        n = 0
+        while n <= 1 or math.fabs(q_2) > 1e-15:
+            q_2 = np.dot(
+                self._coef_T_a - self._coef_T_b, T_old.transpose()
+            ) - np.dot(self._coef_Q, Q_old_2.transpose())
+            q_1 = np.dot(
+                self._coef_T_b - self._coef_T_c, T_old.transpose()
+            ) - np.dot(self._coef_Q, Q_old_1.transpose())
+            Q_2.append(q_2)
+            Q_1.append(q_1)
+            Q_old_2 = np.roll(Q_old_2, 1)
+            Q_old_2[0] = 0
+            Q_old_2[1] = q_2
+            Q_old_1 = np.roll(Q_old_1, 1)
+            Q_old_1[0] = 0
+            Q_old_1[1] = q_1
+            T_old = np.roll(T_old, 1)
+            T_old[0] = 0
+            n = n + 1
+        return (Q_1, Q_2)
+
+    def thermal_resistance(self):
+        resis_tot = 0
+        for i in range(len(self.parameter("materials").value)):
+            resis_tot = resis_tot + self._resis_layer_(i)
+        return resis_tot
+
+    def radiant_property(self, prop, radiation_type, side, theta=0):
+        if (radiation_type == "solar_diffuse" or radiation_type == "solar_direct"):
+            if (prop == "rho"):
+                return 1-self.parameter("solar_alpha").value[side]
+            elif (prop == "tau"):
+                return 0
+            elif (prop == "alpha"):
+                return self.parameter("solar_alpha").value[side]
+            elif (prop == "alpha_other_side"):
+                return 0
+        elif (radiation_type == "long_wave"):
+            if (prop == "rho"):
+                return 1-self.parameter("lw_epsilon").value[side]
+            elif (prop == "tau"):
+                return 0
+            elif (prop == "alpha"):
+                return self.parameter("lw_epsilon").value[side]
+
+    def get_A(self):
+        """
+            Conduction actual time coefficients
+        Returns:
+            (a_0, a_1, a_01): 
+        """
+        return (-self._coef_T_c[0], -self._coef_T_a[0], self._coef_T_b[0])
+
+    def get_P(self, time_i, T_s0, T_s1, q_cd0, q_cd1, T_ini):
+        """
+            Conduction P for one time instant
+        Returns:
+            (p_0, p_1): 
+        """
+        p0 = 0
+        p1 = 0
+        for i in range(1, len(self._coef_T_a)):
+            j = time_i - i
+            if j < 0:
+                T_0 = T_ini
+                T_1 = T_ini
+            else:
+                T_0 = T_s0[j]
+                T_1 = T_s1[j]
+            p0 += -self._coef_T_c[i] * T_0 + self._coef_T_b[i] * T_1
+            p1 += -self._coef_T_a[i] * T_1 + self._coef_T_b[i] * T_0
+        for i in range(1, len(self._coef_Q)):
+            j = time_i - i
+            if j < 0:
+                q_0 = 0
+                q_1 = 0
+            else:
+                q_0 = q_cd0[j]
+                q_1 = q_cd1[j]
+            p0 += -self._coef_Q[i] * q_0
+            p1 += -self._coef_Q[i] * q_1
+        return (p0, p1)
+
+    def _resis_layer_(self, layer):
+        material = self.parameter("materials").component[layer]
+        resis_def = material.parameter("use_resistance").value
+        if resis_def:
+            return material.parameter("thermal_resistance").value
+        else:
+            return (
+                self.parameter("thicknesses").value[layer]
+                / material.parameter("conductivity").value
+            )
+
+    def _alpha_layer_(self, layer):
+        material = self.parameter("materials").component[layer]
+        resis_def = material.parameter("use_resistance").value
+        if resis_def:
+            return (
+                self.parameter("thicknesses").value[layer]
+                / material.parameter("thermal_resistance").value
+            ) / (
+                material.parameter("density").value
+                * material.parameter("specific_heat").value
+            )
+        else:
+            return material.parameter("conductivity").value / (
+                material.parameter("density").value
+                * material.parameter("specific_heat").value
+            )
+
+    def _tau_layer_(self, layer):
+        L = self.parameter("thicknesses").value[layer]
+        return L * L / self._alpha_layer_(layer)
+
+    def _H_Matrix_Layer_(self, s, layer):
+        # Calculate H Matrix for one layer
+        resis = self._resis_layer_(layer)
+        tau = self._tau_layer_(layer)
+        aux = math.sqrt(tau * s)
+
+        A = math.cos(aux)
+        if s == 0:
+            B = resis
+            C = 0
+        else:
+            B = resis / aux * math.sin(aux)
+            C = -aux * math.sin(aux) / resis
+        return np.array([[A, B], [C, A]])
+
+    def _dH_Matrix_Layer_(self, s, layer):
+        # Calculate dif H Matrix for one layer
+        resis = self._resis_layer_(layer)
+        tau = self._tau_layer_(layer)
+        aux = math.sqrt(tau * s)
+
+        if s == 0:
+            A = tau / 2
+            B = (resis * tau) / 6
+            C = tau / resis
+        else:
+            A = (tau / 2) * math.sin(aux) / aux
+            B = (resis / (2 * s)) * (math.sin(aux) / aux - math.cos(aux))
+            C = (tau / (2 * resis)) * ((math.sin(aux) / aux) + math.cos(aux))
+        return np.array([[A, B], [C, A]])
+
+    def _H_Matrix_(self, s):
+        H = np.eye(2)
+        for i in range(len(self.parameter("materials").value)):
+            H = np.dot(H, self._H_Matrix_Layer_(s, i))
+        return H
+
+    def _dH_Matrix_(self, s):
+        H = np.zeros((2, 2))
+        n = len(self.parameter("materials").value)
+        for i in range(n):
+            P1 = np.eye(2)
+            for j in range(i):
+                P1 = np.dot(P1, self._H_Matrix_Layer_(s, j))
+            P2 = np.eye(2)
+            for j in range(i + 1, n):
+                P2 = np.dot(P2, self._H_Matrix_Layer_(s, j))
+            H = H + np.dot(P1, np.dot(self._dH_Matrix_Layer_(s, i), P2))
+        return H
+
+    def _B_roots_(self, delta_t):
+        def func(s):
+            B = self._H_Matrix_(s)[0, 1]
+            return B
+
+        delta_s = 1e-6
+        a = 1e-15
+        B_a = func(a)
+        b = delta_s
+        roots = []
+        exp = 1
+        while exp > 1e-10:
+            B_b = func(b)
+            if B_a * B_b <= 0:  # Signo contrario o un cero
+                bisec = brentq(func, a, b)
+                roots.append(bisec)
+                exp = math.exp(-bisec * delta_t)
+            a = b
+            B_a = B_b
+            b = b + delta_s
+
+        return roots
+
+    def _calc_trans_fun_(self, delta_t):
+        min_coef = 1e-10
+        dH_0 = self._dH_Matrix_(0)
+        H_0 = self._H_Matrix_(0)
+        C0 = H_0[0, 0] / H_0[0, 1]
+        C1x = (dH_0[0, 0] * H_0[0, 1] - H_0[0, 0] * dH_0[0, 1]) / (
+            H_0[0, 1] * H_0[0, 1]
+        )
+        C1y = (-dH_0[0, 1]) / (H_0[0, 1] * H_0[0, 1])
+        C1z = (dH_0[1, 1] * H_0[0, 1] - dH_0[0, 1]) / (H_0[0, 1] * H_0[0, 1])
+
+        # e_coef
+        roots = self._B_roots_(delta_t)
+        n_coef = len(roots) + 1
+        ex = []
+        ey = []
+        ez = []
+        h = []
+        for root in roots:
+            H = self._H_Matrix_(root)
+            dH = self._dH_Matrix_(root)
+            ex.append(H[0, 0] / (root * root * dH[0, 1]))
+            ey.append(1 / (root * root * dH[0, 1]))
+            ez.append(H[1, 1] / (root * root * dH[0, 1]))
+            h.append(math.exp(-root * delta_t))
+        d = [1, -h[0]]
+        for i in range(1, len(roots)):
+            u = [1, -h[i]]
+            d = np.convolve(d, u)
+
+        ox = []
+        oy = []
+        oz = []
+        for i in range(1, n_coef):
+            sum_exp_x = 0
+            sum_exp_y = 0
+            sum_exp_z = 0
+            for j in range(len(roots)):
+                exp = math.exp(-(i) * roots[j] * delta_t)
+                sum_exp_x = sum_exp_x + ex[j] * exp
+                sum_exp_y = sum_exp_y + ey[j] * exp
+                sum_exp_z = sum_exp_z + ez[j] * exp
+            ox.append(C1x + i * C0 * delta_t + sum_exp_x)
+            oy.append(C1y + i * C0 * delta_t + sum_exp_y)
+            oz.append(C1z + i * C0 * delta_t + sum_exp_z)
+
+        ramp = [1 / delta_t, -2 / delta_t, 1 / delta_t]
+        g = np.convolve(ramp, d)
+        a = np.convolve(g, ox)
+        b = np.convolve(g, oy)
+        c = np.convolve(g, oz)
+        # Cut d coefficients
+        for i in range(len(d)):
+            if math.fabs(d[i]) < min_coef:
+                d = d[0: i+1]
+                break
+        # Cut number of coeficients, se producen coeficientes extraños para muros ligeros a partir del n. de roots
+        a = np.resize(a, n_coef-1)
+        b = np.resize(b, n_coef-1)
+        c = np.resize(c, n_coef-1)
+        # Cut a, b, c coefficients
+        for i in range(len(a)):
+            if (
+                math.fabs(a[i]) < min_coef
+                and math.fabs(b[i]) < min_coef
+                and math.fabs(c[i]) < min_coef
+            ):
+                a = a[0: i+1]
+                b = b[0: i+1]
+                c = c[0: i+1]
+                break
+        self._coef_T_a = a
+        self._coef_T_b = b
+        self._coef_T_c = c
+        self._coef_Q = d