KratosOptimizationApplication 10.4.4__py3-none-any.whl

KratosMultiphysics/OptimizationApplication/controls/thickness/shell_thickness_control.py

@@ -0,0 +1,180 @@
+import numpy
+from typing import Optional
+
+import KratosMultiphysics as Kratos
+import KratosMultiphysics.OptimizationApplication as KratosOA
+from KratosMultiphysics.OptimizationApplication.controls.control import Control
+from KratosMultiphysics.OptimizationApplication.utilities.union_utilities import SupportedSensitivityFieldVariableTypes
+from KratosMultiphysics.OptimizationApplication.utilities.model_part_utilities import ModelPartOperation
+from KratosMultiphysics.OptimizationApplication.utilities.logger_utilities import TimeLogger
+from KratosMultiphysics.OptimizationApplication.utilities.component_data_view import ComponentDataView
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem import OptimizationProblem
+from KratosMultiphysics.OptimizationApplication.filtering.filter import Factory as FilterFactory
+from KratosMultiphysics.OptimizationApplication.utilities.opt_projection import CreateProjection
+
+def Factory(model: Kratos.Model, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem) -> Control:
+    if not parameters.Has("name"):
+        raise RuntimeError(f"ShellThicknessControl instantiation requires a \"name\" in parameters [ parameters = {parameters}].")
+    if not parameters.Has("settings"):
+        raise RuntimeError(f"ShellThicknessControl instantiation requires a \"settings\" in parameters [ parameters = {parameters}].")
+
+    return ShellThicknessControl(parameters["name"].GetString(), model, parameters["settings"], optimization_problem)
+
+class ShellThicknessControl(Control):
+    """Shell thickness control
+
+    This is filtering-based discrete thickness control which parametrizes and controls
+    shell elements thickness.
+
+    """
+    def __init__(self, name: str, model: Kratos.Model, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem):
+        super().__init__(name)
+
+        self.parameters = parameters
+        self.model = model
+        self.optimization_problem = optimization_problem
+
+        default_settings = Kratos.Parameters("""{
+            "controlled_model_part_names"       : [],
+            "filter_settings"                   : {},
+            "output_all_fields"                 : false,
+            "physical_thicknesses"              : [],
+            "consider_recursive_property_update": false,
+            "thickness_projection_settings": {}
+        }""")
+
+        self.parameters.ValidateAndAssignDefaults(default_settings)
+
+        controlled_model_names_parts = parameters["controlled_model_part_names"].GetStringArray()
+        if len(controlled_model_names_parts) == 0:
+            raise RuntimeError(f"No model parts were provided for ShellThicknessControl. [ control name = \"{self.GetName()}\"]")
+
+        self.model_part_operation = ModelPartOperation(self.model, ModelPartOperation.OperationType.UNION, f"control_{self.GetName()}", self.parameters["controlled_model_part_names"].GetStringArray(), False)
+        self.model_part: 'Optional[Kratos.ModelPart]' = None
+
+        self.filter = FilterFactory(self.model, self.model_part_operation.GetModelPartFullName(), Kratos.THICKNESS, Kratos.Globals.DataLocation.Element, self.parameters["filter_settings"])
+
+        self.output_all_fields = self.parameters["output_all_fields"].GetBool()
+        self.physical_thicknesses = self.parameters["physical_thicknesses"].GetVector()
+
+        self.thickness_projection = CreateProjection(parameters["thickness_projection_settings"], self.optimization_problem)
+
+        self.consider_recursive_property_update = parameters["consider_recursive_property_update"].GetBool()
+
+        num_phys_thick = len(self.physical_thicknesses)
+        if num_phys_thick == 0:
+            raise RuntimeError("The physical_thicknesses can not be empty, at least min and max should be provided.")
+        self.filtered_thicknesses = [i for i, _ in enumerate(self.physical_thicknesses)]
+
+    def Initialize(self) -> None:
+        self.model_part = self.model_part_operation.GetModelPart()
+
+        if not KratosOA.OptAppModelPartUtils.CheckModelPartStatus(self.model_part, "element_specific_properties_created"):
+            KratosOA.OptimizationUtils.CreateEntitySpecificPropertiesForContainer(self.model_part, self.model_part.Elements, self.consider_recursive_property_update)
+            KratosOA.OptAppModelPartUtils.LogModelPartStatus(self.model_part, "element_specific_properties_created")
+
+        # initialize the filter
+        self.filter.SetComponentDataView(ComponentDataView(self, self.optimization_problem))
+        self.filter.Initialize()
+
+        # initialize the projections
+        self.thickness_projection.SetProjectionSpaces(self.filtered_thicknesses, self.physical_thicknesses)
+
+        physical_thickness_field = KratosOA.TensorAdaptors.PropertiesVariableTensorAdaptor(self.model_part.Elements, Kratos.THICKNESS)
+        physical_thickness_field.CollectData()
+
+        # project backward the uniform physical control field and assign it to the control field
+        self.physical_phi_field = self.thickness_projection.ProjectBackward(physical_thickness_field)
+
+        # take the physical and control field the same
+        self.control_phi_field = self.filter.UnfilterField(self.physical_phi_field)
+
+        # now update the physical thickness field
+        self._UpdateAndOutputFields(self.GetEmptyField())
+
+    def Check(self) -> None:
+        self.filter.Check()
+
+    def Finalize(self) -> None:
+        self.filter.Finalize()
+
+    def GetPhysicalKratosVariables(self) -> 'list[SupportedSensitivityFieldVariableTypes]':
+        return [Kratos.THICKNESS]
+
+    def GetEmptyField(self) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        field = Kratos.TensorAdaptors.VariableTensorAdaptor(self.model_part.Elements, Kratos.THICKNESS)
+        field.data[:] = 0.0
+        return field
+
+    def GetControlField(self) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        return self.control_phi_field.Clone()
+
+    def GetPhysicalField(self) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        physical_thickness_field = KratosOA.TensorAdaptors.PropertiesVariableTensorAdaptor(self.model_part.Elements, Kratos.THICKNESS)
+        physical_thickness_field.CollectData()
+        return physical_thickness_field
+
+    def MapGradient(self, physical_variable_gradient_map: 'dict[SupportedSensitivityFieldVariableTypes, Kratos.TensorAdaptors.DoubleTensorAdaptor]') -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        with TimeLogger("ShellThicknessControl::MapGradient", None, "Finished",False):
+            keys = physical_variable_gradient_map.keys()
+            if len(keys) != 1:
+                raise RuntimeError(f"Provided more than required gradient fields for control \"{self.GetName()}\". Following are the variables:\n\t" + "\n\t".join([k.Name() for k in keys]))
+            if Kratos.THICKNESS not in keys:
+                raise RuntimeError(f"The required gradient for control \"{self.GetName()}\" w.r.t. {Kratos.THICKNESS.Name()} not found. Followings are the variables:\n\t" + "\n\t".join([k.Name() for k in keys]))
+
+            physical_gradient = physical_variable_gradient_map[Kratos.THICKNESS]
+            if physical_gradient.GetContainer() != self.model_part.Elements:
+                raise RuntimeError(f"Gradients for the required element container not found for control \"{self.GetName()}\". [ required model part name: {self.model_part.FullName()}, given model part name: {physical_gradient.GetModelPart().FullName()} ]")
+
+            # multiply the physical sensitivity field with projection derivatives
+            projected_gradient = Kratos.TensorAdaptors.DoubleTensorAdaptor(physical_gradient)
+            projected_gradient.data = physical_gradient.data * self.projection_derivative_field.data
+            # now filter the field
+            filtered_gradient = self.filter.BackwardFilterIntegratedField(projected_gradient)
+
+            return filtered_gradient
+
+    def Update(self, new_control_field: Kratos.TensorAdaptors.DoubleTensorAdaptor) -> bool:
+        if new_control_field.GetContainer() != self.model_part.Elements:
+            raise RuntimeError(f"Updates for the required element container not found for control \"{self.GetName()}\". [ required model part name: {self.model_part.FullName()}, given model part name: {new_control_field.GetModelPart().FullName()} ]")
+
+        update = Kratos.TensorAdaptors.DoubleTensorAdaptor(new_control_field)
+        update.data[:] = new_control_field.data - self.control_phi_field.data
+        if numpy.linalg.norm(update.data) > 1e-15:
+            with TimeLogger(self.__class__.__name__, f"Updating {self.GetName()}...", f"Finished updating of {self.GetName()}.",False):
+                # update the control thickness field
+                self.control_phi_field = new_control_field.Clone()
+                # now update the physical field
+                self._UpdateAndOutputFields(update)
+                self.thickness_projection.Update()
+                return True
+
+        self.thickness_projection.Update()
+        return False
+
+    def _UpdateAndOutputFields(self, update: Kratos.TensorAdaptors.DoubleTensorAdaptor) -> None:
+        # filter the control field
+        filtered_thickness_field_update = self.filter.ForwardFilterField(update)
+        self.physical_phi_field.data += filtered_thickness_field_update.data
+
+        # project forward the filtered thickness field
+        projected_filtered_thickness_field = self.thickness_projection.ProjectForward(self.physical_phi_field)
+        # now update physical field
+        KratosOA.TensorAdaptors.PropertiesVariableTensorAdaptor(projected_filtered_thickness_field, Kratos.THICKNESS, copy=False).StoreData()
+        if self.consider_recursive_property_update:
+            KratosOA.OptimizationUtils.UpdatePropertiesVariableWithRootValueRecursively(projected_filtered_thickness_field.GetContainer(), Kratos.THICKNESS)
+
+        # compute and store projection derivatives for consistent filtering of the sensitivities
+        self.projection_derivative_field = self.thickness_projection.ForwardProjectionGradient(self.physical_phi_field)
+
+        # now output the fields
+        un_buffered_data = ComponentDataView(self, self.optimization_problem).GetUnBufferedData()
+        un_buffered_data.SetValue("physical_thickness", projected_filtered_thickness_field,overwrite=True)
+        if self.output_all_fields:
+            un_buffered_data.SetValue("filtered_thickness_update", filtered_thickness_field_update, overwrite=True)
+            un_buffered_data.SetValue("control_thickness_phi", self.control_phi_field.Clone(), overwrite=True)
+            un_buffered_data.SetValue("physical_thickness_phi", self.physical_phi_field.Clone(), overwrite=True)
+            un_buffered_data.SetValue("projection_derivative", self.projection_derivative_field.Clone(), overwrite=True)
+
+    def __str__(self) -> str:
+        return f"Control [type = {self.__class__.__name__}, name = {self.GetName()}, model part name = {self.model_part.FullName()}, control variable = {Kratos.THICKNESS.Name()}"

