KratosOptimizationApplication 10.4.4__py3-none-any.whl

KratosMultiphysics/OptimizationApplication/__init__.py

@@ -0,0 +1,19 @@
+# ==============================================================================
+#  KratosOptimizationApplication
+#
+#  License:         BSD License
+#                   license: OptimizationApplication/license.txt
+#
+#  Main authors:    Reza Najian Asl, https://github.com/RezaNajian
+#
+# ==============================================================================
+
+# ------------------------------------------------------------------------------
+# Imports
+# ------------------------------------------------------------------------------
+from KratosMultiphysics import _ImportApplication
+from KratosOptimizationApplication import *
+application = KratosOptimizationApplication()
+application_name = "KratosOptimizationApplication"
+
+_ImportApplication(application, application_name)

KratosMultiphysics/OptimizationApplication/algorithms/NLOPT_algorithms.py

@@ -0,0 +1,255 @@
+try:
+    import nlopt
+except ImportError:
+    raise Exception("NLOPT python library is not available")
+
+import KratosMultiphysics as Kratos
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem import OptimizationProblem
+from KratosMultiphysics.OptimizationApplication.algorithms.standardized_NLOPT_objective import StandardizedNLOPTObjective
+from KratosMultiphysics.OptimizationApplication.algorithms.standardized_NLOPT_constraint import StandardizedNLOPTConstraint
+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.logger_utilities import DictLogger
+from KratosMultiphysics.OptimizationApplication.utilities.helper_utilities import CallOnAll
+from KratosMultiphysics.OptimizationApplication.utilities.logger_utilities import time_decorator
+
+
+
+def Factory(model: Kratos.Model, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem):
+    return NLOPTAlgorithms(model, parameters, optimization_problem)
+
+class NLOPTAlgorithms(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"         : {},
+            "constraints"         : [],
+            "controls"          : [],
+            "echo_level"        : 0,
+            "NLOPT_settings"          : {
+                "algorithm_name"      : "mma",
+                "subsidiary_algorithm_name" : "",
+                "verbosity"           : 0,
+                "controls_lower_bound": "",
+                "controls_upper_bound": "",
+                "stopping_criteria"   : {
+                   "rel_obj_tol": 1e-3,
+                   "abs_obj_tol": 1e-3,
+                   "rel_contr_tol": 1e-3,
+                   "abs_contr_tol": 1e-3,
+                   "maximum_function_evalualtion": 10
+                },
+                "algorithm_specific_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())
+
+        # controls
+        self.master_control = MasterControl()
+        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)
+        self.__control_field = None
+
+        # objective & constraints
+        self.__objective = StandardizedNLOPTObjective(parameters["objective"], self.master_control, self._optimization_problem)
+        self._optimization_problem.AddComponent(self.__objective)
+        self.__constraints = []
+        for constraint_settings in parameters["constraints"].values():
+            constraint = StandardizedNLOPTConstraint(constraint_settings, self.master_control, self._optimization_problem)
+            self._optimization_problem.AddComponent(constraint)
+            self.__constraints.append(constraint)
+
+        # nlopt settings
+        NLOPT_settings = parameters["NLOPT_settings"]
+        NLOPT_settings.ValidateAndAssignDefaults(self.GetDefaultParameters()["NLOPT_settings"])
+
+        # nlopt verbosity
+        self.nlopt_verbosity = NLOPT_settings["verbosity"].GetInt()
+
+        # upper and lower bounds
+        self.nlopt_controls_lower_bound = NLOPT_settings["controls_lower_bound"].GetString()
+        self.nlopt_controls_upper_bound = NLOPT_settings["controls_upper_bound"].GetString()
+
+        # nlopt algorithm
+        self.algorithm_name = NLOPT_settings["algorithm_name"].GetString()
+        if len(self.__constraints)==0:
+            self.CheckOptimizerSupport(self.algorithm_name,None)
+        else:
+            for constraint in self.__constraints:
+                if constraint.IsEqualityType():
+                    self.CheckOptimizerSupport(self.algorithm_name,"equality")
+                else:
+                    self.CheckOptimizerSupport(self.algorithm_name,"inequality")
+
+        # nlopt subsidiary algorithm
+        self.subsidiary_algorithm_name = NLOPT_settings["subsidiary_algorithm_name"].GetString()
+        if self.algorithm_name == "augmented_lagrangian":
+            if self.subsidiary_algorithm_name == "":
+                raise ValueError(f"The algorithm {self.algorithm_name} requires a subsidiary optimizer to be provided.")
+            else:
+                self.CheckOptimizerSupport(self.subsidiary_algorithm_name,None)
+
+        # stopping
+        self.stopping_criteria = NLOPT_settings["stopping_criteria"]
+        self.stopping_criteria.ValidateAndAssignDefaults(self.GetDefaultParameters()["NLOPT_settings"]["stopping_criteria"])
+
+        # alg specific settings
+        self.opt_algorithm_specific_settings = NLOPT_settings["algorithm_specific_settings"]
+
+    def GetMinimumBufferSize(self) -> int:
+        return 2
+
+    def Check(self):
+        pass
+
+    @time_decorator()
+    def Initialize(self):
+        self.converged = False
+        self.master_control.Initialize()
+        self.__objective.Initialize()
+        self.__objective.Check()
+        CallOnAll(self.__constraints, StandardizedNLOPTConstraint.Initialize)
+        self.__control_field = self.master_control.GetControlField()
+        self.algorithm_data = ComponentDataView("algorithm", self._optimization_problem)
+
+        # create nlopt optimizer
+        self.x0 = self.__control_field.data.reshape(-1)
+        self.nlopt_optimizer = nlopt.opt(self.GetOptimizer(self.algorithm_name), self.x0.size)
+
+        # add subsidiary optimization algorithm
+        if self.subsidiary_algorithm_name != "":
+            self.nlopt_subsidiary_optimizer = nlopt.opt(self.GetOptimizer(self.subsidiary_algorithm_name), self.x0.size)
+            self.nlopt_optimizer.set_local_optimizer(self.nlopt_subsidiary_optimizer)
+        else:
+            self.nlopt_subsidiary_optimizer = None
+
+        # set nlopt verbosity
+        self.nlopt_optimizer.set_param("verbosity",self.nlopt_verbosity)
+
+        # assign objectives and constraints
+        self.nlopt_optimizer.set_min_objective(self.__objective.CalculateStandardizedValueAndGradients)
+        for constraint in self.__constraints:
+            if constraint.IsEqualityType():
+                self.nlopt_optimizer.add_equality_constraint(constraint.CalculateStandardizedValueAndGradients,1e-8)
+            else:
+                self.nlopt_optimizer.add_inequality_constraint(constraint.CalculateStandardizedValueAndGradients,1e-8)
+
+        # now set stopping criteria
+        self.SetOptimizerStoppingCriteria(self.nlopt_optimizer)
+        if self.nlopt_subsidiary_optimizer is not None:
+            self.SetOptimizerStoppingCriteria(self.nlopt_subsidiary_optimizer)
+
+        # set bounds if exist
+        if self.nlopt_controls_lower_bound != "":
+            self.nlopt_optimizer.set_lower_bounds(float(self.nlopt_controls_lower_bound))
+        if self.nlopt_controls_upper_bound != "":
+            self.nlopt_optimizer.set_upper_bounds(float(self.nlopt_controls_upper_bound))
+
+        # now add algorithm specific settings
+        self.SetOptimizerSepcificSettings(self.nlopt_optimizer)
+        if self.nlopt_subsidiary_optimizer is not None:
+            self.SetOptimizerSepcificSettings(self.nlopt_subsidiary_optimizer)
+
+    @time_decorator()
+    def Finalize(self):
+        self.__objective.Finalize()
+        for constraint in self.__constraints:
+            constraint.Finalize()
+        self.master_control.Finalize()
+
+    @time_decorator()
+    def Solve(self):
+        self.nlopt_optimizer.optimize(self.x0)
+        CallOnAll(self._optimization_problem.GetListOfProcesses("output_processes"), Kratos.OutputProcess.PrintOutput)
+        self.LogTermination()
+
+    def LogTermination(self):
+        stopval = self.nlopt_optimizer.get_stopval()
+        maxtime = self.nlopt_optimizer.get_maxtime()
+        nlopt_result_map = {
+            nlopt.SUCCESS: 'Generic success return value.',
+            nlopt.STOPVAL_REACHED: f'Optimization stopped because stopval ({stopval}) was reached.',
+            nlopt.FTOL_REACHED: f'Optimization stopped because ftol_rel ({self.stopping_criteria["rel_obj_tol"].GetDouble()}) or ftol_abs ({self.stopping_criteria["abs_obj_tol"].GetDouble()}) was reached.',
+            nlopt.XTOL_REACHED: f'Optimization stopped because xtol_rel ({self.stopping_criteria["rel_contr_tol"].GetDouble()}) or xtol_abs ({self.stopping_criteria["abs_contr_tol"].GetDouble()}) was reached.',
+            nlopt.MAXEVAL_REACHED: f'Optimization stopped because maxeval ({self.stopping_criteria["maximum_function_evalualtion"].GetInt()}) was reached.',
+            nlopt.MAXTIME_REACHED: f'Optimization stopped because maxtime ({maxtime}) was reached.',
+            nlopt.FAILURE: 'Generic failure return value.',
+            nlopt.INVALID_ARGS: 'Invalid arguments (e.g. lower bounds are bigger than upper bounds, an unknown algorithm was specified, etcetera).',
+            nlopt.OUT_OF_MEMORY: 'Ran out of memory.',
+            nlopt.ROUNDOFF_LIMITED: 'Halted because roundoff errors limited progress. (In this case, the optimization still typically returns a useful result.)',
+            nlopt.FORCED_STOP: 'Halted because of a forced termination: the user called nlopt_force_stop(opt) on the optimization’s nlopt_opt object opt from the user’s objective function or constraints.'
+        }
+        info = {"Termination":nlopt_result_map[self.nlopt_optimizer.last_optimize_result()]}
+        DictLogger(f"NLOPT-{self.algorithm_name}",info)
+
+    def CheckOptimizerSupport(self, algorithm_name, constraint_type):
+        # Unconstrained gradient-based optimizers
+        unconstrained_optimizers = {"lbfgs","mma","ccsaq","tnewton_precond_restart",
+                                    "tnewton_precond","tnewton_restart","augmented_lagrangian",
+                                    "neldermead","evolutionary"}
+
+        # Constrained gradient-based optimizers with equality constraints
+        equality_constrained_optimizers = {"slsqp","augmented_lagrangian"}
+
+        # Constrained gradient-based optimizers with inequality constraints
+        inequality_constrained_optimizers = {"mma","slsqp","ccsaq","augmented_lagrangian"}
+
+        if constraint_type == "equality":
+            if algorithm_name not in equality_constrained_optimizers:
+                raise ValueError(f"The algorithm {algorithm_name} does not support equality constraints, support {equality_constrained_optimizers}.")
+        elif constraint_type == "inequality":
+            if algorithm_name not in inequality_constrained_optimizers:
+                raise ValueError(f"The algorithm {algorithm_name} does not support inequality constraints, support {inequality_constrained_optimizers}.")
+        else:
+            if algorithm_name not in unconstrained_optimizers:
+                raise ValueError(f"The algorithm {algorithm_name} does not support unconstrained optimization, support {unconstrained_optimizers}.")
+        return True
+
+    def GetOptimizer(self,name):
+        nlopt_algorithm_dict = {
+            "mma": nlopt.LD_MMA,
+            "slsqp": nlopt.LD_SLSQP,
+            "lbfgs": nlopt.LD_LBFGS,
+            "ccsaq": nlopt.LD_CCSAQ,
+            "tnewton_precond_restart": nlopt.LD_TNEWTON_PRECOND_RESTART,
+            "tnewton_precond": nlopt.LD_TNEWTON_PRECOND,
+            "tnewton_restart": nlopt.LD_TNEWTON_RESTART,
+            "augmented_lagrangian": nlopt.AUGLAG,
+            "neldermead": nlopt.LN_NELDERMEAD,
+            "evolutionary": nlopt.GN_ESCH
+        }
+        return nlopt_algorithm_dict[name]
+
+    def SetOptimizerStoppingCriteria(self,nlopt_optimizer):
+        nlopt_optimizer.set_ftol_rel(self.stopping_criteria["rel_obj_tol"].GetDouble())
+        nlopt_optimizer.set_ftol_abs(self.stopping_criteria["abs_obj_tol"].GetDouble())
+        nlopt_optimizer.set_xtol_rel(self.stopping_criteria["rel_contr_tol"].GetDouble())
+        nlopt_optimizer.set_xtol_abs(self.stopping_criteria["abs_contr_tol"].GetDouble())
+        nlopt_optimizer.set_maxeval(self.stopping_criteria["maximum_function_evalualtion"].GetInt())
+
+    def SetOptimizerSepcificSettings(self,nlopt_optimizer):
+        if self.opt_algorithm_specific_settings.Has("inner_maxeval"):
+            nlopt_optimizer.set_param("inner_maxeval",self.opt_algorithm_specific_settings["inner_maxeval"].GetInt())
+        if self.opt_algorithm_specific_settings.Has("dual_ftol_rel"):
+            nlopt_optimizer.set_param("dual_ftol_rel",self.opt_algorithm_specific_settings["dual_ftol_rel"].GetDouble())
+        if self.opt_algorithm_specific_settings.Has("initial_step"):
+            nlopt_optimizer.set_initial_step(self.opt_algorithm_specific_settings["initial_step"].GetDouble())
+        if self.opt_algorithm_specific_settings.Has("population"):
+            nlopt_optimizer.set_population(self.opt_algorithm_specific_settings["population"].GetInt())
+        if self.opt_algorithm_specific_settings.Has("number_of_stored_vectors"):
+            nlopt_optimizer.set_vector_storage(self.opt_algorithm_specific_settings["number_of_stored_vectors"].GetInt())

KratosMultiphysics/OptimizationApplication/algorithms/SciPy_algorithms.py

@@ -0,0 +1,154 @@
+import KratosMultiphysics as Kratos
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem import OptimizationProblem
+from KratosMultiphysics.OptimizationApplication.algorithms.standardized_SciPy_objective import StandardizedSciPyObjective
+from KratosMultiphysics.OptimizationApplication.algorithms.standardized_SciPy_constraint import StandardizedSciPyConstraint
+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.helper_utilities import CallOnAll
+from KratosMultiphysics.OptimizationApplication.utilities.logger_utilities import time_decorator
+
+import numpy as np
+
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem_utilities import OutputGradientFields
+
+try:
+    import scipy
+except ImportError:
+    raise Exception("SciPy python library is not available")
+
+import scipy.optimize
+from scipy.optimize import NonlinearConstraint
+
+def Factory(model: Kratos.Model, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem):
+    return SciPyAlgorithms(model, parameters, optimization_problem)
+
+class SciPyAlgorithms(Algorithm):
+    """
+        A SciPy wrapper to use algorithms from Library. Provide Method and it settings in the options dict.
+    """
+
+    @classmethod
+    def GetDefaultParameters(cls):
+        return Kratos.Parameters("""{
+            "module"            : "KratosMultiphysics.OptimizationApplication.algorithms",
+            "type"              : "PLEASE_PROVIDE_AN_ALGORITHM_CLASS_NAME",
+            "objective"         : {},
+            "constraints"       : [],
+            "controls"          : [],
+            "echo_level"        : 0,
+            "SciPy_settings"    : {
+                "method"      : "",
+                "lower_bound" : -1e16,
+                "upper_bound" : 1e16,
+                "options"     : {}
+            }
+        }""")
+
+    def __init__(self, model:Kratos.Model, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem):
+        self.model = model
+        self.parameters = parameters
+        self.parameters.ValidateAndAssignDefaults(self.GetDefaultParameters())
+        self._optimization_problem = optimization_problem
+
+        # scipy settings
+        self.SciPy_settings = self.parameters["SciPy_settings"]
+        self.SciPy_settings.ValidateAndAssignDefaults(self.GetDefaultParameters()["SciPy_settings"])
+
+        # controls
+        self.master_control = MasterControl()
+        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)
+        self.__control_field = None
+
+        # objective & constraints
+        self.__objective = StandardizedSciPyObjective(parameters["objective"], self.master_control, self._optimization_problem)
+        self._optimization_problem.AddComponent(self.__objective)
+        self.bounds = scipy.optimize.Bounds(lb=self.SciPy_settings["lower_bound"].GetDouble(), ub=self.SciPy_settings["upper_bound"].GetDouble())
+        self.__kratos_constraints = []
+        self.__scipy_constraints = []
+        for constraint_settings in parameters["constraints"].values():
+            constraint = StandardizedSciPyConstraint(constraint_settings, self.master_control, self._optimization_problem)
+            self.__kratos_constraints.append(constraint)
+            self._optimization_problem.AddComponent(constraint)
+
+            # create SciPy specific constraints
+            scipy_constraint = NonlinearConstraint(constraint.CalculateStandardizedValue, constraint.GetLowerBound(), constraint.GetUpperBound(), constraint.CalculateStandardizedGradient)
+            self.__scipy_constraints.append(scipy_constraint)
+
+    def GetMinimumBufferSize(self) -> int:
+        return 2
+
+    def Check(self):
+        pass
+
+    @time_decorator()
+    def Initialize(self):
+        self.converged = False
+        self.master_control.Initialize()
+        self.__objective.Initialize()
+        self.__objective.Check()
+        CallOnAll(self.__kratos_constraints, StandardizedSciPyConstraint.Initialize)
+        self.__control_field = self.master_control.GetControlField()
+        self.algorithm_data = ComponentDataView("algorithm", self._optimization_problem)
+        self.algorithm_data.SetDataBuffer(self.GetMinimumBufferSize())
+
+        # create nlopt optimizer
+        self.x0 = self.__control_field.data.reshape(-1)
+
+    @time_decorator()
+    def Finalize(self):
+        self.__objective.Finalize()
+        for constraint in self.__kratos_constraints:
+            constraint.Finalize()
+        self.master_control.Finalize()
+
+    @time_decorator()
+    def Solve(self):
+        if not self.__scipy_constraints:
+            res = scipy.optimize.minimize(self.__objective.CalculateStandardizedValue, self.x0, method=self.SciPy_settings["method"].GetString(), jac=self.__objective.CalculateStandardizedGradient, options=self.__GetOptions(), callback=self.Output, bounds=self.bounds)
+        elif self.__scipy_constraints:
+            res = scipy.optimize.minimize(self.__objective.CalculateStandardizedValue, self.x0, method=self.SciPy_settings["method"].GetString(), jac=self.__objective.CalculateStandardizedGradient, constraints=self.__scipy_constraints, options=self.__GetOptions(), callback=self.Output, bounds=self.bounds)
+        Kratos.Logger.PrintInfo(self.__class__.__name__, f"res::success: {res.success}")
+        Kratos.Logger.PrintInfo(self.__class__.__name__, f"res::status: {res.status}")
+        Kratos.Logger.PrintInfo(self.__class__.__name__, f"res::message: {res.message}")
+
+    @time_decorator()
+    def Output(self, *args) -> Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor:
+        # SciPy calls it at the end of each optimization iterations. Sometime it doesn't call f(x) during iteration, hence to avoid lack of data in the buffer we have a flag "computed" here.
+        if self.__objective.computed:
+
+            Kratos.Logger.PrintInfo(self.__class__.__name__, f"Output iteration {self._optimization_problem.GetStep()}")
+
+            self.__control_field.data[:] = args[0]
+            Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor(self.__control_field, perform_store_data_recursively=False, copy=False).StoreData()
+
+            self.algorithm_data.GetBufferedData().SetValue("control_field", self.__control_field.Clone(), overwrite=True)
+            OutputGradientFields(self.__objective, self._optimization_problem, True)
+            for constraint in self.__kratos_constraints:
+                OutputGradientFields(constraint, self._optimization_problem, True)
+            for process in self._optimization_problem.GetListOfProcesses("output_processes"):
+                if process.IsOutputStep():
+                    process.PrintOutput()
+
+            # Advance in Optimization Iteration
+            self._optimization_problem.AdvanceStep()
+            self.__objective.computed = False
+
+    def __GetOptions(self):
+        options = self.SciPy_settings["options"]
+        dict_options = dict()
+        for key in options.keys():
+            if options[key].IsBool():
+                dict_options[key] = options[key].GetBool()
+            elif options[key].IsDouble():
+                dict_options[key] = options[key].GetDouble()
+            elif options[key].IsInt():
+                dict_options[key] = options[key].GetInt()
+            elif options[key].IsString():
+                dict_options[key] = options[key].GetString()
+            else:
+                raise RuntimeError(f"Unsupported data type with key = \"{key}\" [ value = {options[key]} ].")
+        return dict_options

