KratosOptimizationApplication 10.4.4__py3-none-any.whl

KratosMultiphysics/OptimizationApplication/optimization_analysis.py

@@ -0,0 +1,146 @@
+import KratosMultiphysics as Kratos
+from KratosMultiphysics.process_factory import KratosProcessFactory
+from KratosMultiphysics.OptimizationApplication.algorithms.algorithm import Algorithm
+from KratosMultiphysics.OptimizationApplication.model_part_controllers.model_part_controller import ModelPartController
+from KratosMultiphysics.OptimizationApplication.execution_policies.execution_policy_decorator import ExecutionPolicyDecorator
+from KratosMultiphysics.OptimizationApplication.responses.response_function import ResponseFunction
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem_utilities import OptimizationComponentFactory
+from KratosMultiphysics.OptimizationApplication.utilities.helper_utilities import CallOnAll
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem import OptimizationProblem
+from KratosMultiphysics.OptimizationApplication.utilities.logger_utilities import OptimizationAnalysisTimeLogger
+
+class OptimizationAnalysis:
+    @classmethod
+    def GetDefaultParameters(cls) -> Kratos.Parameters:
+        return Kratos.Parameters("""{
+            "problem_data"      : {},
+            "model_parts"       : [],
+            "analyses"          : [],
+            "responses"         : [],
+            "controls"          : [],
+            "algorithm_settings": {},
+            "processes"  : {
+                "kratos_processes"           : {},
+                "optimization_data_processes": {}
+            }
+        }""")
+
+    def __init__(self, model: Kratos.Model, project_parameters: Kratos.Parameters):
+        self.model = model
+        self.project_parameters = project_parameters
+        self.project_parameters.ValidateAndAssignDefaults(self.GetDefaultParameters())
+
+        self.optimization_problem = OptimizationProblem(self.project_parameters["problem_data"]["echo_level"].GetInt())
+
+        self.__list_of_model_part_controllers: 'list[ModelPartController]' = []
+        self.__algorithm: Algorithm = None
+
+        self._CreateModelPartControllers()
+        self._CreateAnalyses()
+        self._CreateControls()
+        self._CreateResponses()
+        self._CreateAlgorithm()
+        self._CreateProcesses()
+
+    def Initialize(self):
+        CallOnAll(self.__list_of_model_part_controllers, ModelPartController.ImportModelPart)
+        CallOnAll(self.__list_of_model_part_controllers, ModelPartController.Initialize)
+        for process_type in self.__algorithm.GetProcessesOrder():
+            CallOnAll(self.optimization_problem.GetListOfProcesses(process_type), Kratos.Process.ExecuteInitialize)
+        CallOnAll(self.optimization_problem.GetListOfExecutionPolicies(), ExecutionPolicyDecorator.Initialize)
+
+        self.__algorithm.Initialize()
+
+    def Check(self):
+        for process_type in self.__algorithm.GetProcessesOrder():
+            CallOnAll(self.optimization_problem.GetListOfProcesses(process_type), Kratos.Process.Check)
+        CallOnAll(self.optimization_problem.GetListOfExecutionPolicies(), ExecutionPolicyDecorator.Check)
+
+        self.__algorithm.Check()
+
+    def Finalize(self):
+        self.__algorithm.Finalize()
+
+        CallOnAll(self.__list_of_model_part_controllers, ModelPartController.Finalize)
+        for process_type in self.__algorithm.GetProcessesOrder():
+            CallOnAll(self.optimization_problem.GetListOfProcesses(process_type), Kratos.Process.ExecuteFinalize)
+        CallOnAll(self.optimization_problem.GetListOfExecutionPolicies(), ExecutionPolicyDecorator.Finalize)
+
+    def Run(self):
+        with OptimizationAnalysisTimeLogger():
+            self.Initialize()
+            self.Check()
+            self.__algorithm.Solve()
+            self.Finalize()
+
+    def _CreateModelPartControllers(self):
+        default_settings = Kratos.Parameters("""{
+            "type": "mdpa_model_part_controller",
+            "module": "KratosMultiphysics.OptimizationApplication.model_part_controllers"
+        }""")
+        for model_part_controller_settings in self.project_parameters["model_parts"].values():
+            model_part_controller_settings.AddMissingParameters(default_settings)
+            model_part_controller: ModelPartController = OptimizationComponentFactory(self.model, model_part_controller_settings, self.optimization_problem)
+            self.__list_of_model_part_controllers.append(model_part_controller)
+
+    def _CreateAnalyses(self):
+        default_settings = Kratos.Parameters("""{
+            "module": "KratosMultiphysics.OptimizationApplication.execution_policies"
+        }""")
+        for analyses_settings in self.project_parameters["analyses"].values():
+            analyses_settings.AddMissingParameters(default_settings)
+            execution_policy = OptimizationComponentFactory(self.model, analyses_settings, self.optimization_problem)
+            self.optimization_problem.AddComponent(execution_policy)
+
+    def _CreateResponses(self):
+        default_settings = Kratos.Parameters("""{
+            "module": "KratosMultiphysics.OptimizationApplication.responses"
+        }""")
+        for response_settings in self.project_parameters["responses"].values():
+            response_settings.AddMissingParameters(default_settings)
+            response_function: ResponseFunction = OptimizationComponentFactory(self.model, response_settings, self.optimization_problem)
+            self.optimization_problem.AddComponent(response_function)
+
+    def _CreateControls(self):
+        default_settings = Kratos.Parameters("""{
+            "module" : "KratosMultiphysics.OptimizationApplication.controls"
+        }""")
+        for control_settings in self.project_parameters["controls"].values():
+            control_settings.AddMissingParameters(default_settings)
+            control = OptimizationComponentFactory(self.model, control_settings, self.optimization_problem)
+            self.optimization_problem.AddComponent(control)
+
+    def _CreateProcesses(self):
+        process_settings = self.project_parameters["processes"]
+        process_settings.ValidateAndAssignDefaults(self.GetDefaultParameters()["processes"])
+
+        kratos_processes = process_settings["kratos_processes"]
+        optimization_data_processes = process_settings["optimization_data_processes"]
+
+        factory = KratosProcessFactory(self.model)
+
+        optimization_data_process_default_settings = Kratos.Parameters("""{
+            "module" : "KratosMultiphysics.OptimizationApplication.optimization_data_processes"
+        }""")
+
+        for process_type in self.__algorithm.GetProcessesOrder():
+            self.optimization_problem.AddProcessType(process_type)
+            if kratos_processes.Has(process_type):
+                for process in factory.ConstructListOfProcesses(kratos_processes[process_type]):
+                    self.optimization_problem.AddProcess(process_type, process)
+            if optimization_data_processes.Has(process_type):
+                for process_settings in optimization_data_processes[process_type].values():
+                    process_settings.AddMissingParameters(optimization_data_process_default_settings)
+                    process = OptimizationComponentFactory(self.model, process_settings, self.optimization_problem)
+                    self.optimization_problem.AddProcess(process_type, process)
+
+    def _CreateAlgorithm(self):
+        default_settings = Kratos.Parameters("""{
+            "module" : "KratosMultiphysics.OptimizationApplication.algorithms"
+        }""")
+        algorithm_settings = self.project_parameters["algorithm_settings"]
+        algorithm_settings.AddMissingParameters(default_settings)
+        self.__algorithm = OptimizationComponentFactory(self.model, algorithm_settings, self.optimization_problem)
+
+    def GetAlgorithm(self):
+        return self.__algorithm

