KratosOptimizationApplication 10.4.4__py3-none-any.whl

KratosMultiphysics/OptimizationApplication/algorithms/algorithm_relaxed_gradient_projection.py

@@ -0,0 +1,263 @@
+import numpy
+import KratosMultiphysics as Kratos
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem import OptimizationProblem
+from KratosMultiphysics.OptimizationApplication.algorithms.standardized_objective import StandardizedObjective
+from KratosMultiphysics.OptimizationApplication.controls.master_control import MasterControl
+from KratosMultiphysics.OptimizationApplication.algorithms.algorithm_gradient_projection import AlgorithmGradientProjection
+from KratosMultiphysics.OptimizationApplication.utilities.component_data_view import ComponentDataView
+from KratosMultiphysics.OptimizationApplication.utilities.opt_line_search import CreateLineSearch
+from KratosMultiphysics.OptimizationApplication.algorithms.standardized_rgp_constraint import StandardizedRGPConstraint
+from KratosMultiphysics.LinearSolversApplication.dense_linear_solver_factory import ConstructSolver
+from KratosMultiphysics.OptimizationApplication.utilities.logger_utilities import time_decorator
+from KratosMultiphysics.OptimizationApplication.utilities.logger_utilities import OptimizationAlgorithmTimeLogger
+from KratosMultiphysics.OptimizationApplication.utilities.logger_utilities import ListLogger
+import math
+
+
+def Factory(model: Kratos.Model, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem):
+    return AlgorithmRelaxedGradientProjection(model, parameters, optimization_problem)
+
+class AlgorithmRelaxedGradientProjection(AlgorithmGradientProjection):
+    """
+        Relaxed Gradient Projection algorithm to solve constrained optimization problems. Implemnetation is based on:
+        Antonau, I., Hojjat, M. & Bletzinger, KU. Relaxed gradient projection algorithm for constrained node-based shape optimization. Struct Multidisc Optim 63, 1633–1651 (2021). https://doi.org/10.1007/s00158-020-02821-y
+    """
+
+    @classmethod
+    def GetDefaultParameters(cls):
+        return Kratos.Parameters("""{
+            "module"            : "KratosMultiphysics.OptimizationApplication.algorithms",
+            "type"              : "PLEASE_PROVIDE_AN_ALGORITHM_CLASS_NAME",
+            "objective"         : {},
+            "constraints"       : [],
+            "controls"          : [],
+            "echo_level"        : 0,
+            "settings"          : {
+                "echo_level"      : 0,
+                "line_search"     : {},
+                "conv_settings"   : {},
+                "linear_solver_settings" : {},
+                "history_size"           : 20,
+                "max_inner_iter"         : 20,
+                "buffer_coeff_update_factor" : 0.1
+            }
+        }""")
+
+    def __init__(self, model:Kratos.Model, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem):
+        self.model = model
+        self.parameters = parameters
+        self._optimization_problem = optimization_problem
+        parameters.ValidateAndAssignDefaults(self.GetDefaultParameters())
+
+        self.master_control = MasterControl() # Need to fill it with controls
+        self._optimization_problem.AddComponent(self.master_control)
+
+        for control_name in parameters["controls"].GetStringArray():
+            control = optimization_problem.GetControl(control_name)
+            self.master_control.AddControl(control)
+
+        settings = parameters["settings"]
+        settings.ValidateAndAssignDefaults(self.GetDefaultParameters()["settings"])
+
+        self.history_size = settings["history_size"].GetInt()
+
+        self.echo_level = settings["echo_level"].GetInt()
+
+        ComponentDataView("algorithm", self._optimization_problem).SetDataBuffer(self.GetMinimumBufferSize())
+
+        # self.__convergence_criteria = CreateConvergenceCriteria(settings["conv_settings"], self._optimization_problem)
+        self.__line_search_method = CreateLineSearch(settings["line_search"], self._optimization_problem)
+
+        self._objective = StandardizedObjective(parameters["objective"], self.master_control, self._optimization_problem)
+        self._optimization_problem.AddComponent(self._objective)
+        self._constraints_list: 'list[StandardizedRGPConstraint]' = []
+        for constraint_param in parameters["constraints"].values():
+            constraint = StandardizedRGPConstraint(constraint_param, self.master_control, self._optimization_problem, self.GetMinimumBufferSize())
+            self._optimization_problem.AddComponent(constraint)
+            self._constraints_list.append(constraint)
+        self._control_field = None
+        self._obj_val = None
+
+        self._convergence_criteria = self._CreateConvergenceCriteria(settings["conv_settings"])
+
+        default_linear_solver_settings = Kratos.Parameters("""{
+            "solver_type": "LinearSolversApplication.dense_col_piv_householder_qr"
+        }""")
+        settings["linear_solver_settings"].ValidateAndAssignDefaults(default_linear_solver_settings)
+        self.linear_solver = ConstructSolver(settings["linear_solver_settings"])
+        self.max_inner_iter = settings["max_inner_iter"].GetInt()
+        self.buffer_coeff_update_factor = settings["buffer_coeff_update_factor"].GetDouble()
+
+    def GetMinimumBufferSize(self) -> int:
+        return self.history_size
+
+    @time_decorator()
+    def ComputeSearchDirection(self, obj_grad: Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor, constr_grad: 'list[Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor]', w_r: Kratos.Vector, w_c: Kratos.Vector) -> Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor:
+        active_constraints_list = self.GetActiveConstraintsList()
+        number_of_active_constraints = len(active_constraints_list)
+
+        search_direction = Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor(obj_grad, perform_collect_data_recursively=False, perform_store_data_recursively=False)
+        correction = Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor(search_direction)
+        projected_direction = Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor(search_direction)
+
+        if not number_of_active_constraints:
+            search_direction.data[:] = obj_grad.data * -1.0
+            correction.data[:] = 0.0
+            projected_direction.data[:] = 0.0
+        else:
+            # scaling obj gradients
+            obj_norm = numpy.linalg.norm(obj_grad.data.ravel(), ord=numpy.inf)
+            scaled_obj_grad = Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor(obj_grad, perform_collect_data_recursively=False, perform_store_data_recursively=False)
+            if not math.isclose(obj_norm, 0.0, abs_tol=1e-16):
+                scaled_obj_grad.data[:] /= obj_norm
+                scaled_obj_grad.StoreData()
+
+            scaled_constr_grad: 'list[Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor]' = []
+            lagrangian_multiplier = Kratos.Vector(number_of_active_constraints)
+            for i in range(number_of_active_constraints):
+                # scaling constraints grad
+                norm = numpy.linalg.norm(constr_grad[i].data.ravel(), ord=numpy.inf)
+                ta = Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor(constr_grad[i], perform_collect_data_recursively=False, perform_store_data_recursively=False)
+                scaled_constr_grad.append(ta)
+                if not math.isclose(norm, 0.0, abs_tol=1e-16):
+                    ta.data[:] /= norm
+                    ta.StoreData()
+
+            # compute the projected search direction and correction
+            ntn = Kratos.Matrix(number_of_active_constraints, number_of_active_constraints)
+            for i in range(number_of_active_constraints):
+                for j in range(i, number_of_active_constraints):
+                    ntn[i, j] = numpy.dot(scaled_constr_grad[i].data.ravel(), scaled_constr_grad[j].data.ravel())
+                    ntn[j, i] = ntn[i, j]
+
+            # get the inverse of ntn
+            ntn_inverse = Kratos.Matrix(number_of_active_constraints, number_of_active_constraints)
+
+            # create the identity matrix
+            identity_matrix = Kratos.Matrix(number_of_active_constraints, number_of_active_constraints, 0.0)
+            for i in range(number_of_active_constraints):
+                identity_matrix[i, i] = 1.0
+
+            # solve for inverse of ntn
+            self.linear_solver.Solve(ntn, ntn_inverse, identity_matrix)
+
+            lagrangian_multiplier = ntn_inverse * self._CollectiveListCollectiveProduct(scaled_constr_grad, scaled_obj_grad)
+            for i in range(number_of_active_constraints):
+                if lagrangian_multiplier[i] > 0.0:
+                    lagrangian_multiplier[i] = 0.0
+                else:
+                    lagrangian_multiplier[i] *= w_r[i]
+            projected_direction.data[:] = - (scaled_obj_grad.data - self._CollectiveListVectorProduct(scaled_constr_grad, lagrangian_multiplier).data)
+            correction.data[:] = - self._CollectiveListVectorProduct(scaled_constr_grad, w_c).data
+            search_direction.data[:] = projected_direction.data + correction.data
+        self.algorithm_data.GetBufferedData().SetValue("search_direction", search_direction, overwrite=True)
+        self.algorithm_data.GetBufferedData().SetValue("correction", correction, overwrite=True)
+        self.algorithm_data.GetBufferedData().SetValue("projected_direction", projected_direction, overwrite=True)
+
+    def ComputeBufferCoefficients(self):
+        active_constraints_list = self.GetActiveConstraintsList()
+        number_of_active_constraints = len(active_constraints_list)
+        if number_of_active_constraints == 0:
+            return Kratos.Vector(), Kratos.Vector()
+        else:
+            w_r = Kratos.Vector(number_of_active_constraints)
+            w_c = Kratos.Vector(number_of_active_constraints)
+            for i, active_constraint in enumerate(active_constraints_list):
+                w = active_constraint.ComputeW()
+                w_r[i] = active_constraint.Compute_W_relax(w)
+                w_c[i] = active_constraint.Compute_W_correction(w)
+                print(f"RGP Constraint {active_constraint.GetResponseName()}:: w_r = {w_r[i]}, w_c = {w_c[i]}")
+            return w_r, w_c
+
+    @time_decorator()
+    def ComputeControlUpdate(self, alpha: Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor) -> Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor:
+        search_direction: Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor = self.algorithm_data.GetBufferedData()["search_direction"]
+        update = Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor(search_direction, perform_collect_data_recursively=False, perform_store_data_recursively=False)
+        update.data[:] = search_direction.data * alpha.data
+        update.StoreData()
+        self.algorithm_data.GetBufferedData().SetValue("control_field_update", update, overwrite=True)
+        return update
+
+    def CheckLinearizedConstraints(self, active_constr_grad: 'list[Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor]', update: Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor, w_r, w_c) -> bool:
+        all_feasible = True
+        active_constraints_list = self.GetActiveConstraintsList()
+        for i, constraint in enumerate(active_constraints_list):
+            predicted_value = constraint.GetStandardizedValue() + numpy.dot(active_constr_grad[i].data.ravel(), update.data.ravel())
+            print(f"RGP Constraint {constraint.GetResponseName()}:: predicted g_i {predicted_value}")
+            if not constraint.IsSatisfied(predicted_value):
+                all_feasible = False
+                w = constraint.ComputeW()
+                w += self.buffer_coeff_update_factor
+                w_r[i] = constraint.Compute_W_relax(w)
+                w_c[i] = constraint.Compute_W_correction(w)
+                print(f"RGP Constraint {constraint.GetResponseName()}:: Corrected w_r = {w_r[i]}, w_c = {w_c[i]}")
+            else:
+                print(f"RGP Constraint {constraint.GetResponseName()}:: no correction for w_r, w_c ")
+        return all_feasible
+
+    def GetActiveConstraintsList(self):
+        return [constraint for constraint in self._constraints_list if constraint.IsActive()]
+
+    def GetConstraintsList(self):
+        return self._constraints_list
+
+    @time_decorator()
+    def Solve(self):
+        while not self.converged:
+            with OptimizationAlgorithmTimeLogger("Gradient Projection",self._optimization_problem.GetStep()):
+                self._InitializeIteration()
+
+                self._obj_val = self._objective.CalculateStandardizedValue(self._control_field)
+                obj_info = self._objective.GetInfo()
+                self.algorithm_data.GetBufferedData()["std_obj_value"] = obj_info["std_value"]
+                self.algorithm_data.GetBufferedData()["rel_change[%]"] = obj_info["rel_change [%]"]
+                if "abs_change [%]" in obj_info:
+                    self.algorithm_data.GetBufferedData()["abs_change[%]"] = obj_info["abs_change [%]"]
+
+                obj_grad = self._objective.CalculateStandardizedGradient()
+
+                self.__constr_value = []
+                active_constr_grad = []
+                for constraint in self._constraints_list:
+                    value = constraint.CalculateStandardizedValue(self._control_field)
+                    constraint.UpdateBufferSize()
+                    self.__constr_value.append(value)
+                    constr_name = constraint.GetResponseName()
+                    self.algorithm_data.GetBufferedData()[f"std_constr_{constr_name}_value"] = value
+                    msg = "active" if constraint.IsActive() else "non-active"
+                    print(f"RGP Constraint {constraint.GetResponseName()} is {msg}")
+                    if constraint.IsActive():
+                        active_constr_grad.append(constraint.CalculateStandardizedGradient())
+
+                w_r, w_c = self.ComputeBufferCoefficients()
+
+                inner_iter = 0
+                while inner_iter < self.max_inner_iter:
+
+                    print(f"\n inner_iter :: {inner_iter}")
+
+                    self.ComputeSearchDirection(obj_grad, active_constr_grad, w_r, w_c)
+
+                    alpha = self.__line_search_method.ComputeStep()
+
+                    update = self.ComputeControlUpdate(alpha)
+
+                    if self.CheckLinearizedConstraints(active_constr_grad, update, w_r, w_c):
+                        break
+
+                    inner_iter += 1
+
+                self._FinalizeIteration()
+
+                self.converged = self._convergence_criteria.IsConverged()
+
+                self.Output()
+
+                self.UpdateControl()
+
+                ListLogger("Convergence info", self._convergence_criteria.GetInfo())
+
+                if not self.converged:
+                    self._optimization_problem.AdvanceStep()
+
+        return self.converged

