KratosOptimizationApplication 10.4.4__py3-none-any.whl

KratosMultiphysics/OptimizationApplication/controls/external_response_function_control.py

@@ -0,0 +1,149 @@
+import numpy
+from typing import Optional
+import KratosMultiphysics as Kratos
+from KratosMultiphysics.OptimizationApplication.controls.control import Control
+from KratosMultiphysics.OptimizationApplication.filtering.filter import Filter
+from KratosMultiphysics.OptimizationApplication.filtering.filter import Factory as FilterFactory
+from KratosMultiphysics.OptimizationApplication.utilities.model_part_utilities import ModelPartOperation
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem import OptimizationProblem
+from KratosMultiphysics.OptimizationApplication.utilities.component_data_view import ComponentDataView
+from KratosMultiphysics.OptimizationApplication.utilities.union_utilities import SupportedSensitivityFieldVariableTypes
+from KratosMultiphysics.OptimizationApplication.utilities.logger_utilities import TimeLogger
+
+def Factory(model: Kratos.Model, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem) -> Control:
+    if not parameters.Has("name"):
+        raise RuntimeError(f"ExternalResponseFunctionControl instantiation requires a \"name\" in parameters [ parameters = {parameters}].")
+    if not parameters.Has("settings"):
+        raise RuntimeError(f"ExternalResponseFunctionControl instantiation requires a \"settings\" in parameters [ parameters = {parameters}].")
+
+    return ExternalResponseFunctionControl(parameters["name"].GetString(), model, parameters["settings"], optimization_problem)
+
+class ExternalResponseFunctionControl(Control):
+    def __init__(self, control_name: str, model: Kratos.Model, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem) -> None:
+        super().__init__(control_name)
+
+        default_parameters = Kratos.Parameters("""{
+            "controlled_model_part_names": [],
+            "design_variable"            : "CUSTOM_DESIGN_VARIABLE",
+            "use_filtering"              : false,
+            "filter_settings"            : {},
+            "output_all_fields"          : false
+        }""")
+        parameters.ValidateAndAssignDefaults(default_parameters)
+
+        self.model = model
+        self.optimization_problem = optimization_problem
+
+        self.model_part_operation = ModelPartOperation(self.model, ModelPartOperation.OperationType.UNION, f"control_{self.GetName()}", parameters["controlled_model_part_names"].GetStringArray(), False)
+        self.model_part: 'Optional[Kratos.ModelPart]' = None
+
+        self.design_variable: SupportedSensitivityFieldVariableTypes = Kratos.KratosGlobals.GetVariable(parameters["design_variable"].GetString())
+        self.output_all_fields = parameters["output_all_fields"].GetBool()
+
+        if parameters["use_filtering"].GetBool():
+            self.filter: 'Optional[Filter]' = FilterFactory(self.model, self.model_part_operation.GetModelPartFullName(), self.design_variable, Kratos.Globals.DataLocation.NodeNonHistorical, parameters["filter_settings"])
+        else:
+            self.filter = None
+
+
+    def Initialize(self) -> None:
+        self.model_part = self.model_part_operation.GetModelPart()
+
+        ComponentDataView(self, self.optimization_problem).SetDataBuffer(1)
+
+        # initialize the filter
+        if self.filter:
+            self.filter.SetComponentDataView(ComponentDataView(self, self.optimization_problem))
+            self.filter.Initialize()
+
+        self.physical_phi_field = Kratos.TensorAdaptors.VariableTensorAdaptor(self.model_part.Nodes, self.design_variable)
+        self.physical_phi_field.CollectData()
+
+        if self.filter:
+            # take the physical and control field the same
+            self.control_phi_field = self.filter.UnfilterField(self.physical_phi_field)
+        else:
+            self.control_phi_field = self.physical_phi_field.Clone()
+
+        # now update the physical thickness field
+        self._UpdateAndOutputFields(self.GetEmptyField())
+
+    def Check(self) -> None:
+        if self.filter:
+            self.filter.Check()
+
+    def Finalize(self) -> None:
+        if self.filter:
+            self.filter.Finalize()
+
+    def GetPhysicalKratosVariables(self) -> 'list[SupportedSensitivityFieldVariableTypes]':
+        return [self.design_variable]
+
+    def GetEmptyField(self) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        ta = Kratos.TensorAdaptors.VariableTensorAdaptor(self.model_part.Nodes, self.design_variable)
+        ta.data[:] = 0.0
+        return ta
+
+    def GetControlField(self) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        return self.control_phi_field.Clone()
+
+    def MapGradient(self, physical_variable_gradient_map: 'dict[SupportedSensitivityFieldVariableTypes, Kratos.TensorAdaptors.DoubleTensorAdaptor]') -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        with TimeLogger("ExternalResponseFunctionControl::MapGradient", None, "Finished",False):
+            keys = physical_variable_gradient_map.keys()
+            if len(keys) != 1:
+                raise RuntimeError(f"Provided more than required gradient fields for control \"{self.GetName()}\". Following are the variables:\n\t" + "\n\t".join([k.Name() for k in keys]))
+            if self.design_variable not in keys:
+                raise RuntimeError(f"The required gradient for control \"{self.GetName()}\" w.r.t. {self.design_variable.Name()} not found. Followings are the variables:\n\t" + "\n\t".join([k.Name() for k in keys]))
+
+            physical_gradient = physical_variable_gradient_map[self.design_variable]
+            if physical_gradient.GetContainer() != self.model_part.Nodes:
+                raise RuntimeError(f"Gradients for the required container not found for control \"{self.GetName()}\". [ required model part name: {self.model_part.FullName()}, given model part name: {physical_gradient.GetModelPart().FullName()} ]")
+
+            if self.filter:
+                # now filter the field
+                filtered_gradient = self.filter.BackwardFilterIntegratedField(physical_gradient)
+            else:
+                filtered_gradient = physical_gradient.Clone()
+
+            return filtered_gradient
+
+    def Update(self, new_control_field: Kratos.TensorAdaptors.DoubleTensorAdaptor) -> bool:
+        if new_control_field.GetContainer() != self.model_part.Nodes:
+            raise RuntimeError(f"Updates for the required container not found for control \"{self.GetName()}\". [ required model part name: {self.model_part.FullName()} ]")
+
+        update = new_control_field.Clone()
+        update.data[:] -= self.control_phi_field.data
+        if numpy.linalg.norm(update.data) > 1e-15:
+            with TimeLogger(self.__class__.__name__, f"Updating {self.GetName()}...", f"Finished updating of {self.GetName()}.",False):
+                # update the control thickness field
+                self.control_phi_field.data[:] = new_control_field.data
+                # now update the physical field
+                self._UpdateAndOutputFields(update)
+
+                if self.filter:
+                    self.filter.Update()
+                return True
+        return False
+
+    def _UpdateAndOutputFields(self, update: Kratos.TensorAdaptors.DoubleTensorAdaptor) -> None:
+        if self.filter:
+            # filter the control field
+            filtered_update = self.filter.ForwardFilterField(update)
+        else:
+            filtered_update = update.Clone()
+
+        self.physical_phi_field.data[:] += filtered_update.data
+        Kratos.TensorAdaptors.VariableTensorAdaptor(self.physical_phi_field, self.design_variable, copy=False).StoreData()
+
+        # add the values of the control to the optimization problem.
+        component_data_view = ComponentDataView(self, self.optimization_problem)
+        for i, v in enumerate(self.physical_phi_field.data):
+            component_data_view.GetBufferedData().SetValue(f"{self.model_part.FullName()}_point_{i+1}", float(v))
+
+        # now output the fields
+        un_buffered_data = ComponentDataView(self, self.optimization_problem).GetUnBufferedData()
+        un_buffered_data.SetValue(f"{self.GetName()}_{self.design_variable.Name()}", self.physical_phi_field.Clone(), overwrite=True)
+        if self.output_all_fields:
+            un_buffered_data.SetValue(f"{self.GetName()}_{self.design_variable.Name()}_update", update.Clone(), overwrite=True)
+            un_buffered_data.SetValue(f"{self.GetName()}_{self.design_variable.Name()}_filtered_update", filtered_update.Clone(), overwrite=True)
+            un_buffered_data.SetValue(f"{self.GetName()}_{self.design_variable.Name()}_control_phi", self.control_phi_field.Clone(), overwrite=True)

