KratosOptimizationApplication 10.4.4__py3-none-any.whl

KratosMultiphysics/OptimizationApplication/utilities/opt_projection.py

@@ -0,0 +1,191 @@
+# Temporal fix until to avoid list[type] related errors until we move to 3.9 and above.
+from __future__ import annotations
+
+from typing import Optional
+from abc import ABC, abstractmethod
+
+import KratosMultiphysics as Kratos
+import KratosMultiphysics.OptimizationApplication as KratosOA
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem import OptimizationProblem
+
+class DesignVariableProjection(ABC):
+    """Design variable projection methods to convert given x space values to given y space values
+
+    This is the interface class which can be used to implement design variable projection classes
+    which project forward and backward given x space values to y space.
+
+    The projection spaces should be scalar spaces.
+    """
+
+    @abstractmethod
+    def SetProjectionSpaces(self, x_space_values: 'list[float]', y_space_values: 'list[float]') -> None:
+        """Space values in x space and y space
+
+        Args:
+            x_space_values (list[float]): List of values to be used in x space
+            y_space_values (list[float]): List of values to be used in y space
+        """
+        pass
+
+    @abstractmethod
+    def ProjectForward(self, x_values: Kratos.TensorAdaptors.DoubleTensorAdaptor) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        """Project x space values to y space
+
+        Args:
+            x_values (Kratos.TensorAdaptors.DoubleTensorAdaptor): x space values.
+
+        Returns:
+            Kratos.TensorAdaptors.DoubleTensorAdaptor: y space values.
+        """
+        pass
+
+    @abstractmethod
+    def ProjectBackward(self, y_values: Kratos.TensorAdaptors.DoubleTensorAdaptor) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        """Project y space values to x space values
+
+        Args:
+            y_values (Kratos.TensorAdaptors.DoubleTensorAdaptor): y space values.
+
+        Returns:
+            Kratos.TensorAdaptors.DoubleTensorAdaptor: x space values.
+        """
+        pass
+
+    @abstractmethod
+    def ForwardProjectionGradient(self, x_values: Kratos.TensorAdaptors.DoubleTensorAdaptor) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        """Computes the forward projected y space values' gradient w.r.t x space.
+
+        Args:
+            x_values (Kratos.TensorAdaptors.DoubleTensorAdaptor): x space values.
+
+        Returns:
+            Kratos.TensorAdaptors.DoubleTensorAdaptor: gradient of the y space values w.r.t. x space.
+        """
+        pass
+
+    @abstractmethod
+    def Update(self) -> None:
+        """Updates the projection method
+        """
+
+class IdentityDesignVariableProjection(DesignVariableProjection):
+    def __init__(self, parameters: Kratos.Parameters, _):
+        default_settings = Kratos.Parameters("""{
+            "type"       : "identity_projection"
+        }""")
+        parameters.ValidateAndAssignDefaults(default_settings)
+        pass
+
+    def SetProjectionSpaces(self, _: 'list[float]', __: 'list[float]') -> None:
+        # not using any of the spaces provided.
+        pass
+
+    def ProjectForward(self, x_values: Kratos.TensorAdaptors.DoubleTensorAdaptor) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        # returns the x_values since x and y are the same for IdentityProjection
+        return Kratos.TensorAdaptors.DoubleTensorAdaptor(x_values)
+
+    def ProjectBackward(self, y_values: Kratos.TensorAdaptors.DoubleTensorAdaptor) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        # return the y_values since x and y are the same for Identity projection
+        return Kratos.TensorAdaptors.DoubleTensorAdaptor(y_values)
+
+    def ForwardProjectionGradient(self, x_values: Kratos.TensorAdaptors.DoubleTensorAdaptor) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        result = Kratos.TensorAdaptors.DoubleTensorAdaptor(x_values)
+        # x = y, hence the gradients are 1.0
+        result.data[:] = 1.0
+        return result
+
+    def Update(self) -> None:
+        pass
+
+class SigmoidalDesignVariableProjection(DesignVariableProjection):
+    def __init__(self, parameters: Kratos.Parameters, _):
+        default_parameters = Kratos.Parameters("""{
+            "type"          : "sigmoidal_projection",
+            "beta_value"    : 5,
+            "penalty_factor": 1
+        }""")
+
+        parameters.ValidateAndAssignDefaults(default_parameters)
+        self.beta = parameters["beta_value"].GetDouble()
+        self.penalty_factor = parameters["penalty_factor"].GetInt()
+
+        self.x_space_values: 'Optional[list[float]]' = None
+        self.y_space_values: 'Optional[list[float]]' = None
+
+    def SetProjectionSpaces(self, x_space_values: 'list[float]', y_space_values: 'list[float]') -> None:
+        self.x_space_values = x_space_values
+        self.y_space_values = y_space_values
+
+    def ProjectForward(self, x_values: Kratos.TensorAdaptors.DoubleTensorAdaptor) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        return KratosOA.ControlUtils.SigmoidalProjectionUtils.ProjectForward(x_values, self.x_space_values, self.y_space_values, self.beta, self.penalty_factor)
+
+    def ProjectBackward(self, y_values: Kratos.TensorAdaptors.DoubleTensorAdaptor) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        return KratosOA.ControlUtils.SigmoidalProjectionUtils.ProjectBackward(y_values, self.x_space_values, self.y_space_values, self.beta, self.penalty_factor)
+
+    def ForwardProjectionGradient(self, x_values: Kratos.TensorAdaptors.DoubleTensorAdaptor) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        return KratosOA.ControlUtils.SigmoidalProjectionUtils.CalculateForwardProjectionGradient(x_values, self.x_space_values, self.y_space_values, self.beta, self.penalty_factor)
+
+    def Update(self) -> None:
+        pass
+
+class AdaptiveSigmoidalDesignVariableProjection(DesignVariableProjection):
+    def __init__(self, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem):
+        default_parameters = Kratos.Parameters("""{
+            "type"          : "adaptive_sigmoidal_projection",
+            "initial_value" : 5,
+            "max_value"     : 30,
+            "increase_fac"  : 1.05,
+            "update_period" : 50,
+            "penalty_factor": 1
+        }""")
+
+        parameters.ValidateAndAssignDefaults(default_parameters)
+        self.beta = parameters["initial_value"].GetDouble()
+        self.max_beta = parameters["max_value"].GetDouble()
+        self.increase_fac = parameters["increase_fac"].GetDouble()
+        self.update_period = parameters["update_period"].GetInt()
+        self.penalty_factor = parameters["penalty_factor"].GetInt()
+        self.beta_computed_step = 1
+
+        self.x_space_values: 'Optional[list[float]]' = None
+        self.y_space_values: 'Optional[list[float]]' = None
+
+        self.optimization_problem = optimization_problem
+
+    def SetProjectionSpaces(self, x_space_values: 'list[float]', y_space_values: 'list[float]') -> None:
+        self.x_space_values = x_space_values
+        self.y_space_values = y_space_values
+
+    def ProjectForward(self, x_values: Kratos.TensorAdaptors.DoubleTensorAdaptor) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        return KratosOA.ControlUtils.SigmoidalProjectionUtils.ProjectForward(x_values, self.x_space_values, self.y_space_values, self.beta, self.penalty_factor)
+
+    def ProjectBackward(self, y_values: Kratos.TensorAdaptors.DoubleTensorAdaptor) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        return KratosOA.ControlUtils.SigmoidalProjectionUtils.ProjectBackward(y_values, self.x_space_values, self.y_space_values, self.beta, self.penalty_factor)
+
+    def ForwardProjectionGradient(self, x_values: Kratos.TensorAdaptors.DoubleTensorAdaptor) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        return KratosOA.ControlUtils.SigmoidalProjectionUtils.CalculateForwardProjectionGradient(x_values, self.x_space_values, self.y_space_values, self.beta, self.penalty_factor)
+
+    def Update(self) -> None:
+        step = self.optimization_problem.GetStep()
+        if step % self.update_period == 0 and self.beta_computed_step != step:
+            self.beta_computed_step = step
+            self.beta = min(self.beta * self.increase_fac, self.max_beta)
+            Kratos.Logger.PrintInfo(self.__class__.__name__, f"Increased beta to {self.beta}.")
+
+
+def CreateProjection(parameters: Kratos.Parameters, optimization_problem: OptimizationProblem) -> DesignVariableProjection:
+    if not parameters.Has("type"):
+        raise RuntimeError("DesignVariableProjection \"type\" is not present in following parameters:\n" + str(parameters))
+
+    projection_type = parameters["type"].GetString()
+
+    projection_types_map: 'dict[str, type[DesignVariableProjection]]' = {
+        "identity_projection"          : IdentityDesignVariableProjection,
+        "sigmoidal_projection"         : SigmoidalDesignVariableProjection,
+        "adaptive_sigmoidal_projection": AdaptiveSigmoidalDesignVariableProjection
+    }
+
+    if projection_type in projection_types_map.keys():
+        return projection_types_map[projection_type](parameters, optimization_problem)
+    else:
+        raise RuntimeError(f"Unsupported projected type = \"{projection_type}\" requested. Followings are supported:\n\t" + "\n\t".join(list(projection_types_map.keys())))