KratosMultiphysics/OptimizationApplication/optimizations_controller.py

@@ -0,0 +1,223 @@
+# ==============================================================================
+#  KratosOptimizationApplication
+#
+#  License:         BSD License
+#                   license: OptimizationApplication/license.txt
+#
+#  Main authors:    Reza Najian Asl, https://github.com/RezaNajian
+#
+# ==============================================================================
+
+# Kratos Core and Apps
+import KratosMultiphysics as KM
+
+# Additional imports
+import KratosMultiphysics.OptimizationApplication.algorithms.algorithm_steepest_descent as steepest_descent
+import KratosMultiphysics.OptimizationApplication.algorithms.algorithm_gradient_projection as gradient_projection
+import time as timer
+
+# ==============================================================================
+def CreateController(optimizations_settings,model,model_parts_controller,analyses_controller,responses_controller,controls_controller):
+    return OptimizationsController(optimizations_settings,model,model_parts_controller,analyses_controller,responses_controller,controls_controller)
+
+# ==============================================================================
+class OptimizationsController:
+    # --------------------------------------------------------------------------
+    def __init__(self,optimizations_settings,model,model_parts_controller,analyses_controller,responses_controller,controls_controller):
+        
+        self.optimizations_settings = optimizations_settings
+        self.controls_controller = controls_controller
+        self.responses_controller = responses_controller
+        self.model = model
+
+        default_settings = KM.Parameters("""
+        {
+            "name"                : "OPT_NAME",
+            "type"                : "OPT_TYPE",
+            "settings"                : {
+                "objectives": [],
+                "objectives_improvements": [],
+                "constraints": [],
+                "constraints_types": [],
+                "constraints_ref_values": [],
+                "controls": [],
+                "objectives_controls_weights": [],
+                "constraints_controls_weights": [],
+                "controls_lower_bounds": [],
+                "controls_lower_bounds_values": [],
+                "controls_upper_bounds": [],
+                "controls_upper_bounds_values": [],                
+                "algorithm" : "ALG_NAME",
+                "algorithm_settings" : {
+                    "max_iterations"     : 100,
+                    "step_size"  : 0.1,
+                    "relative_tolerance" : 1e-3
+                }
+            }
+        }""")
+
+        if not self.optimizations_settings.size()>0:
+            raise RuntimeError("OptimizationsController: optimizations list in optimizer's parameters can not be empty !") 
+
+
+        self.optimizations = {}
+        self.optimizations_types={}
+
+
+        self.optimizations_objectives={}
+        self.optimizations_objectives_improvements={}
+
+
+        self.optimizations_constraints={}
+        self.optimizations_constraints_types={}
+        self.optimizations_constraints_ref_values={}
+        
+        
+        self.optimizations_controls={}
+        self.optimizations_objectives_controls_weights={}
+        self.optimizations_constraints_controls_weights={}
+
+
+        self.optimizations_algorithm={}
+        self.supported_opt_types = ["gradient_based"]
+        self.supported_algorithms = ["gradient_projection"]
+
+
+
+        for itr in range(self.optimizations_settings.size()):
+            opt_settings = self.optimizations_settings[itr]
+            opt_name = opt_settings["name"].GetString()
+            opt_type = opt_settings["type"].GetString()   
+            # check for name
+            if opt_name in self.optimizations.keys():  
+                raise RuntimeError("OptimizationsController: Optimization name '{}' already exists.".format(opt_name))    
+
+
+            # check for type
+            if not opt_type in self.supported_opt_types:  
+                raise RuntimeError("OptimizationsController: Optimization type '{}' is not supported, supported types {}.".format(opt_type,self.supported_opt_types))                  
+            self.optimizations_types[opt_name]=opt_type
+
+
+            # checks for objectives
+            objectives_names = opt_settings["settings"]["objectives"].GetStringArray()
+            if not len(objectives_names)>0:  
+                raise RuntimeError("OptimizationsController: Objectives list of optimization '{}' can not be empty.".format(opt_name))   
+            if len(set(objectives_names)) != len(objectives_names):
+                raise RuntimeError("OptimizationsController: Objectives list of optimization '{}' has duplicate response names '{}'.".format(opt_name,objectives_names))
+            self.responses_controller.CheckIfResponsesExist(objectives_names)
+            self.optimizations_objectives[opt_name]=objectives_names
+
+
+            # check for objectives improvements
+            if not opt_settings["settings"]["objectives_improvements"].IsVector():  
+                raise RuntimeError("OptimizationsController:'objectives_improvements' of optimization '{}' should be vector of doubles.".format(opt_name)) 
+            objectives_improvements = opt_settings["settings"]["objectives_improvements"].GetVector()     
+            if not len(objectives_improvements) == len(objectives_names):
+                raise RuntimeError("OptimizationsController:'objectives_improvements' of optimization '{}' should be of the same size of objectives list.".format(opt_name))
+            self.optimizations_objectives_improvements[opt_name]=objectives_improvements
+
+
+            # checks for constraints
+            if opt_settings["settings"]["constraints"].size()>0:
+                constraints_names = opt_settings["settings"]["constraints"].GetStringArray()
+                if len(set(constraints_names)) != len(constraints_names):
+                    raise RuntimeError("OptimizationsController: Constraint list of optimization '{}' has duplicate response names .".format(opt_name))
+                self.responses_controller.CheckIfResponsesExist(constraints_names)
+
+                for constraints_name in constraints_names:
+                    if constraints_name in objectives_names:
+                        raise RuntimeError("OptimizationsController: Response {} in optimization {} is used as both objective and constraint.".format(constraints_name,opt_name))
+                self.optimizations_constraints[opt_name]=constraints_names
+
+                constraints_types = opt_settings["settings"]["constraints_types"].GetStringArray()  
+                if not len(constraints_types) == len(constraints_names):
+                    raise RuntimeError("OptimizationsController:'constraints_types' of optimization '{}' should be of the same size of constraint list.".format(opt_name))
+                for index, type in enumerate(constraints_types):
+                    if not type in ["equality","smaller_than","bigger_than","initial_value_equality","smaller_than_initial_value","bigger_than_initial_value"]: 
+                        raise RuntimeError("OptimizationsController: constraint type {} of constraint {} of optimization '{}' should be either 'equality' or 'inequality'.".format(type,constraints_names[index],opt_name,))
+                self.optimizations_constraints_types[opt_name]=constraints_types                
+
+                if not opt_settings["settings"]["constraints_ref_values"].IsVector():  
+                    raise RuntimeError("OptimizationsController:'constraints_ref_values' of optimization '{}' should be vector of doubles.".format(opt_name)) 
+                constraints_ref_values = opt_settings["settings"]["constraints_ref_values"].GetVector() 
+                if not len(constraints_ref_values) == len(constraints_names):
+                    raise RuntimeError("OptimizationsController:'constraints_ref_values' of optimization '{}' should be of the same size of constraint list.".format(opt_name))
+                self.optimizations_constraints_ref_values[opt_name]=constraints_ref_values
+                
+            
+            # checks for controls
+            controls_names = opt_settings["settings"]["controls"].GetStringArray()
+            if not len(controls_names)>0:  
+                raise RuntimeError("OptimizationsController: Controls list of optimization '{}' can not be empty.".format(opt_name))   
+            if len(set(controls_names)) != len(controls_names):
+                raise RuntimeError("OptimizationsController: Controls list of optimization '{}' has duplicate control names .".format(opt_name))
+            self.controls_controller.CheckIfControlsExist(controls_names)
+
+            for key,values in self.optimizations_controls.items():
+                compare_results = set(controls_names) & set(values)
+                if len(compare_results):
+                    raise RuntimeError("OptimizationsController: Controls {} can not be shared between optimizations '{}' and '{}' .".format(compare_results,key,opt_name))
+            
+            self.optimizations_controls[opt_name]=controls_names            
+
+
+            # checks for objectives controls weights
+            if opt_settings["settings"]["objectives_controls_weights"].size() != len(controls_names):
+                raise RuntimeError("OptimizationsController: 'objectives_controls_weights' of optimization '{}' should be of the same size of control list .".format(opt_name))            
+
+            objectives_controls_weights=[]
+            for i in range(opt_settings["settings"]["objectives_controls_weights"].size()):
+                if not opt_settings["settings"]["objectives_controls_weights"][i].IsNumber():
+                    raise RuntimeError("OptimizationsController: entry {} of 'objectives_controls_weights' of optimization '{}' should be a number .".format(i+1,opt_name))
+                else:
+                    objectives_controls_weights.append(opt_settings["settings"]["objectives_controls_weights"][i].GetDouble())
+
+            self.optimizations_objectives_controls_weights[opt_name] = objectives_controls_weights
+
+
+            # checks for constraints controls weights
+            if opt_settings["settings"]["constraints_controls_weights"].size() != len(controls_names):
+                raise RuntimeError("OptimizationsController: 'constraints_controls_weights' of optimization '{}' should be of the same size of control list .".format(opt_name))            
+
+            constraints_controls_weights=[]
+            for i in range(opt_settings["settings"]["constraints_controls_weights"].size()):
+                if not opt_settings["settings"]["constraints_controls_weights"][i].IsNumber():
+                    raise RuntimeError("OptimizationsController: entry {} of 'constraints_controls_weights' of optimization '{}' should be a number .".format(i+1,opt_name))
+                else:
+                    constraints_controls_weights.append(opt_settings["settings"]["constraints_controls_weights"][i].GetDouble())
+
+            self.optimizations_constraints_controls_weights[opt_name] = constraints_controls_weights
+
+            
+            # checks for algorithms settings
+            algorithm = opt_settings["settings"]["algorithm"].GetString()
+            if not algorithm in self.supported_algorithms:
+                raise RuntimeError("OptimizationsController: Optimization algorithm '{}' is not supported, supported types {}.".format(algorithm,self.supported_algorithms))                  
+
+            if algorithm == "gradient_projection":
+                self.optimizations[opt_name] = gradient_projection.AlgorithmGradientProjection(opt_name,opt_settings["settings"],model,model_parts_controller,analyses_controller,responses_controller,controls_controller)
+    
+        
+    # --------------------------------------------------------------------------
+    def Initialize(self):
+        for opt in self.optimizations.values():
+            opt.InitializeOptimizationLoop()
+
+    # --------------------------------------------------------------------------
+    def Optimize(self,opt_name):
+        if not opt_name in self.optimizations.keys():
+            raise RuntimeError("OptimizationsController:Optimize: Optimization {} doesn not exist !.".format(opt_name))
+        
+        self.optimizations[opt_name].RunOptimizationLoop()
+    # --------------------------------------------------------------------------
+    def OptimizeAll(self):
+        for opt in self.optimizations.values():
+            opt.RunOptimizationLoop()
+
+
+
+            
+
+               
+