KratosMultiphysics/OptimizationApplication/algorithms/algorithm.py

@@ -0,0 +1,78 @@
+from abc import ABC, abstractmethod
+
+import KratosMultiphysics as Kratos
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem import OptimizationProblem
+from KratosMultiphysics.OptimizationApplication.utilities.helper_utilities import CallOnAll
+
+class Algorithm(ABC):
+    """Base class for algorithm.
+
+    Algorithm works purely in the control space. Hence, the ResponseRoutine which
+    the algorithm is associated with should convert all physical space gradients to
+    control space and control space designs to physical space designs.
+
+    The purpose of the algorithm is to solve a minimization problem. Hence, the used
+    ResponseRoutine should standardize the values and gradients it computes accordingly.
+
+    Algorithm should create one MasterControl from all the require controls, and share
+    it among all the ResponseRoutines.
+
+    Once it received the objective/constraint values and their gradients, the algorithm
+    will compute the new design and request new objective/constraints values and their
+    gradients until the specified convergence criteria is met.
+    """
+    def __init__(self, optimization_problem: OptimizationProblem) -> None:
+        self._optimization_problem = optimization_problem
+
+    @abstractmethod
+    def Initialize(self) -> None:
+        """Initializes the algorithm, ResponseRoutines and MasterControl.
+        """
+        pass
+
+    @abstractmethod
+    def Check(self) -> None:
+        """Checks algorithm, ResponseRoutines and MasterControl.
+        """
+        pass
+
+    @abstractmethod
+    def Finalize(self) -> None:
+        """Finalizes algorithm ResponseRoutines and MasterControl.
+        """
+        pass
+
+    @abstractmethod
+    def Solve(self) -> bool:
+        """Solves the optimization problem.
+
+        This method will have a loop which iterates until the specified
+        convergence for the given optimization problem.
+
+        Returns:
+            bool: Convergence status. True for converged, False for non-converged.
+        """
+        pass
+
+    def GetProcessesOrder(self) -> 'list[str]':
+        """The order of execution of the process categories.
+
+        This defines the order of execution of the processes defined under "processes"
+        in either "kratos_process" or "optimization_data_processes".
+
+        Returns:
+            list[str]: List of strings for process categories.
+        """
+        return ["auxiliary_processes", "output_processes"]
+
+    def CallOnAllProcesses(self, process_types: 'list[str]', *args, **kwargs):
+        for process_type in process_types:
+            CallOnAll(self._optimization_problem.GetListOfProcesses(process_type), *args, **kwargs)
+
+    def _InitializeIteration(self) -> None:
+        for process_type in self._optimization_problem.GetAvailableProcessTypes():
+            list(map(lambda x: x.ExecuteInitializeSolutionStep(), self._optimization_problem.GetListOfProcesses(process_type)))
+
+    def _FinalizeIteration(self) -> None:
+        for process_type in self._optimization_problem.GetAvailableProcessTypes():
+            list(map(lambda x: x.ExecuteFinalizeSolutionStep(), self._optimization_problem.GetListOfProcesses(process_type)))

