KratosStructuralMechanicsApplication 10.4.4__py3-none-any.whl

KratosMultiphysics/StructuralMechanicsApplication/__init__.py

@@ -0,0 +1,12 @@
+# Application dependent names and paths
+from KratosMultiphysics import _ImportApplication
+from KratosMultiphysics.kratos_utilities import CheckIfApplicationsAvailable
+from KratosStructuralMechanicsApplication import *
+application = KratosStructuralMechanicsApplication()
+application_name = "KratosStructuralMechanicsApplication"
+
+_ImportApplication(application, application_name)
+
+if CheckIfApplicationsAvailable("ConstitutiveLawsApplication"):
+    # if available import the advanced constitutive laws
+    import KratosMultiphysics.ConstitutiveLawsApplication

KratosMultiphysics/StructuralMechanicsApplication/adaptative_remeshing_structural_mechanics_analysis.py

@@ -0,0 +1,214 @@
+# Importing Kratos
+import KratosMultiphysics as KM
+import KratosMultiphysics.StructuralMechanicsApplication as SMA
+
+# Other imports
+from KratosMultiphysics.StructuralMechanicsApplication import python_solvers_wrapper_adaptative_remeshing_structural
+
+# Import the base structural analysis
+from KratosMultiphysics.StructuralMechanicsApplication.structural_mechanics_analysis import StructuralMechanicsAnalysis as BaseClass
+
+class AdaptativeRemeshingStructuralMechanicsAnalysis(BaseClass):
+    """
+    This class is the main-script of the StructuralMechanicsApplication when using adaptative remeshing put in a class
+
+    It can be imported and used as "black-box"
+    """
+    def __init__(self, model, project_parameters):
+
+        # Construct the base analysis.
+        default_params = KM.Parameters("""
+        {
+            "max_iteration" : 1,
+            "analysis_type" : "linear"
+        }
+        """)
+        if project_parameters["solver_settings"].Has("max_iteration"):
+            self.non_linear_iterations = project_parameters["solver_settings"]["max_iteration"].GetInt()
+        else:
+            self.non_linear_iterations = 10
+            project_parameters["solver_settings"].AddValue("max_iteration", default_params["max_iteration"])
+        if project_parameters["solver_settings"].Has("analysis_type"):
+            project_parameters["solver_settings"]["analysis_type"].SetString("linear")
+        else:
+            project_parameters["solver_settings"].AddValue("analysis_type", default_params["analysis_type"])
+        self.process_remesh = False
+        if project_parameters.Has("mesh_adaptivity_processes"):
+            self.process_remesh = True
+        if project_parameters.Has("processes"):
+            if project_parameters["processes"].Has("mesh_adaptivity_processes"):
+                self.process_remesh = True
+        super().__init__(model, project_parameters)
+
+    def Initialize(self):
+        """ Initializing the Analysis """
+        super().Initialize()
+        computing_model_part = self._GetSolver().GetComputingModelPart()
+        if not self.process_remesh:
+            convergence_criteria = self._GetSolver()._GetConvergenceCriterion()
+            convergence_criteria.Initialize(computing_model_part)
+
+        # Ensuring to have conditions on the BC before remesh
+        is_surface = False
+        for elem in computing_model_part.Elements:
+            geom = elem.GetGeometry()
+            if geom.WorkingSpaceDimension() != geom.LocalSpaceDimension():
+                is_surface = True
+            break
+
+        if not is_surface:
+            # We need to detect the conditions in the boundary conditions
+            list_model_parts = []
+            if self.project_parameters.Has("constraints_process_list"):
+                constraints_process_list = self.project_parameters["constraints_process_list"]
+                for i in range(0,constraints_process_list.size()):
+                    item = constraints_process_list[i]
+                    list_model_parts.append(item["Parameters"]["model_part_name"].GetString())
+            skin_detection_parameters = KM.Parameters("""
+            {
+                "list_model_parts_to_assign_conditions" : []
+            }
+            """)
+            for name_mp in list_model_parts:
+                skin_detection_parameters["list_model_parts_to_assign_conditions"].Append(name_mp)
+
+            if computing_model_part.ProcessInfo[KM.DOMAIN_SIZE] == 2:
+                detect_skin = KM.SkinDetectionProcess2D(computing_model_part, skin_detection_parameters)
+            else:
+                detect_skin = KM.SkinDetectionProcess3D(computing_model_part, skin_detection_parameters)
+            detect_skin.Execute()
+        self._GetSolver().SetEchoLevel(self.echo_level)
+
+    def RunSolutionLoop(self):
+        """This function executes the solution loop of the AnalysisStage
+        It can be overridden by derived classes
+        """
+
+        # If we remesh using a process
+        computing_model_part = self._GetSolver().GetComputingModelPart()
+        root_model_part = computing_model_part.GetRootModelPart()
+        if self.process_remesh:
+            while self.time < self.end_time:
+                self.time = self._GetSolver().AdvanceInTime(self.time)
+                # We reinitialize if remeshed previously
+                if root_model_part.Is(KM.MODIFIED):
+                    self._ReInitializeSolver()
+                self.InitializeSolutionStep()
+                # We reinitialize if remeshed on the InitializeSolutionStep
+                if root_model_part.Is(KM.MODIFIED):
+                    self._ReInitializeSolver()
+                    self.InitializeSolutionStep()
+                self._GetSolver().Predict()
+                self._GetSolver().SolveSolutionStep()
+                self.FinalizeSolutionStep()
+                self.OutputSolutionStep()
+        else: # Remeshing adaptively
+            metric_process = self._GetSolver().get_metric_process()
+            remeshing_process = self._GetSolver().get_remeshing_process()
+            convergence_criteria = self._GetSolver()._GetConvergenceCriterion()
+            builder_and_solver = self._GetSolver()._GetBuilderAndSolver()
+            mechanical_solution_strategy = self._GetSolver()._GetSolutionStrategy()
+
+            while self.time < self.end_time:
+                self.time = self._GetSolver().AdvanceInTime(self.time)
+                non_linear_iteration = 1
+                while non_linear_iteration <= self.non_linear_iterations:
+                    if root_model_part.Is(KM.MODIFIED):
+                        self._ReInitializeSolver()
+                    if non_linear_iteration == 1 or root_model_part.Is(KM.MODIFIED):
+                        self.InitializeSolutionStep()
+                        self._GetSolver().Predict()
+                        computing_model_part.Set(KM.MODIFIED, False)
+                    computing_model_part.ProcessInfo.SetValue(KM.NL_ITERATION_NUMBER, non_linear_iteration)
+                    reform_dofs = mechanical_solution_strategy.GetReformDofSetAtEachStepFlag()
+                    mechanical_solution_strategy.SetReformDofSetAtEachStepFlag(True)
+                    is_converged = convergence_criteria.PreCriteria(computing_model_part, builder_and_solver.GetDofSet(), mechanical_solution_strategy.GetSystemMatrix(), mechanical_solution_strategy.GetSolutionVector(), mechanical_solution_strategy.GetSystemVector())
+                    self._GetSolver().SolveSolutionStep()
+                    is_converged = convergence_criteria.PostCriteria(computing_model_part, builder_and_solver.GetDofSet(), mechanical_solution_strategy.GetSystemMatrix(), mechanical_solution_strategy.GetSolutionVector(), mechanical_solution_strategy.GetSystemVector())
+                    self.FinalizeSolutionStep()
+                    mechanical_solution_strategy.SetReformDofSetAtEachStepFlag(reform_dofs)
+                    if is_converged:
+                        KM.Logger.PrintInfo(self._GetSimulationName(), "Adaptative strategy converged in ", non_linear_iteration, "iterations" )
+                        break
+                    elif non_linear_iteration == self.non_linear_iterations:
+                        KM.Logger.PrintInfo(self._GetSimulationName(), "Adaptative strategy not converged after ", non_linear_iteration, "iterations" )
+                        break
+                    else:
+                        metric_process.Execute()
+                        remeshing_process.Execute()
+                        computing_model_part.Set(KM.MODIFIED, True)
+                        non_linear_iteration += 1
+                self.OutputSolutionStep()
+
+    #### Internal functions ####
+    def _CreateSolver(self):
+        """ Create the Solver (and create and import the ModelPart if it is not already in the model) """
+
+        # To avoid many prints
+        if (self.echo_level == 0):
+            KM.Logger.GetDefaultOutput().SetSeverity(KM.Logger.Severity.WARNING)
+
+        ## Solver construction
+        return python_solvers_wrapper_adaptative_remeshing_structural.CreateSolver(self.model, self.project_parameters)
+
+    def _CreateProcesses(self, parameter_name, initialization_order):
+        """Create a list of Processes
+        This method is TEMPORARY to not break existing code
+        It will be removed in the future
+        """
+        list_of_processes = super()._CreateProcesses(parameter_name, initialization_order)
+
+        if parameter_name == "processes":
+            processes_block_names = ["mesh_adaptivity_processes"]
+            if len(list_of_processes) == 0: # Processes are given in the old format
+                KM.Logger.PrintWarning("AdaptativeRemeshingStructuralMechanicsAnalysis", "Using the old way to create the processes, this will be removed!")
+                from process_factory import KratosProcessFactory
+                factory = KratosProcessFactory(self.model)
+                for process_name in processes_block_names:
+                    if self.project_parameters.Has(process_name):
+                        list_of_processes += factory.ConstructListOfProcesses(self.project_parameters[process_name])
+            else: # Processes are given in the new format
+                for process_name in processes_block_names:
+                    if self.project_parameters.Has(process_name):
+                        raise Exception("Mixing of process initialization is not allowed!")
+        elif parameter_name == "output_processes":
+            pass # Already added
+        else:
+            raise NameError("wrong parameter name")
+
+        return list_of_processes
+
+    def _ReInitializeSolver(self):
+        """ This reinitializes after remesh """
+        self._GetSolver().Clear()
+        # WE INITIALIZE THE SOLVER
+        self._GetSolver().Initialize()
+        # WE RECOMPUTE THE PROCESSES AGAIN
+        ## Processes initialization
+        for process in self._GetListOfProcesses():
+            process.ExecuteInitialize()
+        ## Processes before the loop
+        for process in self._GetListOfProcesses():
+            process.ExecuteBeforeSolutionLoop()
+        ## Processes of initialize the solution step
+        for process in self._GetListOfProcesses():
+            process.ExecuteInitializeSolutionStep()
+
+if __name__ == "__main__":
+    from sys import argv
+
+    if len(argv) > 2:
+        err_msg =  'Too many input arguments!\n'
+        err_msg += 'Use this script in the following way:\n'
+        err_msg += '- With default ProjectParameters (read from "ProjectParameters.json"):\n'
+        err_msg += '    "python3 contact_structural_mechanics_analysis.py"\n'
+        err_msg += '- With custom ProjectParameters:\n'
+        err_msg += '    "python3 contact_structural_mechanics_analysis.py CustomProjectParameters.json"\n'
+        raise Exception(err_msg)
+
+    if len(argv) == 2: # ProjectParameters is being passed from outside
+        project_parameters_file_name = argv[1]
+    else: # using default name
+        project_parameters_file_name = "ProjectParameters.json"
+
+    AdaptativeRemeshingStructuralMechanicsAnalysis(project_parameters_file_name).Run()

