KratosOptimizationApplication 10.4.4__py3-none-any.whl

KratosMultiphysics/OptimizationApplication/algorithms/standardized_objective.py

@@ -0,0 +1,133 @@
+import KratosMultiphysics as Kratos
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem import OptimizationProblem
+from KratosMultiphysics.OptimizationApplication.responses.response_routine import ResponseRoutine
+from KratosMultiphysics.OptimizationApplication.controls.master_control import MasterControl
+from KratosMultiphysics.OptimizationApplication.utilities.component_data_view import ComponentDataView
+from KratosMultiphysics.OptimizationApplication.utilities.logger_utilities import DictLogger
+from KratosMultiphysics.OptimizationApplication.utilities.logger_utilities import TimeLogger
+from KratosMultiphysics.OptimizationApplication.utilities.response_utilities import EvaluateResponseExpression
+from KratosMultiphysics.kratos_utilities import IssueDeprecationWarning
+
+class StandardizedObjective(ResponseRoutine):
+    """Standardized objective response function
+
+    This class transformed a user-given optimization problem into the standard format.
+    Supported objective types:
+        "minimization",
+        "maximization"
+
+    """
+    def __init__(self, parameters: Kratos.Parameters, master_control: MasterControl, optimization_problem: OptimizationProblem, required_buffer_size: int = 2):
+        # backward compatibility
+        if parameters.Has("response_name"):
+            IssueDeprecationWarning(self.__class__.__name__, "\"response_name\" is deprecated. Please use \"response_expression\".")
+            parameters.AddString("response_expression", parameters["response_name"].GetString())
+            parameters.RemoveValue("response_name")
+
+        default_parameters = Kratos.Parameters("""{
+            "response_expression": "",
+            "type"               : "",
+            "scaling"            : 1.0
+        }""")
+        parameters.ValidateAndAssignDefaults(default_parameters)
+
+        response = EvaluateResponseExpression(parameters["response_expression"].GetString(), optimization_problem)
+
+        super().__init__(master_control, response)
+
+        if required_buffer_size < 2:
+            raise RuntimeError(f"Standardized objective requires 2 as minimum buffer size. [ response name = {self.GetResponseName()} ]")
+
+        component_data_view = ComponentDataView(response, optimization_problem)
+        component_data_view.SetDataBuffer(required_buffer_size)
+
+        self.__optimization_problem = optimization_problem
+        self.__buffered_data = component_data_view.GetBufferedData()
+        self.__unbuffered_data = component_data_view.GetUnBufferedData()
+
+        scaling = parameters["scaling"].GetDouble()
+        if scaling < 0.0:
+            raise RuntimeError(f"Scaling should be always positive [ given scale = {scaling}]")
+
+        self.__objective_type = parameters["type"].GetString()
+        if self.__objective_type == "minimization":
+            self.__scaling = scaling
+        elif self.__objective_type == "maximization":
+            self.__scaling = -scaling
+        else:
+            raise RuntimeError(f"Requesting unsupported type {self.__objective_type} for objective response function. Supported types are: \n\tminimization\n\tmaximization")
+
+    def GetInitialValue(self) -> float:
+        if self.__unbuffered_data.HasValue("initial_value"):
+            return self.__unbuffered_data["initial_value"] * self.__scaling
+        else:
+            raise RuntimeError(f"Response value for {self.GetResponseName()} is not calculated yet.")
+
+    def CalculateStandardizedValue(self, control_field: Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor, save_value: bool = True) -> float:
+        with TimeLogger(f"StandardizedObjective::Calculate {self.GetResponseName()} value", None, "Finished"):
+            response_value = self.CalculateValue(control_field)
+            standardized_response_value = response_value * self.__scaling
+
+            if not self.__unbuffered_data.HasValue("initial_value"):
+                self.__unbuffered_data["initial_value"] = response_value
+
+            if save_value:
+                if self.__buffered_data.HasValue("value"): del self.__buffered_data["value"]
+                self.__buffered_data["value"] = response_value
+
+            DictLogger("Objective info",self.GetInfo())
+
+        return standardized_response_value
+
+    def GetValue(self, step_index: int = 0) -> float:
+        return self.__buffered_data.GetValue("value", step_index)
+
+    def GetStandardizedValue(self, step_index: int = 0) -> float:
+        return self.GetValue(step_index) * self.__scaling
+
+    def CalculateStandardizedGradient(self, save_field: bool = True) -> Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor:
+
+        with TimeLogger(f"StandardizedObjective::Calculate {self.GetResponseName()} gradients", None, "Finished"):
+            gradient_cta = self.CalculateGradient()
+            if save_field:
+                # save the physical gradients for post processing in unbuffered data container.
+                for physical_var, physical_gradient in self.GetRequiredPhysicalGradients().items():
+                    variable_name = f"d{self.GetResponseName()}_d{physical_var.Name()}"
+                    if self.__unbuffered_data.HasValue(variable_name): del self.__unbuffered_data[variable_name]
+                    self.__unbuffered_data[variable_name] = Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor(physical_gradient)
+
+                # save the filtered gradients for post processing in unbuffered data container.
+                for gradient_ta, control in zip(gradient_cta.GetTensorAdaptors(), self.GetMasterControl().GetListOfControls()):
+                    variable_name = f"d{self.GetResponseName()}_d{control.GetName()}"
+                    if self.__unbuffered_data.HasValue(variable_name): del self.__unbuffered_data[variable_name]
+                    # cloning is a cheap operation, it only moves underlying pointers
+                    # does not create additional memory.
+                    self.__unbuffered_data[variable_name] = Kratos.TensorAdaptors.DoubleTensorAdaptor(gradient_ta)
+
+        gradient_cta.data[:] *= self.__scaling
+        Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor(gradient_cta, perform_store_data_recursively=False, copy=False).StoreData()
+        return gradient_cta
+
+    def GetRelativeChange(self) -> float:
+        if self.__optimization_problem.GetStep() > 0:
+            return self.GetStandardizedValue() / self.GetStandardizedValue(1) - 1.0 if abs(self.GetStandardizedValue(1)) > 1e-12 else self.GetStandardizedValue()
+        else:
+            return 0.0
+
+    def GetAbsoluteChange(self) -> float:
+        return self.GetStandardizedValue() - self.GetInitialValue()
+
+    def GetInfo(self) -> dict:
+        info = {
+            "name": self.GetResponseName(),
+            "type": self.__objective_type,
+            "value": self.GetValue(),
+            "std_value": self.GetStandardizedValue(),
+            "abs_change": self.GetAbsoluteChange(),
+            "rel_change [%]": self.GetRelativeChange() * 100.0
+        }
+        init_value = self.GetInitialValue()
+        if init_value:
+            info["abs_change [%]"] = self.GetAbsoluteChange()/init_value * 100
+
+        return info