KratosMultiphysics/OptimizationApplication/controls_controller.py

@@ -0,0 +1,205 @@
+# ==============================================================================
+#  KratosOptimizationApplication
+#
+#  License:         BSD License
+#                   license: OptimizationApplication/license.txt
+#
+#  Main authors:    Reza Najian Asl, https://github.com/RezaNajian
+#
+# ==============================================================================
+
+# additional imports
+import KratosMultiphysics as KM 
+import KratosMultiphysics.OptimizationApplication.controls.shape.explicit_vertex_morphing as evm
+import KratosMultiphysics.OptimizationApplication.controls.shape.implicit_vertex_morphing as ivm
+import KratosMultiphysics.OptimizationApplication.controls.thickness.helmholtz_thickness as hlt
+import KratosMultiphysics.OptimizationApplication.controls.material.helmholtz_material as hlm
+import KratosMultiphysics.OptimizationApplication.controls.material.helmholtz_partition as hlp
+
+# ==============================================================================
+def CreateController(controls_settings,model,model_parts_controller):
+    return ControlsController(controls_settings,model,model_parts_controller)
+
+# ==============================================================================
+class ControlsController:
+    # --------------------------------------------------------------------------
+    def __init__(self,controls_settings,model,model_parts_controller):
+        
+        self.controls_settings = controls_settings
+        self.model_parts_controller = model_parts_controller
+        self.model = model
+
+        default_settings = KM.Parameters("""
+        {
+            "name"       : "CONTROL_NAME",
+            "type"       : "CONTROL_TYPE",
+            "settings"       : {
+                "technique"  : "CONTROL_TECHNIQUE",
+                "technique_settings"       : {},
+                "controlling_objects"  : []             
+            }
+        }""")
+
+
+        for itr in range(self.controls_settings.size()):
+            for key in default_settings.keys():
+                if not self.controls_settings[itr].Has(key):
+                    raise RuntimeError("ControlsController: Required setting '{}' missing in 'control Nr.{}'!".format(key,itr+1))  
+            self.controls_settings[itr].ValidateAndAssignDefaults(default_settings)
+            for key in default_settings["settings"].keys():
+                if not self.controls_settings[itr]["settings"].Has(key):
+                    raise RuntimeError("ControlsController: Required setting '{}' missing in 'settings' of 'control Nr.{}' !".format(key,itr+1))             
+            self.controls_settings[itr]["settings"].ValidateAndAssignDefaults(default_settings["settings"])  
+
+
+        self.supported_control_types_techniques = {"shape":["explicit_vertex_morphing","implicit_vertex_morphing"],"material":["helmholtz_material","helmholtz_partition"],"thickness":["helmholtz_thickness"]}
+        # sanity checks
+        self.controls_types_vars_dict = {"shape":[],"material":[],"thickness":[]}
+        self.controls = {}
+        self.controls_type = {}
+        self.controls_controlling_objects = {}
+        for itr in range(self.controls_settings.size()):
+            control_settings = self.controls_settings[itr]
+            
+            # check for name
+            control_name = control_settings["name"].GetString()
+            if  control_name in self.controls.keys():  
+                raise RuntimeError("ControlsController: Control name {} already exists.".format(control_name))            
+            # check control type
+            control_type = control_settings["type"].GetString()
+            if not control_type in self.supported_control_types_techniques.keys():
+                raise RuntimeError("ControlsController: control type '{}' in control {} is not supported!, we support {} ".format(control_type,control_name,self.supported_control_types_techniques))
+            self.controls_type[control_name] = control_type              
+            # check control technique
+            control_technique = control_settings["settings"]["technique"].GetString()
+            if not control_technique in self.supported_control_types_techniques[control_type]:
+                raise RuntimeError("ControlsController: control technique '{}' for control type {} in control {} is not supported!, we support {}".format(control_technique,control_type,control_name,self.supported_control_types_techniques))
+
+            # check for repetitious control over variables
+            control_controlling_objects_list = control_settings["settings"]["controlling_objects"].GetStringArray()
+            control_controlling_objects_list_set = set(control_controlling_objects_list)
+            if len(control_controlling_objects_list_set) != len(control_controlling_objects_list):
+                raise RuntimeError("ControlsController: control '{}' has duplicated control variables!".format(control_name))
+            if control_controlling_objects_list_set.issubset(set(self.controls_types_vars_dict[control_type])):
+                raise RuntimeError("ControlsController: there are duplicated {} control over {}!".format(control_type,control_controlling_objects_list))
+            if control_name in self.controls.keys():
+                raise RuntimeError("ControlsController: control name {} is duplicated !",control_name) 
+            self.controls_controlling_objects[control_name] = control_controlling_objects_list
+
+            # check if root model parts exist
+            self.model_parts_controller.CheckIfRootModelPartsExist(control_controlling_objects_list,True)
+
+            # now checks passed and create the control
+            if control_type == "shape":
+                if control_technique == "explicit_vertex_morphing":
+                    control = evm.ExplicitVertexMorphing(control_name,model,control_settings["settings"])   
+                elif control_technique == "implicit_vertex_morphing":
+                    control = ivm.ImplicitVertexMorphing(control_name,model,control_settings["settings"])  
+            elif control_type == "thickness":
+                if control_technique == "helmholtz_thickness":
+                    control = hlt.HelmholtzThickness(control_name,model,control_settings["settings"])    
+            elif control_type == "material":
+                if control_technique == "helmholtz_material":
+                    control = hlm.HelmholtzMaterial(control_name,model,control_settings["settings"])     
+                elif control_technique == "helmholtz_partition":
+                    control = hlp.HelmholtzPartition(control_name,model,control_settings["settings"])                                                      
+
+            self.controls[control_name] = control
+            self.controls_types_vars_dict[control_type].extend(control_controlling_objects_list)
+                            
+    # --------------------------------------------------------------------------
+    def Initialize(self):
+        for key,value in self.controls.items():
+            value.Initialize()
+
+    # --------------------------------------------------------------------------
+    def ControlMapFirstDerivative(self,control_name,derivative_name,mapped_derivative_name,raise_error=True):
+        if raise_error:
+            if not control_name in self.controls.keys():
+                raise RuntimeError("ControlsController:ControlMapFirstDerivative: Control {} does not exist.".format(control_name))
+
+        self.controls[control_name].MapFirstDerivative(derivative_name,mapped_derivative_name)
+
+    # --------------------------------------------------------------------------
+    def CheckIfControlExists(self,control_name,raise_error=True):
+        if not control_name in self.controls.keys():
+            if raise_error:
+                raise RuntimeError("ControlsController:CheckIfControlExists: Control {} does not exist.".format(control_name))
+            else: 
+                return False
+        else:
+            return True
+    # --------------------------------------------------------------------------
+    def CheckIfControlsExist(self,controls_name,raise_error=True):
+        if type(controls_name) is not list:
+            raise RuntimeError("ControlsController:CheckIfControlsExist requires list of control names")
+        
+        if_exist = True
+        for control_name in controls_name:
+            if not control_name in self.controls.keys():
+                if raise_error:
+                    raise RuntimeError("ControlsController:CheckIfControlsExist: Control {} does not exist!".format(control_name))
+                else:
+                    if_exist = False
+                    break
+        return if_exist      
+
+    # --------------------------------------------------------------------------
+    def GetControlType(self,control_name,raise_error=True):
+        if not control_name in self.controls_type.keys():
+            if raise_error:
+                raise RuntimeError("ControlsController:GetControlType: Control {} does not exist.".format(control_name))
+        else:
+            return self.controls_type[control_name]           
+    # --------------------------------------------------------------------------
+    def GetControlVariableName(self,control_name,raise_error=True):
+        if not control_name in self.controls_type.keys():
+            if raise_error:
+                raise RuntimeError("ControlsController:GetControlVariableName: Control {} does not exist.".format(control_name))
+        else:
+            return self.controls[control_name].GetVariableName() 
+    # --------------------------------------------------------------------------
+    def GetControlUpdateName(self,control_name,raise_error=True):
+        if not control_name in self.controls_type.keys():
+            if raise_error:
+                raise RuntimeError("ControlsController:GetControlUpdateName: Control {} does not exist.".format(control_name))
+        else:
+            return self.controls[control_name].GetUpdateName()  
+    # --------------------------------------------------------------------------
+    def GetControlOutputNames(self,control_name,raise_error=True):
+        if not control_name in self.controls_type.keys():
+            if raise_error:
+                raise RuntimeError("ControlsController:GetControlOutputNames: Control {} does not exist.".format(control_name))
+        else:
+            return self.controls[control_name].GetOutputNames() 
+    # --------------------------------------------------------------------------
+    def GetControlControllingObjects(self,control_name,raise_error=True):
+        if raise_error:
+            if not control_name in self.controls_controlling_objects.keys():
+                raise RuntimeError("ControlsController:GetControlControllingObjects: Control {} does not exist.".format(control_name))
+       
+        return self.controls[control_name].GetControllingObjects()            
+
+    # --------------------------------------------------------------------------
+    def MapControlFirstDerivative(self, control_name, derivative_variable_name, mapped_derivative_variable_name, raise_error=True):   
+        if raise_error:
+            if not control_name in self.controls_controlling_objects.keys():
+                raise RuntimeError("ControlsController:MapControlFirstDerivative: Control {} does not exist.".format(control_name)) 
+
+        self.controls[control_name].MapFirstDerivative(derivative_variable_name,mapped_derivative_variable_name)       
+
+    # --------------------------------------------------------------------------
+    def UpdateControl(self, control_name, raise_error=True):   
+        if raise_error:
+            if not control_name in self.controls_controlling_objects.keys():
+                raise RuntimeError("ControlsController:UpdateControl: Control {} does not exist.".format(control_name)) 
+
+        self.controls[control_name].Update()  
+
+    # --------------------------------------------------------------------------
+    def ComputeControl(self, control_name, raise_error=True):   
+        if raise_error:
+            if not control_name in self.controls_controlling_objects.keys():
+                raise RuntimeError("ControlsController:ComputeControl: Control {} does not exist.".format(control_name)) 
+
+        self.controls[control_name].Compute()          

