KratosOptimizationApplication 10.4.4__py3-none-any.whl

KratosMultiphysics/OptimizationApplication/responses/combined_response_function.py

@@ -0,0 +1,127 @@
+from typing import Optional
+
+import KratosMultiphysics as Kratos
+from KratosMultiphysics.OptimizationApplication.responses.response_function import ResponseFunction
+from KratosMultiphysics.OptimizationApplication.utilities.union_utilities import SupportedSensitivityFieldVariableTypes
+from KratosMultiphysics.OptimizationApplication.utilities.model_part_utilities import ModelPartOperation
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem import OptimizationProblem
+from KratosMultiphysics.OptimizationApplication.utilities.component_data_view import ComponentDataView
+
+def Factory(model: Kratos.Model, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem) -> ResponseFunction:
+    if not parameters.Has("name"):
+        raise RuntimeError(f"CombinedResponseFunction instantiation requires a \"name\" in parameters [ parameters = {parameters}].")
+    if not parameters.Has("settings"):
+        raise RuntimeError(f"CombinedResponseFunction instantiation requires a \"settings\" in parameters [ parameters = {parameters}].")
+
+    return CombinedResponseFunction(parameters["name"].GetString(), model, parameters["settings"], optimization_problem)
+
+class CombinedResponseFunction(ResponseFunction):
+    """Response function to combine multiple response functions.
+
+    This response function can combine multiple response functions to a single response function.
+    Following methods are used to combine the response values:
+              1. weighted sum - Weighted summation of responses list is used as the combined response function value.
+
+    """
+    def __init__(self, name: str, model: Kratos.Model, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem):
+        super().__init__(name)
+
+        default_settings = Kratos.Parameters("""{
+            "combining_method"   : "sum",
+            "combining_responses": [
+                {
+                    "response_name"  : "",
+                    "response_weight": 0.0
+                }
+            ]
+        }""")
+        parameters.ValidateAndAssignDefaults(default_settings)
+        self.combining_method = parameters["combining_method"].GetString()
+
+        self.model = model
+        self.model_part: Optional[Kratos.ModelPart] = None
+        self.optimization_problem = optimization_problem
+
+        self.list_of_responses: 'list[tuple[ResponseFunction, float]]' = []
+        for response_params in parameters["combining_responses"].values():
+            response_params.ValidateAndAssignDefaults(default_settings["combining_responses"].values()[0])
+            response_name = response_params["response_name"].GetString()
+
+            if response_name not in [response.GetName() for response in optimization_problem.GetListOfResponses()]:
+                raise RuntimeError(f"\"{response_name}\" not found in the optimization problem. Please check whether this response is defined before the \"{self.GetName()}\".")
+
+            self.list_of_responses.append(
+                (
+                    self.optimization_problem.GetResponse(response_name),
+                    response_params["response_weight"].GetDouble()
+                ))
+
+        if len(self.list_of_responses) == 0:
+            raise RuntimeError(f"Combined response \"{self.GetName()}\" does not have any responses to combine.")
+
+    def GetImplementedPhysicalKratosVariables(self) -> 'list[SupportedSensitivityFieldVariableTypes]':
+        variables_list: 'list[SupportedSensitivityFieldVariableTypes]' = []
+        for response, _ in self.list_of_responses:
+            variables_list.extend(response.GetImplementedPhysicalKratosVariables())
+        return list(set(variables_list))
+
+    def GetInfluencingModelPart(self) -> Kratos.ModelPart:
+        influencing_model_part_names = [response.GetInfluencingModelPart().FullName() for response, _ in self.list_of_responses]
+        model_part_operation = ModelPartOperation(self.model, ModelPartOperation.OperationType.UNION, f"response_{self.GetName()}", influencing_model_part_names, False)
+        self.model_part = model_part_operation.GetModelPart()
+        return self.model_part
+
+    def Initialize(self) -> None:
+        for response, _ in self.list_of_responses:
+            response.Initialize()
+
+        component_data_view = ComponentDataView(self, self.optimization_problem)
+        component_data_view.SetDataBuffer(1)
+        self.buffered_data = component_data_view.GetBufferedData()
+        self.unbuffered_data = component_data_view.GetUnBufferedData()
+
+    def Check(self) -> None:
+        for response, _ in self.list_of_responses:
+            response.Check()
+
+    def Finalize(self) -> None:
+        for response, _ in self.list_of_responses:
+            response.Finalize()
+
+    def CalculateValue(self) -> float:
+        if self.combining_method == "sum":
+            value = 0.0
+            for response, weight in self.list_of_responses:
+                    response_value = response.CalculateValue()
+                    value += response_value * weight
+                    self.buffered_data.SetValue(f"{response.GetName()}", response_value, overwrite=True)
+        else:
+            raise RuntimeError(f"Unsupported combining_method = \"{self.combining_method}\". Followings are supported:\n\tsum")
+        return value
+
+    def CalculateGradient(self, physical_variable_gradient_map: 'dict[SupportedSensitivityFieldVariableTypes, Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor]') -> None:
+        # make everything zeros
+        for _, combined_tensor_adaptor in physical_variable_gradient_map.items():
+            combined_tensor_adaptor.data[:] = 0.0
+            Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor(combined_tensor_adaptor, perform_store_data_recursively=False, copy=False).StoreData()
+
+        for response_function, weight in self.list_of_responses:
+            # get the map for the response function
+            sub_physical_variable_combined_tensor_adaptor: 'dict[SupportedSensitivityFieldVariableTypes, Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor]' = {}
+            for physical_variable, combined_tensor_adaptor in physical_variable_gradient_map.items():
+                if physical_variable in response_function.GetImplementedPhysicalKratosVariables():
+                    sub_physical_variable_combined_tensor_adaptor[physical_variable] = combined_tensor_adaptor.Clone()
+
+            # calculate the gradients
+            response_function.CalculateGradient(sub_physical_variable_combined_tensor_adaptor)
+
+            # now aggregate the gradients
+            for physical_variable, local_combined_tensor_adaptor in sub_physical_variable_combined_tensor_adaptor.items():
+                self.unbuffered_data.SetValue(f"d{response_function.GetName()}_d{physical_variable.Name()}", local_combined_tensor_adaptor.Clone(), overwrite=True)
+                if self.combining_method == "sum":
+                    physical_variable_gradient_map[physical_variable].data[:] += local_combined_tensor_adaptor.data[:] * weight
+                else:
+                    raise RuntimeError(f"Unsupported combining_method = \"{self.combining_method}\". Followings are supported:\n\tsum")
+
+        for _, combined_tensor_adaptor in physical_variable_gradient_map.items():
+            Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor(combined_tensor_adaptor, perform_store_data_recursively=False, copy=False).StoreData()