KratosMultiphysics/StructuralMechanicsApplication/adaptative_remeshing_structural_mechanics_implicit_dynamic_solver.py

@@ -0,0 +1,69 @@
+# Importing the Kratos Library
+import KratosMultiphysics
+
+# Import applications
+import KratosMultiphysics.StructuralMechanicsApplication as StructuralMechanicsApplication
+
+import KratosMultiphysics.kratos_utilities as kratos_utilities
+if kratos_utilities.CheckIfApplicationsAvailable("MeshingApplication"):
+    import KratosMultiphysics.MeshingApplication as MeshingApplication
+    missing_meshing_dependencies = True
+else:
+    missing_meshing_dependencies = False
+
+# Import base class file
+from KratosMultiphysics.StructuralMechanicsApplication import structural_mechanics_implicit_dynamic_solver
+
+# Import auxiliary methods
+from KratosMultiphysics.StructuralMechanicsApplication import auxiliary_methods_adaptative_solvers
+from KratosMultiphysics.StructuralMechanicsApplication import adaptative_remeshing_structural_mechanics_utilities
+
+def CreateSolver(model, custom_settings):
+    return AdaptativeRemeshingImplicitMechanicalSolver(model, custom_settings)
+
+class AdaptativeRemeshingImplicitMechanicalSolver(structural_mechanics_implicit_dynamic_solver.ImplicitMechanicalSolver):
+    """The structural mechanics implicit dynamic solver. (For adaptative remeshing)
+    See structural_mechanics_implicit_dynamic_solver.py for more information.
+    """
+    def __init__(self, model, custom_settings):
+        # Set defaults and validate custom settings.
+        self.adaptative_remeshing_utilities = adaptative_remeshing_structural_mechanics_utilities.AdaptativeRemeshingMechanicalUtilities()
+
+        # Construct the base solver.
+        super().__init__(model, custom_settings)
+        KratosMultiphysics.Logger.PrintInfo("::[AdaptativeRemeshingImplicitMechanicalSolver]:: ", "Construction finished")
+
+    #### Private functions ####
+
+    def AddVariables(self):
+        super().AddVariables()
+        if not missing_meshing_dependencies:
+            self.main_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.NODAL_H)
+        KratosMultiphysics.Logger.PrintInfo("::[AdaptativeRemeshingImplicitMechanicalSolver]:: ", "Variables ADDED")
+
+    def get_remeshing_process(self):
+        if not hasattr(self, '_remeshing_process'):
+            self._remeshing_process = self._create_remeshing_process()
+        return self._remeshing_process
+
+    def _create_remeshing_process(self):
+        return auxiliary_methods_adaptative_solvers.CreateRemeshingProcess(self.main_model_part, self.settings)
+
+    def get_metric_process(self):
+        if not hasattr(self, '_metric_process'):
+            self._metric_process = self._create_metric_process()
+        return self._metric_process
+
+    def _create_metric_process(self):
+        return auxiliary_methods_adaptative_solvers.CreateMetricProcess(self.main_model_part, self.settings)
+
+    def _CreateConvergenceCriterion(self):
+        error_criteria = self.settings["convergence_criterion"].GetString()
+        conv_settings = self._get_convergence_criterion_settings()
+        return self.adaptative_remeshing_utilities.GetConvergenceCriteria(error_criteria, conv_settings)
+
+    @classmethod
+    def GetDefaultParameters(cls):
+        this_defaults = adaptative_remeshing_structural_mechanics_utilities.AdaptativeRemeshingMechanicalUtilities().GetDefaultParameters()
+        this_defaults.AddMissingParameters(super().GetDefaultParameters())
+        return this_defaults