KratosMultiphysics/OptimizationApplication/convergence_criteria/avg_abs_improvement_conv_criterion.py

@@ -0,0 +1,98 @@
+import typing
+import numpy
+import KratosMultiphysics as Kratos
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem import OptimizationProblem
+from KratosMultiphysics.OptimizationApplication.utilities.component_data_view import ComponentDataView
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem_utilities import GetComponentHavingDataByFullName
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem_utilities import GetComponentValueByFullName
+from KratosMultiphysics.OptimizationApplication.convergence_criteria.convergence_criterion import ConvergenceCriterion
+from KratosMultiphysics.OptimizationApplication.utilities.logger_utilities import time_decorator
+
+def Factory(_: Kratos.Model, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem) -> ConvergenceCriterion:
+    if not parameters.Has("settings"):
+        raise RuntimeError(f"AvgAbsImprovementConvCriterion instantiation requires a \"settings\" in parameters [ parameters = {parameters}].")
+    return AvgAbsImprovementConvCriterion(parameters["settings"], optimization_problem)
+
+class AvgAbsImprovementConvCriterion(ConvergenceCriterion):
+    """
+    AvgAbsImprovementConvCriterion is a convergence criterion for optimization algorithms that checks
+    whether the average absolute improvement of a tracked value over a specified number of iterations
+    falls below a given tolerance.
+    """
+    @classmethod
+    def GetDefaultParameters(cls):
+        return Kratos.Parameters("""{
+            "component_name": "algorithm",
+            "value_name"    : "std_obj_value",
+            "tracked_iter"  : 5,
+            "tolerance"     : 1e-6
+        }""")
+
+    def __init__(self, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem):
+        parameters.ValidateAndAssignDefaults(self.GetDefaultParameters())
+
+        self.__component_name = parameters["component_name"].GetString()
+        self.__value_name = parameters["value_name"].GetString()
+        self.__tolerance = parameters["tolerance"].GetDouble()
+        self.__tracked_iter = parameters["tracked_iter"].GetInt()
+        self.__optimization_problem = optimization_problem
+        self.__component_data_view: 'typing.Optional[ComponentDataView]' = None
+
+        if self.__value_name.find(":") == -1:
+            # not found where the data location. So the default for value names
+            # will be buffered (i.e. historical). So appending it
+            self.__value_name += ":historical"
+
+        if self.__tolerance < 0.0:
+            raise RuntimeError(f"Tolerance should be non-negative [ tolerance = {self.__tolerance} ].")
+
+        if self.__tracked_iter <= 2:
+            raise RuntimeError(f"The tracked_iter value must be greater than 2 [ tracked_iter = {self.__tracked_iter} ].")
+
+        self.__abs_value_change = numpy.zeros(self.__tracked_iter - 1)
+
+    def Initialize(self):
+        component = GetComponentHavingDataByFullName(self.__component_name, self.__optimization_problem)
+        self.__component_data_view = ComponentDataView(component, self.__optimization_problem)
+
+    @time_decorator()
+    def IsConverged(self) -> bool:
+        step = self.__optimization_problem.GetStep()
+        value = GetComponentValueByFullName(self.__component_data_view, self.__value_name)
+
+        if not isinstance(value, float) and not isinstance(value, int):
+            raise RuntimeError(f"The value represented by {self.__value_name} is not a floating or int value.")
+
+        if step == 0:
+            self.__init_value = value
+            self.__value = 0.0
+            self.__conv = False
+        elif step > 0:
+            prev_value = GetComponentValueByFullName(self.__component_data_view, self.__value_name, 1)
+            self.__abs_value_change[step % (self.__tracked_iter - 1)] = ((value - prev_value) / self.__init_value)
+
+            if step >= self.__tracked_iter - 1:
+                self.__value = numpy.abs(numpy.sum(self.__abs_value_change)) / (self.__tracked_iter - 1)
+                self.__conv = self.__value <= self.__tolerance
+            else:
+                self.__value = numpy.abs(numpy.sum(self.__abs_value_change)) / step
+                self.__conv = False
+
+        self.__component_data_view.GetBufferedData().SetValue(f"{self.__value_name.split(':')[0]}_avg_abs_{self.__tracked_iter}_itr", self.__value)
+
+        return self.__conv
+
+    def Finalize(self):
+        pass
+
+    def GetInfo(self) -> 'list[tuple[str, typing.Union[int, float, str]]]':
+        info = [
+                    ('type'          , 'avg_abs_improvement_conv_criterion'),
+                    ('avg_value'     , self.__value),
+                    ('tracked_iter'  , self.__tracked_iter),
+                    ('tolerance'     , self.__tolerance),
+                    ('component_name', self.__component_name),
+                    ('value_name'    , self.__value_name),
+                    ('status'        , str("converged" if self.__conv else "not converged"))
+                ]
+        return info