KratosMultiphysics/OptimizationApplication/controls/master_control.py

@@ -0,0 +1,198 @@
+import typing
+import KratosMultiphysics as Kratos
+from KratosMultiphysics.OptimizationApplication.controls.control import Control
+from KratosMultiphysics.OptimizationApplication.utilities.union_utilities import SupportedSensitivityFieldVariableTypes
+from KratosMultiphysics.OptimizationApplication.utilities.logger_utilities import time_decorator
+from KratosMultiphysics.OptimizationApplication.utilities.helper_utilities import CallOnAll
+
+class MasterControl:
+    """Master control class.
+
+    This class is used to simplify working with many controls at once. Following responsibilities are assumed:
+        1. Maps physical gradients from different domains to one @ref Kratos::CombinedTensorAdaptor (using MapGradient).
+        2. Updates each respective domain from updates given by one @ref Kratos::CombinedTensorAdaptor (using Update).
+
+    There should be only one master control class per optimization problem.
+
+    """
+    def __init__(self) -> None:
+        self.__list_of_controls: 'list[Control]' = []
+
+    def AddControl(self, control: Control) -> None:
+        """Adds a given control to the master control.
+
+        Args:
+            control (Control): Control to be added
+        """
+        self.__list_of_controls.append(control)
+
+    def GetListOfControls(self) -> 'list[Control]':
+        """Returns the list of controls in the master control.
+
+        Returns:
+            list[Control]: List of controls.
+        """
+        return self.__list_of_controls
+
+    def GetPhysicalKratosVariableMap(self) -> 'dict[SupportedSensitivityFieldVariableTypes, Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor]':
+        """Returns map of physical variables and @ref Kratos::CombinedTensorAdaptor from each control.
+
+        This returns a map of physical control variables and a @ref Kratos::CombinedTensorAdaptor. The @ref Kratos::CombinedTensorAdaptor will contain
+        all the @ref Kratos::TensorAdaptor for respective control's control domains for each physical control variable. The repeated @ref Kratos::TensorAdaptor s
+        for the same physical control variable is omitted to avoid double calculations.
+
+        Returns:
+            dict[SupportedSensitivityFieldVariableTypes, Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor]: Physical control variable and @ref Kratos::CombinedTensorAdaptor map.
+        """
+
+        physical_variable_containers_dict: 'dict[SupportedSensitivityFieldVariableTypes, list[typing.Union[Kratos.NodesArray, Kratos.ElementsArray, Kratos.ConditionsArray]]]' = {}
+        for control in self.__list_of_controls:
+            for physical_variable in control.GetPhysicalKratosVariables():
+                # check whether the physical variable is already there.
+                if not physical_variable in physical_variable_containers_dict.keys():
+                    physical_variable_containers_dict[physical_variable] = []
+
+                # check whether the container for that physical variable is already there.
+                control_ta = control.GetEmptyField()
+                if control_ta.GetContainer() not in physical_variable_containers_dict[physical_variable]:
+                    physical_variable_containers_dict[physical_variable].append(control_ta.GetContainer())
+
+        physical_variable_combined_ta_dict: 'dict[SupportedSensitivityFieldVariableTypes, Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor]' = {}
+        for variable, containers_list in physical_variable_containers_dict.items():
+            physical_variable_combined_ta_dict[variable] = Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor([Kratos.TensorAdaptors.DoubleTensorAdaptor(Kratos.TensorAdaptors.VariableTensorAdaptor(container, variable), copy=False) for container in containers_list], perform_collect_data_recursively=False, perform_store_data_recursively=False)
+
+        return physical_variable_combined_ta_dict
+
+    def GetEmptyField(self) -> Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor:
+        """Returns empty CombinedTensorAdaptor containing empty TensorAdaptor for each control.
+
+        Returns:
+            Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor: Empty CombinedTensorAdaptor
+        """
+        ta = Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor([control.GetEmptyField() for control in self.__list_of_controls], perform_collect_data_recursively=False, perform_store_data_recursively=False)
+        ta.CollectData() # reading all the data from each ta adaptor to the combined tensor adaptor
+        return ta
+
+    def GetControlField(self) -> Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor:
+        """Returns CombinedTensorAdaptor containing control field TensorAdaptor for each control.
+
+        Returns:
+            Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor: Control field CombinedTensorAdaptor
+        """
+        ta = Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor([control.GetControlField() for control in self.__list_of_controls], perform_collect_data_recursively=False, perform_store_data_recursively=False)
+        ta.CollectData() # reading all the data from each ta adaptor to the combined tensor adaptor
+        return ta
+
+    @time_decorator()
+    def MapGradient(self, physical_space_gradient_variable_and_combined_tensor_adaptor_map: 'dict[SupportedSensitivityFieldVariableTypes, Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor]') -> Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor:
+        """Maps physical space gradients to a combined tensor adaptor.
+
+        This method maps sensitivities w.r.t. physical space variables to control space by using each control. It is done by converting input
+        map with @ref Kratos::CombinedTensorAdaptor to a map with @ref Kratos::TensorAdaptor. The following is a pseudo example:
+
+        input:
+
+        physical_space_gradient_variable_and_combined_tensor_adaptor_map = {
+            "YOUND_MODULUS": [ControlDomain1, ControlDomain2],
+            "DENSITY"      : [ControlDomain1],
+            "VISCOSITY"    : [ControlDomain2],
+        }
+
+        control info:
+        control1: domain = ControlDomain1
+                  physical_vars = YOUND_MODULUS, DENSITY
+
+        control2: domain = ControlDomain2
+                  physical_vars = VISCOSITY, DENSITY
+
+
+        from above information, following two maps are created and passed to each control to obtain one @ref Kratos::TensorAdaptor from each control.
+        control_specific_maps:
+        for control1: {YOUND_MODULUS: ControlDomain1, DENSITY: ControlDomain1}
+        for control2: {VISCOSITY: ControlDomain2, DENSITY: A zero valued ControlDomain}
+
+        then returned mapped gradients are added to one @ref Kratos::CombinedTensorAdaptor.
+
+        In here, the missing gradients for required physical variables will be assumed to be zero.
+
+        This converts given map of sensitivities w.r.t. different physical space variables to one sensitivities in control space and aggregated
+        to one @ref Kratos::CombinedTensorAdaptor.
+
+        Args:
+            physical_space_gradient_variable_and_combined_tensor_adaptor_map (dict[SupportedSensitivityFieldVariableTypes, Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor]): Map of physical space sensitivities.
+
+        Returns:
+            Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor: Control space sensitivities.
+        """
+
+
+        mapped_gradients: 'list[Kratos.TensorAdaptors.DoubleTensorAdaptor]' = []
+
+        for control in self.__list_of_controls:
+            # iterate through each control to create its own container map from the combined tensor adaptor map given as input
+            control_physical_sensitivities_tensor_adaptor_map: 'dict[SupportedSensitivityFieldVariableTypes, Kratos.TensorAdaptors.DoubleTensorAdaptor]' = {}
+            for physical_control_variable in control.GetPhysicalKratosVariables():
+                # first assume the gradients for this physical_control_variable is zero, hence get the zero valued tensor adaptor.
+                control_ta = control.GetEmptyField()
+
+                # get the required physical variables from control.
+                if physical_control_variable in physical_space_gradient_variable_and_combined_tensor_adaptor_map.keys():
+                    # if the sensitivities for the given physical control variable exists, then try to find whether
+                    # for this specific control the physical control variable sensitivities exists.
+
+                    sensitivity_cta = physical_space_gradient_variable_and_combined_tensor_adaptor_map[physical_control_variable]
+                    for ta in sensitivity_cta.GetTensorAdaptors():
+                        if ta.GetContainer() == control_ta.GetContainer():
+                            # there exists for this control's physical variables sensitivities.
+                            control_physical_sensitivities_tensor_adaptor_map[physical_control_variable] = ta
+                            break
+
+                if physical_control_variable not in control_physical_sensitivities_tensor_adaptor_map.keys():
+                    # If it is found from input gradients, the tensor_adaptor will have those values,
+                    # otherwise it will have representative zero tensor_adaptor.
+                    control_physical_sensitivities_tensor_adaptor_map[physical_control_variable] = control_ta
+
+            # map the physical control variable sensitivities to one control space
+            mapped_gradients.append(control.MapGradient(control_physical_sensitivities_tensor_adaptor_map))
+
+        result = Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor([mapped_gradient for mapped_gradient in mapped_gradients], perform_collect_data_recursively=False, perform_store_data_recursively=False)
+        result.CollectData()
+        return result
+
+    @time_decorator()
+    def Update(self, update_combined_tensor_adaptor: Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor) -> 'dict[Control, bool]':
+        """Update each control with given combined tensor adaptor's respective tensor adaptor.
+
+        Args:
+            update_combined_tensor_adaptor (Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor): Update
+
+        Raises:
+            RuntimeError: If number of controls and number of tensor adaptors mismatch.
+
+        Returns:
+            dict[Control, bool]: A map with control and a boolean whether the update changed anything in that control.
+        """
+        if len(self.__list_of_controls) != len(update_combined_tensor_adaptor.GetTensorAdaptors()):
+            raise RuntimeError(f"Controls size and update size mismatch [ number of controls: {len(self.__list_of_controls)}, number of tensor adaptors: {len(update_combined_tensor_adaptor.GetTensorAdaptors())} ].")
+
+        update_map: 'dict[Control, bool]' = {}
+        for control, ta in zip(self.__list_of_controls, update_combined_tensor_adaptor.GetTensorAdaptors()):
+            update_map[control] = control.Update(ta)
+            if update_map[control]:
+                Kratos.Logger.PrintInfo(f"Control {control.GetName()} updated.")
+            else:
+                Kratos.Logger.PrintInfo(f"Control {control.GetName()} not updated")
+
+        return update_map
+
+    def Check(self) -> None:
+        CallOnAll(self.__list_of_controls, Control.Check)
+
+    def Initialize(self) -> None:
+        CallOnAll(self.__list_of_controls, Control.Initialize)
+
+    def Finalize(self) -> None:
+        CallOnAll(self.__list_of_controls, Control.Finalize)
+
+    def GetName(self) -> str:
+        return "master_control"