KratosMultiphysics/StructuralMechanicsApplication/adaptative_remeshing_structural_mechanics_static_solver.py

@@ -0,0 +1,69 @@
+# Importing the Kratos Library
+import KratosMultiphysics
+
+# Import applications
+import KratosMultiphysics.StructuralMechanicsApplication as StructuralMechanicsApplication
+
+import KratosMultiphysics.kratos_utilities as kratos_utilities
+if kratos_utilities.CheckIfApplicationsAvailable("MeshingApplication"):
+    import KratosMultiphysics.MeshingApplication as MeshingApplication
+    missing_meshing_dependencies = True
+else:
+    missing_meshing_dependencies = False
+
+# Import base class file
+from KratosMultiphysics.StructuralMechanicsApplication import structural_mechanics_static_solver
+
+# Import auxiliary methods
+from KratosMultiphysics.StructuralMechanicsApplication import auxiliary_methods_adaptative_solvers
+from KratosMultiphysics.StructuralMechanicsApplication import adaptative_remeshing_structural_mechanics_utilities
+
+def CreateSolver(model, custom_settings):
+    return AdaptativeRemeshingStaticMechanicalSolver(model, custom_settings)
+
+class AdaptativeRemeshingStaticMechanicalSolver(structural_mechanics_static_solver.StaticMechanicalSolver):
+    """The structural mechanics static solver. (For adaptative remeshing)
+    See structural_mechanics_static_solver.py for more information.
+    """
+    def __init__(self, model, custom_settings):
+        # Set defaults and validate custom settings.
+        self.adaptative_remeshing_utilities = adaptative_remeshing_structural_mechanics_utilities.AdaptativeRemeshingMechanicalUtilities()
+
+        # Construct the base solver.
+        super().__init__(model, custom_settings)
+        KratosMultiphysics.Logger.PrintInfo("::[AdaptativeRemeshingStaticMechanicalSolver]:: ", "Construction finished")
+
+    #### Private functions ####
+
+    def AddVariables(self):
+        super().AddVariables()
+        if not missing_meshing_dependencies:
+            self.main_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.NODAL_H)
+        KratosMultiphysics.Logger.PrintInfo("::[AdaptativeRemeshingStaticMechanicalSolver]:: ", "Variables ADDED")
+
+    def get_remeshing_process(self):
+        if not hasattr(self, '_remeshing_process'):
+            self._remeshing_process = self._create_remeshing_process()
+        return self._remeshing_process
+
+    def _create_remeshing_process(self):
+        return auxiliary_methods_adaptative_solvers.CreateRemeshingProcess(self.main_model_part, self.settings)
+
+    def get_metric_process(self):
+        if not hasattr(self, '_metric_process'):
+            self._metric_process = self._create_metric_process()
+        return self._metric_process
+
+    def _create_metric_process(self):
+        return auxiliary_methods_adaptative_solvers.CreateMetricProcess(self.main_model_part, self.settings)
+
+    def _CreateConvergenceCriterion(self):
+        error_criteria = self.settings["convergence_criterion"].GetString()
+        conv_settings = self._get_convergence_criterion_settings()
+        return self.adaptative_remeshing_utilities.GetConvergenceCriteria(error_criteria, conv_settings)
+
+    @classmethod
+    def GetDefaultParameters(cls):
+        this_defaults = adaptative_remeshing_structural_mechanics_utilities.AdaptativeRemeshingMechanicalUtilities().GetDefaultParameters()
+        this_defaults.AddMissingParameters(super().GetDefaultParameters())
+        return this_defaults