KratosMultiphysics/OptimizationApplication/convergence_criteria/combined_conv_criterion.py

@@ -0,0 +1,87 @@
+import typing
+import KratosMultiphysics as Kratos
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem import OptimizationProblem
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem_utilities import OptimizationComponentFactory
+from KratosMultiphysics.OptimizationApplication.convergence_criteria.convergence_criterion import ConvergenceCriterion
+
+def Factory(model: Kratos.Model, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem) -> ConvergenceCriterion:
+    if not parameters.Has("settings"):
+        raise RuntimeError(f"CombinedConvCriterion instantiation requires a \"settings\" in parameters [ parameters = {parameters}].")
+    return CombinedConvCriterion(model, parameters["settings"], optimization_problem)
+
+class CombinedConvCriterion(ConvergenceCriterion):
+    """
+    CombinedConvCriterion is a convergence criterion that combines multiple sub-criteria using a logical operator ("and" or "or").
+    It evaluates convergence by applying the specified operator to the results of its sub-criteria.
+
+    Args:
+        model (Kratos.Model): The Kratos model instance.
+        parameters (Kratos.Parameters): Parameters specifying the operator and the list of sub-criteria.
+        optimization_problem (OptimizationProblem): The optimization problem instance.
+
+    Raises:
+        RuntimeError: If an unsupported operator is specified or if the list of sub-criteria is empty.
+    """
+    @classmethod
+    def GetDefaultParameters(cls):
+        return Kratos.Parameters("""{
+            "operator"                    : "",
+            "list_of_convergence_criteria": []
+        }""")
+
+    def __init__(self, model: Kratos.Model, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem):
+        default_params = self.GetDefaultParameters()
+
+        parameters.ValidateAndAssignDefaults(default_params)
+
+        self.__operator = parameters["operator"].GetString()
+        if self.__operator not in ["and", "or"]:
+            raise RuntimeError(f"Unsupported operator = \"{self.__operator}\". Followings are supported:\n\tand\n\tor")
+
+        self.__list_of_convergence_criteria: 'list[ConvergenceCriterion]' = []
+        default_sub_conv_settings = Kratos.Parameters("""{
+            "type"    : "",
+            "module"  : "KratosMultiphysics.OptimizationApplication.convergence_criteria",
+            "settings": {}
+        }""")
+        for sub_convergence_params in parameters["list_of_convergence_criteria"].values():
+            sub_convergence_params.ValidateAndAssignDefaults(default_sub_conv_settings)
+            self.__list_of_convergence_criteria.append(OptimizationComponentFactory(model, sub_convergence_params, optimization_problem))
+
+    def Add(self, convergence_criterion: ConvergenceCriterion) -> None:
+        self.__list_of_convergence_criteria.append(convergence_criterion)
+
+    def Initialize(self):
+        if len(self.__list_of_convergence_criteria) == 0:
+            raise RuntimeError("An empty combined convergence criteria is not allowed.")
+
+        for conv in self.__list_of_convergence_criteria:
+            conv.Initialize()
+
+    def IsConverged(self) -> bool:
+        if self.__operator == "and":
+            self.__conv = all([conv.IsConverged()  for conv in self.__list_of_convergence_criteria])
+        elif self.__operator == "or":
+            self.__conv = any([conv.IsConverged()  for conv in self.__list_of_convergence_criteria])
+        return self.__conv
+
+    def Finalize(self):
+        for conv in self.__list_of_convergence_criteria:
+            conv.Finalize()
+
+    def GetInfo(self) -> 'list[tuple[str, typing.Union[int, float, str]]]':
+        info = []
+        if len(self.__list_of_convergence_criteria) > 1:
+            info.append(("(", ""))
+
+        info.extend(self.__list_of_convergence_criteria[0].GetInfo())
+
+        for conv in self.__list_of_convergence_criteria[1:]:
+            info.append((f"--- {self.__operator} ---", ""))
+            info.extend(conv.GetInfo())
+
+        if len(self.__list_of_convergence_criteria) > 1:
+            info.append((")  -->", str("converged" if self.__conv else "not converged")))
+
+        return info
+

