KratosShapeOptimizationApplication 10.4.4__py3-none-any.whl

KratosMultiphysics/ShapeOptimizationApplication/communicator_factory.py

@@ -0,0 +1,259 @@
+# ==============================================================================
+#  KratosShapeOptimizationApplication
+#
+#  License:         BSD License
+#                   license: ShapeOptimizationApplication/license.txt
+#
+#  Main authors:    Baumgaertner Daniel, https://github.com/dbaumgaertner
+#
+# ==============================================================================
+
+
+# ==============================================================================
+def CreateCommunicator(optimization_settings):
+    return Communicator(optimization_settings)
+
+# ==============================================================================
+class Communicator:
+
+    # --------------------------------------------------------------------------
+    def __init__(self, optimization_settings):
+        self.optimization_settings = optimization_settings
+        self.supported_objective_types = ["minimization", "maximization"]
+        self.supported_constraint_types = ["=", "<", ">", "<=", ">="]
+        self.supported_constraint_references = ["initial_value", "specified_value"]
+
+        objective_settings = self.__ExtractResponseSettingsRecursively(optimization_settings["objectives"])
+        constraint_settings = self.__ExtractResponseSettingsRecursively(optimization_settings["constraints"])
+        all_response_settings = objective_settings + constraint_settings
+
+        self.list_of_requests = self.__initializeListOfRequests(all_response_settings)
+        self.list_of_responses = self.__initializeListOfObjectives(objective_settings)
+        self.list_of_responses.update(self.__initializeListOfConstraints(constraint_settings))
+
+    # --------------------------------------------------------------------------
+    def initializeCommunication(self):
+        self.__deleteAllRequests()
+        self.__deleteAllReportedValues()
+
+    # --------------------------------------------------------------------------
+    def updateRequest(self, response_id, **kwargs):
+        if "request_value" in kwargs.keys():
+            self.list_of_requests[response_id]["calculateValue"] = kwargs["request_value"]
+        if "request_gradient" in kwargs.keys():
+            self.list_of_requests[response_id]["calculateGradient"] = kwargs["request_gradient"]
+
+    # --------------------------------------------------------------------------
+    def requestValueOf(self, response_id):
+        self.list_of_requests[response_id]["calculateValue"] = True
+
+    # --------------------------------------------------------------------------
+    def requestGradientOf(self, response_id):
+        self.list_of_requests[response_id]["calculateGradient"] = True
+
+    # --------------------------------------------------------------------------
+    def isRequestingValueOf(self, response_id):
+        if response_id not in self.list_of_requests.keys():
+            return False
+        else:
+            return self.list_of_requests[response_id]["calculateValue"]
+
+    # --------------------------------------------------------------------------
+    def isRequestingGradientOf(self, response_id):
+        if response_id not in self.list_of_requests.keys():
+            return False
+        else:
+            return self.list_of_requests[response_id]["calculateGradient"]
+
+    # --------------------------------------------------------------------------
+    def reportValue(self, response_id, value):
+        self.__storeValue(response_id, value)
+        if self.__isResponseWaitingForInitialValueAsReference(response_id):
+            self.__setValueAsReference(response_id, value)
+
+        standardized_value = self.__translateValueToStandardForm(response_id, value)
+        self.__storeStandardizedValue(response_id, standardized_value)
+
+    # --------------------------------------------------------------------------
+    def reportGradient(self, response_id, gradient):
+        dimension = len(next(iter(gradient.values())))
+        if dimension == 1:
+            gradient = {key: [value[0], 0.0, 0.0] for key, value in gradient.items()}
+        elif dimension == 2:
+            gradient = {key: [value[0], value[1], 0.0] for key, value in gradient.items()}
+
+        standardized_gradient = self.__translateGradientToStandardForm(response_id, gradient)
+        self.__storeStandardizedGradient(response_id, standardized_gradient)
+
+    # --------------------------------------------------------------------------
+    def getValue(self, response_id):
+        if self.list_of_responses[response_id]["value"] is None:
+            raise RuntimeError("The requested value for ", response_id, " is None!")
+        return self.list_of_responses[response_id]["value"]
+
+    # --------------------------------------------------------------------------
+    def getReferenceValue(self, response_id):
+        if self.list_of_responses[response_id]["reference_value"] is None:
+            raise RuntimeError("The requested reference_value for ", response_id, " is None!")
+        return self.list_of_responses[response_id]["reference_value"]
+
+    # --------------------------------------------------------------------------
+    def getStandardizedValue(self, response_id):
+        if self.list_of_responses[response_id]["standardized_value"] is None:
+            raise RuntimeError("The requested standardized_value for ", response_id, " is None!")
+        return self.list_of_responses[response_id]["standardized_value"]
+
+    # --------------------------------------------------------------------------
+    def getStandardizedGradient(self, response_id):
+        if self.list_of_responses[response_id]["standardized_gradient"] is None:
+            raise RuntimeError("The requested standardized_gradient for ", response_id, " is None!")
+        return self.list_of_responses[response_id]["standardized_gradient"]
+
+    # --------------------------------------------------------------------------
+    @classmethod
+    def __ExtractResponseSettingsRecursively(cls, response_settings):
+        list_of_settings = []
+
+        for itr in range(response_settings.size()):
+            response_i = response_settings[itr]
+            if response_i.Has("is_combined"):
+                if response_i["is_combined"].GetBool():
+                    list_of_settings += cls.__ExtractResponseSettingsRecursively(response_i["combined_responses"])
+
+            list_of_settings += [response_i]
+
+        return list_of_settings
+
+    # --------------------------------------------------------------------------
+    @classmethod
+    def __initializeListOfRequests(cls, response_settings):
+        list_of_requests = {}
+
+        for response in response_settings:
+            response_id = response["identifier"].GetString()
+            list_of_requests[response_id] = {"calculateValue": False, "calculateGradient": False}
+
+        return list_of_requests
+
+    # --------------------------------------------------------------------------
+    def __initializeListOfObjectives(self, objective_settings):
+        list_of_objectives = {}
+
+        for objective in objective_settings:
+            objective_id =  objective["identifier"].GetString()
+
+            if objective["type"].GetString() not in self.supported_objective_types:
+                raise RuntimeError("Unsupported type defined for the following objective: " + objective_id)
+
+            list_of_objectives[objective_id] = { "type"                 : objective["type"].GetString(),
+                                                 "value"                : None,
+                                                 "scaling_factor"       : objective["scaling_factor"].GetDouble(),
+                                                 "standardized_value"   : None,
+                                                 "standardized_gradient": None }
+
+        return list_of_objectives
+
+    # --------------------------------------------------------------------------
+    def __initializeListOfConstraints(self, constraint_settings):
+        list_of_constraints = {}
+
+        for constraint in constraint_settings:
+            constraint_id = constraint["identifier"].GetString()
+
+            if constraint["type"].GetString() not in self.supported_constraint_types:
+                raise RuntimeError("Unsupported type defined for the following constraint: " + constraint_id)
+
+            if constraint["reference"].GetString() not in self.supported_constraint_references:
+                raise RuntimeError("Unsupported reference defined for the following constraint: " + constraint_id)
+
+            if  constraint["reference"].GetString() == "specified_value":
+                list_of_constraints[constraint_id] = { "type"                 : constraint["type"].GetString(),
+                                                        "value"                : None,
+                                                        "scaling_factor"       : constraint["scaling_factor"].GetDouble(),
+                                                        "standardized_value"   : None,
+                                                        "standardized_gradient": None,
+                                                        "reference_value"      : constraint["reference_value"].GetDouble() }
+            elif constraint["reference"].GetString() == "initial_value":
+                list_of_constraints[constraint_id] = { "type"                 : constraint["type"].GetString(),
+                                                        "value"                : None,
+                                                        "scaling_factor"       : constraint["scaling_factor"].GetDouble(),
+                                                        "standardized_value"   : None,
+                                                        "standardized_gradient": None,
+                                                        "reference_value"      : None }
+            else:
+                raise RuntimeError("Unsupported reference defined for the following constraint: " + constraint_id)
+
+        return list_of_constraints
+
+    # --------------------------------------------------------------------------
+    def __deleteAllRequests(self):
+        for response_id in self.list_of_requests:
+            self.list_of_requests[response_id]["calculateValue"] = False
+            self.list_of_requests[response_id]["calculateGradient"] = False
+
+    # --------------------------------------------------------------------------
+    def __deleteAllReportedValues(self):
+        for response_id in self.list_of_responses:
+            self.list_of_responses[response_id]["value"] = None
+            self.list_of_responses[response_id]["standardized_value"] = None
+            self.list_of_responses[response_id]["standardized_gradient"] = None
+
+    # --------------------------------------------------------------------------
+    def __isResponseWaitingForInitialValueAsReference(self, response_id):
+        response = self.list_of_responses[response_id]
+        if "reference_value" in response:
+            is_reference_value_missing = (response["reference_value"] is None)
+            if is_reference_value_missing:
+                return True
+        return False
+
+    # --------------------------------------------------------------------------
+    def __setValueAsReference(self, response_id, value):
+        self.list_of_responses[response_id]["reference_value"] = value
+
+    # --------------------------------------------------------------------------
+    def __translateValueToStandardForm(self, response_id, value):
+        response_type = self.list_of_responses[response_id]["type"]
+        scaling_factor = self.list_of_responses[response_id]["scaling_factor"]
+
+        if response_type in self.supported_objective_types:
+            if response_type == "maximization":
+                return -scaling_factor*value
+            else:
+                return scaling_factor*value
+        else:
+            reference_value = self.list_of_responses[response_id]["reference_value"]
+
+            if response_type == ">" or response_type == ">=":
+                return scaling_factor*(reference_value-value)
+            else:
+                return scaling_factor*(value-reference_value)
+
+    # --------------------------------------------------------------------------
+    def __translateGradientToStandardForm(self, response_id, gradient):
+        response_type = self.list_of_responses[response_id]["type"]
+        scaling_factor = self.list_of_responses[response_id]["scaling_factor"]
+
+        if response_type == "maximization" or response_type == ">" or response_type == ">=":
+            scaling_factor *= -1
+
+        for vector in gradient.values():
+            vector[0] *= scaling_factor
+            vector[1] *= scaling_factor
+            vector[2] *= scaling_factor
+
+        return gradient
+
+    # --------------------------------------------------------------------------
+    def __storeValue(self, response_id, value):
+        self.list_of_responses[response_id]["value"] = value
+
+    # --------------------------------------------------------------------------
+    def __storeStandardizedValue(self, response_id, value):
+        self.list_of_responses[response_id]["standardized_value"] = value
+
+    # --------------------------------------------------------------------------
+    def __storeStandardizedGradient(self, response_id, gradient):
+        self.list_of_responses[response_id]["standardized_gradient"] = gradient
+
+# ==============================================================================