KratosMultiphysics/OptimizationApplication/utilities/optimization_problem.py

@@ -0,0 +1,237 @@
+from __future__ import annotations
+from typing import Any, Union
+
+import KratosMultiphysics as Kratos
+from KratosMultiphysics.OptimizationApplication.utilities.buffered_dict import BufferedDict
+from KratosMultiphysics.OptimizationApplication.execution_policies.execution_policy import ExecutionPolicy
+from KratosMultiphysics.OptimizationApplication.controls.master_control import MasterControl
+from KratosMultiphysics.OptimizationApplication.responses.response_function import ResponseFunction
+from KratosMultiphysics.OptimizationApplication.controls.control import Control
+from KratosMultiphysics.OptimizationApplication.responses.response_routine import ResponseRoutine
+
+class OptimizationProblem:
+    """This is the main data holder for optimization problems
+
+    This class holds one private @ref BufferedDict container
+    which is used to hold components of the optimization problem being solved,
+    and the problem data generated while solving the optimization problem.
+
+    """
+    def __init__(self, echo_level: int = 0) -> None:
+        """Creates an instance of Optimization info
+
+        Creates an instance of optimization info with most basic structure
+        for the BufferedDict container and components container.
+
+        """
+        self.__echo_level = echo_level
+
+        # create the optimization components data container with basic types
+        self.__components: 'dict[Any, dict[str, Any]]' = {
+            ResponseFunction: {},
+            ExecutionPolicy: {},
+            Control: {},
+            MasterControl:{},
+            ResponseRoutine:{}
+        }
+
+        # now set the processes dict with different categories of processes
+        # such as initialization, output processes
+        self.__proceses: 'dict[str, list[Kratos.Process]]' = {}
+
+        # create the unbufferd optimization problem data container
+        self.__problem_data = BufferedDict(1)
+
+        # initialize the step
+        self.__problem_data["step"] = 0
+
+    def GetComponentType(self, component: Union[ExecutionPolicy, ResponseFunction, Control, MasterControl, ResponseRoutine]) -> Any:
+        for k in self.__components.keys():
+            if isinstance(component, k):
+                return k
+
+        return None
+
+    def GetComponentName(self, component: Union[ExecutionPolicy, ResponseFunction, Control, MasterControl, ResponseRoutine]) -> str:
+        component_type = self.GetComponentType(component)
+        if not component_type is None:
+            components = self.__components[component_type]
+        else:
+            raise RuntimeError(f"Unsupported component type {component} provided.")
+
+        for comp_name, current_component in components.items():
+            if component == current_component:
+                return comp_name
+
+        raise RuntimeError(f"The given {component} not found in components of type {component_type}.")
+
+    def AddComponent(self, component: Union[ExecutionPolicy, ResponseFunction, Control, MasterControl, ResponseRoutine]) -> None:
+        for k, v in self.__components.items():
+            if isinstance(component, k):
+                added_component_type = k.__name__
+                v[component.GetName()] = component
+                break
+
+        if added_component_type is None:
+            raise RuntimeError(f"The given component is of not supported types. Supported types:\n\tKratos.Process\n\t" + "\n\t".join([k.__name__ for k in self.__components.keys()]))
+        else:
+            if self.__echo_level > 0:
+                Kratos.Logger.PrintInfo(self.__class__.__name__, f"Added \"{component.GetName()}\" to \"{added_component_type}\".")
+
+    def GetResponse(self, name: str) -> ResponseFunction:
+        return self.GetComponent(name, ResponseFunction)
+
+    def GetListOfResponses(self) -> 'list[ResponseFunction]':
+        return self.__components[ResponseFunction].values()
+
+    def HasResponse(self, name_or_response: 'Union[str, ResponseFunction]') -> bool:
+        if isinstance(name_or_response, str):
+            return name_or_response in [response_function.GetName() for response_function in self.GetListOfResponses()]
+        elif isinstance(name_or_response, ResponseFunction):
+            return name_or_response in self.GetListOfResponses()
+        else:
+            raise RuntimeError(f"Unsupported type provided for name_or_response. Only allowed to have string or ResponseFunction types.")
+
+    def RemoveResponse(self, name: str) -> None:
+        self.RemoveComponent(name, ResponseFunction)
+
+    def GetExecutionPolicy(self, name: str) -> ExecutionPolicy:
+        return self.GetComponent(name, ExecutionPolicy)
+
+    def GetListOfExecutionPolicies(self) -> 'list[ExecutionPolicy]':
+        return self.__components[ExecutionPolicy].values()
+
+    def HasExecutionPolicy(self, name_or_execution_policy: 'Union[str, ExecutionPolicy]') -> bool:
+        if isinstance(name_or_execution_policy, str):
+            return name_or_execution_policy in [execution_policy.GetName() for execution_policy in self.GetListOfExecutionPolicies()]
+        elif isinstance(name_or_execution_policy, ExecutionPolicy):
+            return name_or_execution_policy in self.GetListOfExecutionPolicies()
+        else:
+            raise RuntimeError(f"Unsupported type provided for name_or_execution_policy. Only allowed to have string or ExecutionPolicy types.")
+
+    def RemoveExecutionPolicy(self, name: str) -> None:
+        self.RemoveComponent(name, ExecutionPolicy)
+
+    def GetControl(self, name: str) -> Control:
+        return self.GetComponent(name, Control)
+
+    def GetListOfControls(self) -> 'list[Control]':
+        return self.__components[Control].values()
+
+    def HasControl(self, name_or_control: 'Union[str, Control]') -> bool:
+        if isinstance(name_or_control, str):
+            return name_or_control in [control.GetName() for control in self.GetListOfControls()]
+        elif isinstance(name_or_control, Control):
+            return name_or_control in self.GetListOfControls()
+        else:
+            raise RuntimeError(f"Unsupported type provided for name_or_control. Only allowed to have string or Control types.")
+
+    def RemoveControl(self, name: str) -> None:
+        self.RemoveComponent(name, Control)
+
+    def AddProcessType(self, process_type: str) -> None:
+        self.__proceses[process_type] = []
+
+    def GetResponseRoutine(self, name: str) -> ResponseRoutine:
+        return self.GetComponent(name, ResponseRoutine)
+
+    def GetListOfResponseRoutines(self) -> 'list[ResponseRoutine]':
+        return self.__components[ResponseRoutine].values()
+
+    def HasResponseRoutine(self, name_or_response_routine: 'Union[str, ResponseRoutine]') -> bool:
+        if isinstance(name_or_response_routine, str):
+            return name_or_response_routine in [response_routine.GetName() for response_routine in self.GetListOfResponseRoutines()]
+        elif isinstance(name_or_response_routine, ResponseRoutine):
+            return name_or_response_routine in self.GetListOfResponseRoutines()
+        else:
+            raise RuntimeError(f"Unsupported type provided for name_or_control. Only allowed to have string or Control types.")
+
+    def RemoveResponseRoutine(self, name: str) -> None:
+        self.RemoveComponent(name, ResponseRoutine)
+
+    def GetMasterControl(self, name: str) -> MasterControl:
+        return self.GetComponent(name, MasterControl)
+
+    def GetListOfMasterControls(self) -> 'list[MasterControl]':
+        return self.__components[MasterControl].values()
+
+    def HasMasterControl(self, name_or_master_control: 'Union[str, MasterControl]') -> bool:
+        if isinstance(name_or_master_control, str):
+            return name_or_master_control in [master_control.GetName() for master_control in self.GetListOfMasterControls()]
+        elif isinstance(name_or_master_control, MasterControl):
+            return name_or_master_control in self.GetListOfMasterControls()
+        else:
+            raise RuntimeError(f"Unsupported type provided for name_or_control. Only allowed to have string or Control types.")
+
+    def RemoveMasterControl(self, name: str) -> None:
+        self.RemoveComponent(name, MasterControl)
+
+    def AddProcess(self, process_type: str, process: Kratos.Process) -> None:
+        if process_type not in self.__proceses.keys():
+            self.__proceses[process_type]: 'list[Kratos.Process]' = []
+
+        if not isinstance(process, Kratos.Process):
+            raise RuntimeError(f"The provided process is not of type Kratos.Process. [ process = {process}]")
+
+        if self.__echo_level > 0:
+            Kratos.Logger.PrintInfo(self.__class__.__name__, f"Added \"{process.__class__.__name__}\" to \"{process_type}\".")
+        self.__proceses[process_type].append(process)
+
+    def GetAvailableProcessTypes(self) -> 'list[str]':
+        return self.__proceses.keys()
+
+    def GetListOfProcesses(self, process_type: str) -> 'list[Kratos.Process]':
+        if process_type not in self.__proceses.keys():
+            raise RuntimeError(f"The process type = \"{process_type}\" not found. Followings are available process types:\n\t" + "\n\t".join([k for k in self.__proceses.keys()]))
+
+        return self.__proceses[process_type]
+
+    def GetStep(self) -> int:
+        """Gets the current step of the optimization info
+
+        Returns:
+            int: Current step of the optimization info.
+        """
+        return self.__problem_data["step"]
+
+    def AdvanceStep(self) -> None:
+        """Advances the problem data by one step.
+
+        This method advances problem data by one step and
+        clears all the data in the advanced step.
+
+        """
+        current_step = self.__problem_data["step"]
+        self.__problem_data.AdvanceStep()
+        self.__problem_data["step"] = current_step + 1
+
+    def GetProblemDataContainer(self) -> BufferedDict:
+        """Gets the global problem data container.
+
+        Returns:
+            BufferedDict: Global problem data container.
+        """
+        return self.__problem_data
+
+    def GetComponentContainer(self) -> 'dict[Any, dict[str, Any]]':
+        return self.__components
+
+    def GetComponent(self, name: str, component_type: Any) -> Any:
+        if component_type not in self.__components.keys():
+            raise RuntimeError(f"Unsupported component type requested from GetComponent. [ requested component type = \"{component_type}\" ]. Followings are supported component types:\n\t" + "\n\t".join([component_type.__name__ for component_type in list(self.__components.keys())]))
+
+        components = self.__components[component_type]
+        if name in components.keys():
+            return components[name]
+        else:
+            raise RuntimeError(f"No {component_type.__name__} with name = \"{name}\" exists. Followings are the available {component_type.__name__}:\n" + "\n\t".join(components.keys()))
+
+    def RemoveComponent(self, name: str, component_type: Any) -> None:
+        if component_type not in self.__components.keys():
+            raise RuntimeError(f"Unsupported component type requested from RemoveComponent. [ requested component type = \"{str(component_type)}\" ]. Followings are supported component types:\n\t" + "\n\t".join([component_type.__name__ for component_type in list(self.__components.keys())]))
+
+        components = self.__components[component_type]
+        if name in components.keys():
+            del components[name]
+        else:
+            raise RuntimeError(f"No {component_type.__name__} with name = \"{name}\" exists. Followings are the available {component_type.__name__}:\n" + "\n\t".join(components.keys()))