KratosMultiphysics/OptimizationApplication/convergence_criteria/constraint_conv_criterion.py

@@ -0,0 +1,68 @@
+import typing
+import KratosMultiphysics as Kratos
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem import OptimizationProblem
+from KratosMultiphysics.OptimizationApplication.utilities.component_data_view import ComponentDataView
+from KratosMultiphysics.OptimizationApplication.convergence_criteria.convergence_criterion import ConvergenceCriterion
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem_utilities import GetComponentHavingDataByFullName
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem_utilities import GetComponentValueByFullName
+from KratosMultiphysics.OptimizationApplication.utilities.logger_utilities import time_decorator
+
+def Factory(_: Kratos.Model, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem) -> ConvergenceCriterion:
+    if not parameters.Has("settings"):
+        raise RuntimeError(f"ConstraintConvCriterion instantiation requires a \"settings\" in parameters [ parameters = {parameters}].")
+    return ConstraintConvCriterion(parameters["settings"], optimization_problem)
+
+class ConstraintConvCriterion(ConvergenceCriterion):
+    """
+    ConstraintConvCriterion is a convergence criterion for optimization problems, specifically designed to check the convergence of constraints.
+
+    This class checks whether a specified value associated with a component in the optimization problem has reached a given tolerance.
+    """
+    @classmethod
+    def GetDefaultParameters(cls):
+        return Kratos.Parameters("""{
+            "component_name": "",
+            "value_name"    : "std_value",
+            "tolerance"     : 0.0
+        }""")
+
+    def __init__(self, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem):
+        parameters.ValidateAndAssignDefaults(self.GetDefaultParameters())
+
+
+        self.__component_name = parameters["component_name"].GetString()
+        self.__value_name = parameters["value_name"].GetString()
+        self.__tolerance = parameters["tolerance"].GetDouble()
+        self.__optimization_problem = optimization_problem
+
+        if self.__value_name.find(":") == -1:
+            # not found where the data location. So the default for value names
+            # will be buffered (i.e. historical). So appending it
+            self.__value_name += ":historical"
+
+        if self.__tolerance < 0.0:
+            raise RuntimeError(f"Tolerance should be non-negative [ tolerance = {self.__tolerance} ].")
+
+    def Initialize(self):
+        component = GetComponentHavingDataByFullName(self.__component_name, self.__optimization_problem)
+        self.__component_data_view = ComponentDataView(component, self.__optimization_problem)
+
+    @time_decorator()
+    def IsConverged(self) -> bool:
+        self.__value = GetComponentValueByFullName(self.__component_data_view, self.__value_name)
+        self.__conv = self.__value <= self.__tolerance
+        return self.__conv
+
+    def Finalize(self):
+        pass
+
+    def GetInfo(self) -> 'list[tuple[str, typing.Union[int, float, str]]]':
+        info = [
+                    ("type"          , "constraint_conv_criterion"),
+                    ("value"         , self.__value),
+                    ("tolerance"     , self.__tolerance),
+                    ('component_name', self.__component_name),
+                    ('value_name'    , self.__value_name),
+                    ("status", str("converged" if self.__conv else "not converged"))
+               ]
+        return info