KratosMultiphysics/ShapeOptimizationApplication/custom_ios/wrl_io.py

@@ -0,0 +1,82 @@
+# ==============================================================================
+#  KratosShapeOptimizationApplication
+#
+#  License:         BSD License
+#                   license: ShapeOptimizationApplication/license.txt
+#
+#  Main authors:    Geiser Armin, https://github.com/armingeiser
+#
+# ==============================================================================
+
+import KratosMultiphysics as KM
+from .wrl_reader import read_shapes, detect_file
+
+def _rename_to_valid_name(model_part, shape):
+    name = shape.name
+
+    ref_name = name
+    i = 2
+    while model_part.HasSubModelPart(name):
+        name = ref_name +"_{}".format(i)
+        i += 1
+
+    if shape.name != name:
+        KM.Logger.PrintWarning("ShapeOpt", "WrlIO: Name of the sub model part has been changed from '{}' to '{}' in order "\
+            "to avoid name clashes!".format(shape.name, name))
+        shape.name = name
+
+class WrlIO:
+
+    def __init__(self, file_name):
+        self.file_name = detect_file(file_name)
+
+    def ReadModelPart(self, model_part):
+        KM.Logger.PrintInfo("ShapeOpt", "Start reading model part from '{}'.".format(self.file_name))
+
+        if model_part.ProcessInfo.GetValue(KM.DOMAIN_SIZE) != 3:
+            raise Exception("WrlIO: Domain size has to be 3!")
+
+        shapes = read_shapes(self.file_name)
+
+        node_multiplicity = {}
+
+        nodes_shift = 0
+        faces_shift = 0
+        for i, shape in enumerate(shapes):
+            _rename_to_valid_name(model_part, shape)
+            sub_model_part = model_part.CreateSubModelPart(shape.name)
+
+            property_id = i+1
+            new_property = model_part.CreateNewProperties(property_id)
+
+            for i, node in enumerate(shape.nodes):
+                node_id = i + nodes_shift
+                new_node = model_part.CreateNewNode(node_id, *node)
+                sub_model_part.AddNode(new_node, 0)
+                node_multiplicity[node_id] = 0
+
+            for i, face in enumerate(shape.faces):
+                face_id = i + faces_shift
+                node_ids = [x + nodes_shift for x in face]
+
+                for node_id in node_ids:
+                    node_multiplicity[node_id] += 1
+
+                condition_type = "SurfaceCondition3D{}N".format(len(node_ids))
+                new_condition = model_part.CreateNewCondition(condition_type, face_id, node_ids, new_property)
+                sub_model_part.AddCondition(new_condition)
+
+            nodes_shift += len(shape.nodes)
+            faces_shift += len(shape.faces)
+
+        # remove flying nodes
+        counter = 0
+        for node_id, count in node_multiplicity.items():
+            if count == 0:
+                model_part.RemoveNode(node_id)
+                counter += 1
+
+        if counter > 0:
+            KM.Logger.PrintWarning("WrlIO", "Deleted {} flying nodes from model part!".format(counter))
+
+        KM.Logger.PrintInfo("ShapeOpt", "Finished reading model part.")