KratosMultiphysics/OptimizationApplication/algorithms/algorithm_adam.py

@@ -0,0 +1,68 @@
+import KratosMultiphysics as Kratos
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem import OptimizationProblem
+from KratosMultiphysics.OptimizationApplication.utilities.logger_utilities import time_decorator
+from KratosMultiphysics.OptimizationApplication.algorithms.algorithm_steepest_descent import AlgorithmSteepestDescent
+
+
+def Factory(model: Kratos.Model, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem):
+    return AlgorithmAdam(model, parameters, optimization_problem)
+
+class AlgorithmAdam(AlgorithmSteepestDescent):
+    """
+        Adam (Adaptive Moment Estimation) method to solve unconstrained optimization problems.
+        The implementation is based on https://arxiv.org/pdf/1412.6980
+    """
+
+    @classmethod
+    def GetDefaultParameters(cls):
+        return Kratos.Parameters("""{
+            "module"            : "KratosMultiphysics.OptimizationApplication.algorithms",
+            "type"              : "PLEASE_PROVIDE_AN_ALGORITHM_CLASS_NAME",
+            "objective"         : {},
+            "controls"          : [],
+            "echo_level"        : 0,
+            "settings"          : {
+                "beta_1"          : 0.9,
+                "beta_2"          : 0.999,
+                "epsilon"         : 1e-8,
+                "echo_level"      : 0,
+                "line_search"     : {},
+                "conv_settings"   : {}
+            }
+        }""")
+
+    def __init__(self, model:Kratos.Model, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem):
+        super().__init__(model, parameters, optimization_problem)
+        self.beta_1 = self.parameters["settings"]["beta_1"].GetDouble()
+        self.beta_2 = self.parameters["settings"]["beta_2"].GetDouble()
+        self.epsilon = self.parameters["settings"]["epsilon"].GetDouble()
+        self.prev_moment_1 = None
+        self.prev_moment_2 = None
+
+    @time_decorator()
+    def ComputeControlUpdate(self, alpha: Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor):
+        search_direction: Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor = self.algorithm_data.GetBufferedData()["search_direction"]
+        time_step = self._optimization_problem.GetStep() + 1
+
+        # update the biased first and second raw moment estimates
+        moment_1 = Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor(search_direction, perform_collect_data_recursively=False, perform_store_data_recursively=False)
+        moment_2 = Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor(search_direction, perform_collect_data_recursively=False, perform_store_data_recursively=False)
+        if self.prev_moment_1 and self.prev_moment_2:
+            moment_1.data[:] = self.prev_moment_1.data * self.beta_1 + search_direction.data * (1.0 - self.beta_1)
+            moment_2.data[:] = self.prev_moment_2.data * self.beta_2 + search_direction.data ** 2 * (1.0 - self.beta_2)
+        else:
+            moment_1.data[:] = search_direction.data * (1.0 - self.beta_1)
+            moment_2.data[:] = search_direction.data ** 2 * (1.0 - self.beta_2)
+        moment_1.StoreData()
+        moment_2.StoreData()
+        self.prev_moment_1 = moment_1
+        self.prev_moment_2 = moment_2
+
+        # bias correct the moment estimates and compute the control field update
+        moment_1_hat = moment_1.data / (1.0 - self.beta_1 ** time_step)
+        moment_2_hat = moment_2.data / (1.0 - self.beta_2 ** time_step)
+
+        control_field_update = Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor(moment_2, perform_store_data_recursively=False)
+        control_field_update.data[:] = alpha.data * moment_1_hat / (moment_2_hat ** 0.5 + self.epsilon)
+        control_field_update.StoreData()
+        self.algorithm_data.GetBufferedData()["control_field_update"] = control_field_update