KratosMultiphysics/OptimizationApplication/responses/discrete_value_residual_response_function.py

@@ -0,0 +1,131 @@
+import numpy
+from typing import Optional
+
+import KratosMultiphysics as Kratos
+import KratosMultiphysics.OptimizationApplication as KratosOA
+from KratosMultiphysics.OptimizationApplication.responses.response_function import ResponseFunction
+from KratosMultiphysics.OptimizationApplication.utilities.union_utilities import SupportedSensitivityFieldVariableTypes
+from KratosMultiphysics.OptimizationApplication.utilities.model_part_utilities import ModelPartOperation
+
+def Factory(model: Kratos.Model, parameters: Kratos.Parameters, _) -> ResponseFunction:
+    if not parameters.Has("name"):
+        raise RuntimeError(f"DiscreteValueResidualResponseFunction instantiation requires a \"name\" in parameters [ parameters = {parameters}].")
+    if not parameters.Has("settings"):
+        raise RuntimeError(f"DiscreteValueResidualResponseFunction instantiation requires a \"settings\" in parameters [ parameters = {parameters}].")
+
+    return DiscreteValueResidualResponseFunction(parameters["name"].GetString(), model, parameters["settings"])
+
+class DiscreteValueResidualResponseFunction(ResponseFunction):
+    def __init__(self, name: str, model: Kratos.Model, parameters: Kratos.Parameters):
+        super().__init__(name)
+
+        default_settings = Kratos.Parameters("""{
+            "evaluated_model_part_names"     : [
+                "PLEASE_PROVIDE_A_MODEL_PART_NAME"
+            ],
+            "container_type"         : "node_historical",
+            "variable_name"          : "",
+            "residual_type"          : "exact",
+            "list_of_discrete_values": [0.0]
+        }""")
+        parameters.ValidateAndAssignDefaults(default_settings)
+
+        self.model = model
+        self.variable: SupportedSensitivityFieldVariableTypes = Kratos.KratosGlobals.GetVariable(parameters["variable_name"].GetString())
+        if not isinstance(self.variable, Kratos.DoubleVariable):
+            raise RuntimeError(f"Only supports double variables. Provided variable is \"{self.variable.Name()}\".")
+
+        self.list_of_discrete_values = parameters["list_of_discrete_values"].GetVector()
+
+        self.residual_type = parameters["residual_type"].GetString()
+        if self.residual_type  not in ["exact", "logarithm"]:
+            raise RuntimeError(f"Unsupported residual_type = \"{self.residual_type}\" requested. Followings are supported:\n\texact\n\tlogarithm")
+
+        container_type = parameters["container_type"].GetString()
+        if container_type == "node_historical":
+            self.ta_getter = lambda model_part: Kratos.TensorAdaptors.HistoricalVariableTensorAdaptor(model_part.Nodes, self.variable)
+        elif container_type == "node_non_historical":
+            self.ta_getter = lambda model_part : Kratos.TensorAdaptors.VariableTensorAdaptor(model_part.Nodes, self.variable)
+        elif container_type == "condition":
+            self.ta_getter = lambda model_part : Kratos.TensorAdaptors.VariableTensorAdaptor(model_part.Conditions, self.variable)
+        elif container_type == "condition_properties":
+            self.ta_getter = lambda model_part : KratosOA.TensorAdaptors.PropertiesVariableTensorAdaptor(model_part.Conditions, self.variable)
+        elif container_type == "element":
+            self.ta_getter = lambda model_part : Kratos.TensorAdaptors.VariableTensorAdaptor(model_part.Elements, self.variable)
+        elif container_type == "element_properties":
+            self.ta_getter = lambda model_part : KratosOA.TensorAdaptors.PropertiesVariableTensorAdaptor(model_part.Elements, self.variable)
+        else:
+            raise RuntimeError(f"Unsupported container_type = \"{container_type}\" requested. Followings are supported:\n\tnode_historical\n\tnode_non_historical\n\tcondition\n\tcondition_properties\n\telement\n\telement_properties")
+
+        evaluated_model_part_names = parameters["evaluated_model_part_names"].GetStringArray()
+        if len(evaluated_model_part_names) == 0:
+            raise RuntimeError(f"No model parts were provided for DiscreteValueResidualResponseFunction. [ response name = \"{self.GetName()}\"]")
+
+        self.model_part_operation = ModelPartOperation(self.model, ModelPartOperation.OperationType.UNION, f"response_{self.GetName()}", evaluated_model_part_names, False)
+        self.model_part: Optional[Kratos.ModelPart] = None
+
+    def GetImplementedPhysicalKratosVariables(self) -> 'list[SupportedSensitivityFieldVariableTypes]':
+        return [self.variable]
+
+    def GetInfluencingModelPart(self) -> Kratos.ModelPart:
+        if self.model_part is None:
+            raise RuntimeError("Please call DiscreteValueResidualResponseFunction::Initialize first.")
+        return self.model_part
+
+    def Initialize(self) -> None:
+        self.model_part = self.model_part_operation.GetModelPart()
+
+    def Check(self) -> None:
+        pass
+
+    def Finalize(self) -> None:
+        pass
+
+    def CalculateValue(self) -> float:
+        ta = self.ta_getter(self.model_part)
+        ta.CollectData()
+
+        resultant = Kratos.TensorAdaptors.DoubleTensorAdaptor(ta)
+
+        if self.residual_type == "exact":
+            resultant.data[:] = 1.0
+        elif self.residual_type == "logarithm":
+            resultant.data[:] = 0.0
+
+        for value in self.list_of_discrete_values:
+            if self.residual_type == "exact":
+                resultant.data[:] *= (ta.data[:] - value) ** 2
+            elif self.residual_type == "logarithm":
+                resultant.data[:] += numpy.log((ta.data[:] - value) ** 2)
+
+        return numpy.sum(resultant.data)
+
+    def CalculateGradient(self, physical_variable_gradient_map: 'dict[SupportedSensitivityFieldVariableTypes, Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor]') -> None:
+        values = self.ta_getter(self.model_part)
+        values.CollectData()
+
+        # calculate the gradients
+        for physical_variable, cta in physical_variable_gradient_map.items():
+            if physical_variable == self.variable:
+
+                # initialize the current tensor adaptor
+                for ta in cta.GetTensorAdaptors():
+                    ta.data[:] = 0.0
+
+                for ta in cta.GetTensorAdaptors():
+                    for i, value_i in enumerate(self.list_of_discrete_values):
+                        if self.residual_type == "exact":
+                            partial_gradient_ta = Kratos.TensorAdaptors.DoubleTensorAdaptor(ta)
+                            partial_gradient_ta.data[:] = 1.0
+                            for j, value_j in enumerate(self.list_of_discrete_values):
+                                if i == j:
+                                    partial_gradient_ta.data *= (values.data[:] - value_j) * 2.0
+                                else:
+                                    partial_gradient_ta.data *= (values.data[:] - value_j) ** 2
+                            ta.data[:] += partial_gradient_ta.data
+                        elif self.residual_type == "logarithm":
+                            ta.data[:] += (((values.data - value_i) ** (-2)) * (values.data - value_i) * 2.0)
+
+                Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor(cta, perform_collect_data_recursively=False, copy=False).CollectData()
+            else:
+                raise RuntimeError(f"Unsupported sensitivity w.r.t. {physical_variable.Name()} requested. Followings are supported sensitivity variables:\n\t{self.variable.Name()}")