KratosMultiphysics/OptimizationApplication/algorithms/algorithm_steepest_descent.py

@@ -0,0 +1,205 @@
+import KratosMultiphysics as Kratos
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem import OptimizationProblem
+from KratosMultiphysics.OptimizationApplication.algorithms.standardized_objective import StandardizedObjective
+from KratosMultiphysics.OptimizationApplication.controls.master_control import MasterControl
+from KratosMultiphysics.OptimizationApplication.algorithms.algorithm import Algorithm
+from KratosMultiphysics.OptimizationApplication.utilities.component_data_view import ComponentDataView
+from KratosMultiphysics.OptimizationApplication.utilities.opt_line_search import CreateLineSearch
+from KratosMultiphysics.OptimizationApplication.utilities.logger_utilities import time_decorator
+from KratosMultiphysics.OptimizationApplication.utilities.logger_utilities import OptimizationAlgorithmTimeLogger
+from KratosMultiphysics.OptimizationApplication.convergence_criteria.convergence_criterion import ConvergenceCriterion
+from KratosMultiphysics.OptimizationApplication.convergence_criteria.combined_conv_criterion import CombinedConvCriterion
+from KratosMultiphysics.OptimizationApplication.convergence_criteria.max_iter_conv_criterion import MaxIterConvCriterion
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem_utilities import OptimizationComponentFactory
+from KratosMultiphysics.OptimizationApplication.utilities.logger_utilities import ListLogger
+
+
+def Factory(model: Kratos.Model, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem):
+    return AlgorithmSteepestDescent(model, parameters, optimization_problem)
+
+class AlgorithmSteepestDescent(Algorithm):
+    """
+        A classical steepest descent algorithm to solve unconstrained optimization problems.
+    """
+
+    @classmethod
+    def GetDefaultParameters(cls):
+        return Kratos.Parameters("""{
+            "module"            : "KratosMultiphysics.OptimizationApplication.algorithms",
+            "type"              : "PLEASE_PROVIDE_AN_ALGORITHM_CLASS_NAME",
+            "objective"         : {},
+            "controls"          : [],
+            "echo_level"        : 0,
+            "settings"          : {
+                "echo_level"      : 0,
+                "line_search"     : {},
+                "conv_settings"   : {}
+            }
+        }""")
+
+    def __init__(self, model:Kratos.Model, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem):
+        self.model = model
+        self.parameters = parameters
+        self._optimization_problem = optimization_problem
+
+        parameters.ValidateAndAssignDefaults(self.GetDefaultParameters())
+
+        self.master_control = MasterControl() # Need to fill it with controls
+        self._optimization_problem.AddComponent(self.master_control)
+
+        for control_name in parameters["controls"].GetStringArray():
+            control = optimization_problem.GetControl(control_name)
+            self.master_control.AddControl(control)
+
+
+        settings = parameters["settings"]
+        settings.ValidateAndAssignDefaults(self.GetDefaultParameters()["settings"])
+
+        self.echo_level = settings["echo_level"].GetInt()
+
+        ComponentDataView("algorithm", self._optimization_problem).SetDataBuffer(self.GetMinimumBufferSize())
+
+        self._convergence_criteria = self.__CreateConvergenceCriteria(settings["conv_settings"])
+        self.__line_search_method = CreateLineSearch(settings["line_search"], self._optimization_problem)
+
+        self.__objective = StandardizedObjective(parameters["objective"], self.master_control, self._optimization_problem)
+        self._optimization_problem.AddComponent(self.__objective)
+        self.__control_field = None
+        self.__obj_val = None
+
+    def GetMinimumBufferSize(self) -> int:
+        return 2
+
+    def Check(self) -> None:
+        self.master_control.Check()
+        self.__objective.Check()
+
+    @time_decorator()
+    def Initialize(self) -> None:
+        self.converged = False
+        self.__obj_val = None
+        self.master_control.Initialize()
+        self.__objective.Initialize()
+        self.__control_field = self.master_control.GetControlField()
+        self.algorithm_data = ComponentDataView("algorithm", self._optimization_problem)
+        self._convergence_criteria.Initialize()
+
+    def Finalize(self) -> None:
+        self.master_control.Finalize()
+        self.__objective.Finalize()
+        self._convergence_criteria.Finalize()
+
+    @time_decorator()
+    def ComputeSearchDirection(self, obj_grad: Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor) -> Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor:
+        search_direction: Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor = obj_grad.Clone()
+        search_direction.data[:] *= -1.0
+        Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor(search_direction, perform_store_data_recursively=False, copy=False).StoreData()
+        self.algorithm_data.GetBufferedData()["search_direction"] = search_direction
+        return search_direction
+
+    @time_decorator()
+    def ComputeControlUpdate(self, alpha: Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor) -> None:
+        update: Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor = self.algorithm_data.GetBufferedData()["search_direction"].Clone()
+        update.data[:] *= alpha.data[:]
+        Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor(update, perform_store_data_recursively=False, copy=False).StoreData()
+        self.algorithm_data.GetBufferedData()["control_field_update"] = update
+
+    @time_decorator()
+    def UpdateControl(self) -> Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor:
+        update: Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor = self.algorithm_data.GetBufferedData()["control_field_update"]
+        self.__control_field.data[:] += update.data
+        Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor(self.__control_field, perform_store_data_recursively=False, copy=False).StoreData()
+
+    @time_decorator()
+    def Output(self) -> None:
+        self.algorithm_data.GetBufferedData()["control_field"] = Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor(self.__control_field)
+        for process in self._optimization_problem.GetListOfProcesses("output_processes"):
+            if process.IsOutputStep():
+                process.PrintOutput()
+
+    def GetCurrentObjValue(self) -> float:
+        return self.__obj_val
+
+    def GetCurrentControlField(self) -> Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor:
+        return self.__control_field
+
+    @time_decorator()
+    def Solve(self) -> bool:
+        while not self.converged:
+            with OptimizationAlgorithmTimeLogger("AlgorithmSteepestDescent",self._optimization_problem.GetStep()):
+                self._InitializeIteration()
+
+                self.__obj_val = self.__objective.CalculateStandardizedValue(self.__control_field)
+                obj_info = self.__objective.GetInfo()
+                self.algorithm_data.GetBufferedData()["std_obj_value"] = obj_info["std_value"]
+                self.algorithm_data.GetBufferedData()["rel_obj[%]"] = obj_info["rel_change [%]"]
+                if "abs_change [%]" in obj_info:
+                    self.algorithm_data.GetBufferedData()["abs_obj[%]"] = obj_info["abs_change [%]"]
+
+                obj_grad = self.__objective.CalculateStandardizedGradient()
+
+                self.ComputeSearchDirection(obj_grad)
+
+                alpha = self.__line_search_method.ComputeStep()
+
+                self.ComputeControlUpdate(alpha)
+
+                self._FinalizeIteration()
+
+                self.converged = self._convergence_criteria.IsConverged()
+
+                self.Output()
+
+                self.UpdateControl()
+
+                ListLogger("Convergence info", self._convergence_criteria.GetInfo())
+
+                if not self.converged:
+                    self._optimization_problem.AdvanceStep()
+
+        return self.converged
+
+    def GetOptimizedObjectiveValue(self) -> float:
+        if self.converged:
+            return self.__obj_val
+        else:
+            raise RuntimeError("Optimization problem hasn't been solved.")
+
+    def __CreateConvergenceCriteria(self, settings: Kratos.Parameters) -> ConvergenceCriterion:
+        default_settings = Kratos.Parameters("""{
+            "max_iter": 0,
+            "type"    : "",
+            "module"  : "KratosMultiphysics.OptimizationApplication.convergence_criteria",
+            "settings": {}
+        }""")
+        settings.AddMissingParameters(default_settings)
+
+        max_iter_params = Kratos.Parameters("""{
+            "max_iter": """ + str(settings["max_iter"].GetInt()) + """
+        }""")
+        max_iter_conv_criteria = MaxIterConvCriterion(max_iter_params, self._optimization_problem)
+        if settings["type"].GetString() == "":
+            return max_iter_conv_criteria
+        else:
+            # create the additional convergence criterions given by the user
+            additional_conv_params = Kratos.Parameters("""{
+                "type"    : "",
+                "module"  : "",
+                "settings": {}
+            }""")
+            additional_conv_params["type"].SetString(settings["type"].GetString())
+            additional_conv_params["module"].SetString(settings["module"].GetString())
+            additional_conv_params["settings"] = settings["settings"]
+            additional_conv: ConvergenceCriterion = OptimizationComponentFactory(self.model, additional_conv_params, self._optimization_problem)
+
+            # now create the combined one and return the combined one
+            combined_params = Kratos.Parameters("""{
+                "operator": "or"
+            }""")
+            combined_conv_criteria = CombinedConvCriterion(self.model, combined_params, self._optimization_problem)
+            combined_conv_criteria.Add(max_iter_conv_criteria) # add the max iter conv criteria
+            combined_conv_criteria.Add(additional_conv) # add the additional conv criteria
+            return combined_conv_criteria
+
+
+

