KratosOptimizationApplication 10.4.4__py3-none-any.whl

KratosMultiphysics/OptimizationApplication/convergence_criteria/convergence_criterion.py

@@ -0,0 +1,26 @@
+import abc
+import typing
+
+class ConvergenceCriterion(abc.ABC):
+    """Initializes the convergence criteria
+    """
+    @abc.abstractmethod
+    def Initialize(self) -> None:
+        pass
+
+    """This method returns whether the convergence criteria detected the optimization
+    has converged.
+    """
+    @abc.abstractmethod
+    def IsConverged(self) -> bool:
+        pass
+
+    """Finalizes the convergence criteria """
+    @abc.abstractmethod
+    def Finalize(self) -> None:
+        pass
+
+    """Returns a list[(str, Any)] with information about the current convergence."""
+    @abc.abstractmethod
+    def GetInfo(self) -> 'list[tuple[str, typing.Union[int, float, str]]]':
+        pass

KratosMultiphysics/OptimizationApplication/convergence_criteria/l2_conv_criterion.py

@@ -0,0 +1,77 @@
+import typing, numpy
+import KratosMultiphysics as Kratos
+import KratosMultiphysics.OptimizationApplication as KratosOA
+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"L2ConvCriterion instantiation requires a \"settings\" in parameters [ parameters = {parameters}].")
+    return L2ConvCriterion(parameters["settings"], optimization_problem)
+
+class L2ConvCriterion(ConvergenceCriterion):
+    """
+    L2ConvCriterion is a convergence criterion based on the L2 norm of a specified field in an optimization problem.
+
+    This class checks whether the L2 norm of a given field (e.g., search direction) falls below a specified tolerance,
+    indicating convergence. The field can be either historical or non-historical, and the criterion is configurable
+    via parameters.
+    """
+    @classmethod
+    def GetDefaultParameters(cls):
+        return Kratos.Parameters("""{
+            "component_name": "algorithm",
+            "field_name"    : "search_direction:historical",
+            "tolerance"     : 1e-9
+        }""")
+
+    def __init__(self, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem):
+        parameters.ValidateAndAssignDefaults(self.GetDefaultParameters())
+
+        self.__component_name = parameters["component_name"].GetString()
+        self.__field_name = parameters["field_name"].GetString()
+        self.__tolerance = parameters["tolerance"].GetDouble()
+        self.__optimization_problem = optimization_problem
+        self.__component_data_view: 'typing.Optional[ComponentDataView]' = None
+
+        if self.__field_name.find(":") == -1:
+            # not found where the data location. So the default for field names
+            # will be unbuffered (i.e. non_historical). So appending it
+            self.__field_name += ":non_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:
+        field: Kratos.TensorAdaptors.DoubleTensorAdaptor = GetComponentValueByFullName(self.__component_data_view, self.__field_name)
+
+        if not hasattr(field, "data"):
+            raise RuntimeError(f"The value represented by {self.__field_name} is not a field.")
+
+        self.__norm = numpy.linalg.norm(field.data)
+        self.__conv = self.__norm <= self.__tolerance
+        self.__component_data_view.GetBufferedData().SetValue(self.__field_name.split(':')[0] + "_l2_norm", self.__norm)
+        return self.__conv
+
+    def Finalize(self):
+        pass
+
+    def GetInfo(self) -> 'list[tuple[str, typing.Union[int, float, str]]]':
+        info = [
+                    ('type'          , 'l2_conv_criterion'),
+                    ('l2_norm'       , self.__norm),
+                    ('tolerance'     , self.__tolerance),
+                    ('component_name', self.__component_name),
+                    ('field_name'    , self.__field_name),
+                    ('status'        , str("converged" if self.__conv else "not converged"))
+               ]
+        return info

KratosMultiphysics/OptimizationApplication/convergence_criteria/magnitude_reduction_conv_criterion.py