KratosMultiphysics/ShapeOptimizationApplication/custom_ios/wrl_reader.py

@@ -0,0 +1,119 @@
+# ==============================================================================
+#  KratosShapeOptimizationApplication
+#
+#  License:         BSD License
+#                   license: ShapeOptimizationApplication/license.txt
+#
+#  Main authors:    Geiser Armin, https://github.com/armingeiser
+#
+# ==============================================================================
+
+import os
+
+class Shape:
+    def __init__(self, name, nodes, faces):
+        self.name = name
+        self.nodes = nodes
+        self.faces = faces
+
+def detect_file(file_name):
+    wrl_name = file_name + ".wrl"
+    vrml_name = file_name + ".vrml"
+
+    if os.path.isfile(wrl_name) and os.path.isfile(vrml_name):
+        raise Exception("Wrl reader: file {} found with '.wrl' and '.vrml' ending! Please remove one of them!".format(file_name))
+    elif os.path.isfile(wrl_name):
+        return wrl_name
+    elif os.path.isfile(vrml_name):
+        return vrml_name
+    else:
+        raise Exception("Wrl reader: file {} not found with '.wrl' or '.vrml' ending!".format(file_name))
+
+def read_nodes(line, file):
+    nodes = []
+    while "[" not in line:
+        line = next(file)
+
+    line = next(file)
+
+    while "]" not in line:
+        if line == "\n":
+            line = next(file)
+
+        try:
+            entries = line.split(",")[0].split()
+            if len(entries) != 3:
+                raise RuntimeError("wrl_reader: Did not find 3 coordinate components!", line)
+            nodes.append([float(x) for x in entries])
+        except IOError:
+            pass
+
+        line = next(file)
+
+    return nodes
+
+def read_faces(line, file):
+    faces = []
+    while "[" not in line:
+        line = next(file)
+
+    line = next(file)
+
+    while "]" not in line:
+        if line == "\n":
+            line = next(file)
+
+        try:
+            entries = line.split(",")
+            entries = [x.strip() for x in entries]
+            if entries.count("-1") != 1:
+                raise RuntimeError("wrl_reader: Can only read one face per line!", line)
+            entries = entries[:entries.index("-1")]
+            if len(entries) < 2:
+                raise RuntimeError("wrl_reader: Can not read faces with less than 3 nodes!", line)
+            elif len(entries) > 4:
+                raise RuntimeError("wrl_reader: Can not read faces with more than 4 nodes!", line)
+            faces.append([int(x) for x in entries])
+        except IOError:
+            pass
+
+        line = next(file)
+
+    return faces
+
+def read_shape(line, file):
+    try:
+        name = line.split("#")[1].strip()
+    except IndexError:
+        name = "geometry"
+    nodes = []
+    faces = []
+
+    while "geometry" not in line:
+        line = next(file)
+    if "IndexedFaceSet" not in line:
+        raise RuntimeError("wrl_reader: Can not read '{}'".format(line))
+
+    while not nodes or not faces:
+        if line.strip().startswith("coord "):
+            nodes = read_nodes(line, file)
+        elif line.strip().startswith("coordIndex"):
+            faces = read_faces(line, file)
+        line = next(file)
+
+    return Shape(name, nodes, faces)
+
+def read_shapes(file_name):
+    shapes = []
+    with open(file_name, "r") as file:
+
+        first_line = file.readline()
+        if not first_line.startswith("#VRML V2.0"):
+            raise RuntimeError("wrl_reader: Can not read '{}' format!"\
+                " Only '#VRML V2.0' is supported.".format(first_line.strip()))
+
+        for line in file:
+            if line.strip().startswith("Shape"):
+                shapes.append(read_shape(line, file))
+                line = next(file)
+    return shapes