KratosMultiphysics/OptimizationApplication/algorithms/standardized_rgp_constraint.py

@@ -0,0 +1,268 @@
+import KratosMultiphysics as Kratos
+import KratosMultiphysics.OptimizationApplication as KratosOA
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem import OptimizationProblem
+from KratosMultiphysics.OptimizationApplication.responses.response_routine import ResponseRoutine
+from KratosMultiphysics.OptimizationApplication.controls.master_control import MasterControl
+from KratosMultiphysics.OptimizationApplication.utilities.component_data_view import ComponentDataView
+from KratosMultiphysics.OptimizationApplication.utilities.logger_utilities import DictLogger
+from KratosMultiphysics.OptimizationApplication.utilities.logger_utilities import TimeLogger
+from KratosMultiphysics.OptimizationApplication.utilities.response_utilities import EvaluateResponseExpression
+from KratosMultiphysics.kratos_utilities import IssueDeprecationWarning
+from enum import Enum
+
+
+class ConstraintType(Enum):
+    EQUAL = "="
+    LOWER = "<"
+    LOWEREQ = "<="
+    GREATER = ">"
+    GREATEREQ = ">="
+
+class StandardizedRGPConstraint(ResponseRoutine):
+    """Standardized RGP constraint response function
+
+    This class creates instances to standardize any response function for the specified type of the constraint.
+    Supported constraint types:
+        "=",
+        "<",
+        "<=,
+        ">",
+        ">="
+
+    The reference value for the constraint either can be the "initial_value" or a specified value.
+
+    It can be used only with relaxed_gradient_projection_algorithm. The class contains necessary functions to compute critical zones.
+
+    """
+    def __init__(self, parameters: Kratos.Parameters, master_control: MasterControl, optimization_problem: OptimizationProblem, required_buffer_size: int = 4):
+        # backward compatibility
+        if parameters.Has("response_name"):
+            IssueDeprecationWarning(self.__class__.__name__, "\"response_name\" is deprecated. Please use \"response_expression\".")
+            parameters.AddString("response_expression", parameters["response_name"].GetString())
+            parameters.RemoveValue("response_name")
+
+        default_parameters = Kratos.Parameters("""{
+            "response_expression" : "",
+            "type"                : "",
+            "scaled_ref_value"    : 0.0,
+            "buffer_factor"       : 2.0,
+            "max_w_c"             : 10.0,
+            "tolerance"           : 1e-3
+        }""")
+
+        if parameters.Has("scaled_ref_value") and parameters["scaled_ref_value"].IsDouble():
+            default_parameters["scaled_ref_value"].SetDouble(0.0)
+        elif parameters.Has("scaled_ref_value") and parameters["scaled_ref_value"].GetString() == "initial_value":
+            default_parameters["scaled_ref_value"].SetString("initial_value")
+        else:
+            type = parameters["scaled_ref_value"].GetString()
+            raise RuntimeError(f"Provided \"scaled_ref_value\" = {type} is not supported for constraint response functions. Followings are supported options: \n\tinitial_value\n\tfloat value")
+
+        parameters.ValidateAndAssignDefaults(default_parameters)
+
+        response = EvaluateResponseExpression(parameters["response_expression"].GetString(), optimization_problem)
+
+        super().__init__(master_control, response)
+
+        if required_buffer_size < 4:
+            raise RuntimeError(f"Standardized RGP constraint requires 4 as minimum buffer size. [ response name = {self.GetResponseName()} ]")
+
+        component_data_view = ComponentDataView(response, optimization_problem)
+        component_data_view.SetDataBuffer(required_buffer_size)
+
+        self.__optimization_problem = optimization_problem
+        self.__buffered_data = component_data_view.GetBufferedData()
+        self.__unbuffered_data = component_data_view.GetUnBufferedData()
+
+        if parameters["scaled_ref_value"].IsDouble():
+            self.__reference_value = parameters["scaled_ref_value"].GetDouble()
+        elif parameters["scaled_ref_value"].IsString() and parameters["scaled_ref_value"].GetString() == "initial_value":
+            self.__reference_value = None
+
+
+        self.__constraint_type = ConstraintType(parameters["type"].GetString())
+        if self.__constraint_type in [ConstraintType.EQUAL, ConstraintType.LOWEREQ, ConstraintType.LOWER]:
+            self.__scaling = 1.0
+        elif self.__constraint_type in [ConstraintType.GREATEREQ, ConstraintType.GREATER]:
+            self.__scaling = -1.0
+            if not self.__reference_value is None: self.__reference_value *= -1
+        else:
+            raise RuntimeError(f"Provided \"type\" = {self.__constraint_type} is not supported in constraint response functions. Followings are supported options: \n\t=\n\t<=\n\t<\n\t>=\n\t>")
+
+        # buffer coefficients
+        self.BSF = parameters["buffer_factor"].GetDouble()
+        self.BSF_init = self.BSF
+        self.CBV = 0.0
+        self.BS = 1e-6
+        self.max_w_c = parameters["max_w_c"].GetDouble()
+        self.CF = 1.0
+
+        self.tolerance = parameters["tolerance"].GetDouble()
+
+    def IsEqualityType(self) -> str:
+        return self.__constraint_type == ConstraintType.EQUAL
+
+    def ComputeW(self) -> float:
+        if self.IsEqualityType():
+            return max(abs(self.GetStandardizedValue() - (self.CBV - self.BS)), 0.0) / self.BS
+        else:
+            return max(self.GetStandardizedValue() - (self.CBV - self.BS), 0.0) / self.BS
+
+    def PredictW(self, value):
+        if self.IsEqualityType():
+            return max(abs(value - (self.CBV - self.BS)), 0.0) / self.BS
+        else:
+            return max(value - (self.CBV - self.BS), 0.0) / self.BS
+
+    def Compute_W_relax(self, w:float) -> float:
+        if w <= 0.0:
+            return 0.0
+        elif w <= 1.0:
+            return w
+        else:
+            return 1.0
+
+    def Compute_W_correction(self, w:float) -> float:
+        if w <= 1.0:
+            return 0.0
+        elif w <= self.max_w_c:
+            return (w - 1.0) * self.BSF_init * self.CF
+        else:
+            return (self.max_w_c - 1) * self.BSF_init * self.CF
+
+    def UpdateBufferSize(self):
+        step = self.__optimization_problem.GetStep() + 1
+        if step == 1:
+            return
+
+        max_step = min(step, self.__buffered_data.GetBufferSize())
+        values = []
+        delta_values = []
+        abs_delta_values = []
+        for index in range(max_step):
+            values.append(self.GetStandardizedValue(index))
+            if index > 0:
+                delta_values.append(values[index - 1] - values[index])
+                abs_delta_values.append(abs(values[index - 1] - values[index]))
+
+        max_delta = max(abs_delta_values)
+
+        # # Update CBV if violating
+        if self.IsEqualityType():
+            if step > 1:
+                if values[0] > 0.0 and values[1] > 0.0 and delta_values[0] > 0.0:
+                    self.CF += 0.5
+
+                if values[0] < 0.0 and values[1] < 0.0 and delta_values[0] < 0.0:
+                    self.CF += 0.5
+        else:
+            if step > 1:
+                if values[0] > 0.0 and values[1] > 0.0 and delta_values[0] > 0.0:
+                    self.CF += 0.5
+
+                if values[0] < 0.0 and values[1] < 0.0 and delta_values[0] < 0.0:
+                    self.CF -= 0.5
+                    self.CF = max (self.CF, 1.0)
+
+        self.BS = max(self.BSF * max_delta, 1e-6)
+        # Update BSF if zig zaging
+        if step > 3:
+            if delta_values[0] * delta_values[1] < 0.0 and delta_values[1] * delta_values[2] < 0.0:
+                self.BSF += 1
+
+        print(f"RGP Constraint {self.GetResponseName()}:: UpdateBufferSize")
+        print(f"RGP Constraint {self.GetResponseName()}:: CBV = {self.CBV}")
+        print(f"RGP Constraint {self.GetResponseName()}:: BSF = {self.BSF}")
+        print(f"RGP Constraint {self.GetResponseName()}:: BS = {self.BS}")
+        print(f"RGP Constraint {self.GetResponseName()}:: CF = {self.CF}")
+
+    def IsActive(self):
+        return self.ComputeW() > 0.0
+
+    def IsSatisfied(self, value=None):
+        if not value:
+            value = abs(self.GetStandardizedValue()) if self.IsEqualityType() else self.GetStandardizedValue()
+        if self.IsEqualityType():
+            if abs(value) <= self.tolerance: return True
+            else: return False
+        else:
+            if value <= self.tolerance: return True
+            else: return False
+
+    def GetReferenceValue(self) -> float:
+        if self.__reference_value is not None:
+            return self.__reference_value
+        else:
+            if self.__unbuffered_data.HasValue("initial_value"):
+                return self.__unbuffered_data["initial_value"] * self.__scaling
+            else:
+                raise RuntimeError(f"Response value for {self.GetResponseName()} is not calculated yet.")
+
+    def CalculateStandardizedValue(self, control_field: Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor, save_value: bool = True) -> float:
+        with TimeLogger(f"StandardizedRGPConstraint::Calculate {self.GetResponseName()} value", None, "Finished"):
+            response_value = self.CalculateValue(control_field)
+            standardized_response_value = response_value * self.__scaling
+
+            if not self.__unbuffered_data.HasValue("initial_value"):
+                self.__unbuffered_data["initial_value"] = response_value
+
+            standardized_response_value -= self.GetReferenceValue()
+
+            if save_value:
+                if self.__buffered_data.HasValue("value"): del self.__buffered_data["value"]
+                if self.__buffered_data.HasValue("std_value"): del self.__buffered_data["std_value"]
+                self.__buffered_data["value"] = response_value
+                self.__buffered_data["std_value"] = standardized_response_value
+
+            DictLogger("Constraint info",self.GetInfo())
+
+        return standardized_response_value
+
+    def CalculateStandardizedGradient(self) -> Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor:
+        with TimeLogger(f"StandardizedRGPConstraint::Calculate {self.GetResponseName()} gradients", None, "Finished"):
+            gradient_cta = self.CalculateGradient()
+            if self.IsEqualityType():
+                factor = 1.0 if self.GetStandardizedValue() > 0.0 else -1.0
+            else:
+                factor = 1.0
+            gradient_cta.data[:] *= self.__scaling * factor
+            return gradient_cta
+
+    def GetValue(self, step_index: int = 0) -> float:
+        return self.__buffered_data.GetValue("value", step_index)
+
+    def GetStandardizedValue(self, step_index: int = 0) -> float:
+        return self.GetValue(step_index) * self.__scaling - self.GetReferenceValue()
+
+    def GetIfConstraintActive(self, step_index: int = 0) -> bool:
+        return True
+
+    def GetAbsoluteViolation(self, step_index: int = 0) -> float:
+        is_violated = self.IsEqualityType() or self.GetStandardizedValue(step_index) >= 0.0
+        return self.GetStandardizedValue(step_index) * is_violated
+
+    def GetRelativeViolation(self, step_index: int = 0) -> float:
+        return self.GetAbsoluteViolation(step_index) / self.GetReferenceValue() if abs(self.GetReferenceValue()) > 1e-12 else 0.0
+
+    def GetRelativeChange(self) -> float:
+        if self.__optimization_problem.GetStep() > 1:
+            return self.GetStandardizedValue() / self.GetStandardizedValue(1) - 1.0 if abs(self.GetStandardizedValue(1)) > 1e-12 else self.GetStandardizedValue()
+        else:
+            return 0.0
+
+    def GetAbsoluteChange(self) -> float:
+        return self.GetValue() - self.__unbuffered_data["initial_value"] if abs(self.GetReferenceValue()) > 1e-12 else self.GetStandardizedValue()
+
+    def GetInfo(self) -> dict:
+        info = {
+            "name": self.GetResponseName(),
+            "value": self.GetValue(),
+            "type": self.__constraint_type,
+            "ref_value": self.GetReferenceValue(),
+            "standartiezed_value": self.GetStandardizedValue(),
+            "abs_change": self.GetAbsoluteChange(),
+            "abs_violation": self.GetAbsoluteViolation(),
+            "rel_change [%]": self.GetRelativeChange() * 100.0,
+            "rel_violation [%]": self.GetRelativeViolation() * 100.0 if not self.GetReferenceValue() == 0.0 else str(None)
+        }
+        return info

