KratosShapeOptimizationApplication 10.4.4__py3-none-any.whl

KratosMultiphysics/ShapeOptimizationApplication/mesh_controllers/mesh_controller_with_solver.py

@@ -0,0 +1,237 @@
+# ==============================================================================
+#  KratosShapeOptimizationApplication
+#
+#  License:         BSD License
+#                   license: ShapeOptimizationApplication/license.txt
+#
+#  Main authors:    Baumgaertner Daniel, https://github.com/dbaumgaertner
+#
+# ==============================================================================
+
+
+# Kratos Core and Apps
+import KratosMultiphysics as KM
+import KratosMultiphysics.ShapeOptimizationApplication as KSO
+
+# Additional imports
+import time as timer
+from KratosMultiphysics.ShapeOptimizationApplication.mesh_controllers.mesh_controller_base import MeshController
+from KratosMultiphysics.MeshMovingApplication.mesh_moving_analysis import MeshMovingAnalysis
+
+try:
+    import KratosMultiphysics.MeshingApplication as KMA
+    from KratosMultiphysics.MeshingApplication.mmg_process import MmgProcess as automatic_remeshing_process
+    if not hasattr(KMA, "MmgProcess2D"):
+        automatic_remeshing_process = None
+        automatic_remeshing_error_msg = "MeshingApplication is not compiled with '-DINCLUDE_MMG=ON'"
+except ImportError as err:
+    automatic_remeshing_process = None
+    automatic_remeshing_error_msg = str(err)
+
+# # ==============================================================================
+class MeshControllerWithSolver(MeshController) :
+    # --------------------------------------------------------------------------
+    def __init__(self, MeshSolverSettings, model):
+        default_settings = KM.Parameters("""
+        {
+            "apply_mesh_solver" : true,
+            "solver_settings" : {
+                "domain_size"     : 3,
+                "echo_level"      : 0,
+                "solver_type"     : "structural_similarity",
+                "model_part_name" : "NONE",
+                "model_import_settings"              : {
+                    "input_type"     : "use_input_model_part"
+                },
+                "time_stepping" : {
+                    "time_step"       : 1.0
+                },
+                "linear_solver_settings" : {
+                    "solver_type" : "amgcl",
+                    "smoother_type":"ilu0",
+                    "krylov_type": "gmres",
+                    "coarsening_type": "aggregation",
+                    "max_iteration": 200,
+                    "verbosity" : 0,
+                    "tolerance": 1e-7
+                },
+                "compute_reactions"                : false,
+                "calculate_mesh_velocity"          : false
+            },
+            "processes" : {
+                "boundary_conditions_process_list" : []
+            },
+            "use_automatic_remeshing"     : false,
+            "automatic_remeshing_settings": {
+                "strategy"        : "optimization",
+                "step_frequency"  : 1,
+                "automatic_remesh": true,
+                "automatic_remesh_parameters": {
+                    "automatic_remesh_type": "Ratio",
+                    "min_size_ratio": 1.0,
+                    "max_size_ratio": 5.0,
+                    "refer_type"    : "Mean"
+                },
+                "echo_level": 0,
+                "force_min" : true,
+                "force_max" : true
+            }
+        }""")
+        self.MeshSolverSettings = MeshSolverSettings
+        self.MeshSolverSettings.ValidateAndAssignDefaults(default_settings)
+        self.MeshSolverSettings["solver_settings"].ValidateAndAssignDefaults(default_settings["solver_settings"])
+        self.MeshSolverSettings["processes"].ValidateAndAssignDefaults(default_settings["processes"])
+
+        if not self.MeshSolverSettings["solver_settings"].Has("linear_solver_settings"):
+            MeshSolverSettings.AddValue("linear_solver_settings", default_settings["solver_settings"]["linear_solver_settings"])
+            KM.Logger.PrintInfo("ShapeOpt", "::[MeshControllerWithSolver]:: using default linear solver for mesh motion.")
+
+        if not MeshSolverSettings.Has("problem_data"):
+            self.__AddDefaultProblemData(self.MeshSolverSettings)
+        else:
+            KM.Logger.PrintInfo("ShapeOpt", "::[MeshControllerWithSolver]:: using custom problem data for mesh motion.")
+
+        self.OptimizationModelPart = model[self.MeshSolverSettings["solver_settings"]["model_part_name"].GetString()]
+
+        if self.MeshSolverSettings["processes"]["boundary_conditions_process_list"].size() == 0:
+            self.__FixWholeSurface(self.OptimizationModelPart, self.MeshSolverSettings)
+            self.has_automatic_boundary_process = True
+        else:
+            self.has_automatic_boundary_process = False
+
+        self.is_remeshing_used = self.MeshSolverSettings["use_automatic_remeshing"].GetBool()
+        if (self.is_remeshing_used):
+            automatic_remeshing_process_settings = self.MeshSolverSettings["automatic_remeshing_settings"]
+            if (automatic_remeshing_process is None):
+                raise RuntimeError("Automatic remeshing requires to import MeshingApplication. Importing failed with following error msg.\n\t" + automatic_remeshing_error_msg)
+
+            self.__CheckAndSetAutomaticMeshRefinementSettings(automatic_remeshing_process_settings)
+            self.remeshing_process = automatic_remeshing_process(model, automatic_remeshing_process_settings)
+
+            # remeshing requires to reinitialize the model_part of the mesh solver
+            self.MeshSolverSettings["solver_settings"].AddBool("reinitialize_model_part_each_step", True)
+
+            KM.Logger.PrintInfo("ShapeOpt", "Initialized automatic automatic remeshing process")
+
+        self._mesh_moving_analysis = MeshMovingAnalysis(model, self.MeshSolverSettings)
+
+    # --------------------------------------------------------------------------
+    def Initialize(self):
+        if self.has_automatic_boundary_process:
+            KSO.GeometryUtilities(self.OptimizationModelPart).ExtractBoundaryNodes("auto_surface_nodes")
+
+        self._mesh_moving_analysis.Initialize()
+        if self.is_remeshing_used:
+            self.remeshing_process.ExecuteInitialize()
+
+    # --------------------------------------------------------------------------
+    def UpdateMeshAccordingInputVariable(self, variable):
+        KM.Logger.Print("")
+        KM.Logger.PrintInfo("ShapeOpt", "Starting to update the mesh...")
+        startTime = timer.time()
+
+        time_before_update = self.OptimizationModelPart.ProcessInfo.GetValue(KM.TIME)
+        step_before_update = self.OptimizationModelPart.ProcessInfo.GetValue(KM.STEP)
+        delta_time_before_update = self.OptimizationModelPart.ProcessInfo.GetValue(KM.DELTA_TIME)
+
+        # Reset step/time iterators such that they match the current iteration after calling RunSolutionLoop (which internally calls CloneTimeStep)
+        self.OptimizationModelPart.ProcessInfo.SetValue(KM.STEP, step_before_update-1)
+        self.OptimizationModelPart.ProcessInfo.SetValue(KM.TIME, time_before_update-1)
+        self.OptimizationModelPart.ProcessInfo.SetValue(KM.DELTA_TIME, 0)
+
+        KM.VariableUtils().CopyVectorVar(variable, KM.MESH_DISPLACEMENT, self.OptimizationModelPart.Nodes)
+
+        if self.has_automatic_boundary_process and self.is_remeshing_used:
+            self.OptimizationModelPart.GetSubModelPart("auto_surface_nodes").GetNodes().clear()
+            KSO.GeometryUtilities(self.OptimizationModelPart).ExtractBoundaryNodes("auto_surface_nodes")
+
+        if not self._mesh_moving_analysis.time < self._mesh_moving_analysis.end_time:
+            self._mesh_moving_analysis.end_time += 1
+        self._mesh_moving_analysis.RunSolutionLoop()
+
+        if self.is_remeshing_used:
+            self.OptimizationModelPart.Set(KM.MODIFIED, False)
+            self.remeshing_process.ExecuteInitializeSolutionStep()
+            self.remeshing_process.ExecuteFinalizeSolutionStep()
+
+        KSO.MeshControllerUtilities(self.OptimizationModelPart).LogMeshChangeAccordingInputVariable(KM.MESH_DISPLACEMENT)
+
+        self.OptimizationModelPart.ProcessInfo.SetValue(KM.STEP, step_before_update)
+        self.OptimizationModelPart.ProcessInfo.SetValue(KM.TIME, time_before_update)
+        self.OptimizationModelPart.ProcessInfo.SetValue(KM.DELTA_TIME, delta_time_before_update)
+
+        KM.Logger.PrintInfo("ShapeOpt", "Time needed for updating the mesh = ",round(timer.time() - startTime,2),"s")
+
+    # --------------------------------------------------------------------------
+    def Finalize(self):
+        self._mesh_moving_analysis.Finalize()
+
+        if self.is_remeshing_used:
+            self.remeshing_process.ExecuteFinalize()
+
+    # --------------------------------------------------------------------------
+    @staticmethod
+    def __AddDefaultProblemData(mesh_solver_settings):
+        problem_data = KM.Parameters("""{
+            "echo_level"    : 0,
+            "start_time"    : 0.0,
+            "end_time"      : 1.0,
+            "parallel_type" : "OpenMP"
+        }""")
+
+        mesh_solver_settings.AddValue("problem_data", problem_data)
+
+    # --------------------------------------------------------------------------
+    @staticmethod
+    def __FixWholeSurface(optimization_model_part, mesh_solver_settings):
+        optimization_model_part.CreateSubModelPart("auto_surface_nodes")
+
+        auto_process_settings = KM.Parameters(
+            """
+            {
+                "python_module" : "fix_vector_variable_process",
+                "kratos_module" : "KratosMultiphysics",
+                "help"          : "This process fixes the selected components of a given vector variable without modifying the value of the variable.",
+                "process_name"  : "FixVectorVariableProcess",
+                "Parameters"    : {
+                    "model_part_name"      : \""""+str(optimization_model_part.Name)+""".auto_surface_nodes\",
+                    "variable_name"        : "MESH_DISPLACEMENT",
+                    "constrained"          : [true,true,true]
+                }
+            }
+            """)
+
+        KM.Logger.PrintInfo("ShapeOpt", "Add automatic process to fix the whole surface to mesh motion solver:")
+        mesh_solver_settings["processes"]["boundary_conditions_process_list"].Append(auto_process_settings)
+
+    # --------------------------------------------------------------------------
+    def __CheckAndSetAutomaticMeshRefinementSettings(self, parameters):
+        if (parameters.Has("interpolate_nodal_values")):
+            if (parameters["interpolate_nodal_values"].GetBool()):
+                KM.Logger.PrintWarning("ShapeOpt", "Historical value interpolation is not allowed in automatic remeshing. Turning it off.")
+            parameters["interpolate_nodal_values"].SetBool(False)
+        else:
+            parameters.AddBool("interpolate_nodal_values", False)
+
+        if (parameters.Has("interpolate_non_historical")):
+            if (parameters["interpolate_non_historical"].GetBool()):
+                KM.Logger.PrintWarning("ShapeOpt", "Non-historical value interpolation is not allowed in automatic remeshing. Turning it off.")
+            parameters["interpolate_non_historical"].SetBool(False)
+        else:
+            parameters.AddBool("interpolate_non_historical", False)
+
+        if (parameters.Has("extrapolate_contour_values")):
+            if (parameters["extrapolate_contour_values"].GetBool()):
+                KM.Logger.PrintWarning("ShapeOpt", "Value extrapolation is not allowed in automatic remeshing. Turning it off.")
+            parameters["extrapolate_contour_values"].SetBool(False)
+        else:
+            parameters.AddBool("extrapolate_contour_values", False)
+
+        if (parameters.Has("model_part_name")):
+            if (parameters["model_part_name"].GetString() != self.OptimizationModelPart.Name):
+                KM.Logger.PrintWarning("ShapeOpt", "Mismatching model part name provided for automatic remeshing [ " + parameters["model_part_name"].GetString() + " ]. Using the optimization model part [ " + self.OptimizationModelPart.Name + " ].")
+            parameters["model_part_name"].SetString(self.OptimizationModelPart.Name)
+        else:
+            parameters.AddString("model_part_name", self.OptimizationModelPart.Name)
+
+# ==============================================================================