KratosMultiphysics/OptimizationApplication/responses/evaluation_response_function.py

@@ -0,0 +1,68 @@
+import KratosMultiphysics as Kratos
+from KratosMultiphysics.OptimizationApplication.responses.response_function import ResponseFunction
+from KratosMultiphysics.OptimizationApplication.responses.response_function import SupportedSensitivityFieldVariableTypes
+from KratosMultiphysics.OptimizationApplication.utilities.component_data_view import ComponentDataView
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem import OptimizationProblem
+from KratosMultiphysics.OptimizationApplication.utilities.buffered_dict import BufferedDict
+
+class EvaluationResponseFunction(ResponseFunction):
+    def __init__(self, response_function: ResponseFunction, optimization_problem: OptimizationProblem):
+        super().__init__(f"Eval_{response_function.GetName()}")
+        self.response_function = response_function
+        self.optimization_problem = optimization_problem
+
+    def GetImplementedPhysicalKratosVariables(self) -> 'list[SupportedSensitivityFieldVariableTypes]':
+        return self.response_function.GetImplementedPhysicalKratosVariables()
+
+    def Initialize(self) -> None:
+        self.response_function.Initialize()
+        if not ComponentDataView("evaluated_responses", self.optimization_problem).HasDataBuffer():
+            ComponentDataView("evaluated_responses", self.optimization_problem).SetDataBuffer(1)
+
+    def Check(self) -> None:
+        self.response_function.Check()
+
+    def Finalize(self) -> None:
+        self.response_function.Finalize()
+
+    def GetInfluencingModelPart(self) -> Kratos.ModelPart:
+        return self.response_function.GetInfluencingModelPart()
+
+    def CalculateValue(self) -> float:
+        # this response is used at the top most level of the evaluated chained responses.
+        # so this creates a new data container under the optimization problem to avoid
+        # having to compute the same response value twice.
+
+        buffered_data = ComponentDataView("evaluated_responses", self.optimization_problem).GetBufferedData()
+
+        # reset data of the evaluation
+        self.__ResetEvaluationData(self, buffered_data, "values")
+
+        # now calculate
+        return self.response_function.CalculateValue()
+
+    def CalculateGradient(self, physical_variable_gradient_map: 'dict[SupportedSensitivityFieldVariableTypes, Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor]') -> None:
+        # this response is used at the top most level of the evaluated chained responses.
+        # so this creates a new data container under the optimization problem to avoid
+        # having to compute the same response gradient twice.
+
+        unbuffered_data = ComponentDataView("evaluated_responses", self.optimization_problem).GetUnBufferedData()
+
+        # reset data of the evaluation
+        self.__ResetEvaluationData(self, unbuffered_data, "gradients")
+
+        return self.response_function.CalculateGradient(physical_variable_gradient_map)
+
+    def GetChildResponses(self) -> 'list[ResponseFunction]':
+        return [self.response_function]
+
+    def __str__(self) -> str:
+        return f"Response [type = {self.__class__.__name__}, name = {self.GetName()}]"
+
+    @staticmethod
+    def __ResetEvaluationData(response_function: ResponseFunction, data: BufferedDict, prefix: str) -> None:
+        if data.HasValue(f"{prefix}/{response_function.GetName()}"):
+            del data[f"{prefix}/{response_function.GetName()}"]
+        for child_response in response_function.GetChildResponses():
+            # now reset the children
+            EvaluationResponseFunction.__ResetEvaluationData(child_response, data, prefix)