KratosMultiphysics/OptimizationApplication/utilities/optimization_problem_utilities.py

@@ -0,0 +1,237 @@
+from importlib import import_module
+from typing import Any, Union
+
+import KratosMultiphysics as Kratos
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem import OptimizationProblem
+from KratosMultiphysics.OptimizationApplication.responses.response_routine import ResponseRoutine
+from KratosMultiphysics.OptimizationApplication.utilities.component_data_view import ComponentDataView
+from KratosMultiphysics.OptimizationApplication.responses.response_function import ResponseFunction
+from KratosMultiphysics.OptimizationApplication.controls.control import Control
+from KratosMultiphysics.OptimizationApplication.execution_policies.execution_policy import ExecutionPolicy
+
+def OptimizationComponentFactory(model: Kratos.Model, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem):
+    if not parameters.Has("type"):
+        raise RuntimeError(f"Components created from OptimizationComponentFactory require the \"type\" [ provided parameters = {parameters}].")
+
+    python_type = parameters["type"].GetString()
+
+    if not parameters.Has("module") or parameters["module"].GetString() == "":
+        # in the case python type comes without a module
+        # as in the case python_type is in the sys path or the current working directory.
+        full_module_name = python_type
+    else:
+        # in the case python type comes with a module.
+        module = parameters["module"].GetString()
+        full_module_name = f"{module}.{python_type}"
+
+    module = import_module(full_module_name)
+    if not hasattr(module, "Factory"):
+        raise RuntimeError(f"Python module {full_module_name} does not have a Factory method.")
+
+    return getattr(module, "Factory")(model, parameters, optimization_problem)
+
+def GetAllComponentFullNamesWithData(optimization_problem: OptimizationProblem) -> 'list[str]':
+    data_container = optimization_problem.GetProblemDataContainer()
+
+    list_of_components_full_names_with_data: 'list[str]' = []
+    for component_type_str, components_dict in data_container.GetSubItems().items():
+        if component_type_str != "object":
+            component_type_str = Kratos.StringUtilities.ConvertCamelCaseToSnakeCase(component_type_str) + "."
+        else:
+            component_type_str = ""
+        for component_name in components_dict.GetSubItems().keys():
+            list_of_components_full_names_with_data.append(f"{component_type_str}{component_name}")
+
+    return list_of_components_full_names_with_data
+
+def GetComponentHavingDataByFullName(component_full_name: str, optimization_problem: OptimizationProblem) -> Any:
+    data_container = optimization_problem.GetProblemDataContainer()
+
+    name_data = component_full_name.split(".")
+
+    if len(name_data) == 1:
+        if data_container.HasValue("object") and data_container["object"].HasValue(component_full_name):
+            return component_full_name
+    else:
+        component_type_str = Kratos.StringUtilities.ConvertSnakeCaseToCamelCase(name_data[0])
+        component_name = name_data[1]
+
+        for component_type in optimization_problem.GetComponentContainer().keys():
+            if component_type.__name__ == component_type_str:
+                return optimization_problem.GetComponent(component_name, component_type)
+
+    msg = ""
+    for component_type, dict_of_components in optimization_problem.GetComponentContainer().items():
+        for sub_item_name in dict_of_components.keys():
+            msg += "\n\t" + Kratos.StringUtilities.ConvertCamelCaseToSnakeCase(component_type.__name__) + f".{sub_item_name}"
+    if data_container.HasValue("object"):
+        for sub_item_name in data_container["object"].GetSubItems().keys():
+            msg += "\n\t" + sub_item_name
+
+    raise RuntimeError(f"\"{component_full_name}\" full component name is not found in the optimization problem. Followings are supported component with full names:" + msg)
+
+def GetComponentValueByFullName(component_data_view: ComponentDataView, value_name: str, step_index = 0) -> Any:
+    value_info = value_name.split(":")
+    if len(value_info) != 2 or value_info[1] not in ["historical", "non_historical"]:
+        raise RuntimeError(f"The value_name should contain the name of the value and either it is located at buffered data or un buffered data. Ex: \"objective_Value:historical\" for buffered container or \"reference_value:non_historical\" for unbuffered container [ value_name = \"{value_name}\" ].")
+
+    if value_info[1] == "historical":
+        data = component_data_view.GetBufferedData()
+    elif value_info[1] == "non_historical":
+        data = component_data_view.GetUnBufferedData()
+
+    if not data.HasValue(value_info[0], step_index):
+        raise RuntimeError(f"The value = \"{value_info[0]}\" is not found in the component = \"{component_data_view.GetComponentName()}\" [ value_name = \"{value_name}\", step_index = {step_index}, data = {data}, component_data_view = {component_data_view}")
+
+    return data.GetValue(value_info[0], step_index)
+
+def SetComponentValueByFullName(component_data_view: ComponentDataView, value_name: str, value: Any, step_index = 0, overwrite = False) -> None:
+    value_info = value_name.split(":")
+    if len(value_info) != 2 or value_info[1] not in ["historical", "non_historical"]:
+        raise RuntimeError(f"The value_name should contain the name of the value and either it is located at buffered data or un buffered data. Ex: \"objective_Value:historical\" for buffered container or \"reference_value:non_historical\" for unbuffered container [ value_name = \"{value_name}\" ].")
+
+    if value_info[1] == "historical":
+        data = component_data_view.GetBufferedData()
+    elif value_info[1] == "non_historical":
+        data = component_data_view.GetUnBufferedData()
+
+    data.SetValue(value_info[0], value, step_index, overwrite)
+
+def OutputGradientFields(response: ResponseRoutine, optimization_problem: OptimizationProblem, is_gradients_computed: bool) -> None:
+    unbuffered_data = ComponentDataView(response.GetReponse(), optimization_problem).GetUnBufferedData()
+    if is_gradients_computed:
+        # save the physical gradients for post processing in unbuffered data container.
+        for physical_var, physical_gradient in response.GetRequiredPhysicalGradients().items():
+            variable_name = f"d{response.GetResponseName()}_d{physical_var.Name()}"
+            for physical_gradient_ta in physical_gradient.GetTensorAdaptors():
+                unbuffered_data.SetValue(variable_name, Kratos.TensorAdaptors.DoubleTensorAdaptor(physical_gradient_ta), overwrite=True)
+
+        # save the filtered gradients for post processing in unbuffered data container.
+        for gradient_container_ta, control in zip(response.GetMappedGradients().GetTensorAdaptors(), response.GetMasterControl().GetListOfControls()):
+            variable_name = f"d{response.GetResponseName()}_d{control.GetName()}"
+            unbuffered_data.SetValue(variable_name, Kratos.TensorAdaptors.DoubleTensorAdaptor(gradient_container_ta), overwrite=True)
+    else:
+        # save the physical gradients for post processing in unbuffered data container.
+        for physical_var, physical_gradient in response.GetRequiredPhysicalGradients().items():
+            variable_name = f"d{response.GetResponseName()}_d{physical_var.Name()}"
+            for physical_gradient_ta in physical_gradient.GetTensorAdaptors():
+                temp_ta = Kratos.TensorAdaptors.DoubleTensorAdaptor(physical_gradient_ta)
+                temp_ta.data[:] = 0.0
+                unbuffered_data.SetValue(variable_name, temp_ta, overwrite=True)
+
+        # save the filtered gradients for post processing in unbuffered data container.
+        for control in response.GetMasterControl().GetListOfControls():
+            variable_name = f"d{response.GetResponseName()}_d{control.GetName()}"
+            unbuffered_data.SetValue(variable_name, control.GetEmptyField(), overwrite=True)
+
+class TensorAdaptorData:
+    def __init__(self, tensor_adaptor_path: str, tensor_adaptor: Kratos.TensorAdaptors.DoubleTensorAdaptor) -> None:
+        self.tensor_adaptor_path = tensor_adaptor_path
+        self.container = tensor_adaptor.GetContainer()
+
+    def GetTensorAdaptorName(self) -> str:
+        return self.tensor_adaptor_path[self.tensor_adaptor_path.rfind("/")+1:]
+
+    def GetTensorAdaptorPath(self) -> str:
+        return self.tensor_adaptor_path
+
+    def GetContainer(self):
+        return self.container
+
+    def GetTensorAdaptor(self, optimization_problem: OptimizationProblem) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        data = optimization_problem.GetProblemDataContainer()[self.tensor_adaptor_path]
+
+        if not isinstance(data, Kratos.TensorAdaptors.DoubleTensorAdaptor):
+            raise RuntimeError(f"The data type at \"{self.tensor_adaptor_path}\" changed from {Kratos.TensorAdaptors.DoubleTensorAdaptor.__name__} to {type(data).__class__.__name__}. Found data = {data}")
+        if not data.HasContainer():
+            raise RuntimeError(f"The data at \"{self.tensor_adaptor_path}\" does not represent a {Kratos.TensorAdaptors.DoubleTensorAdaptor.__name__} with a container. Found data = {data}")
+        if data.GetContainer() != self.container:
+            raise RuntimeError(f"The container at \"{self.tensor_adaptor_path}\" mismatch with the original container. Found data = {data}")
+
+        return data
+
+class CombinedTensorAdaptorData(TensorAdaptorData):
+    def __init__(self, combined_tensor_adaptor_path: str, combined_tensor_adaptor: Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor, tensor_adaptor_index: int) -> None:
+        super().__init__(combined_tensor_adaptor_path, combined_tensor_adaptor.GetTensorAdaptors()[tensor_adaptor_index])
+        self.tensor_adaptor_index = tensor_adaptor_index
+
+    def GetTensorAdaptor(self, optimization_problem: OptimizationProblem) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        data = optimization_problem.GetProblemDataContainer()[self.tensor_adaptor_path]
+
+        if not isinstance(data, Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor):
+            raise RuntimeError(f"The data type at \"{self.tensor_adaptor_path}\" changed from {Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor.__name__} to {type(data).__class__.__name__}. Found data = {data}")
+        if not data.GetTensorAdaptors()[self.tensor_adaptor_index].HasContainer():
+            raise RuntimeError(f"The tensor adaptor at \"{self.tensor_adaptor_path}\" with index = {self.tensor_adaptor_index} does not represent a {Kratos.TensorAdaptors.DoubleTensorAdaptor.__name__} with a container. Found data = {data}")
+        if data.GetTensorAdaptors()[self.tensor_adaptor_index].GetContainer() != self.container:
+            raise RuntimeError(f"The container from tensor adaptor \"{self.tensor_adaptor_path}\" with index = {self.tensor_adaptor_index} mismatch with the original container. Found data = {data}")
+
+        return data.GetTensorAdaptors()[self.tensor_adaptor_index]
+
+class TensorAdaptorDataManager:
+    def __init__(self, optimization_problem: OptimizationProblem):
+        self.optimization_problem = optimization_problem
+        self.list_of_component_names = ["all"]
+        self.list_of_tensor_adaptor_hdf5_outputs = []
+        self.create_method = None
+
+    def InitializeHDF5Output(self) -> None:
+        # get all the component names at the first writing point
+        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)
+
+        list_of_components: 'list[Union[str, ResponseFunction, Control, ExecutionPolicy]]' = []
+        for component_name in self.list_of_component_names:
+            list_of_components.append(GetComponentHavingDataByFullName(component_name, self.optimization_problem))
+
+        global_values_map = self.optimization_problem.GetProblemDataContainer().GetMap()
+        for global_k, global_v in global_values_map.items():
+             # first check whether this is part of requested list of components
+            found_valid_component = False
+            for component in list_of_components:
+                component_data = ComponentDataView(component, self.optimization_problem)
+                if global_k.startswith(component_data.GetDataPath()):
+                     found_valid_component = True
+                     break
+
+            # if a valid component is found, add the tensor adaptor
+            if found_valid_component:
+                if isinstance(global_v, Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor):
+                    for i, _ in enumerate(global_v.GetTensorAdaptors()):
+                        self._AddContainerTensorAdaptor(CombinedTensorAdaptorData(global_k, global_v, i))
+                elif isinstance(global_v, Kratos.TensorAdaptors.DoubleTensorAdaptor) or  \
+                     isinstance(global_v, Kratos.TensorAdaptors.IntTensorAdaptor) or \
+                     isinstance(global_v, Kratos.TensorAdaptors.BoolTensorAdaptor):
+                    self._AddContainerTensorAdaptor(TensorAdaptorData(global_k, global_v))
+
+    def _AddContainerTensorAdaptor(self, tensor_adaptor_data: TensorAdaptorData):
+        found_vtu_output = False
+        for tensor_adaptor_hdf5_output in self.list_of_tensor_adaptor_hdf5_outputs:
+            if tensor_adaptor_hdf5_output.AddTensorAdaptorData(tensor_adaptor_data):
+                found_vtu_output = True
+                break
+
+        if not found_vtu_output:
+            tensor_adaptor_hdf5_output = self.create_method(self.__GetRootModelPart(tensor_adaptor_data.GetContainer()), self.optimization_problem)
+            tensor_adaptor_hdf5_output.AddTensorAdaptorData(tensor_adaptor_data)
+            self.list_of_tensor_adaptor_hdf5_outputs.append(tensor_adaptor_hdf5_output)
+            if self.echo_level > 0:
+                Kratos.Logger.PrintInfo(self.__class__.__name__, f"Created tensor adaptor hdf5 output for {tensor_adaptor_hdf5_output.model_part.FullName()}.")
+
+    def __GetRootModelPart(self, container) -> Kratos.ModelPart:
+        def get_model_part(container, model_part: Kratos.ModelPart):
+            if container in [model_part.Nodes, model_part.Conditions, model_part.Elements]:
+                return model_part.GetRootModelPart()
+
+            for sub_model_part_name in model_part.GetSubModelPartNames():
+                root_model_part = get_model_part(container, model_part.GetSubModelPart(sub_model_part_name))
+                if root_model_part is not None:
+                    return root_model_part
+
+            return None
+
+        for model_part_name in self.model.GetModelPartNames():
+            root_model_part = get_model_part(container, self.model[model_part_name])
+            if root_model_part is not None:
+                return root_model_part
+
+        raise RuntimeError(f"No model part contains the provided container.")