KratosMultiphysics/OptimizationApplication/analyses_controller.py

@@ -0,0 +1,75 @@
+#    |  /           |
+#    ' /   __| _` | __|  _ \   __|
+#    . \  |   (   | |   (   |\__ `
+#   _|\_\_|  \__,_|\__|\___/ ____/
+#                   Multi-Physics
+#
+#  License:		 BSD License
+#					 license: OptimizationApplication/license.txt
+#
+#  Main authors:    Reza Najian Asl, https://github.com/RezaNajian
+#                   Suneth Warnakulasuriya
+#
+
+# additional imports
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem import OptimizationProblem
+from KratosMultiphysics.OptimizationApplication.execution_policies.execution_policy_decorator import ExecutionPolicyDecorator
+from KratosMultiphysics.OptimizationApplication.utilities.logger_utilities import TimeLogger
+
+# ==============================================================================
+def CreateController(execution_policies_settings,model,model_parts_controller):
+    return AnalysesController(execution_policies_settings,model,model_parts_controller)
+
+# ==============================================================================
+class AnalysesController:
+    # --------------------------------------------------------------------------
+    def __init__(self, execution_policies_settings, model, model_parts_controller):
+        self.execution_policies_settings = execution_policies_settings
+        self.model_parts_controller = model_parts_controller
+        self.model = model
+
+        self.execution_policy_decorators = {}
+        for execution_policy_settings in self.execution_policies_settings:
+            execution_policy_wrapper = ExecutionPolicyDecorator(self.model, execution_policy_settings, OptimizationProblem())
+            if not execution_policy_wrapper.GetName() in self.execution_policy_decorators.keys():
+                self.execution_policy_decorators[execution_policy_wrapper.GetName()] = execution_policy_wrapper
+            else:
+                raise RuntimeError(f"Found already existing execution policy with the name \"{execution_policy_wrapper.GetExecutionPolicyName()}\". Please provide unique names.")
+
+    # --------------------------------------------------------------------------
+    def GetExecutionPolicyDecorator(self, execution_policy_name: str) -> ExecutionPolicyDecorator:
+        if not execution_policy_name in self.execution_policy_decorators.keys():
+            raise RuntimeError("AnalysesController: Try to get an execution policy {} which does not exist.".format(execution_policy_name))
+        else:
+            return self.execution_policy_decorators[execution_policy_name]
+
+    # --------------------------------------------------------------------------
+    def GetAnalysis(self, execution_policy_name: str):
+        return self.GetExecutionPolicyDecorator(execution_policy_name).GetExecutionPolicy().analysis
+
+    # --------------------------------------------------------------------------
+    def Initialize(self):
+        for execution_policy_wrapper in self.execution_policy_decorators.values():
+            execution_policy_name = execution_policy_wrapper.GetName()
+            with TimeLogger(self.__class__.__name__, f"Initializing {execution_policy_name}...", f"Finished initializing {execution_policy_name}"):
+                execution_policy_wrapper.Initialize()
+
+    # --------------------------------------------------------------------------
+    def RunAnalysis(self, execution_policy_name: str):
+        with TimeLogger(self.__class__.__name__, f"Starting {execution_policy_name}...", f"Finished execution of {execution_policy_name}."):
+            self.GetExecutionPolicyDecorator(execution_policy_name).Execute()
+
+    # --------------------------------------------------------------------------
+    def RunAll(self):
+        for name in self.analyses.keys():
+            self.RunAnalysis(name)
+
+    # --------------------------------------------------------------------------
+    def RunAnalyses(self, analyses_name):
+        if not isinstance(analyses_name, list):
+            raise RuntimeError("AnalysesController: RunAnalyses requires list of analysis names")
+        for analysis_name in analyses_name:
+            self.RunAnalysis(analysis_name)
+
+
+