KratosMultiphysics/ShapeOptimizationApplication/loggers/data_logger_factory.py

@@ -0,0 +1,199 @@
+# ==============================================================================
+#  KratosShapeOptimizationApplication
+#
+#  License:         BSD License
+#                   license: ShapeOptimizationApplication/license.txt
+#
+#  Main authors:    Baumgaertner Daniel, https://github.com/dbaumgaertner
+#                   Geiser Armin, https://github.com/armingeiser
+#
+# ==============================================================================
+
+
+# Kratos Core and Apps
+import KratosMultiphysics as Kratos
+
+# Additional imports
+import shutil
+import os
+
+from KratosMultiphysics.ShapeOptimizationApplication.loggers.design_logger_gid import DesignLoggerGID
+from KratosMultiphysics.ShapeOptimizationApplication.loggers.design_logger_unv import DesignLoggerUNV
+from KratosMultiphysics.ShapeOptimizationApplication.loggers.design_logger_vtk import DesignLoggerVTK
+
+from KratosMultiphysics.ShapeOptimizationApplication.loggers.value_logger_steepest_descent import ValueLoggerSteepestDescent
+from KratosMultiphysics.ShapeOptimizationApplication.loggers.value_logger_penalized_projection import ValueLoggerPenalizedProjection
+from KratosMultiphysics.ShapeOptimizationApplication.loggers.value_logger_trust_region import ValueLoggerTrustRegion
+from KratosMultiphysics.ShapeOptimizationApplication.loggers.value_logger_bead_optimization import ValueLoggerBeadOptimization
+from KratosMultiphysics.ShapeOptimizationApplication.loggers.value_logger_gradient_projection import ValueLoggerGradientProjection
+from KratosMultiphysics.ShapeOptimizationApplication.loggers.value_logger_relaxed_gradient_projection import ValueLoggerRelaxedGradientProjection
+from KratosMultiphysics.ShapeOptimizationApplication.loggers.value_logger_shape_fraction_optimization import ValueLoggerShapeFractionOptimization
+from KratosMultiphysics.ShapeOptimizationApplication.loggers.sensitivity_heatmap_logger import (
+    SensitivityHeatmapLoggerSteepestDescent,
+    SensitivityHeatmapLoggerPenalizedProjection,
+    SensitivityHeatmapLoggerGradientProjection,
+    SensitivityHeatmapLoggerTrustRegion,
+    SensitivityHeatmapLoggerBeadOptimization)
+
+# ==============================================================================
+def CreateDataLogger( ModelPartController, Communicator, OptimizationSettings ):
+    return DataLogger( ModelPartController, Communicator, OptimizationSettings )
+
+# ==============================================================================
+class DataLogger():
+    # --------------------------------------------------------------------------
+    def __init__( self, ModelPartController, Communicator, OptimizationSettings ):
+        self.ModelPartController = ModelPartController
+        self.Communicator = Communicator
+        self.OptimizationSettings = OptimizationSettings
+
+        default_logger_settings = Kratos.Parameters("""
+        {
+            "output_directory"          : "Optimization_Results",
+            "optimization_log_filename" : "optimization_log",
+            "design_output_mode"        : "write_optimization_model_part",
+            "sensitivity_heatmap"       : false,
+            "sensitivity_heatmap_settings": {},
+            "nodal_results"             : [ "SHAPE_CHANGE" ],
+            "output_format"             : { "name": "vtk" }
+        }""")
+
+        self.OptimizationSettings["output"].ValidateAndAssignDefaults(default_logger_settings)
+
+        self.ValueLogger = self.__CreateValueLogger()
+        self.DesignLogger = self.__CreateDesignLogger()
+        self.SensitivityHeatmapLogger = self.__CreateSensitivityHeatmapLogger()
+
+        self.__CreateFolderToStoreOptimizationResults()
+        self.__OutputInformationAboutResponseFunctions()
+
+    # -----------------------------------------------------------------------------
+    def __CreateValueLogger( self ):
+        AlgorithmName = self.OptimizationSettings["optimization_algorithm"]["name"].GetString()
+        if AlgorithmName == "steepest_descent":
+            return ValueLoggerSteepestDescent( self.Communicator, self.OptimizationSettings )
+        elif AlgorithmName == "penalized_projection":
+            return ValueLoggerPenalizedProjection( self.Communicator, self.OptimizationSettings )
+        elif AlgorithmName == "gradient_projection":
+            return ValueLoggerGradientProjection( self.Communicator, self.OptimizationSettings )
+        elif AlgorithmName == "trust_region":
+            return ValueLoggerTrustRegion( self.Communicator, self.OptimizationSettings )
+        elif AlgorithmName == "bead_optimization":
+            return ValueLoggerBeadOptimization( self.Communicator, self.OptimizationSettings )
+        elif AlgorithmName == "relaxed_gradient_projection":
+            return ValueLoggerRelaxedGradientProjection(self.Communicator, self.OptimizationSettings)
+        elif AlgorithmName == "shape_fraction_optimization":
+            return ValueLoggerShapeFractionOptimization( self.Communicator, self.OptimizationSettings )
+        else:
+            raise NameError("The following optimization algorithm not supported by the response logger (name may be misspelled): " + AlgorithmName)
+
+    # -----------------------------------------------------------------------------
+    def __CreateDesignLogger( self ):
+        valid_output_modes = ["write_design_surface", "write_optimization_model_part", "none"]
+        output_mode = self.OptimizationSettings["output"]["design_output_mode"].GetString()
+
+        # backward compatibility
+        if output_mode == "WriteDesignSurface":
+            Kratos.Logger.PrintWarning("ShapeOpt", "'design_output_mode': 'WriteDesignSurface' is deprecated and replaced with 'write_design_surface'.")
+            self.OptimizationSettings["output"]["design_output_mode"].SetString("write_design_surface")
+            output_mode = self.OptimizationSettings["output"]["design_output_mode"].GetString()
+
+        if output_mode == "WriteOptimizationModelPart":
+            Kratos.Logger.PrintWarning("ShapeOpt", "'design_output_mode': 'WriteOptimizationModelPart' is deprecated and replaced with 'write_optimization_model_part'.")
+            self.OptimizationSettings["output"]["design_output_mode"].SetString("write_optimization_model_part")
+            output_mode = self.OptimizationSettings["output"]["design_output_mode"].GetString()
+
+        if output_mode not in valid_output_modes:
+            raise RuntimeError("Invalid 'design_output_mode', available options are: {}".format(valid_output_modes))
+
+        if output_mode == "none":
+            Kratos.Logger.Print("")
+            Kratos.Logger.PrintInfo("ShapeOpt", "No design output will be created because 'design_output_mode' = 'None'.")
+            return None
+
+        outputFormatName = self.OptimizationSettings["output"]["output_format"]["name"].GetString()
+        if outputFormatName == "gid":
+            return DesignLoggerGID( self.ModelPartController, self.OptimizationSettings )
+        if outputFormatName == "unv":
+            return DesignLoggerUNV( self.ModelPartController, self.OptimizationSettings )
+        if outputFormatName == "vtk":
+            return DesignLoggerVTK( self.ModelPartController, self.OptimizationSettings )
+        else:
+            raise NameError("The following output format is not supported by the design logger (name may be misspelled): " + outputFormatName)
+
+    # -----------------------------------------------------------------------------
+    def __CreateSensitivityHeatmapLogger( self ):
+        if not self.OptimizationSettings["output"]["sensitivity_heatmap"].GetBool():
+            return None
+
+        AlgorithmName = self.OptimizationSettings["optimization_algorithm"]["name"].GetString()
+        if AlgorithmName == "steepest_descent":
+            return SensitivityHeatmapLoggerSteepestDescent( self.ModelPartController, self.OptimizationSettings )
+        elif AlgorithmName == "penalized_projection":
+            return SensitivityHeatmapLoggerPenalizedProjection( self.ModelPartController, self.OptimizationSettings )
+        elif AlgorithmName == "gradient_projection":
+            return SensitivityHeatmapLoggerGradientProjection( self.ModelPartController, self.OptimizationSettings )
+        elif AlgorithmName == "trust_region":
+            return SensitivityHeatmapLoggerTrustRegion( self.ModelPartController, self.OptimizationSettings )
+        elif AlgorithmName == "bead_optimization":
+            return SensitivityHeatmapLoggerBeadOptimization( self.ModelPartController, self.OptimizationSettings )
+        else:
+            raise NameError("The following optimization algorithm is not supported by the sensitivity heatmap logger (name may be misspelled): " + AlgorithmName)
+
+    # --------------------------------------------------------------------------
+    def __CreateFolderToStoreOptimizationResults ( self ):
+        resultsDirectory = self.OptimizationSettings["output"]["output_directory"].GetString()
+        if os.path.exists(resultsDirectory):
+            shutil.rmtree(resultsDirectory)
+        os.makedirs(resultsDirectory)
+
+    # --------------------------------------------------------------------------
+    def __OutputInformationAboutResponseFunctions( self ):
+        numberOfObjectives = self.OptimizationSettings["objectives"].size()
+        numberOfConstraints = self.OptimizationSettings["constraints"].size()
+
+        Kratos.Logger.Print("")
+        Kratos.Logger.PrintInfo("ShapeOpt", "The following objectives are defined:\n")
+        for objectiveNumber in range(numberOfObjectives):
+            Kratos.Logger.Print(self.OptimizationSettings["objectives"][objectiveNumber])
+
+        if numberOfConstraints != 0:
+            Kratos.Logger.PrintInfo("ShapeOpt", "The following constraints are defined:\n")
+            for constraintNumber in range(numberOfConstraints):
+                Kratos.Logger.Print(self.OptimizationSettings["constraints"][constraintNumber],"\n")
+        else:
+            Kratos.Logger.PrintInfo("ShapeOpt", "No constraints defined.\n")
+
+    # --------------------------------------------------------------------------
+    def InitializeDataLogging( self ):
+        if self.DesignLogger:
+            self.DesignLogger.InitializeLogging()
+        self.ValueLogger.InitializeLogging()
+        if self.SensitivityHeatmapLogger:
+            self.SensitivityHeatmapLogger.InitializeLogging()
+
+    # --------------------------------------------------------------------------
+    def LogCurrentDesign( self, current_iteration ):
+        if self.DesignLogger:
+            self.DesignLogger.LogCurrentDesign( current_iteration )
+
+    # --------------------------------------------------------------------------
+    def LogCurrentValues( self, current_iteration, additional_values ):
+        self.ValueLogger.LogCurrentValues( current_iteration, additional_values )
+
+    # --------------------------------------------------------------------------
+    def LogSensitivityHeatmap( self, current_iteration, mapper ):
+        if self.SensitivityHeatmapLogger:
+            self.SensitivityHeatmapLogger.LogSensitivityHeatmap( current_iteration, mapper )
+
+    # --------------------------------------------------------------------------
+    def FinalizeDataLogging( self ):
+        if self.DesignLogger:
+            self.DesignLogger.FinalizeLogging()
+        self.ValueLogger.FinalizeLogging()
+
+    # --------------------------------------------------------------------------
+    def GetValues( self, key ):
+        return self.ValueLogger.GetValues(key)
+
+# ==============================================================================