@@ -0,0 +1,85 @@
+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.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"MagnitudeReductionConvCriterion instantiation requires a \"settings\" in parameters [ parameters = {parameters}].")
+    return MagnitudeReductionConvCriterion(parameters["settings"], optimization_problem)
+
+class MagnitudeReductionConvCriterion(ConvergenceCriterion):
+    """
+    Convergence criterion based on the reduction of a magnitude (e.g., objective value) during optimization.
+
+    This criterion checks whether the current value of a specified component has been reduced below a target value,
+    which is computed as a scaling factor of the initial value or a specified machine precision, whichever is greater.
+
+    Raises:
+        RuntimeError: If the target scaling factor is not greater than zero or machine precision is negative.
+    """
+    @classmethod
+    def GetDefaultParameters(cls):
+        return Kratos.Parameters("""{
+            "component_name"       : "algorithm",
+            "value_name"           : "std_obj_value",
+            "target_scaling_factor": 1e-3,
+            "machine_precision"    : 1e-16
+        }""")
+
+    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.__target_scaling_factor = parameters["target_scaling_factor"].GetDouble()
+        self.__machine_precision = parameters["machine_precision"].GetDouble()
+        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.__target_scaling_factor <= 0.0:
+            raise RuntimeError(f"The target scaling factor should be greater than zero [ target_scaling_factor = {self.__target_scaling_factor} ].")
+
+        if self.__machine_precision < 0.0:
+            raise RuntimeError(f"The machine precision should be non-negative [ machine_precision = {self.__machine_precision} ].")
+
+    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:
+        iter = self.__optimization_problem.GetStep()
+        self.__current_value = GetComponentValueByFullName(self.__component_data_view, self.__value_name)
+
+        if iter == 0:
+            self.__target_value = max(self.__current_value * self.__target_scaling_factor, self.__machine_precision)
+            self.__component_data_view.GetUnBufferedData().SetValue(f"{self.__value_name.split(':')[0]}_conv_target", self.__target_value)
+            self.__conv = False
+        else:
+            self.__conv = self.__current_value <= self.__target_value
+
+        return self.__conv
+
+    def Finalize(self):
+        pass
+
+    def GetInfo(self) -> 'list[tuple[str, typing.Union[int, float, str]]]':
+        info = [
+                    ('type'          , 'magnitude_reduction_conv_criterion'),
+                    ('value'         , self.__current_value),
+                    ('target_value'  , self.__target_value),
+                    ('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/max_iter_conv_criterion.py

@@ -0,0 +1,48 @@
+import typing
+import KratosMultiphysics as Kratos
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem import OptimizationProblem
+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"MaxIterConvCriterion instantiation requires a \"settings\" in parameters [ parameters = {parameters}].")
+    return MaxIterConvCriterion(parameters["settings"], optimization_problem)
+
+class MaxIterConvCriterion(ConvergenceCriterion):
+    """
+    MaxIterConvCriterion is a convergence criterion for optimization problems based on the maximum number of iterations.
+    """
+    @classmethod
+    def GetDefaultParameters(cls):
+        return Kratos.Parameters("""{
+            "max_iter": 0
+        }""")
+
+    def __init__(self, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem):
+        parameters.ValidateAndAssignDefaults(self.GetDefaultParameters())
+
+        self.__max_iter = parameters["max_iter"].GetInt()
+        self.__optimization_problem = optimization_problem
+
+        if self.__max_iter < 0:
+            raise RuntimeError(f"The number of max iterations cannot negative.")
+
+    def Initialize(self):
+        pass
+
+    @time_decorator()
+    def IsConverged(self) -> bool:
+        self.__conv = (self.__optimization_problem.GetStep() >= self.__max_iter)
+        return self.__conv
+
+    def Finalize(self):
+        pass
+
+    def GetInfo(self) -> 'list[tuple[str, typing.Union[int, float, str]]]':
+        info = [
+                    ("type"  , "max_iter_conv_criterion"),
+                    ("iter"  , f"{self.__optimization_problem.GetStep()} of {self.__max_iter}"),
+                    ("status", str("converged" if self.__conv else "not converged"))
+               ]
+        return info

KratosMultiphysics/OptimizationApplication/convergence_criteria/patience_conv_criterion.py

@@ -0,0 +1,116 @@
+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"PatienceConvCriterion instantiation requires a \"settings\" in parameters [ parameters = {parameters}].")
+    return PatienceConvCriterion(parameters["settings"], optimization_problem)
+
+class PatienceConvCriterion(ConvergenceCriterion):
+    """
+    Convergence criterion based on the 'patience' concept, commonly used in optimization and machine learning.
+
+    This criterion monitors the improvement of a specified value (e.g., objective function) over iterations.
+    Convergence is declared if no significant improvement (greater than a specified tolerance) is observed
+    for a consecutive number of iterations (patience_itr), after a minimum number of iterations (minimum_itr)
+    have been performed.
+
+    Raises:
+        RuntimeError: If tolerance is negative, minimum_itr is not positive, patience_itr is not greater than minimum_itr,
+                      or the monitored value is not a float or int.
+    """
+    @classmethod
+    def GetDefaultParameters(cls):
+        return Kratos.Parameters("""{
+            "component_name": "algorithm",
+            "value_name"    : "std_obj_value",
+            "minimum_itr"   : 100,
+            "patience_itr"  : 50,
+            "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.__patience_itr = parameters["patience_itr"].GetInt()
+        self.__minimum_itr = parameters["minimum_itr"].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.__minimum_itr <= 0:
+            raise RuntimeError(f"The minimum number of iterations needs to be greater than 0 [ minimum_itr = {self.__minimum_itr} ].")
+
+        if self.__patience_itr >= self.__minimum_itr:
+            raise RuntimeError(f"The number of patience iterations needs to be greater than minimum number of iterations [ patience_itr = {self.__patience_itr}, minimum_itr = {self.__minimum_itr} ].")
+
+        self.__best_value: 'typing.Optional[float]' = None
+        self.__patience_step = 0
+
+    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 self.__best_value is None:
+            self.__init_value = value
+            self.__best_value = value
+
+        if step >= self.__minimum_itr:
+            if self.__best_value > value + self.__tolerance * self.__init_value:
+                self.__best_value = value
+                self.__patience_step = 0
+            else:
+                self.__patience_step += 1
+
+            # say it is converged if you cannot find a better solution within the number of
+            # patience iterations. That means, there were no improvement for patience iterations.
+            self.__conv = self.__patience_step >= self.__patience_itr
+        else:
+            self.__conv = False
+
+        self.__component_data_view.GetBufferedData().SetValue(f"{self.__value_name.split(':')[0]}_pat_itr_{self.__patience_itr}_best_value", self.__best_value)
+        self.__component_data_view.GetBufferedData().SetValue(f"{self.__value_name.split(':')[0]}_pat_itr_{self.__patience_itr}_patience_step", self.__patience_step)
+
+        return self.__conv
+
+    def Finalize(self):
+        pass
+
+    def GetInfo(self) -> 'list[tuple[str, typing.Union[int, float, str]]]':
+        info = [
+                    ('type'          , 'patience_conv_criterion'),
+                    ('best_value'    , self.__best_value),
+                    ('patience_step' , self.__patience_step),
+                    ('patience_itr'  , self.__patience_itr),
+                    ('minimum_itr'   , self.__minimum_itr),
+                    ('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/target_value_conv_criterion.py

@@ -0,0 +1,64 @@
+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.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"TargetValueConvCriterion instantiation requires a \"settings\" in parameters [ parameters = {parameters}].")
+    return TargetValueConvCriterion(parameters["settings"], optimization_problem)
+
+class TargetValueConvCriterion(ConvergenceCriterion):
+    """
+    TargetValueConvCriterion is a convergence criterion for optimization problems that checks
+    whether a specified value associated with a component has reached a target threshold.
+    """
+    @classmethod
+    def GetDefaultParameters(cls):
+        return Kratos.Parameters("""{
+            "component_name": "algorithm",
+            "value_name"    : "std_obj_value",
+            "target_value"  : 1e-9
+        }""")
+
+    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.__target_value = parameters["target_value"].GetDouble()
+        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"
+
+    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.__current_value = GetComponentValueByFullName(self.__component_data_view, self.__value_name)
+        self.__conv = self.__current_value <= self.__target_value
+        return self.__conv
+
+    def Finalize(self):
+        pass
+
+    def GetInfo(self) -> 'list[tuple[str, typing.Union[int, float, str]]]':
+        info = [
+                    ('type'          , 'target_value_conv_criteria'),
+                    ('value'         , self.__current_value),
+                    ('target_value'  , self.__target_value),
+                    ('component_name', self.__component_name),
+                    ('value_name'    , self.__value_name),
+                    ('status'        , str("converged" if self.__conv else "not converged"))
+               ]
+        return info

KratosMultiphysics/OptimizationApplication/execution_policies/execution_policy.py

@@ -0,0 +1,46 @@
+from abc import ABC, abstractmethod
+import KratosMultiphysics as Kratos
+
+class ExecutionPolicy(ABC):
+    """Base class for execution policy
+
+    This represents the base class for the execution policy which
+    can be used to execute primal analysis to obtain response function
+    values and their gradients.
+
+    """
+    def __init__(self, execution_policy_name: str) -> None:
+        self.__name = execution_policy_name
+
+    def GetName(self) -> str:
+        return self.__name
+
+    @abstractmethod
+    def Initialize(self) -> None:
+        pass
+
+    @abstractmethod
+    def Check(self) -> None:
+        pass
+
+    @abstractmethod
+    def Finalize(self) -> None:
+        pass
+
+    @abstractmethod
+    def GetAnalysisModelPart(self) -> Kratos.ModelPart:
+        """Returns the analysis model part.
+
+        Each execution policy will be using a domain to compute the primal model part.
+        This method should return that domain as a Kratos::ModelPart.
+
+        Returns:
+            Kratos.ModelPart: Domain used to compute the primal solution.
+        """
+        pass
+
+    @abstractmethod
+    def Execute(self) -> None:
+        """Solves the associated primal problem.
+        """
+        pass

KratosMultiphysics/OptimizationApplication/execution_policies/execution_policy_decorator.py

@@ -0,0 +1,67 @@
+import KratosMultiphysics as Kratos
+from KratosMultiphysics.model_parameters_factory import KratosModelParametersFactory
+from KratosMultiphysics.OptimizationApplication.execution_policies.execution_policy import ExecutionPolicy
+from KratosMultiphysics.OptimizationApplication.utilities.logger_utilities import FileLogger
+from KratosMultiphysics.OptimizationApplication.utilities.logger_utilities import TimeLogger
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem_utilities import OptimizationComponentFactory
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem import OptimizationProblem
+from KratosMultiphysics.OptimizationApplication.utilities.helper_utilities import CallOnAll
+
+class ExecutionPolicyDecorator(ExecutionPolicy):
+    def __init__(self, model: Kratos.Model, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem):
+        default_parameters = Kratos.Parameters("""{
+            "name"           : "",
+            "type"           : "please_provide_python_module_name",
+            "module"         : "KratosMultiphysics.OptimizationApplication.execution_policies",
+            "pre_operations" : [],
+            "post_operations": [],
+            "log_in_file"    : false,
+            "log_file_name"  : "",
+            "settings"       : {}
+        }""")
+        parameters.ValidateAndAssignDefaults(default_parameters)
+
+        super().__init__(parameters["name"].GetString())
+
+        self.__log_file_name = parameters["log_file_name"].GetString()
+        self.__log_in_file = parameters["log_in_file"].GetBool()
+
+        if self.__log_in_file and self.__log_file_name == "":
+            raise RuntimeError("Logger file name is empty for execution policy. Please provide \"log_file_name\" or make \"log_in_file\" to false.")
+
+        factory = KratosModelParametersFactory(model)
+
+        # create operations
+        self.__list_of_pre_operations: 'list[Kratos.Operation]' = factory.ConstructListOfItems(parameters["pre_operations"])
+        self.__list_of_post_operations: 'list[Kratos.Operation]' = factory.ConstructListOfItems(parameters["post_operations"])
+
+        # create execution policy
+        self.__execution_policy: ExecutionPolicy = OptimizationComponentFactory(model, parameters, optimization_problem)
+
+    def GetExecutionPolicy(self):
+        return self.__execution_policy
+
+    def GetAnalysisModelPart(self) -> Kratos.ModelPart:
+        return self.__execution_policy.GetAnalysisModelPart()
+
+    def Initialize(self):
+        self.__execution_policy.Initialize()
+
+    def Check(self):
+        self.__execution_policy.Check()
+
+    def Finalize(self):
+        self.__execution_policy.Finalize()
+
+    def Execute(self):
+        with TimeLogger(f"ExecutionPolicyDecorator::Executing {self.GetName()}", None, "Finished"):
+            if self.__log_in_file:
+                with FileLogger(self.__log_file_name):
+                    self.__ExecuteWithoutFileLogger()
+            else:
+                self.__ExecuteWithoutFileLogger()
+
+    def __ExecuteWithoutFileLogger(self):
+        CallOnAll(self.__list_of_pre_operations, Kratos.Operation.Execute)
+        self.__execution_policy.Execute()
+        CallOnAll(self.__list_of_post_operations, Kratos.Operation.Execute)

KratosMultiphysics/OptimizationApplication/execution_policies/independent_analysis_execution_policy.py

@@ -0,0 +1,78 @@
+from typing import Union
+from importlib import import_module
+
+import KratosMultiphysics as Kratos
+from KratosMultiphysics.analysis_stage import AnalysisStage
+from KratosMultiphysics.project import Project
+from KratosMultiphysics.orchestrators.orchestrator import Orchestrator
+from KratosMultiphysics.OptimizationApplication.execution_policies.execution_policy import ExecutionPolicy
+from KratosMultiphysics.OptimizationApplication.utilities.helper_utilities import GetClassModuleFromKratos
+
+def Factory(model: Kratos.Model, parameters: Kratos.Parameters, _) -> ExecutionPolicy:
+    if not parameters.Has("name"):
+        raise RuntimeError(f"IndependentAnalysisExecutionPolicy instantiation requires a \"name\" in parameters [ parameters = {parameters}].")
+    if not parameters.Has("settings"):
+        raise RuntimeError(f"IndependentAnalysisExecutionPolicy instantiation requires a \"settings\" in parameters [ parameters = {parameters}].")
+
+    return IndependentAnalysisExecutionPolicy(parameters["name"].GetString(), model, parameters["settings"])
+
+class IndependentAnalysisExecutionPolicy(ExecutionPolicy):
+    def __init__(self, name: str, model: Kratos.Model, parameters: Kratos.Parameters):
+        super().__init__(name)
+
+        self.model = model
+
+        default_settings = Kratos.Parameters("""{
+            "analysis_module"         : "KratosMultiphysics",
+            "analysis_type"           : "",
+            "analysis_model_part_name": "",
+            "analysis_settings"       : {}
+        }""")
+
+        parameters.ValidateAndAssignDefaults(default_settings)
+
+        self.analysis_module = parameters["analysis_module"].GetString()
+        self.analysis_type = parameters["analysis_type"].GetString()
+        self.analysis_settings = parameters["analysis_settings"]
+        self.analysis_model_part_name = parameters["analysis_model_part_name"].GetString()
+
+        if self.analysis_module == "KratosMultiphysics":
+            self.analysis_full_module, self.analysis_type = GetClassModuleFromKratos(self.analysis_type)
+        else:
+            self.analysis_full_module = f"{self.analysis_module}.{Kratos.StringUtilities.ConvertCamelCaseToSnakeCase(self.analysis_type)}"
+
+
+    def Initialize(self) -> None:
+        pass
+
+    def Check(self) -> None:
+        pass
+
+    def Finalize(self) -> None:
+        pass
+
+    def Execute(self):
+        analysis_type = getattr(import_module(self.analysis_full_module), self.analysis_type)
+        if AnalysisStage in analysis_type.mro():
+            # the analysis type is derived from AnalysisStage
+            self.current_analysis: AnalysisStage = getattr(import_module(self.analysis_full_module), self.analysis_type)(self.model, self.analysis_settings.Clone())
+        elif Orchestrator in analysis_type.mro():
+            # the analysis type is derive from the Orchestrator
+            project = Project(self.analysis_settings.Clone())
+            self.current_analysis: Orchestrator = getattr(import_module(self.analysis_full_module), self.analysis_type)(project)
+
+        self.current_analysis.Run()
+
+    def GetAnalysisModelPart(self):
+        if self.current_analysis is not None:
+            if isinstance(self.current_analysis, AnalysisStage):
+                if self.analysis_model_part_name == "" or self.analysis_model_part_name == self.current_analysis._GetSolver().GetComputingModelPart().FullName():
+                    return self.current_analysis._GetSolver().GetComputingModelPart()
+                else:
+                    raise RuntimeError(f"The specified analysis model part name mismatch [ specified analysis model part name = {self.analysis_model_part_name}, used analysis model part name = {self.current_analysis._GetSolver().GetComputingModelPart().FullName()} ].")
+            elif isinstance(self.current_analysis, Orchestrator):
+                return self.current_analysis.GetProject().GetModel()[self.analysis_model_part_name]
+            else:
+                raise RuntimeError(f"Unsupported analysis type = {self.current_analysis}.")
+        else:
+            raise RuntimeError("The analysis is not run yet.")