KratosMultiphysics/OptimizationApplication/optimizer.py

@@ -0,0 +1,61 @@
+# ==============================================================================
+#  KratosOptimizationApplication
+#
+#  License:         BSD License
+#                   license: OptimizationApplication/license.txt
+#
+#  Main authors:    Reza Najian Asl, https://github.com/RezaNajian
+#
+# ==============================================================================
+
+# Kratos Core and Apps
+import KratosMultiphysics as KM
+from KratosMultiphysics.OptimizationApplication import model_parts_controller
+from KratosMultiphysics.OptimizationApplication import analyses_controller
+from KratosMultiphysics.OptimizationApplication import responses_controller
+from KratosMultiphysics.OptimizationApplication import controls_controller
+from KratosMultiphysics.OptimizationApplication import optimizations_controller
+
+# additional imports
+
+
+## Purely for backward compatibility, should be removed soon.
+def CreateOptimizer(optimization_settings,model):
+    return Optimizer(optimization_settings,model)
+
+def Create(optimization_settings,model):
+    return Optimizer(optimization_settings,model)
+
+# ==============================================================================
+class Optimizer:
+    # --------------------------------------------------------------------------
+    def __init__(self, optimization_settings,model):
+        self._ValidateSettings(optimization_settings)
+        self.optimization_settings = optimization_settings
+        self.model_parts_controller = model_parts_controller.CreateController(optimization_settings["model_parts"],model)
+        self.analyses_controller = analyses_controller.CreateController(optimization_settings["analyses"],model,self.model_parts_controller)
+        self.responses_controller = responses_controller.CreateController(optimization_settings["responses"],model,self.model_parts_controller,self.analyses_controller)
+        self.controls_controller = controls_controller.CreateController(optimization_settings["controls"],model,self.model_parts_controller)
+        self.optimizations_controller = optimizations_controller.CreateController(optimization_settings["optimizations"],model,self.model_parts_controller,self.analyses_controller,self.responses_controller,self.controls_controller)
+
+
+    def _ValidateSettings(self, optimization_settings):
+        self._ValidateTopLevelSettings(optimization_settings)
+    # ------------------------------------------------------------------------------
+    def _ValidateTopLevelSettings(self, optimization_settings):
+        default_settings = KM.Parameters("""
+        {
+            "model_parts" : [ ],
+            "analyses" : [ ],
+            "responses" : [ ],            
+            "controls" : [ ],
+            "optimizations" : [ ]
+        }""")
+
+        for key in default_settings.keys():
+            if not optimization_settings.Has(key):
+                raise RuntimeError("Optimizer: Required setting '{}' missing in optimizer's input parameters !".format(key))
+
+        optimization_settings.ValidateAndAssignDefaults(default_settings)
+
+       