KratosMultiphysics/ShapeOptimizationApplication/model_part_controller_factory.py

@@ -0,0 +1,197 @@
+# ==============================================================================
+#  KratosShapeOptimizationApplication
+#
+#  License:         BSD License
+#                   license: ShapeOptimizationApplication/license.txt
+#
+#  Main authors:    Baumgaertner Daniel, https://github.com/dbaumgaertner
+#
+# ==============================================================================
+
+
+# importing the Kratos Library
+import KratosMultiphysics as KM
+import KratosMultiphysics.ShapeOptimizationApplication as KSO
+
+# ==============================================================================
+def CreateController(model_settings, model):
+    return ModelPartController(model_settings, model)
+
+# ==============================================================================
+class ModelPartController:
+    # --------------------------------------------------------------------------
+    def __init__(self, model_settings, model):
+        self.model_settings = model_settings
+
+        default_settings = KM.Parameters("""
+        {
+            "domain_size"           : 3,
+            "model_part_name"       : "OPTIMIZATION_MODEL_PART_NAME",
+            "model_import_settings"              : {
+                "input_type"     : "mdpa",
+                "input_filename" : "OPTIMIZATION_MODEL_PART_FILENAME"
+            },
+            "design_surface_sub_model_part_name" : "DESIGN_SURFACE_NAME",
+            "damping" : {
+                "apply_damping"      : false,
+                "recalculate_damping": false,
+                "max_neighbor_nodes" : 10000,
+                "damping_regions"    : []
+            },
+            "direction_damping" : {
+                "recalculate_damping": true,
+                "max_neighbor_nodes" : 10000,
+                "damping_regions"    : []
+            },
+            "mesh_motion" : {
+                "apply_mesh_solver" : false
+            }
+        }""")
+
+        self.model_settings.ValidateAndAssignDefaults(default_settings)
+        self.model_settings["model_import_settings"].ValidateAndAssignDefaults(default_settings["model_import_settings"])
+        self.model_settings["damping"].ValidateAndAssignDefaults(default_settings["damping"])
+        self.model_settings["direction_damping"].ValidateAndAssignDefaults(default_settings["direction_damping"])
+
+        for direction_damping_settings in self.model_settings["direction_damping"]["damping_regions"].values():
+            if not direction_damping_settings.Has("max_neighbor_nodes"):
+                max_neighbors = self.model_settings["direction_damping"]["max_neighbor_nodes"].GetInt()
+                direction_damping_settings.AddEmptyValue("max_neighbor_nodes").SetInt(max_neighbors)
+
+        self.model = model
+
+        model_part_name = self.model_settings["model_part_name"].GetString()
+        self.optimization_model_part = model.CreateModelPart(model_part_name)
+        self.optimization_model_part.ProcessInfo.SetValue(KM.DOMAIN_SIZE, self.model_settings["domain_size"].GetInt())
+
+        if self.model_settings["mesh_motion"]["apply_mesh_solver"].GetBool():
+            from KratosMultiphysics.ShapeOptimizationApplication.mesh_controllers.mesh_controller_with_solver import MeshControllerWithSolver
+            self.mesh_controller = MeshControllerWithSolver(self.model_settings["mesh_motion"], self.model)
+        else:
+            from KratosMultiphysics.ShapeOptimizationApplication.mesh_controllers.mesh_controller_basic_updating import MeshControllerBasicUpdating
+            self.mesh_controller = MeshControllerBasicUpdating(self.optimization_model_part)
+
+        self.design_surface = None
+        self.damping_utility = None
+        self.direction_dampings = []
+
+    # --------------------------------------------------------------------------
+    def Initialize(self):
+        self.__ImportOptimizationModelPart()
+        self.__IdentifyDesignSurface()
+
+        self.mesh_controller.Initialize()
+
+    def InitializeDamping(self):
+        """Initialize damping utilities, should be called after mapper is initialized"""
+        if self.model_settings["damping"]["apply_damping"].GetBool():
+            self.damping_utility = KSO.DampingUtilities(
+                self.design_surface, self.model_settings["damping"]
+            )
+
+        for direction_damping_settings in self.model_settings["direction_damping"]["damping_regions"].values():
+            self.direction_dampings.append(
+                KSO.DirectionDampingUtilities(
+                    self.design_surface, direction_damping_settings
+                )
+            )
+
+    # --------------------------------------------------------------------------
+    def SetMinimalBufferSize(self, buffer_size):
+        if self.optimization_model_part.GetBufferSize() < buffer_size:
+            self.optimization_model_part.SetBufferSize(buffer_size)
+
+    # --------------------------------------------------------------------------
+    def UpdateTimeStep(self, step):
+        self.optimization_model_part.CloneTimeStep(step)
+        self.optimization_model_part.ProcessInfo.SetValue(KM.STEP, step)
+
+    # --------------------------------------------------------------------------
+    def UpdateMeshAccordingInputVariable(self, InputVariable):
+        self.mesh_controller.UpdateMeshAccordingInputVariable(InputVariable)
+
+        if self.model_settings["damping"]["recalculate_damping"].GetBool():
+            self.damping_utility = KSO.DampingUtilities(
+                self.design_surface, self.model_settings["damping"]
+            )
+
+        if self.model_settings["direction_damping"]["recalculate_damping"].GetBool():
+            self.direction_dampings = []
+            for direction_damping_settings in self.model_settings["direction_damping"]["damping_regions"].values():
+                self.direction_dampings.append(
+                    KSO.DirectionDampingUtilities(
+                        self.design_surface, direction_damping_settings
+                    )
+                )
+
+    # --------------------------------------------------------------------------
+    def SetMeshToReferenceMesh(self):
+        KSO.MeshControllerUtilities(self.optimization_model_part).SetMeshToReferenceMesh()
+
+    # --------------------------------------------------------------------------
+    def SetReferenceMeshToMesh(self):
+        KSO.MeshControllerUtilities(self.optimization_model_part).SetReferenceMeshToMesh()
+
+    # --------------------------------------------------------------------------
+    def SetDeformationVariablesToZero(self):
+        KSO.MeshControllerUtilities(self.optimization_model_part).SetDeformationVariablesToZero()
+
+    # --------------------------------------------------------------------------
+    def GetOptimizationModelPart(self):
+        return self.optimization_model_part
+
+    # --------------------------------------------------------------------------
+    def GetModel(self):
+        return self.model
+
+    # --------------------------------------------------------------------------
+    def GetDesignSurface(self):
+        return self.design_surface
+
+    # --------------------------------------------------------------------------
+    def DampNodalSensitivityVariableIfSpecified(self, variable):
+        if self.model_settings["damping"]["apply_damping"].GetBool():
+            self.damping_utility.DampNodalVariable(variable)
+
+        for direction_damping in reversed(self.direction_dampings):
+            direction_damping.DampNodalVariable(variable)
+
+    # --------------------------------------------------------------------------
+    def DampNodalUpdateVariableIfSpecified(self, variable):
+        for direction_damping in self.direction_dampings:
+            direction_damping.DampNodalVariable(variable)
+
+        if self.model_settings["damping"]["apply_damping"].GetBool():
+            self.damping_utility.DampNodalVariable(variable)
+
+    # --------------------------------------------------------------------------
+    def ComputeUnitSurfaceNormals(self):
+        KSO.GeometryUtilities(self.GetDesignSurface()).ComputeUnitSurfaceNormals()
+
+    # --------------------------------------------------------------------------
+    def ProjectNodalVariableOnUnitSurfaceNormals(self, variable):
+        KSO.GeometryUtilities(self.GetDesignSurface()).ProjectNodalVariableOnUnitSurfaceNormals(variable)
+
+    # --------------------------------------------------------------------------
+    def __ImportOptimizationModelPart(self):
+        input_type = self.model_settings["model_import_settings"]["input_type"].GetString()
+        if input_type != "mdpa":
+            raise RuntimeError("The model part for the optimization has to be read from the mdpa file!")
+        input_filename = self.model_settings["model_import_settings"]["input_filename"].GetString()
+
+        model_part_io = KM.ModelPartIO(input_filename)
+        model_part_io.ReadModelPart(self.optimization_model_part)
+
+        self.SetMinimalBufferSize(1)
+
+    # --------------------------------------------------------------------------
+    def __IdentifyDesignSurface(self):
+        nameOfDesignSurface = self.model_settings["design_surface_sub_model_part_name"].GetString()
+        if self.optimization_model_part.HasSubModelPart(nameOfDesignSurface):
+            self.design_surface = self.optimization_model_part.GetSubModelPart(nameOfDesignSurface)
+            KM.Logger.Print("")
+            KM.Logger.PrintInfo("ShapeOpt", "The following design surface was defined:\n\n",self.design_surface)
+        else:
+            raise ValueError("The following sub-model part (design surface) specified for shape optimization does not exist: ",nameOfDesignSurface)
+
+# ==============================================================================