KratosMultiphysics/OptimizationApplication/responses/external_response_function.py

@@ -0,0 +1,87 @@
+import numpy
+from typing import Optional
+import KratosMultiphysics as Kratos
+import KratosMultiphysics.OptimizationApplication as KratosOA
+from KratosMultiphysics.OptimizationApplication.responses.response_function import ResponseFunction
+from KratosMultiphysics.OptimizationApplication.utilities.model_part_utilities import ModelPartOperation
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem import OptimizationProblem
+from KratosMultiphysics.OptimizationApplication.utilities.union_utilities import SupportedSensitivityFieldVariableTypes
+
+def Factory(model: Kratos.Model, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem) -> ResponseFunction:
+    if not parameters.Has("name"):
+        raise RuntimeError(f"ExternalResponseFunction instantiation requires a \"name\" in parameters [ parameters = {parameters}].")
+    if not parameters.Has("settings"):
+        raise RuntimeError(f"ExternalResponseFunction instantiation requires a \"settings\" in parameters [ parameters = {parameters}].")
+
+    return ExternalResponseFunction(parameters["name"].GetString(), model, parameters["settings"], optimization_problem)
+
+class ExternalResponseFunction(ResponseFunction):
+    def __init__(self, response_name: str, model: Kratos.Model, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem) -> None:
+        super().__init__(response_name)
+
+        default_parameters = Kratos.Parameters("""{
+            "evaluated_model_part_names": []
+        }""")
+        parameters.ValidateAndAssignDefaults(default_parameters)
+
+        self.model = model
+        self.optimization_problem = optimization_problem
+
+        evaluated_model_part_names = parameters["evaluated_model_part_names"].GetStringArray()
+        if len(evaluated_model_part_names) == 0:
+            raise RuntimeError(f"No model parts were provided for MassResponseFunction. [ response name = \"{self.GetName()}\"]")
+        self.model_part_operation = ModelPartOperation(self.model, ModelPartOperation.OperationType.UNION, f"response_{self.GetName()}", evaluated_model_part_names, False)
+        self.model_part: Optional[Kratos.ModelPart] = None
+
+    def Initialize(self) -> None:
+        self.model_part = self.model_part_operation.GetModelPart()
+
+    def Check(self) -> None:
+        pass
+
+    def Finalize(self) -> None:
+        pass
+
+    def GetImplementedPhysicalKratosVariables(self) -> 'list[SupportedSensitivityFieldVariableTypes]':
+        return [KratosOA.CUSTOM_DESIGN_VARIABLE]
+
+    def GetInfluencingModelPart(self) -> Kratos.ModelPart:
+        return self.model_part
+
+    def _GetDesignVariableValues(self) -> 'dict[str, numpy.ndarray]':
+        # get the values from the model part nodal non-historical container
+        result: 'dict[str, numpy.ndarray]' = {}
+        for mp_name in self.model_part_operation.list_of_operation_model_part_full_names:
+            ta = Kratos.TensorAdaptors.VariableTensorAdaptor(self.model[mp_name].Nodes, KratosOA.CUSTOM_DESIGN_VARIABLE)
+            ta.CollectData()
+            result[mp_name] = ta.data
+
+        return result
+
+    def _UpdateGradientsFromNumpy(self, numpy_values_map: 'dict[str, numpy.ndarray]', physical_variable_gradient_map: 'dict[SupportedSensitivityFieldVariableTypes, Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor]') -> None:
+        for i, mp_name in enumerate(self.model_part_operation.list_of_operation_model_part_full_names):
+            # assign the sensitivities to the physical_variable_gradient_map
+            physical_variable_gradient_map[KratosOA.CUSTOM_DESIGN_VARIABLE].GetTensorAdaptors()[i].data[:] = numpy_values_map[mp_name]
+            Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor(physical_variable_gradient_map[KratosOA.CUSTOM_DESIGN_VARIABLE], perform_collect_data_recursively=False, copy=False).CollectData()
+
+    def CalculateValue(self) -> float:
+        numpy_values = self._GetDesignVariableValues()[self.model_part_operation.list_of_operation_model_part_full_names[0]]
+
+        # do the update of the model here with the new values.
+        # there after compute the new response value.
+
+        return float((numpy_values[0]-2) ** 2 + (numpy_values[1]-3) ** 2 + (numpy_values[2]-4) ** 2 + (numpy_values[3]-5))**2
+
+    def CalculateGradient(self, physical_variable_gradient_map: 'dict[SupportedSensitivityFieldVariableTypes, Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor]') -> None:
+        numpy_values = self._GetDesignVariableValues()[self.model_part_operation.list_of_operation_model_part_full_names[0]]
+
+        # compute the gradients
+        df_dx0 = 2 * (numpy_values[0]-2)
+        df_dx1 = 2 * (numpy_values[1]-3)
+        df_dx2 = 2 * (numpy_values[2]-4)
+        df_dx3 = 2 * (numpy_values[3]-5)
+
+        # create the numpy array of sensitivities
+        numpy_exp_map = {self.model_part_operation.list_of_operation_model_part_full_names[0]: numpy.array([df_dx0, df_dx1, df_dx2, df_dx3])}
+
+        self._UpdateGradientsFromNumpy(numpy_exp_map, physical_variable_gradient_map)