KratosMultiphysics/OptimizationApplication/controls/control.py

@@ -0,0 +1,123 @@
+from abc import ABC, abstractmethod
+import KratosMultiphysics as Kratos
+from KratosMultiphysics.OptimizationApplication.utilities.union_utilities import SupportedSensitivityFieldVariableTypes
+
+class Control(ABC):
+    """Base abstract control class.
+
+    The base abstract control class has the following responsibilities.
+        1. Initializes and finalizes the control.
+        2. Maps physical space gradients to control space gradients, if needed. Otherwise, it passes.
+        2. Updating the controlled parts of the model part with new given design.
+        3. Retrieve control field.
+        4. Retrieve physical space kratos variables (If more than one physical space kratos variables are controlled by the given control field.)
+
+    This control should only work on one model part and one kratos control variable. Hence, if multiple model parts required then,
+    a single model part should be created using Kratos.ModelPartOperationUtilities.
+
+    """
+    def __init__(self, control_name: str) -> None:
+        self.__name = control_name
+
+    def GetName(self) -> str:
+        return self.__name
+
+    @abstractmethod
+    def Initialize(self) -> None:
+        """Initializes the control.
+
+        This method initializes the control. This is only called once in the whole optimization process.
+
+        """
+        pass
+
+    @abstractmethod
+    def Check(self) -> None:
+        """Checks the control.
+
+        This method checks the control. This is only called once in the whole optimization process.
+
+        """
+        pass
+
+    @abstractmethod
+    def Finalize(self) -> None:
+        """Finalizes the control.
+
+        This method finalizes the control. This is only called once in the whole optimization process.
+
+        """
+        pass
+
+    @abstractmethod
+    def GetPhysicalKratosVariables(self) -> 'list[SupportedSensitivityFieldVariableTypes]':
+        """Returns list of physical control variables controlled by this control.
+
+        This method returns list of physical variable which are controlled by the control. In most of the cases, there is only one
+        control variable per control. But in some rare cases, there may be the requirement to control two physical variables. Anyhow,
+        the control space should only have one variable per control in the control space, but they can have multiple physical variables
+        in their design space.
+
+        Returns:
+            list[SupportedSensitivityFieldVariableTypes]: List of physical control variables.
+        """
+        pass
+
+    @abstractmethod
+    def GetEmptyField(self) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        """Returns a new empty data field holder with correct dimensionality information.
+
+        This returns a new empty data field holder to give information about on which model part's container
+        this model part is acting on. It does not read any data from respective model part's container.
+
+        Returns:
+            Kratos.TensorAdaptors.DoubleTensorAdaptor: Returns a new empty @ref Kratos.TensorAdaptor corresponding to control's model part's respective container.
+        """
+        pass
+
+    @abstractmethod
+    def GetControlField(self) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        """Returns the current control field of the control.
+
+        This method returns the control field of the current design.
+
+        Returns:
+            Kratos.TensorAdaptors.DoubleTensorAdaptor: Current designs control field.
+        """
+        pass
+
+    @abstractmethod
+    def MapGradient(self, physical_variable_gradient_map: 'dict[SupportedSensitivityFieldVariableTypes, Kratos.TensorAdaptors.DoubleTensorAdaptor]') -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        """Maps physical space gradients to the control space.
+
+        This method is used to map the given physical space gradients to the control space. The input should be as in the following example:
+            physical_variable_gradient_map = {
+                Kratos.YOUNG_MODULUS: Kratos.DoubleTensorAdaptor,
+                Kratos.DENSITY      : Kratos.DoubleTensorAdaptor,
+                Kratos.SHAPE        : Kratos.DoubleTensorAdaptor
+            }
+
+        All the gradients w.r.t. @see GetPhysicalKratosVariables() variables will be given in @ref physical_variable_gradient_map.
+        If the response does not depend on some of them or all, then @ref Kratos.TensorAdaptor with correctly sized zero tensors will be passed.
+
+        Args:
+            physical_variable_gradient_map (dict[SupportedSensitivityFieldVariableTypes, Kratos.TensorAdaptors.DoubleTensorAdaptor]): Map of physical space variable and @ref Kratos::TensorAdaptor with sensitivities.
+
+        Returns:
+            Kratos.TensorAdaptors.DoubleTensorAdaptor: Gradients mapped in to control space.
+        """
+        pass
+
+    @abstractmethod
+    def Update(self, control_field: Kratos.TensorAdaptors.DoubleTensorAdaptor) -> bool:
+        """Modifies the current control with the given control field.
+
+        Args:
+            control_field (Kratos.TensorAdaptors.DoubleTensorAdaptor): The control field in control space.
+
+        Returns:
+            bool: True if the control field was applied to obtain a new design, otherwise False
+        """
+        pass
+
+