KratosMultiphysics/OptimizationApplication/controls/material/material_properties_control.py

@@ -0,0 +1,115 @@
+import numpy
+from typing import Optional
+
+import KratosMultiphysics as Kratos
+import KratosMultiphysics.OptimizationApplication as KratosOA
+from KratosMultiphysics.OptimizationApplication.controls.control import Control
+from KratosMultiphysics.OptimizationApplication.utilities.union_utilities import SupportedSensitivityFieldVariableTypes
+from KratosMultiphysics.OptimizationApplication.utilities.model_part_utilities import ModelPartOperation
+
+def Factory(model: Kratos.Model, parameters: Kratos.Parameters, _) -> Control:
+    if not parameters.Has("name"):
+        raise RuntimeError(f"MaterialPropertiesControl instantiation requires a \"name\" in parameters [ parameters = {parameters}].")
+    if not parameters.Has("settings"):
+        raise RuntimeError(f"MaterialPropertiesControl instantiation requires a \"settings\" in parameters [ parameters = {parameters}].")
+
+    return MaterialPropertiesControl(parameters["name"].GetString(), model, parameters["settings"])
+
+class MaterialPropertiesControl(Control):
+    """Material properties control
+
+    This is a generic material properties control which creates a control
+    for the specified control variable. This does not do any filtering.
+
+    TODO: Extend with filtering techniques when they are implemented.
+
+    """
+    def __init__(self, name: str, model: Kratos.Model, parameters: Kratos.Parameters):
+        super().__init__(name)
+
+        default_settings = Kratos.Parameters("""{
+            "model_part_names"                  : [""],
+            "control_variable_name"             : "",
+            "consider_recursive_property_update": false
+        }""")
+        parameters.ValidateAndAssignDefaults(default_settings)
+
+        self.model = model
+
+        control_variable_name = parameters["control_variable_name"].GetString()
+        control_variable_type = Kratos.KratosGlobals.GetVariableType(control_variable_name)
+        if control_variable_type != "Double":
+            raise RuntimeError(f"{control_variable_name} with {control_variable_type} type is not supported. Only supports double variables")
+        self.controlled_physical_variable = Kratos.KratosGlobals.GetVariable(control_variable_name)
+
+        controlled_model_part_names = parameters["model_part_names"].GetStringArray()
+        if len(controlled_model_part_names) == 0:
+            raise RuntimeError(f"No model parts were provided for MaterialPropertiesControl. [ control name = \"{self.GetName()}\"]")
+
+        self.model_part_operation = ModelPartOperation(self.model, ModelPartOperation.OperationType.UNION, f"control_{self.GetName()}", controlled_model_part_names, False)
+        self.model_part: Optional[Kratos.ModelPart] = None
+
+        self.consider_recursive_property_update = parameters["consider_recursive_property_update"].GetBool()
+
+    def Initialize(self) -> None:
+        self.model_part = self.model_part_operation.GetModelPart()
+
+        if not KratosOA.OptAppModelPartUtils.CheckModelPartStatus(self.model_part, "element_specific_properties_created"):
+            KratosOA.OptimizationUtils.CreateEntitySpecificPropertiesForContainer(self.model_part, self.model_part.Elements, self.consider_recursive_property_update)
+            KratosOA.OptAppModelPartUtils.LogModelPartStatus(self.model_part, "element_specific_properties_created")
+
+    def Check(self) -> None:
+        pass
+
+    def Finalize(self) -> None:
+        pass
+
+    def GetPhysicalKratosVariables(self) -> 'list[SupportedSensitivityFieldVariableTypes]':
+        return [self.controlled_physical_variable]
+
+    def GetEmptyField(self) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        field = KratosOA.TensorAdaptors.PropertiesVariableTensorAdaptor(self.model_part.Elements, self.controlled_physical_variable)
+        field.data[:] = 0.0
+        return Kratos.TensorAdaptors.DoubleTensorAdaptor(field, copy=False)
+
+    def GetControlField(self) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        field = KratosOA.TensorAdaptors.PropertiesVariableTensorAdaptor(self.model_part.Elements, self.controlled_physical_variable)
+        field.CollectData()
+        return Kratos.TensorAdaptors.DoubleTensorAdaptor(field, copy=False)
+
+    def MapGradient(self, physical_variable_gradient_map: 'dict[SupportedSensitivityFieldVariableTypes, Kratos.TensorAdaptors.DoubleTensorAdaptor]') -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        keys = physical_variable_gradient_map.keys()
+        if len(keys) != 1:
+            raise RuntimeError(f"Provided more than required gradient fields for control \"{self.GetName()}\". Following are the variables:\n\t" + "\n\t".join([k.Name() for k in keys]))
+        if self.controlled_physical_variable not in keys:
+            raise RuntimeError(f"The required gradient for control \"{self.GetName()}\" w.r.t. {self.controlled_physical_variable.Name()} not found. Followings are the variables:\n\t" + "\n\t".join([k.Name() for k in keys]))
+
+        physical_gradient = physical_variable_gradient_map[self.controlled_physical_variable]
+        if physical_gradient.GetContainer() != self.GetEmptyField().GetContainer():
+            raise RuntimeError(f"Gradients for the required element container not found for control \"{self.GetName()}\". [ required model part name: {self.model_part.FullName()} ]")
+
+        # TODO: Implement filtering mechanisms here
+        return  physical_variable_gradient_map[self.controlled_physical_variable].Clone()
+
+    def Update(self, control_field: Kratos.TensorAdaptors.DoubleTensorAdaptor) -> bool:
+        if control_field.GetContainer() != self.GetEmptyField().GetContainer():
+            raise RuntimeError(f"Updates for the required element container not found for control \"{self.GetName()}\". [ required model part name: {self.model_part.FullName()} ]")
+
+        # TODO: Implement inverse filtering mechanisms here
+        # since no filtering is implemented yet, we are checking the unfiltered updates with the filtered updates. This needs to be changed once the
+        # filtering mechanisms are implemented.
+
+        # get the current unfiltered control field
+        unfiltered_control_field = self.GetControlField()
+
+        if numpy.linalg.norm(unfiltered_control_field.data - control_field.data) > 1e-9:
+            KratosOA.TensorAdaptors.PropertiesVariableTensorAdaptor(control_field, self.controlled_physical_variable, copy=False).StoreData()
+
+            if self.consider_recursive_property_update:
+                KratosOA.OptimizationUtils.UpdatePropertiesVariableWithRootValueRecursively(control_field.GetContainer(), self.controlled_physical_variable)
+            return True
+
+        return False
+
+    def __str__(self) -> str:
+        return f"Control [type = {self.__class__.__name__}, name = {self.GetName()}, model part name = {self.model_part.FullName()}, control variable = {self.controlled_physical_variable.Name()}"