KratosOptimizationApplication 10.4.4__py3-none-any.whl

KratosMultiphysics/OptimizationApplication/algorithms/standardized_NLOPT_objective.py

@@ -0,0 +1,191 @@
+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.helper_utilities import CallOnAll
+from KratosMultiphysics.OptimizationApplication.utilities.response_utilities import EvaluateResponseExpression
+from KratosMultiphysics.kratos_utilities import IssueDeprecationWarning
+import numpy
+import datetime
+
+class StandardizedNLOPTObjective(ResponseRoutine):
+    """Standardized objective response function
+
+    This class transformed a user-given optimization problem into the standard format.
+    Supported objective types:
+        "minimization",
+        "maximization"
+
+    """
+    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"               : "",
+            "scaling"            : 1.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 objective 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()
+
+        scaling = parameters["scaling"].GetDouble()
+        if scaling < 0.0:
+            raise RuntimeError(f"Scaling should be always positive [ given scale = {scaling}]")
+
+        self.__objective_type = parameters["type"].GetString()
+        if self.__objective_type == "minimization":
+            self.__scaling = scaling
+        elif self.__objective_type == "maximization":
+            self.__scaling = -scaling
+        else:
+            raise RuntimeError(f"Requesting unsupported type {self.__objective_type} for objective response function. Supported types are: \n\tminimization\n\tmaximization")
+
+    def GetInitialValue(self) -> float:
+        if self.__unbuffered_data.HasValue("initial_value"):
+            return self.__unbuffered_data["initial_value"] * self.__scaling
+        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:
+        if self.UpdateMasterControlAndLogFields(control_field) or self.__optimization_problem.GetStep()==0:
+            with TimeLogger(f"CalculateStandardizedValueAndGradients {self.GetReponse().GetName()} value", None, "Finished"):
+
+                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("Objective info",self.GetInfo())
+
+                # compute standardization factor
+                self.standardization_factor = self.__scaling
+                if abs(self.__unbuffered_data["initial_value"])>1e-15:
+                    self.standardization_factor /= abs(self.__unbuffered_data["initial_value"])
+                self.standardized_response_value = self.standardization_factor * response_value
+
+                # compute gradients
+                if gradient_field.size > 0:
+                    self.gradient_combined_tensor_adaptor = self.CalculateGradient()
+                    # save gradients
+                    if save_value:
+                        self.LogGradientFields()
+
+        if gradient_field.size > 0:
+            gradient_field[:] = self.standardization_factor * self.gradient_combined_tensor_adaptor.data.reshape(-1)
+
+        return self.standardized_response_value
+
+    def GetValue(self, step_index: int = 0) -> float:
+        return self.__buffered_data.GetValue("value", step_index)
+
+    def GetStandardizedValue(self, step_index: int = 0) -> float:
+        return self.GetValue(step_index) * self.__scaling
+
+    def GetRelativeChange(self) -> float:
+        if self.__optimization_problem.GetStep() > 0:
+            return self.GetStandardizedValue() / self.GetStandardizedValue(1) - 1.0 if abs(self.GetStandardizedValue(1)) > 1e-12 else self.GetStandardizedValue()
+        else:
+            return 0.0
+
+    def GetAbsoluteChange(self) -> float:
+        if self.__optimization_problem.GetStep() > 0:
+            return self.GetStandardizedValue() / self.GetInitialValue() - 1.0 if abs(self.GetInitialValue()) > 1e-12 else self.GetStandardizedValue()
+        else:
+            return 0.0
+
+    def GetInfo(self) -> dict:
+        info = {
+            "name": self.GetReponse().GetName(),
+            "type": self.__objective_type,
+            "value": self.GetValue(),
+            "abs_change [%]": self.GetAbsoluteChange() * 100.0,
+            "rel_change [%]": self.GetRelativeChange() * 100.0
+        }
+        return info
+
+    def LogValues(self) -> None:
+        values_info = self.GetInfo()
+        if self.__buffered_data.HasValue("rel_change [%]"): del self.__buffered_data["rel_change [%]"]
+        self.__buffered_data["rel_change [%]"] = values_info["rel_change [%]"]
+        if self.__buffered_data.HasValue("abs_change [%]"): del self.__buffered_data["abs_change [%]"]
+        self.__buffered_data["abs_change [%]"] = values_info["abs_change [%]"]
+
+    def LogGradientFields(self) -> 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(self.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 LogOptimizationStep(self) -> None:
+        now = datetime.datetime.now()
+        now_str = now.strftime("%Y-%m-%d %H:%M:%S")
+        iteration_text = f" EoF Iteration {self.__optimization_problem.GetStep()}"
+        iteration_output = f"{'#'}  {iteration_text} [Time: {now_str}]  {'#'}"
+        divided_line = len(iteration_output) * '#'
+        to_print = f"{divided_line}\n{iteration_output}\n{divided_line}\n"
+        Kratos.Logger.PrintInfo(to_print)
+
+    def UpdateMasterControlAndLogFields(self, new_control_field: numpy.ndarray) -> bool:
+        master_control_updated = False
+        master_control = self.GetMasterControl()
+        control_change_norm = numpy.linalg.norm(master_control.GetControlField().Evaluate().reshape(-1)-new_control_field)
+        if control_change_norm > 1e-15:
+            # first out put the fields and update step
+            CallOnAll(self.__optimization_problem.GetListOfProcesses("output_processes"), Kratos.OutputProcess.PrintOutput)
+            self.LogOptimizationStep()
+            self.__optimization_problem.AdvanceStep()
+            # convert numpy array to tensor adaptor
+            new_control_field_cta = 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_cta.data[:] = new_control_field
+            Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor(new_control_field_cta, perform_store_data_recursively=False, copy=False).StoreData()
+            # now update the master control
+            master_control.Update(new_control_field_cta)
+            master_control_updated = True
+        return master_control_updated

KratosMultiphysics/OptimizationApplication/algorithms/standardized_SciPy_constraint.py

@@ -0,0 +1,123 @@
+import KratosMultiphysics as Kratos
+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 as np
+
+class StandardizedSciPyConstraint(ResponseRoutine):
+    """Standardized SciPy constraint response function
+
+    This class creates instances to create constraint routine that SciPy is required to handle constraints.
+
+
+    """
+
+    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" : "",
+            "upper_boundary"      : 1e16,
+            "lower_boundary"      :-1e16
+        }""")
+
+        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 objective requires 2 as minimum buffer size. [ response name = {self.GetResponseName()} ]")
+
+        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()
+
+        self.upper_bound = parameters["upper_boundary"].GetDouble()
+        self.lower_bound = parameters["lower_boundary"].GetDouble()
+
+    def CalculateStandardizedValue(self, x:np.array, save_data: bool = True) -> float:
+        control_field = self.GetMasterControl().GetEmptyField()
+        control_field.data[:] = x
+        Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor(control_field, perform_store_data_recursively=False, copy=False).StoreData()
+
+        with TimeLogger(f"StandardizedObjective::Calculate {self.GetResponseName()} value", None, "Finished"):
+            response_value = self.CalculateValue(control_field)
+            standardized_response_value = response_value
+
+            if not self.__unbuffered_data.HasValue("initial_value"):
+                self.__unbuffered_data["initial_value"] = response_value
+
+            if save_data:
+                if self.__buffered_data.HasValue("value"): del self.__buffered_data["value"]
+                self.__buffered_data["value"] = response_value
+
+                DictLogger("Constraint info",self.GetInfo())
+
+        return standardized_response_value
+
+    def GetValue(self, step_index: int = 0) -> float:
+        return self.__buffered_data.GetValue("value", step_index)
+
+    def GetStandardizedValue(self, step_index: int = 0) -> float:
+        return self.GetValue(step_index)
+
+    def CalculateStandardizedGradient(self, x:np.array, save_field: bool = True) -> np.array:
+
+        self.CalculateStandardizedValue(x, False)  # Compute new primal if x has changed. Does nothing if x the same.
+
+        with TimeLogger(f"StandardizedObjective::Calculate {self.GetResponseName()} gradients", None, "Finished"):
+            gradient_combined_tensor_adaptor = self.CalculateGradient()
+            if save_field:
+                # save the physical gradients for post processing in unbuffered data container.
+                for physical_var, physical_gradient in self.GetRequiredPhysicalGradients().items():
+                    for physical_gradient_ta in physical_gradient.GetTensorAdaptors():
+                        variable_name = f"d{self.GetResponseName()}_d{physical_var.Name()}"
+                        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.GetResponseName()}_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()
+
+        return gradient_combined_tensor_adaptor.data.reshape(-1)
+
+    def GetValue(self, step_index: int = 0) -> float:
+        return self.__buffered_data.GetValue("value", step_index)
+
+    def GetStandardizedValue(self, step_index: int = 0) -> float:
+        return self.GetValue(step_index) - self.GetStandardizedReferenceValue()
+
+    def GetUpperBound(self):
+        return self.upper_bound
+
+    def GetLowerBound(self):
+        return self.lower_bound
+
+    def GetInfo(self) -> dict:
+        info = {
+            "name": self.GetResponseName(),
+            "value": self.GetValue(),
+            "upper_bound": self.upper_bound,
+            "lower_bound": self.lower_bound
+        }
+        return info

KratosMultiphysics/OptimizationApplication/algorithms/standardized_SciPy_objective.py

@@ -0,0 +1,148 @@
+import KratosMultiphysics as Kratos
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem import OptimizationProblem
+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
+from KratosMultiphysics.OptimizationApplication.responses.response_routine import ResponseRoutine
+
+import numpy as np
+
+class StandardizedSciPyObjective(ResponseRoutine):
+    """Standardized SciPy objective response routine.
+
+    This class transformed a user-given optimization problem into the standard format.
+    Supported objective types:
+        "minimization",
+        "maximization"
+
+    """
+
+    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"               : "",
+            "scaling"            : 1.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 objective requires 2 as minimum buffer size. [ response name = {self.GetResponseName()} ]")
+
+        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()
+
+        self.computed = False
+
+        scaling = parameters["scaling"].GetDouble()
+        if scaling < 0.0:
+            raise RuntimeError(f"Scaling should be always positive [ given scale = {scaling}]")
+
+        self.__objective_type = parameters["type"].GetString()
+        if self.__objective_type == "minimization":
+            self.__scaling = scaling
+        elif self.__objective_type == "maximization":
+            self.__scaling = -scaling
+        else:
+            raise RuntimeError(f"Requesting unsupported type {self.__objective_type} for objective response function. Supported types are: \n\tminimization\n\tmaximization")
+
+    def GetInitialValue(self) -> float:
+        if self.__unbuffered_data.HasValue("initial_value"):
+            return self.__unbuffered_data["initial_value"] * self.__scaling
+        else:
+            raise RuntimeError(f"Response value for {self.GetResponseName()} is not calculated yet.")
+
+    def CalculateStandardizedValue(self, x:np.array, save_data: bool = True) -> float:
+
+        control_field = self.GetMasterControl().GetEmptyField()
+        control_field.data[:] = x
+        Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor(control_field, perform_store_data_recursively=False, copy=False).StoreData()
+
+        with TimeLogger(f"StandardizedObjective::Calculate {self.GetResponseName()} value", None, "Finished"):
+            response_value = self.CalculateValue(control_field)
+            standardized_response_value = response_value * self.__scaling
+
+            if not self.__unbuffered_data.HasValue("initial_value"):
+                self.__unbuffered_data["initial_value"] = response_value
+
+            if save_data:
+
+                if self.__buffered_data.HasValue("value"): del self.__buffered_data["value"]
+                self.__buffered_data["value"] = response_value
+                self.computed = True
+
+                DictLogger("Objective info",self.GetInfo())
+
+        return standardized_response_value
+
+    def GetValue(self, step_index: int = 0) -> float:
+        return self.__buffered_data.GetValue("value", step_index)
+
+    def GetStandardizedValue(self, step_index: int = 0) -> float:
+        return self.GetValue(step_index) * self.__scaling
+
+    def CalculateStandardizedGradient(self, x:np.array, save_field: bool = True) -> np.array:
+
+        self.CalculateStandardizedValue(x, False)  # Compute new primal if x has changed. Does nothing if x the same
+
+        with TimeLogger(f"StandardizedObjective::Calculate {self.GetResponseName()} gradients", None, "Finished"):
+            gradient_combined_tensor_adaptor = self.CalculateGradient()
+            if save_field:
+                # save the physical gradients for post processing in unbuffered data container.
+                for physical_var, physical_gradient in self.GetRequiredPhysicalGradients().items():
+                    for physical_gradient_ta in physical_gradient.GetTensorAdaptors():
+                        variable_name = f"d{self.GetResponseName()}_d{physical_var.Name()}"
+                        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.GetResponseName()}_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()
+
+        return gradient_combined_tensor_adaptor.data.reshape(-1) * self.__scaling
+
+    def GetRelativeChange(self) -> float:
+        if self.__optimization_problem.GetStep() > 0:
+            return self.GetStandardizedValue() / self.GetStandardizedValue(1) - 1.0 if abs(self.GetStandardizedValue(1)) > 1e-12 else self.GetStandardizedValue()
+        else:
+            return 0.0
+
+    def GetAbsoluteChange(self) -> float:
+        return self.GetValue() - self.GetInitialValue()
+
+    def GetInfo(self) -> dict:
+        info = {
+            "name": self.GetResponseName(),
+            "type": self.__objective_type,
+            "value": self.GetValue(),
+            "std_value": self.GetStandardizedValue(),
+            "abs_change": self.GetAbsoluteChange(),
+            "rel_change [%]": self.GetRelativeChange() * 100.0
+        }
+        init_value = self.GetInitialValue()
+        if init_value:
+            info["abs_change [%]"] = self.GetAbsoluteChange()/init_value * 100
+
+        return info

KratosMultiphysics/OptimizationApplication/algorithms/standardized_constraint.py

@@ -0,0 +1,180 @@
+import KratosMultiphysics as Kratos
+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
+
+class StandardizedConstraint(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"                : "",
+            "scaling"             : 1.0,
+            "violation_scaling"   : 1.0,
+            "scaled_ref_value"    : "initial_value"
+        }""")
+
+        if parameters.Has("scaled_ref_value") and parameters["scaled_ref_value"].IsDouble():
+            default_parameters["scaled_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 objective requires 2 as minimum buffer size. [ response name = {self.GetResponseName()} ]")
+
+        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()
+
+        scaling = parameters["scaling"].GetDouble()
+        if scaling < 0.0:
+            raise RuntimeError(f"Scaling should be always positive [ given scale = {scaling}]")
+
+        if parameters["scaled_ref_value"].IsDouble():
+            self.__ref_type = "specified_value"
+            self.__reference_value = parameters["scaled_ref_value"].GetDouble()
+        elif parameters["scaled_ref_value"].IsString() and parameters["scaled_ref_value"].GetString() == "initial_value":
+            self.__ref_type = "initial_value"
+            self.__reference_value = None
+        else:
+            raise RuntimeError(f"Provided \"reference_type\" = {self.__ref_type} is not supported for constraint response functions. Followings are supported options: \n\tinitial_value\n\tfloat value")
+
+        self.__violation_scaling = parameters["violation_scaling"].GetDouble()
+        self.__constraint_type = parameters["type"].GetString()
+        if self.__constraint_type in ["<=", "="]:
+            self.__scaling = scaling
+        elif self.__constraint_type in [">="]:
+            self.__scaling = -scaling
+            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<\n\t>=\n\t>")
+
+    def IsEqualityType(self) -> str:
+        return self.__constraint_type == "="
+
+    def GetStandardizedReferenceValue(self) -> float:
+        if self.__reference_value is not None:
+            return self.__reference_value
+        else:
+            if self.__unbuffered_data.HasValue("initial_value"):
+                return self.__unbuffered_data["initial_value"] * self.__scaling
+            else:
+                raise RuntimeError(f"Response value for {self.GetResponseName()} is not calculated yet.")
+
+    def CalculateStandardizedValue(self, control_field: Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor, save_value: bool = True) -> float:
+        with TimeLogger(f"StandardizedConstraint::Calculate {self.GetResponseName()} value", None, "Finished"):
+            response_value = self.CalculateValue(control_field)
+            standardized_response_value = response_value * self.__scaling
+
+            if not self.__unbuffered_data.HasValue("initial_value"):
+                self.__unbuffered_data["initial_value"] = response_value
+
+            standardized_response_value -= self.GetStandardizedReferenceValue()
+
+            if save_value:
+                if self.__buffered_data.HasValue("value"): del self.__buffered_data["value"]
+                if self.__buffered_data.HasValue("std_value"): del self.__buffered_data["std_value"]
+                self.__buffered_data["value"] = response_value
+                self.__buffered_data["std_value"] = standardized_response_value
+
+            DictLogger("Constraint info",self.GetInfo())
+
+        return standardized_response_value
+
+    def IsActive(self):
+        return self.GetStandardizedValue() > 0.0
+
+    def CalculateStandardizedGradient(self, save_field: bool = True) -> Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor:
+
+        with TimeLogger(f"StandardizedConstraint::Calculate {self.GetResponseName()} gradients", None, "Finished"):
+            gradient_cta = self.CalculateGradient()
+            if save_field:
+                # 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.GetResponseName()}_d{physical_var.Name()}"
+                    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] = Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor(physical_gradient)
+
+                # save the filtered gradients for post processing in unbuffered data container.
+                for gradient_ta, control in zip(gradient_cta.GetTensorAdaptors(), self.GetMasterControl().GetListOfControls()):
+                    variable_name = f"d{self.GetResponseName()}_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] = Kratos.TensorAdaptors.DoubleTensorAdaptor(gradient_ta)
+
+        gradient_cta.data[:] *= self.__scaling
+        Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor(gradient_cta, perform_store_data_recursively=False, copy=False).StoreData()
+        return gradient_cta
+
+    def GetValue(self, step_index: int = 0) -> float:
+        return self.__buffered_data.GetValue("value", step_index)
+
+    def GetStandardizedValue(self, step_index: int = 0) -> float:
+        return self.GetValue(step_index) * self.__scaling - self.GetStandardizedReferenceValue()
+
+    def GetScaledViolationValue(self, step_index: int = 0) -> float:
+        value = self.GetStandardizedValue(step_index)
+        return max(0.0, value * self.__violation_scaling)
+
+    def GetAbsoluteViolation(self, step_index: int = 0) -> float:
+        is_violated = self.IsEqualityType() or self.GetStandardizedValue(step_index) >= 0.0
+        return self.GetStandardizedValue(step_index) * is_violated
+
+    def GetRelativeViolation(self, step_index: int = 0) -> float:
+        return self.GetAbsoluteViolation(step_index) / self.GetStandardizedReferenceValue() if abs(self.GetStandardizedReferenceValue()) > 1e-12 else self.GetAbsoluteViolation(step_index)
+
+    def GetRelativeChange(self) -> float:
+        if self.__optimization_problem.GetStep() > 1:
+            return self.GetStandardizedValue() / self.GetStandardizedValue(1) - 1.0 if abs(self.GetStandardizedValue(1)) > 1e-12 else self.GetStandardizedValue()
+        else:
+            return 0.0
+
+    def GetAbsoluteChange(self) -> float:
+        return self.GetStandardizedValue() / self.GetStandardizedReferenceValue() - 1.0 if abs(self.GetStandardizedReferenceValue()) > 1e-12 else self.GetStandardizedValue()
+
+    def GetInfo(self) -> dict:
+        info = {
+            "name": self.GetResponseName(),
+            "value": self.GetValue(),
+            "scaled_value": self.GetValue() * abs(self.__scaling),
+            "type": self.__constraint_type,
+            "ref_value": self.GetStandardizedReferenceValue(),
+            "abs_change": self.GetAbsoluteChange(),
+            "rel_change [%]": self.GetRelativeChange() * 100.0,
+            "abs_violation [%]": self.GetAbsoluteViolation() * 100,
+            "rel_violation [%]": self.GetRelativeViolation() * 100.0
+        }
+        return info