KratosMultiphysics/StructuralMechanicsApplication/adaptative_remeshing_structural_mechanics_utilities.py

@@ -0,0 +1,94 @@
+# Importing the Kratos Library
+import KratosMultiphysics
+
+# Import applications
+import KratosMultiphysics.StructuralMechanicsApplication as StructuralMechanicsApplication
+from KratosMultiphysics.StructuralMechanicsApplication import convergence_criteria_factory
+
+try:
+    import KratosMultiphysics.MeshingApplication as MeshingApplication
+    missing_meshing_dependencies = False
+    missing_application = ''
+except ImportError as e:
+    missing_meshing_dependencies = True
+    # extract name of the missing application from the error message
+    import re
+    missing_application = re.search(r'''.*'KratosMultiphysics\.(.*)'.*''','{0}'.format(e)).group(1)
+
+class AdaptativeRemeshingMechanicalUtilities(object):
+    """These are common utilities for adaptative remeshing
+    """
+
+    def __init__(self):
+        self.adaptative_remesh_parameters = KratosMultiphysics.Parameters("""
+        {
+            "compute_error_settings" : {
+                "error_mesh_tolerance" : 5.0e-3,
+                "error_mesh_constant"  : 5.0e-3,
+                "compute_error_extra_parameters":
+                {
+                    "stress_vector_variable"              : "CAUCHY_STRESS_VECTOR",
+                    "echo_level"                          : 0
+                }
+            },
+            "metric_error_parameters" :
+            {
+                "minimal_size"                        : 0.01,
+                "maximal_size"                        : 1.0,
+                "error_strategy_parameters":
+                {
+                    "target_error"                        : 0.01,
+                    "set_target_number_of_elements"       : false,
+                    "target_number_of_elements"           : 1000,
+                    "perform_nodal_h_averaging"           : false
+                },
+                "echo_level"                          : 0
+            },
+            "remeshing_parameters":
+            {
+                "filename"                             : "out",
+                "framework"                            : "Lagrangian",
+                "internal_variables_parameters"        :
+                {
+                    "allocation_size"                      : 1000,
+                    "bucket_size"                          : 4,
+                    "search_factor"                        : 2,
+                    "interpolation_type"                   : "LST",
+                    "internal_variable_interpolation_list" :[]
+                },
+                "save_external_files"              : false,
+                "max_number_of_searchs"            : 1000,
+                "echo_level"                       : 0
+            }
+        }
+        """)
+
+    def GetDefaultParameters(self):
+        return self.adaptative_remesh_parameters
+
+    def SetDefaultParameters(self, settings):
+        self.adaptative_remesh_parameters = settings
+
+    def GetConvergenceCriteria(self, error_criteria, conv_settings):
+        if ("_with_adaptative_remesh" in error_criteria):
+            conv_settings["convergence_criterion"].SetString(error_criteria.replace("_with_adaptative_remesh", ""))
+        # If we just use the adaptative convergence criteria
+        if (missing_meshing_dependencies is True):
+            if ("adaptative_remesh" in error_criteria):
+                raise NameError('The AdaptativeErrorCriteria can not be used without compiling the MeshingApplication')
+        else:
+            if (error_criteria == "adaptative_remesh_criteria"):
+                adaptative_error_criteria = StructuralMechanicsApplication.ErrorMeshCriteria(self.adaptative_remesh_parameters["compute_error_settings"])
+                adaptative_error_criteria.SetEchoLevel(conv_settings["echo_level"].GetInt())
+                return adaptative_error_criteria
+
+        # Regular convergence criteria
+        convergence_criterion = convergence_criteria_factory.convergence_criterion(conv_settings)
+
+        # If we combine the regular convergence criteria with adaptative
+        if (missing_meshing_dependencies is False):
+            if ("_with_adaptative_remesh" in error_criteria):
+                adaptative_error_criteria = StructuralMechanicsApplication.ErrorMeshCriteria(self.adaptative_remesh_parameters["compute_error_settings"])
+                adaptative_error_criteria.SetEchoLevel(conv_settings["echo_level"].GetInt())
+                convergence_criterion.mechanical_convergence_criterion = KratosMultiphysics.AndCriteria(convergence_criterion.mechanical_convergence_criterion, adaptative_error_criteria)
+        return convergence_criterion.mechanical_convergence_criterion