KratosMultiphysics/ShapeOptimizationApplication/optimizer_factory.py

@@ -0,0 +1,235 @@
+# ==============================================================================
+#  KratosShapeOptimizationApplication
+#
+#  License:         BSD License
+#                   license: ShapeOptimizationApplication/license.txt
+#
+#  Main authors:    Baumgaertner Daniel, https://github.com/dbaumgaertner
+#
+# ==============================================================================
+
+
+# Kratos Core and Apps
+import KratosMultiphysics as KM
+import KratosMultiphysics.ShapeOptimizationApplication as KSO
+
+# additional imports
+from KratosMultiphysics.ShapeOptimizationApplication.utilities.custom_timer import Timer
+from KratosMultiphysics.ShapeOptimizationApplication.analyzers.analyzer_empty import EmptyAnalyzer
+from KratosMultiphysics.ShapeOptimizationApplication import model_part_controller_factory
+from KratosMultiphysics.ShapeOptimizationApplication.analyzers import analyzer_factory
+from KratosMultiphysics.ShapeOptimizationApplication import communicator_factory
+from KratosMultiphysics.ShapeOptimizationApplication.algorithms import algorithm_factory
+
+## Purely for backward compatibility, should be removed soon.
+def CreateOptimizer(optimization_settings,model,external_analyzer=EmptyAnalyzer()):
+    return Optimizer(model, optimization_settings, external_analyzer)
+
+def Create( model, optimization_settings, external_analyzer=EmptyAnalyzer()):
+    return Optimizer(model, optimization_settings, external_analyzer)
+
+# ==============================================================================
+class Optimizer:
+    # --------------------------------------------------------------------------
+    def __init__(self, model, optimization_settings, external_analyzer=EmptyAnalyzer()):
+        self._ValidateSettings(optimization_settings)
+        self.optimization_settings = optimization_settings
+
+        self.model_part_controller = model_part_controller_factory.CreateController(optimization_settings["model_settings"], model)
+        self.analyzer = analyzer_factory.CreateAnalyzer(optimization_settings, self.model_part_controller, external_analyzer)
+        self.communicator = communicator_factory.CreateCommunicator(optimization_settings)
+
+        if not optimization_settings["design_variables"]["type"].GetString() == "vertex_morphing":
+            raise NameError("The following type of design variables is not supported by the optimizer: " + variable_type)
+
+        self.__AddVariablesToBeUsedByAllAlgorithms()
+        self.__AddVariablesToBeUsedByDesignVariables()
+
+    # --------------------------------------------------------------------------
+    def __AddVariablesToBeUsedByAllAlgorithms(self):
+        model_part = self.model_part_controller.GetOptimizationModelPart()
+        number_of_objectives = self.optimization_settings["objectives"].size()
+        number_of_constraints = self.optimization_settings["constraints"].size()
+
+        nodal_variable = KM.KratosGlobals.GetVariable("DF1DX")
+        model_part.AddNodalSolutionStepVariable(nodal_variable)
+        nodal_variable = KM.KratosGlobals.GetVariable("DF1DX_MAPPED")
+        model_part.AddNodalSolutionStepVariable(nodal_variable)
+
+        for itr in range(1,number_of_constraints+1):
+            nodal_variable = KM.KratosGlobals.GetVariable(f"DC{(itr)}DX")
+            model_part.AddNodalSolutionStepVariable(nodal_variable)
+            nodal_variable = KM.KratosGlobals.GetVariable(f"DC{(itr)}DX_MAPPED")
+            model_part.AddNodalSolutionStepVariable(nodal_variable)
+
+        model_part.AddNodalSolutionStepVariable(KSO.CONTROL_POINT_UPDATE)
+        model_part.AddNodalSolutionStepVariable(KSO.CONTROL_POINT_CHANGE)
+        model_part.AddNodalSolutionStepVariable(KSO.SHAPE_UPDATE)
+        model_part.AddNodalSolutionStepVariable(KSO.SHAPE_CHANGE)
+        model_part.AddNodalSolutionStepVariable(KSO.MESH_CHANGE)
+        model_part.AddNodalSolutionStepVariable(KM.NORMAL)
+        model_part.AddNodalSolutionStepVariable(KSO.NORMALIZED_SURFACE_NORMAL)
+
+        # variables required for remeshing
+        model_part.AddNodalSolutionStepVariable(KM.DISTANCE)
+        model_part.AddNodalSolutionStepVariable(KM.DISTANCE_GRADIENT)
+
+        # sensitivity heatmap
+        if self.optimization_settings["output"].Has("sensitivity_heatmap") and \
+            self.optimization_settings["output"]["sensitivity_heatmap"].GetBool():
+            self.__AddVariablesToBeUsedBySensitivityHeatmap()
+
+    def __AddVariablesToBeUsedByDesignVariables(self):
+        if self.optimization_settings["design_variables"]["filter"].Has("in_plane_morphing") and \
+            self.optimization_settings["design_variables"]["filter"]["in_plane_morphing"].GetBool():
+                model_part = self.model_part_controller.GetOptimizationModelPart()
+                model_part.AddNodalSolutionStepVariable(KSO.BACKGROUND_COORDINATE)
+                model_part.AddNodalSolutionStepVariable(KSO.BACKGROUND_NORMAL)
+                model_part.AddNodalSolutionStepVariable(KSO.OUT_OF_PLANE_DELTA)
+        if self.optimization_settings["design_variables"]["filter"].Has("sliding_morphing") and \
+            self.optimization_settings["design_variables"]["filter"]["sliding_morphing"].GetBool():
+                model_part = self.model_part_controller.GetOptimizationModelPart()
+                model_part.AddNodalSolutionStepVariable(KSO.BACKGROUND_COORDINATE)
+                model_part.AddNodalSolutionStepVariable(KSO.BACKGROUND_NORMAL)
+                model_part.AddNodalSolutionStepVariable(KSO.OUT_OF_PLANE_DELTA)
+
+        if self.optimization_settings["design_variables"]["filter"]["filter_radius"].IsString() and \
+            self.optimization_settings["design_variables"]["filter"]["filter_radius"].GetString() == "adaptive":
+            # variables required for adaptive
+            model_part = self.model_part_controller.GetOptimizationModelPart()
+            model_part.AddNodalSolutionStepVariable(KSO.VERTEX_MORPHING_RADIUS)
+            model_part.AddNodalSolutionStepVariable(KSO.VERTEX_MORPHING_RADIUS_RAW)
+            model_part.AddNodalSolutionStepVariable(KSO.GAUSSIAN_CURVATURE)
+            model_part.AddNodalSolutionStepVariable(KSO.MAX_NEIGHBOUR_DISTANCE)
+
+    def __AddVariablesToBeUsedBySensitivityHeatmap(self):
+        model_part = self.model_part_controller.GetOptimizationModelPart()
+
+        model_part.AddNodalSolutionStepVariable(KM.NODAL_AREA)
+
+        sensitivity_heatmap_settings = None
+        if self.optimization_settings["output"].Has("sensitivity_heatmap_settings"):
+            sensitivity_heatmap_settings = self.optimization_settings["output"]["sensitivity_heatmap_settings"]
+
+        weigthing = True
+        mapping = True
+        if sensitivity_heatmap_settings:
+            if sensitivity_heatmap_settings.Has("sensitivity_weighting") and \
+                not sensitivity_heatmap_settings["sensitivity_weighting"].GetBool():
+                weigthing = False
+            if sensitivity_heatmap_settings.Has("mapping") and \
+                not sensitivity_heatmap_settings["mapping"].GetBool():
+                mapping = False
+
+        if self.optimization_settings["optimization_algorithm"]["name"].GetString() == "bead_optimization":
+            model_part.AddNodalSolutionStepVariable(KSO.HEATMAP_DF1DALPHA)
+            if weigthing:
+                model_part.AddNodalSolutionStepVariable(KSO.DF1DALPHA_WEIGHTED)
+                if mapping:
+                    model_part.AddNodalSolutionStepVariable(KSO.DF1DALPHA_WEIGHTED_MAPPED)
+        else:
+            model_part.AddNodalSolutionStepVariable(KSO.HEATMAP_DF1DX)
+            if weigthing:
+                model_part.AddNodalSolutionStepVariable(KSO.DF1DX_WEIGHTED)
+                if mapping:
+                    model_part.AddNodalSolutionStepVariable(KSO.DF1DX_WEIGHTED_MAPPED)
+
+            number_of_constraints = self.optimization_settings["constraints"].size()
+            if number_of_constraints != 0:
+                model_part.AddNodalSolutionStepVariable(KSO.HEATMAP_MAX)
+                model_part.AddNodalSolutionStepVariable(KSO.HEATMAP_L2)
+            for itr in range(1,number_of_constraints+1):
+                nodal_variable = KM.KratosGlobals.GetVariable(f"HEATMAP_DC{(itr)}DX")
+                model_part.AddNodalSolutionStepVariable(nodal_variable)
+                if weigthing:
+                    nodal_variable = KM.KratosGlobals.GetVariable(f"DC{(itr)}DX_WEIGHTED")
+                    model_part.AddNodalSolutionStepVariable(nodal_variable)
+                    if mapping:
+                        nodal_variable = KM.KratosGlobals.GetVariable(f"DC{(itr)}DX_WEIGHTED_MAPPED")
+                        model_part.AddNodalSolutionStepVariable(nodal_variable)
+
+    # --------------------------------------------------------------------------
+    def Optimize(self):
+        algorithm_name = self.optimization_settings["optimization_algorithm"]["name"].GetString()
+
+        KM.Logger.Print("")
+        KM.Logger.Print("===============================================================================")
+        KM.Logger.PrintInfo("ShapeOpt", Timer().GetTimeStamp(), ": Starting optimization using the following algorithm: ", algorithm_name)
+        KM.Logger.Print("===============================================================================\n")
+
+        algorithm = algorithm_factory.CreateOptimizationAlgorithm(self.optimization_settings,
+                                                                  self.analyzer,
+                                                                  self.communicator,
+                                                                  self.model_part_controller)
+        algorithm.CheckApplicability()
+        algorithm.InitializeOptimizationLoop()
+        algorithm.RunOptimizationLoop()
+        algorithm.FinalizeOptimizationLoop()
+
+        KM.Logger.Print("")
+        KM.Logger.Print("===============================================================================")
+        KM.Logger.PrintInfo("ShapeOpt", "Finished optimization")
+        KM.Logger.Print("===============================================================================\n")
+
+    # ==============================================================================
+    # ------------------------------------------------------------------------------
+    # ==============================================================================
+    def _ValidateSettings(self, optimization_settings):
+        self._ValidateTopLevelSettings(optimization_settings)
+        self._ValidateObjectiveSettingsRecursively(optimization_settings["objectives"])
+        self._ValidateConstraintSettings(optimization_settings["constraints"])
+
+    # ------------------------------------------------------------------------------
+    def _ValidateTopLevelSettings(self, optimization_settings):
+        default_settings = KM.Parameters("""
+        {
+            "model_settings" : { },
+            "objectives" : [ ],
+            "constraints" : [ ],
+            "design_variables" : { },
+            "optimization_algorithm" : { },
+            "output" : { }
+        }""")
+
+        for key in default_settings.keys():
+            if not optimization_settings.Has(key):
+                raise RuntimeError("Optimizer: Required setting '{}' missing in 'optimization_settings'!".format(key))
+
+        optimization_settings.ValidateAndAssignDefaults(default_settings)
+
+    # ------------------------------------------------------------------------------
+    def _ValidateObjectiveSettingsRecursively(self, objective_settings):
+        default_settings = KM.Parameters("""
+        {
+            "identifier"                          : "NO_IDENTIFIER_SPECIFIED",
+            "type"                                : "minimization",
+            "scaling_factor"                      : 1.0,
+            "analyzer"                            : "external",
+            "response_settings"                   : {},
+            "is_combined"                         : false,
+            "combination_type"                    : "sum",
+            "combined_responses"                  : [],
+            "weight"                              : 1.0,
+            "project_gradient_on_surface_normals" : false
+        }""")
+        for itr in range(objective_settings.size()):
+            objective_settings[itr].ValidateAndAssignDefaults(default_settings)
+
+            if objective_settings[itr]["is_combined"].GetBool():
+                self._ValidateObjectiveSettingsRecursively(objective_settings[itr]["combined_responses"])
+
+    # ------------------------------------------------------------------------------
+    def _ValidateConstraintSettings(self, constraint_settings):
+        default_settings = KM.Parameters("""
+        {
+            "identifier"                          : "NO_IDENTIFIER_SPECIFIED",
+            "type"                                : "<",
+            "scaling_factor"                      : 1.0,
+            "reference"                           : "initial_value",
+            "reference_value"                     : 1.0,
+            "analyzer"                            : "external",
+            "response_settings"                   : {},
+            "project_gradient_on_surface_normals" : false
+        }""")
+        for itr in range(constraint_settings.size()):
+            constraint_settings[itr].ValidateAndAssignDefaults(default_settings)