KratosMultiphysics/OptimizationApplication/processes/optimization_problem_ascii_output_process.py

@@ -0,0 +1,212 @@
+from datetime import datetime
+from typing import Union, Any
+
+import KratosMultiphysics as Kratos
+from KratosMultiphysics.OptimizationApplication.responses.response_function import ResponseFunction
+from KratosMultiphysics.OptimizationApplication.controls.control import Control
+from KratosMultiphysics.OptimizationApplication.execution_policies.execution_policy import ExecutionPolicy
+from KratosMultiphysics.OptimizationApplication.utilities.component_data_view import ComponentDataView
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem import OptimizationProblem
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem_utilities import GetAllComponentFullNamesWithData
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem_utilities import GetComponentHavingDataByFullName
+
+def Factory(_: Kratos.Model, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem) -> ExecutionPolicy:
+    if not parameters.Has("settings"):
+        raise RuntimeError(f"OptimizationProblemAsciiOutputProcess instantiation requires a \"settings\" in parameters [ parameters = {parameters}].")
+    return OptimizationProblemAsciiOutputProcess(parameters["settings"], optimization_problem)
+
+class Header:
+    def __init__(self, header_name: str, value: Any, format_info: dict):
+        header_name = header_name.strip()
+        header_length = len(header_name)
+
+        if isinstance(value, bool):
+            value_length = max(len(format_info[bool][0]), len(format_info[bool][1]))
+            value_format_post_fix = "s"
+            self.__value_converter = lambda x: format_info[bool][1] if x else format_info[bool][0]
+        elif isinstance(value, int):
+            value_length = len(("{:" + str(format_info[int]) + "d}").format(value))
+            value_format_post_fix = "d"
+            self.__value_converter = lambda x: int(x)
+        elif isinstance(value, float):
+            value_length = len(("{:0." + str(format_info[float]) + "e}").format(value))
+            value_format_post_fix = f".{format_info[float]}e"
+            self.__value_converter = lambda x: float(x)
+        else:
+            value_length = format_info[str]
+            value_format_post_fix = "s"
+            self.__value_converter = lambda x: str(x)
+
+        if header_length > value_length:
+            self.__header_name = header_name
+            self.__value_format = "{:>" + str(header_length) + value_format_post_fix + "}"
+        else:
+            self.__header_name = ("{:>" + str(value_length) + "s}").format(header_name)
+            self.__value_format = "{:>" + str(value_length) + value_format_post_fix + "}"
+
+    def GetHeaderName(self) -> str:
+        return self.__header_name
+
+    def GetValueStr(self, value: Any) -> str:
+        return self.__value_format.format(self.__value_converter(value))
+
+class OptimizationProblemAsciiOutputProcess(Kratos.OutputProcess):
+    def GetDefaultParameters(self):
+        return Kratos.Parameters(
+            """
+            {
+                "output_file_name"         : "SPECIFY_OUTPUT_FILE_NAME",
+                "write_kratos_version"     : true,
+                "write_time_stamp"         : true,
+                "write_initial_values"     : true,
+                "list_of_output_components": ["all"],
+                "format_info": {
+                    "int_length"     : 7,
+                    "float_precision": 9,
+                    "bool_values"    : ["no", "yes"],
+                    "string_length"  : 10
+                }
+            }
+            """
+        )
+
+    def __init__(self, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem):
+        Kratos.OutputProcess.__init__(self)
+
+        self.optimization_problem = optimization_problem
+        parameters.RecursivelyValidateAndAssignDefaults(self.GetDefaultParameters())
+
+        self.output_file_name = parameters["output_file_name"].GetString()
+        if not self.output_file_name.endswith(".csv"):
+            self.output_file_name += ".csv"
+
+        self.write_kratos_version = parameters["write_kratos_version"].GetBool()
+        self.write_time_stamp = parameters["write_time_stamp"].GetBool()
+        self.write_initial_values = parameters["write_initial_values"].GetBool()
+
+        self.format_info = {
+            int  : parameters["format_info"]["int_length"].GetInt(),
+            float: parameters["format_info"]["float_precision"].GetInt(),
+            bool : parameters["format_info"]["bool_values"].GetStringArray(),
+            str  : parameters["format_info"]["string_length"].GetInt(),
+        }
+
+        self.list_of_component_names = parameters["list_of_output_components"].GetStringArray()
+
+        if len(self.format_info[bool]) != 2:
+            raise RuntimeError("The \"bool_values\" should have only two strings corresponding to False and True values in the mentioned order.")
+
+        self.list_of_headers: 'list[tuple[Any, dict[str, Header]]]' = []
+        self.initialized_headers = False
+
+    def IsOutputStep(self) -> bool:
+        return True
+
+    def PrintOutput(self) -> None:
+        if not self.initialized_headers:
+            # now get the buffered data headers
+            self.list_of_headers = self._GetHeaders(lambda x: x.GetBufferedData())
+            # write the ehader information
+            self._WriteHeaders()
+            self.initialized_headers = True
+
+        if self._IsWritingProcess():
+            # now write step data
+            with open(self.output_file_name, "a") as file_output:
+                # write the step
+                file_output.write("{:>7d}".format(self.optimization_problem.GetStep()))
+
+                # write the values
+                for component, header_info_dict in self.list_of_headers:
+                    componend_data_view = ComponentDataView(component, self.optimization_problem)
+                    buffered_dict = componend_data_view.GetBufferedData()
+                    for k, header in header_info_dict.items():
+                        file_output.write(", " + header.GetValueStr(buffered_dict[k]))
+
+                file_output.write("\n")
+
+    def ExecuteFinalize(self):
+        if self._IsWritingProcess():
+            with open(self.output_file_name, "a") as file_output:
+                file_output.write("# End of file")
+
+    def _IsWritingProcess(self):
+        if Kratos.IsDistributedRun():
+            data_communicator: Kratos.DataCommunicator = Kratos.ParallelEnvironment.GetDefaultDataCommunicator()
+            return data_communicator.Rank() == 0
+        else:
+            return True
+
+    def _WriteHeaders(self):
+        if (self._IsWritingProcess()):
+            kratos_version = "not_given"
+            if (self.write_kratos_version):
+                kratos_version = str(Kratos.KratosGlobals.Kernel.Version())
+
+            time_stamp = "not_specified"
+            if (self.write_time_stamp):
+                time_stamp = str(datetime.now())
+
+            msg_header = ""
+            msg_header = f"{msg_header}# Optimization problem ascii output\n"
+            msg_header = f"{msg_header}# Kratos version: {kratos_version}\n"
+            msg_header = f"{msg_header}# Timestamp     : {time_stamp}\n"
+            msg_header = f"{msg_header}# -----------------------------------------------\n"
+
+            if self.write_initial_values:
+                msg_header = f"{msg_header}# --------------- Initial values ----------------\n"
+
+                initial_headers = self._GetHeaders(lambda x: x.GetUnBufferedData())
+                # now write the initial value container data
+                for component, header_info_dict in initial_headers:
+                    componend_data_view = ComponentDataView(component, self.optimization_problem)
+                    buffered_dict = componend_data_view.GetUnBufferedData()
+                    component_name = componend_data_view.GetComponentName()
+                    msg_header = f"{msg_header}# \t" + component_name + ":\n"
+                    for k, header in header_info_dict.items():
+                        component_name_header = header.GetHeaderName().strip()[len(component_name)+1:]
+                        msg_header = f"{msg_header}# \t\t" + component_name_header + ": " + header.GetValueStr(buffered_dict[k]).strip() + "\n"
+
+                msg_header = f"{msg_header}# ------------ End of initial values ------------\n"
+                msg_header = f"{msg_header}# -----------------------------------------------\n"
+
+            msg_header = f"{msg_header}# ------------ Start of step values -------------\n"
+            msg_header = f"{msg_header}# Headers:\n"
+
+            msg_header = f"{msg_header}#  STEP"
+
+            for _, header_info_dict in self.list_of_headers:
+                for header in header_info_dict.values():
+                    msg_header = f"{msg_header}, " + header.GetHeaderName()
+
+            msg_header = f"{msg_header}\n"
+
+            # write the header
+            with open(self.output_file_name, "w") as file_output:
+                file_output.write(msg_header)
+
+    def _GetHeaders(self, dict_getter_method) ->  'list[tuple[Any, dict[str, Header]]]':
+        self.list_of_components: 'list[Union[str, ResponseFunction, Control, ExecutionPolicy]]' = []
+
+        if len(self.list_of_component_names) == 1 and self.list_of_component_names[0] == "all":
+            self.list_of_component_names = GetAllComponentFullNamesWithData(self.optimization_problem)
+
+        for component_name in self.list_of_component_names:
+            component = GetComponentHavingDataByFullName(component_name, self.optimization_problem)
+            if ComponentDataView(component, self.optimization_problem).HasDataBuffer():
+                self.list_of_components.append(component)
+
+        list_of_headers: 'list[tuple[Any, dict[str, Header]]]' = []
+        for component in self.list_of_components:
+            componend_data_view = ComponentDataView(component, self.optimization_problem)
+            values_map = dict_getter_method(componend_data_view).GetMap()
+            header_info_dict: 'dict[str, Header]' = {}
+            component_name = componend_data_view.GetComponentName()
+            for k, v in values_map.items():
+                if isinstance(v, (bool, int, float, str)):
+                    header_name = component_name + ":" + k[k.rfind("/") + 1:]
+                    if header_name in [header.GetHeaderName().strip() for header in header_info_dict.values()]:
+                        Kratos.Logger.PrintWarning(self.__class__.__name__, "Second value with same header name = \"" + header_name + "\" found.")
+                    header_info_dict[k] = Header(header_name, v, self.format_info)
+            list_of_headers.append([component, header_info_dict])
+        return list_of_headers