KratosMultiphysics/OptimizationApplication/responses/geometric_centroid_deviation_response_function.py

@@ -0,0 +1,97 @@
+from typing import Optional
+
+import KratosMultiphysics as Kratos
+import KratosMultiphysics.OptimizationApplication as KratosOA
+from KratosMultiphysics.OptimizationApplication.responses.response_function import ResponseFunction
+from KratosMultiphysics.OptimizationApplication.utilities.union_utilities import SupportedSensitivityFieldVariableTypes
+from KratosMultiphysics.OptimizationApplication.utilities.model_part_utilities import ModelPartOperation
+from KratosMultiphysics.OptimizationApplication.utilities.model_part_utilities import ModelPartUtilities
+
+def Factory(model: Kratos.Model, parameters: Kratos.Parameters, _) -> ResponseFunction:
+    if not parameters.Has("name"):
+        raise RuntimeError(f"GeometricCentroidDeviationResponseFunction instantiation requires a \"name\" in parameters [ parameters = {parameters}].")
+    if not parameters.Has("settings"):
+        raise RuntimeError(f"GeometricCentroidDeviationResponseFunction instantiation requires a \"settings\" in parameters [ parameters = {parameters}].")
+
+    return GeometricCentroidDeviationResponseFunction(parameters["name"].GetString(), model, parameters["settings"])
+
+class GeometricCentroidDeviationResponseFunction(ResponseFunction):
+    def __init__(self, name: str, model: Kratos.Model, parameters: Kratos.Parameters):
+        super().__init__(name)
+
+        default_settings = Kratos.Parameters("""{
+            "evaluated_model_part_names"     : [
+                "PLEASE_PROVIDE_A_MODEL_PART_NAME"
+            ]
+        }""")
+        parameters.ValidateAndAssignDefaults(default_settings)
+
+        self.model = model
+
+        evaluated_model_part_names = parameters["evaluated_model_part_names"].GetStringArray()
+        if len(evaluated_model_part_names) == 0:
+            raise RuntimeError(f"No model parts were provided for GeometricCentroidDeviationResponseFunction. [ response name = \"{self.GetName()}\"]")
+
+        self.model_part_operation = ModelPartOperation(self.model, ModelPartOperation.OperationType.UNION, f"response_{self.GetName()}", evaluated_model_part_names, False)
+        self.model_part: Optional[Kratos.ModelPart] = None
+
+    def GetImplementedPhysicalKratosVariables(self) -> 'list[SupportedSensitivityFieldVariableTypes]':
+        return [KratosOA.SHAPE]
+
+    def GetInfluencingModelPart(self) -> Kratos.ModelPart:
+        if self.model_part is None:
+            raise RuntimeError("Please call GeometricCentroidDeviationResponseFunction::Initialize first.")
+        return self.model_part
+
+    def Initialize(self) -> None:
+        self.model_part = self.model_part_operation.GetModelPart()
+
+        self.model_part_center = Kratos.Array3(0.0)
+        number_of_nodes = self.model_part.GetCommunicator().GlobalNumberOfNodes()
+
+        if number_of_nodes == 0:
+            raise RuntimeError(f"The provided model part {self.model_part.FullName()} does not contain any nodes.")
+
+        for node in self.model_part.Nodes:
+            self.model_part_center[0] += node.X
+            self.model_part_center[1] += node.Y
+            self.model_part_center[2] += node.Z
+
+        self.model_part_center = self.model_part.GetCommunicator().GetDataCommunicator().SumAll(self.model_part_center)
+        self.model_part_center /= number_of_nodes
+
+    def Check(self) -> None:
+        pass
+
+    def Finalize(self) -> None:
+        pass
+
+    def CalculateValue(self) -> float:
+        average_location = Kratos.Array3(0.0)
+        for node in self.model_part.Nodes:
+            average_location[0] += node.X
+            average_location[1] += node.Y
+            average_location[2] += node.Z
+
+        average_location = self.model_part.GetCommunicator().GetDataCommunicator().SumAll(average_location)
+
+        number_of_nodes = self.model_part.GetCommunicator().GlobalNumberOfNodes()
+        self.value_array = (average_location / number_of_nodes  - self.model_part_center)
+        return self.value_array[0] ** 2 + self.value_array[1] ** 2 + self.value_array[2] ** 2
+
+    def CalculateGradient(self, physical_variable_gradient_map: 'dict[SupportedSensitivityFieldVariableTypes, Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor]') -> None:
+        number_of_nodes = self.model_part.GetCommunicator().GlobalNumberOfNodes()
+
+        # calculate the gradients
+        for physical_variable, sensitivity_ta in physical_variable_gradient_map.items():
+            if physical_variable == KratosOA.SHAPE:
+                Kratos.VariableUtils().SetNonHistoricalVariableToZero(Kratos.SHAPE_SENSITIVITY, self.model_part.Nodes)
+                Kratos.VariableUtils().SetNonHistoricalVariable(Kratos.SHAPE_SENSITIVITY, 2.0 * self.value_array / number_of_nodes, self.model_part.Nodes)
+                for sub_sensitivity_ta in sensitivity_ta.GetTensorAdaptors():
+                    if isinstance(sub_sensitivity_ta.GetContainer(), Kratos.NodesArray):
+                        Kratos.TensorAdaptors.VariableTensorAdaptor(sub_sensitivity_ta, Kratos.SHAPE_SENSITIVITY, copy=False).CollectData()
+                    else:
+                        raise RuntimeError(f"Requesting sensitivity w.r.t. SHAPE for a non nodal tensor adaptor. [ Requested container tensor adaptor = {sub_sensitivity_ta} ].")
+                sensitivity_ta.CollectData()
+            else:
+                raise RuntimeError(f"Unsupported sensitivity w.r.t. {physical_variable.Name()} requested. Followings are supported sensitivity variables:\n\tSHAPE")