KratosMultiphysics/StructuralMechanicsApplication/automatic_rayleigh_parameters_computation_process.py

@@ -0,0 +1,190 @@
+# Importing the Kratos Library
+import KratosMultiphysics as KM
+from KratosMultiphysics import eigen_solver_factory
+
+import KratosMultiphysics.StructuralMechanicsApplication as SMA
+
+def Factory(settings, Model):
+    if not isinstance(settings, KM.Parameters):
+        raise Exception("Expected input shall be a Parameters object, encapsulating a json string")
+    return AutomaticRayleighComputationProcess(Model, settings["Parameters"])
+
+# All the processes python processes should be derived from "Process"
+
+class AutomaticRayleighComputationProcess(KM.Process):
+    """This class is used in order to compute automatically the Rayleigh damping parameters computing in first place the eigenvalues of the system
+
+    Only the member variables listed below should be accessed directly.
+
+    Public member variables:
+    Model -- the container of the different model parts.
+    settings -- Kratos parameters containing the settings.
+    """
+
+    def __init__(self, Model, settings):
+        """ The default constructor of the class
+
+        Keyword arguments:
+        self -- It signifies an instance of a class.
+        Model -- the container of the different model parts.
+        settings -- Kratos parameters containing solver settings.
+        """
+        KM.Process.__init__(self)
+
+        # Settings string in json format
+        default_parameters = KM.Parameters("""
+        {
+            "help"                           :"This class is used in order to compute automatically the Rayleigh damping parameters computing in first place the eigenvalues of the system",
+            "model_part_name"                : "Structure",
+            "echo_level"                     : 0,
+            "write_on_properties"            : true,
+            "damping_ratio_0"                : 0.0,
+            "damping_ratio_1"                : -1.0,
+            "eigen_values_vector"            : [0.0],
+            "eigen_system_settings" : {
+                "solver_type"       : "eigen_eigensystem"
+            }
+        }
+        """)
+
+        # Setting solver settings
+        if settings.Has("eigen_system_settings"):
+            if not settings["eigen_system_settings"].Has("solver_type"):
+              settings["eigen_system_settings"].AddValue("solver_type", default_parameters["eigen_system_settings"]["solver_type"])
+        else:
+            settings.AddValue("eigen_system_settings", default_parameters["eigen_system_settings"])
+        solver_type = settings["eigen_system_settings"]["solver_type"].GetString()
+        eigen_system_settings = self._auxiliary_eigen_settings(solver_type)
+        default_parameters["eigen_system_settings"] = eigen_system_settings["eigen_system_settings"]
+
+        # Overwrite the default settings with user-provided parameters
+        self.settings = settings
+        self.settings.RecursivelyValidateAndAssignDefaults(default_parameters)
+
+        # We define the model parts
+        self.model = Model
+        self.main_model_part = self.model[self.settings["model_part_name"].GetString()]
+
+    def ExecuteBeforeSolutionLoop(self):
+        """ This method is executed before starting the time loop
+
+        Keyword arguments:
+        self -- It signifies an instance of a class.
+        """
+
+        # The general damping ratios
+        damping_ratio_0 = self.settings["damping_ratio_0"].GetDouble()
+        damping_ratio_1 = self.settings["damping_ratio_1"].GetDouble()
+
+        # We get the model parts which divide the problem
+        current_process_info = self.main_model_part.ProcessInfo
+        existing_computation = current_process_info.Has(SMA.EIGENVALUE_VECTOR)
+
+        # Create auxiliary parameters
+        compute_damping_coefficients_settings = KM.Parameters("""
+        {
+            "echo_level"          : 0,
+            "damping_ratio_0"     : 0.0,
+            "damping_ratio_1"     : -1.0,
+            "eigen_values_vector" : [0.0]
+        }
+        """)
+
+        # Setting custom parameters
+        compute_damping_coefficients_settings["echo_level"].SetInt(self.settings["echo_level"].GetInt())
+        compute_damping_coefficients_settings["damping_ratio_0"].SetDouble(damping_ratio_0)
+        compute_damping_coefficients_settings["damping_ratio_1"].SetDouble(damping_ratio_1)
+
+        # We check if the values are previously defined
+        properties = self.main_model_part.GetProperties()
+        for prop in properties:
+            if prop.Has(SMA.SYSTEM_DAMPING_RATIO):
+                self.settings["damping_ratio_0"].SetDouble(prop.GetValue(SMA.SYSTEM_DAMPING_RATIO))
+                break
+        for prop in properties:
+            if prop.Has(SMA.SECOND_SYSTEM_DAMPING_RATIO):
+                self.settings["damping_ratio_1"].SetDouble(prop.GetValue(SMA.SECOND_SYSTEM_DAMPING_RATIO))
+                break
+
+        # We have computed already the eigen values
+        current_process_info = self.main_model_part.ProcessInfo
+        precomputed_eigen_values = self.settings["eigen_values_vector"].GetVector()
+        if len(precomputed_eigen_values) > 1:
+            compute_damping_coefficients_settings["eigen_values_vector"].SetVector(precomputed_eigen_values)
+        else:
+            # If not computed eigen values already
+            if not existing_computation:
+                KM.Logger.PrintInfo("::[MechanicalSolver]::", "EIGENVALUE_VECTOR not previously computed. Computing automatically, take care")
+                eigen_linear_solver = eigen_solver_factory.ConstructSolver(self.settings["eigen_system_settings"])
+                builder_and_solver = KM.ResidualBasedBlockBuilderAndSolver(eigen_linear_solver)
+                eigen_scheme = SMA.EigensolverDynamicScheme()
+                eigen_solver = SMA.EigensolverStrategy(self.main_model_part, eigen_scheme, builder_and_solver,
+                    self.mass_matrix_diagonal_value,
+                    self.stiffness_matrix_diagonal_value)
+                eigen_solver.Solve()
+
+                # Setting the variable RESET_EQUATION_IDS
+                current_process_info[SMA.RESET_EQUATION_IDS] = True
+
+            eigenvalue_vector = current_process_info.GetValue(SMA.EIGENVALUE_VECTOR)
+            compute_damping_coefficients_settings["eigen_values_vector"].SetVector(eigenvalue_vector)
+
+        # We compute the coefficients
+        coefficients_vector = SMA.ComputeDampingCoefficients(compute_damping_coefficients_settings)
+
+        # We set the values
+        if self.settings["write_on_properties"].GetBool():
+            for prop in self.main_model_part.Properties:
+                prop.SetValue(SMA.RAYLEIGH_ALPHA, coefficients_vector[0])
+                if current_process_info.Has(KM.COMPUTE_LUMPED_MASS_MATRIX):
+                    if current_process_info[KM.COMPUTE_LUMPED_MASS_MATRIX]:
+                        prop.SetValue(SMA.RAYLEIGH_BETA, 0.0)
+                    else:
+                        prop.SetValue(SMA.RAYLEIGH_BETA, coefficients_vector[1])
+                else:
+                    prop.SetValue(SMA.RAYLEIGH_BETA, coefficients_vector[1])
+        else:
+            current_process_info.SetValue(SMA.RAYLEIGH_ALPHA, coefficients_vector[0])
+            if current_process_info.Has(KM.COMPUTE_LUMPED_MASS_MATRIX):
+                if current_process_info[KM.COMPUTE_LUMPED_MASS_MATRIX]:
+                    current_process_info.SetValue(SMA.RAYLEIGH_BETA, 0.0)
+                else:
+                    current_process_info.SetValue(SMA.RAYLEIGH_BETA, coefficients_vector[1])
+            else:
+                current_process_info.SetValue(SMA.RAYLEIGH_BETA, coefficients_vector[1])
+
+    def _auxiliary_eigen_settings(self, solver_type):
+        """ This method returns the settings for the eigenvalues computations
+
+        Keyword arguments:
+        self -- It signifies an instance of a class.
+        """
+        if solver_type == "feast":
+            eigen_system_settings = KM.Parameters("""
+            {
+                "eigen_system_settings" : {
+                    "solver_type"           : "feast",
+                    "echo_level"            : 0,
+                    "tolerance"             : 1e-10,
+                    "symmetric"             : true,
+                    "e_min"                 : 0.0,
+                    "e_max"                 : 4.0e5,
+                    "number_of_eigenvalues" : 2,
+                    "subspace_size"         : 15
+                }
+            }
+            """)
+            self.mass_matrix_diagonal_value = 1.0
+            self.stiffness_matrix_diagonal_value = -1.0
+        else:
+            eigen_system_settings = KM.Parameters("""
+            {
+                "eigen_system_settings" : {
+                    "solver_type"       : "eigen_eigensystem"
+                }
+            }
+            """)
+            eigen_system_settings["eigen_system_settings"]["solver_type"].SetString(solver_type)
+            self.mass_matrix_diagonal_value = 0.0
+            self.stiffness_matrix_diagonal_value = 1.0
+        return eigen_system_settings