KratosMultiphysics/OptimizationApplication/algorithms/standardized_NLOPT_constraint.py

@@ -0,0 +1,194 @@
+import KratosMultiphysics as Kratos
+import KratosMultiphysics.OptimizationApplication as KratosOA
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem import OptimizationProblem
+from KratosMultiphysics.OptimizationApplication.responses.response_routine import ResponseRoutine
+from KratosMultiphysics.OptimizationApplication.controls.master_control import MasterControl
+from KratosMultiphysics.OptimizationApplication.utilities.component_data_view import ComponentDataView
+from KratosMultiphysics.OptimizationApplication.utilities.logger_utilities import DictLogger
+from KratosMultiphysics.OptimizationApplication.utilities.logger_utilities import TimeLogger
+from KratosMultiphysics.OptimizationApplication.utilities.response_utilities import EvaluateResponseExpression
+from KratosMultiphysics.kratos_utilities import IssueDeprecationWarning
+import numpy
+import sys
+
+class StandardizedNLOPTConstraint(ResponseRoutine):
+    """Standardized constraint response function
+
+    This class creates instances to standardize any response function for the specified type of the constraint.
+    Supported constraint types:
+        "=",
+        "<",
+        ">"
+
+    The reference value for the constraint either can be the "initial_value" or a specified value.
+
+    """
+    def __init__(self, parameters: Kratos.Parameters, master_control: MasterControl, optimization_problem: OptimizationProblem, required_buffer_size: int = 2):
+        # backward compatibility
+        if parameters.Has("response_name"):
+            IssueDeprecationWarning(self.__class__.__name__, "\"response_name\" is deprecated. Please use \"response_expression\".")
+            parameters.AddString("response_expression", parameters["response_name"].GetString())
+            parameters.RemoveValue("response_name")
+
+        default_parameters = Kratos.Parameters("""{
+            "response_expression": "",
+            "type"               : "",
+            "ref_value"          : "initial_value"
+        }""")
+
+        response_name = str(parameters["response_name"].GetString())
+        if not parameters.Has("ref_value"):
+            raise RuntimeError(f"Constraint for response {response_name} requires reference value specified in ref_value")
+
+        if parameters.Has("ref_value") and parameters["ref_value"].IsDouble():
+            default_parameters["ref_value"].SetDouble(0.0)
+
+        parameters.ValidateAndAssignDefaults(default_parameters)
+
+        response = EvaluateResponseExpression(parameters["response_expression"].GetString(), optimization_problem)
+
+        super().__init__(master_control, response)
+
+        if required_buffer_size < 2:
+            raise RuntimeError(f"Standardized constraint requires 2 as minimum buffer size. [ response name = {self.GetReponse().GetName()} ]")
+
+        component_data_view = ComponentDataView(response, optimization_problem)
+        component_data_view.SetDataBuffer(required_buffer_size)
+
+        self.__optimization_problem = optimization_problem
+        self.__buffered_data = component_data_view.GetBufferedData()
+        self.__unbuffered_data = component_data_view.GetUnBufferedData()
+
+        if parameters["ref_value"].IsDouble():
+            self.__reference_value = parameters["ref_value"].GetDouble()
+        elif parameters["ref_value"].IsString() and parameters["ref_value"].GetString() == "initial_value":
+            self.__reference_value = None
+        else:
+            raise RuntimeError("Provided \"reference_type\" is not supported for constraint response functions. Followings are supported options: \n\tinitial_value\n\tfloat value")
+
+        self.__constraint_type = parameters["type"].GetString()
+        if self.__constraint_type in ["=", "<"]:
+            self.__scaling = 1.0
+        elif self.__constraint_type in [">"]:
+            self.__scaling = -1.0
+            if not self.__reference_value is None: self.__reference_value *= -1
+        else:
+            raise RuntimeError(f"Provided \"type\" = {self.__constraint_type} is not supported in constraint response functions. Followings are supported options: \n\t=\n\t<\n\t>")
+
+        self.__zero_threshold = sys.float_info.epsilon
+
+    def IsEqualityType(self) -> str:
+        return self.__constraint_type == "="
+
+    def GetReferenceValue(self) -> float:
+        if self.__reference_value is not None:
+            return self.__reference_value
+        else:
+            if self.__unbuffered_data.HasValue("initial_value"):
+                self.__reference_value = self.__unbuffered_data["initial_value"]
+                return self.__reference_value
+            else:
+                raise RuntimeError(f"Response value for {self.GetReponse().GetName()} is not calculated yet.")
+
+    def CalculateStandardizedValueAndGradients(self, control_field: numpy.ndarray, gradient_field: numpy.ndarray, save_value: bool = True) -> float:
+
+        with TimeLogger(f"StandardizedNLOPTConstraint::Calculate {self.GetReponse().GetName()} value", None, "Finished"):
+
+            # first update the master control
+            self.UpdateMasterControl(control_field)
+
+            # compute the value
+            response_value = self.GetReponse().CalculateValue()
+
+            if not self.__unbuffered_data.HasValue("initial_value"):
+                self.__unbuffered_data["initial_value"] = response_value
+
+            if self.__buffered_data.HasValue("value"): del self.__buffered_data["value"]
+            self.__buffered_data["value"] = response_value
+
+            # log values
+            if save_value:
+                self.LogValues()
+
+            # print the info
+            DictLogger("Constraint info",self.GetInfo())
+
+            if gradient_field.size > 0:
+                gradient_combined_tensor_adaptor = self.CalculateGradient()
+                gradient_field[:] = gradient_combined_tensor_adaptor.data.reshape(-1) * self.GetStandardizationFactor()
+
+                if save_value:
+                    self.LogGradientFields(gradient_combined_tensor_adaptor)
+
+        return self.GetStandardizedValue()
+
+    def GetValue(self, step_index: int = 0) -> float:
+        return self.__buffered_data.GetValue("value", step_index)
+
+    def GetStandardizationFactor(self):
+        ref_value = self.GetReferenceValue()
+        standardization_factor = self.__scaling
+        if abs(ref_value) > self.__zero_threshold:
+            standardization_factor /= abs(ref_value)
+        return standardization_factor
+
+    def GetStandardizedValue(self, step_index: int = 0) -> float:
+        ref_value = self.GetReferenceValue()
+        standardized_response_value = self.GetValue(step_index) - ref_value
+        standardized_response_value *= self.GetStandardizationFactor()
+        return standardized_response_value
+
+    def GetAbsoluteViolation(self, step_index: int = 0) -> float:
+            ref_value = self.GetReferenceValue()
+            standardized_response_value = self.GetValue(step_index) - ref_value
+            standardization_factor = self.__scaling
+            if abs(ref_value) > self.__zero_threshold:
+                standardization_factor /= abs(ref_value)
+                standardization_factor *= 100
+            standardized_response_value *= standardization_factor
+            return standardized_response_value
+
+    def GetInfo(self) -> dict:
+        info = {
+            "name": self.GetReponse().GetName(),
+            "value": self.GetValue(),
+            "type": self.__constraint_type,
+            "ref_value": self.GetReferenceValue(),
+            "violation [%]": self.GetAbsoluteViolation()
+        }
+        return info
+
+    def LogValues(self) -> None:
+        if self.__buffered_data.HasValue("violation [%]"): del self.__buffered_data["violation [%]"]
+        self.__buffered_data["violation [%]"] = self.GetAbsoluteViolation()
+
+    def LogGradientFields(self, gradient_combined_tensor_adaptor: Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor) -> None:
+        # save the physical gradients for post processing in unbuffered data container.
+        for physical_var, physical_gradient in self.GetRequiredPhysicalGradients().items():
+            variable_name = f"d{self.GetReponse().GetName()}_d{physical_var.Name()}"
+            for physical_gradient_ta in physical_gradient.GetTensorAdaptors():
+                if self.__unbuffered_data.HasValue(variable_name): del self.__unbuffered_data[variable_name]
+                # cloning is a cheap operation, it only moves underlying pointers
+                # does not create additional memory.
+                self.__unbuffered_data[variable_name] = physical_gradient_ta.Clone()
+
+        # save the filtered gradients for post processing in unbuffered data container.
+        for gradient_ta, control in zip(gradient_combined_tensor_adaptor.GetTensorAdaptors(), self.GetMasterControl().GetListOfControls()):
+            variable_name = f"d{self.GetReponse().GetName()}_d{control.GetName()}"
+            if self.__unbuffered_data.HasValue(variable_name): del self.__unbuffered_data[variable_name]
+            # cloning is a cheap operation, it only moves underlying pointers
+            # does not create additional memory.
+            self.__unbuffered_data[variable_name] = gradient_ta.Clone()
+
+    def UpdateMasterControl(self, new_control_field: numpy.ndarray) -> None:
+        master_control = self.GetMasterControl()
+        new_control_field_ta = master_control.GetEmptyField()
+        number_of_entities = []
+        shapes = []
+        for control in master_control.GetListOfControls():
+            number_of_entities.append(len(control.GetControlField().GetContainer()))
+            shapes.append(control.GetControlField().GetItemShape())
+        new_control_field_ta.data[:] = new_control_field
+        Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor(new_control_field_ta, perform_store_data_recursively=False, copy=False).StoreData()
+        # now update the master control
+        master_control.Update(new_control_field_ta)