KratosMultiphysics/OptimizationApplication/responses/linear_strain_energy_response_function.py

@@ -0,0 +1,72 @@
+from typing import Optional
+
+import KratosMultiphysics as Kratos
+import KratosMultiphysics.OptimizationApplication as KratosOA
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem import OptimizationProblem
+from KratosMultiphysics.OptimizationApplication.execution_policies.execution_policy_decorator import ExecutionPolicyDecorator
+from KratosMultiphysics.OptimizationApplication.responses.response_function import ResponseFunction
+from KratosMultiphysics.OptimizationApplication.responses.response_function import SupportedSensitivityFieldVariableTypes
+from KratosMultiphysics.OptimizationApplication.utilities.model_part_utilities import ModelPartOperation
+
+def Factory(model: Kratos.Model, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem) -> ResponseFunction:
+    if not parameters.Has("name"):
+        raise RuntimeError(f"LinearStrainEnergyResponseFunction instantiation requires a \"name\" in parameters [ parameters = {parameters}].")
+    if not parameters.Has("settings"):
+        raise RuntimeError(f"LinearStrainEnergyResponseFunction instantiation requires a \"settings\" in parameters [ parameters = {parameters}].")
+
+    return LinearStrainEnergyResponseFunction(parameters["name"].GetString(), model, parameters["settings"], optimization_problem)
+
+class LinearStrainEnergyResponseFunction(ResponseFunction):
+    def __init__(self, name: str, model: Kratos.Model, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem):
+        super().__init__(name)
+
+        default_settings = Kratos.Parameters("""{
+            "primal_analysis_name"           : "",
+            "perturbation_size"              : 1e-8,
+            "evaluated_model_part_names"     : [
+                "PLEASE_PROVIDE_A_MODEL_PART_NAME"
+            ]
+        }""")
+        parameters.ValidateAndAssignDefaults(default_settings)
+
+        self.perturbation_size = parameters["perturbation_size"].GetDouble()
+        self.model = model
+        self.primal_analysis_execution_policy_decorator: ExecutionPolicyDecorator = optimization_problem.GetExecutionPolicy(parameters["primal_analysis_name"].GetString())
+
+        evaluated_model_part_names = parameters["evaluated_model_part_names"].GetStringArray()
+        if len(evaluated_model_part_names) == 0:
+            raise RuntimeError(f"No model parts were provided for LinearStrainEnergyResponseFunction. [ response name = \"{self.GetName()}\"]")
+
+        self.model_part_operation = ModelPartOperation(self.model, ModelPartOperation.OperationType.UNION, f"response_{self.GetName()}", evaluated_model_part_names, False)
+        self.model_part: Optional[Kratos.ModelPart] = None
+
+    def GetImplementedPhysicalKratosVariables(self) -> 'list[SupportedSensitivityFieldVariableTypes]':
+        return [KratosOA.SHAPE, Kratos.YOUNG_MODULUS, Kratos.THICKNESS, Kratos.POISSON_RATIO]
+
+    def Initialize(self) -> None:
+        self.model_part = self.model_part_operation.GetModelPart()
+
+    def Check(self) -> None:
+        pass
+
+    def Finalize(self) -> None:
+        pass
+
+    def GetInfluencingModelPart(self) -> Kratos.ModelPart:
+        return self.primal_analysis_execution_policy_decorator.GetAnalysisModelPart()
+
+    def CalculateValue(self) -> float:
+        self.primal_analysis_execution_policy_decorator.Execute()
+        return KratosOA.ResponseUtils.LinearStrainEnergyResponseUtils.CalculateValue(self.model_part)
+
+    def CalculateGradient(self, physical_variable_gradient_map: 'dict[SupportedSensitivityFieldVariableTypes, Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor]') -> None:
+        # calculate the gradients
+        for physical_variable, cta in physical_variable_gradient_map.items():
+            KratosOA.ResponseUtils.LinearStrainEnergyResponseUtils.CalculateGradient(
+                physical_variable,
+                self.GetInfluencingModelPart(),
+                cta,
+                self.perturbation_size)
+
+    def __str__(self) -> str:
+        return f"Response [type = {self.__class__.__name__}, name = {self.GetName()}, model part name = {self.model_part.FullName()}]"

KratosMultiphysics/OptimizationApplication/responses/literal_value_response_function.py

@@ -0,0 +1,33 @@
+import KratosMultiphysics as Kratos
+from KratosMultiphysics.OptimizationApplication.responses.response_function import ResponseFunction
+from KratosMultiphysics.OptimizationApplication.utilities.union_utilities import SupportedSensitivityFieldVariableTypes
+
+class LiteralValueResponseFunction(ResponseFunction):
+    def __init__(self, value: float):
+        super().__init__(str(value))
+
+        self.value = value
+
+    def GetImplementedPhysicalKratosVariables(self) -> 'list[SupportedSensitivityFieldVariableTypes]':
+        return []
+
+    def Initialize(self) -> None:
+        pass
+
+    def Check(self) -> None:
+        pass
+
+    def Finalize(self) -> None:
+        pass
+
+    def GetInfluencingModelPart(self) -> Kratos.ModelPart:
+        raise RuntimeError(f"The literal value response function does not have an influencing model part.")
+
+    def CalculateValue(self) -> float:
+        return self.value
+
+    def CalculateGradient(self, _: 'dict[SupportedSensitivityFieldVariableTypes, Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor]') -> None:
+        raise RuntimeError(f"The literal value response function does not depend on any variable, hence no gradients.")
+
+    def __str__(self) -> str:
+        return f"Response [type = {self.__class__.__name__}, name = {self.GetName()}]"