KratosOptimizationApplication 10.4.4__py3-none-any.whl

KratosMultiphysics/OptimizationApplication/responses/log_response_function.py

@@ -0,0 +1,47 @@
+from math import log
+import KratosMultiphysics as Kratos
+from KratosMultiphysics.OptimizationApplication.responses.response_function import ResponseFunction
+from KratosMultiphysics.OptimizationApplication.responses.response_function import SupportedSensitivityFieldVariableTypes
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem import OptimizationProblem
+from KratosMultiphysics.OptimizationApplication.utilities.response_utilities import EvaluateValue
+from KratosMultiphysics.OptimizationApplication.utilities.response_utilities import EvaluateGradient
+
+class LogResponseFunction(ResponseFunction):
+    def __init__(self, response_function: ResponseFunction, optimization_problem: OptimizationProblem):
+        super().__init__(f"log({response_function.GetName()})")
+        self.response_function = response_function
+        self.optimization_problem = optimization_problem
+
+    def GetImplementedPhysicalKratosVariables(self) -> 'list[SupportedSensitivityFieldVariableTypes]':
+        return self.response_function.GetImplementedPhysicalKratosVariables()
+
+    def Initialize(self) -> None:
+        self.response_function.Initialize()
+
+    def Check(self) -> None:
+        self.response_function.Check()
+
+    def Finalize(self) -> None:
+        self.response_function.Finalize()
+
+    def GetInfluencingModelPart(self) -> Kratos.ModelPart:
+        return self.response_function.GetInfluencingModelPart()
+
+    def CalculateValue(self) -> float:
+        return log(EvaluateValue(self.response_function, self.optimization_problem))
+
+    def CalculateGradient(self, physical_variable_gradient_map: 'dict[SupportedSensitivityFieldVariableTypes, Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor]') -> None:
+        v = EvaluateValue(self.response_function, self.optimization_problem)
+
+        resp_gradients = {var: Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor(cta) for var, cta in physical_variable_gradient_map.items()}
+        EvaluateGradient(self.response_function, resp_gradients, self.optimization_problem)
+
+        for variable, cta in physical_variable_gradient_map.items():
+            cta.data = resp_gradients[variable].data / v
+            Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor(cta, perform_collect_data_recursively=False, perform_store_data_recursively=False, copy=False).StoreData()
+
+    def GetChildResponses(self) -> 'list[ResponseFunction]':
+        return [self.response_function]
+
+    def __str__(self) -> str:
+        return f"Response [type = {self.__class__.__name__}, name = {self.GetName()}]"

KratosMultiphysics/OptimizationApplication/responses/mass_response_function.py

@@ -0,0 +1,71 @@
+from typing import Optional
+
+import KratosMultiphysics as Kratos
+import KratosMultiphysics.OptimizationApplication as KratosOA
+from KratosMultiphysics.OptimizationApplication.responses.response_function import ResponseFunction
+from KratosMultiphysics.OptimizationApplication.responses.response_function import SupportedSensitivityFieldVariableTypes
+from KratosMultiphysics.OptimizationApplication.utilities.model_part_utilities import ModelPartOperation
+
+def Factory(model: Kratos.Model, parameters: Kratos.Parameters, _) -> ResponseFunction:
+    if not parameters.Has("name"):
+        raise RuntimeError(f"MassResponseFunction instantiation requires a \"name\" in parameters [ parameters = {parameters}].")
+    if not parameters.Has("settings"):
+        raise RuntimeError(f"MassResponseFunction instantiation requires a \"settings\" in parameters [ parameters = {parameters}].")
+
+    return MassResponseFunction(parameters["name"].GetString(), model, parameters["settings"])
+
+class MassResponseFunction(ResponseFunction):
+    def __init__(self, name: str, model: Kratos.Model, parameters: Kratos.Parameters):
+        super().__init__(name)
+
+        default_settings = Kratos.Parameters("""{
+            "evaluated_model_part_names"     : [
+                "PLEASE_PROVIDE_A_MODEL_PART_NAME"
+            ],
+            "perturbation_size": 1e-6
+        }""")
+        parameters.ValidateAndAssignDefaults(default_settings)
+
+        self.model = model
+
+        evaluated_model_part_names = parameters["evaluated_model_part_names"].GetStringArray()
+        if len(evaluated_model_part_names) == 0:
+            raise RuntimeError(f"No model parts were provided for MassResponseFunction. [ response name = \"{self.GetName()}\"]")
+
+        self.model_part_operation = ModelPartOperation(self.model, ModelPartOperation.OperationType.UNION, f"response_{self.GetName()}", evaluated_model_part_names, False)
+        self.model_part: Optional[Kratos.ModelPart] = None
+        self.perturbation_size = parameters["perturbation_size"].GetDouble()
+
+    def GetImplementedPhysicalKratosVariables(self) -> 'list[SupportedSensitivityFieldVariableTypes]':
+        return [KratosOA.SHAPE, Kratos.DENSITY, Kratos.THICKNESS, KratosOA.CROSS_AREA]
+
+    def Initialize(self) -> None:
+        self.model_part = self.model_part_operation.GetModelPart()
+
+    def Check(self) -> None:
+        if self.model_part is None:
+            raise RuntimeError("Please call MassResponseFunction::Initialize first.")
+        KratosOA.ResponseUtils.MassResponseUtils.Check(self.model_part)
+
+    def Finalize(self) -> None:
+        pass
+
+    def GetInfluencingModelPart(self) -> Kratos.ModelPart:
+        if self.model_part is None:
+            raise RuntimeError("Please call MassResponseFunction::Initialize first.")
+        return self.model_part
+
+    def CalculateValue(self) -> float:
+        return KratosOA.ResponseUtils.MassResponseUtils.CalculateValue(self.model_part)
+
+    def CalculateGradient(self, physical_variable_gradient_map: 'dict[SupportedSensitivityFieldVariableTypes, Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor]') -> None:
+        # calculate the gradients
+        for physical_variable, cta in physical_variable_gradient_map.items():
+            KratosOA.ResponseUtils.MassResponseUtils.CalculateGradient(
+                physical_variable,
+                self.model_part,
+                cta,
+                self.perturbation_size)
+
+    def __str__(self) -> str:
+        return f"Response [type = {self.__class__.__name__}, name = {self.GetName()}, model part name = {self.model_part.FullName()}]"

KratosMultiphysics/OptimizationApplication/responses/response_function.py

@@ -0,0 +1,126 @@
+from abc import ABC, abstractmethod
+from typing import Union
+import KratosMultiphysics as Kratos
+import KratosMultiphysics.OptimizationApplication as KratosOA
+from KratosMultiphysics.OptimizationApplication.utilities.union_utilities import SupportedSensitivityFieldVariableTypes
+
+class ResponseFunction(ABC):
+    """Base response function.
+
+    This response function is the base response function. This is assumed to have following responsibilities.
+        1. CalculateValue for a new design. (@see CalculateValue)
+        2. CalculateSensitivity for a new design (@see CalculateSensitivity)
+
+    This response should only work on one model part. Hence, if multiple model parts required then,
+    a single model part should be created using Kratos.ModelPartOperationUtilities.
+    """
+    def __init__(self, response_name: str) -> None:
+        self.__name = response_name
+
+    def GetName(self) -> str:
+        return self.__name
+
+    @abstractmethod
+    def Initialize(self) -> None:
+        """Initializes the response.
+
+        This method initializes the response. This is only called once in the whole optimization process.
+
+        """
+        pass
+
+    @abstractmethod
+    def Check(self) -> None:
+        """Checks the response.
+
+        This method checks the response. This is only called once in the whole optimization process.
+
+        """
+        pass
+
+    @abstractmethod
+    def Finalize(self) -> None:
+        """Finalizes the response.
+
+        This method finalizes the response. This is only called once in the whole optimization process.
+
+        """
+        pass
+
+    @abstractmethod
+    def GetImplementedPhysicalKratosVariables(self) -> 'list[SupportedSensitivityFieldVariableTypes]':
+        """Returns all the dependent physical kratos variables of the response.
+
+        This method should return all the dependent physical variables of the response to make sure
+        that sensitivities w.r.t. those variables are requested from the response. If sensitivities
+        w.r.t. other variables are required from this response, they are ASSUMED TO BE ZERO.
+
+        Please return all the dependent physical variables, even though the gradient computation is not yet
+        implemented for some to avoid future bugs.
+
+        Returns:
+            list[SupportedSensitivityFieldVariableTypes]: All dependent physical variables of the response.
+        """
+        pass
+
+    @abstractmethod
+    def CalculateValue(self) -> float:
+        """Calculates the response value.
+
+        This method should always calculate the response value assuming the domain has changed.
+
+        Returns:
+            float: Calculated response value.
+        """
+        pass
+
+    @abstractmethod
+    def CalculateGradient(self, physical_variable_gradient_map: 'dict[SupportedSensitivityFieldVariableTypes, Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor]') -> None:
+        """Calculate gradient w.r.t. given physical variables.
+
+        This method should always calculate the sensitivities w.r.t. requested physical variables on the given @ref  Kratos::TensorAdaptor
+        in the @ref Kratos::CombinedTensorAdaptor. An error should be thrown if sensitivitiy computation w.r.t. one or more given physical variables
+        are not implemented.
+
+        This method should always calculate the sensitivities assuming the domain has changed.
+
+        physical_variable_gradient_map is a map of physical variables, and their domains. The domains are represented by a @ref Kratos::CombinedTensorAdaptor
+        which contains list of empty @ref Kratos::TensorAdaptor. Each empty Kratos::TensorAdaptor contains details of the model part's nodes/conditions/element/properties
+        container for which the sensitivities w.r.t. physical variable requested.
+
+        Args:
+            physical_variable_gradient_map (dict[SupportedSensitivityFieldVariableTypes, Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor]): Output containing calculated sensitivities w.r.t. requested physical variables.
+        """
+        pass
+
+    @abstractmethod
+    def GetInfluencingModelPart(self) -> Kratos.ModelPart:
+        """Returns the model part which influences the computation of the response value.
+
+        Following two cases are considered:
+            1. Responses without adjoint system solve: The value of the response can only be influenced by
+               changing the quantities in the evaluated model part (evaluated model part is the one which the
+               response value is computed.) Therefore, in this case, this method should return the
+               evaluated model part.
+            2. Responses with adjoint system solve: The value of the response can be influenced by
+                changing quantities in the adjoint/primal model part (Evaluated model part needs to have
+                intersection with the adjoint/primal model part). Therefore, in this case, this method should return the
+                adjoint analysis model part.
+
+        Returns:
+            Kratos.ModelPart: Response function model part which influences the response value.
+        """
+        pass
+
+    def GetChildResponses(self) -> 'list[ResponseFunction]':
+        """Returns the list of child responses.
+
+        This method returns list of child responses. If the current response is a leaf response,
+        then it will return empty list.
+
+        Needs to be implemented in non-leaf response functions.
+
+        Returns:
+            list[ResponseFunction]: List of child responses.
+        """
+        return []

KratosMultiphysics/OptimizationApplication/responses/response_routine.py

@@ -0,0 +1,158 @@
+import KratosMultiphysics as Kratos
+import KratosMultiphysics.OptimizationApplication as KratosOA
+from KratosMultiphysics.OptimizationApplication.controls.control import Control
+from KratosMultiphysics.OptimizationApplication.responses.response_function import ResponseFunction
+from KratosMultiphysics.OptimizationApplication.controls.master_control import MasterControl
+from KratosMultiphysics.OptimizationApplication.utilities.union_utilities import SupportedSensitivityFieldVariableTypes
+import math, numpy
+
+class ResponseRoutine:
+    """A class which adds optimization-specific utilities to simplify routines
+       and synchronization between the control field from algorithms and analysis models.
+    """
+    def __init__(self, master_control: MasterControl, response: ResponseFunction) -> None:
+        # set the master control
+        self.__master_control = master_control
+
+        # set the response
+        self.__response = response
+        self.__response_value = None
+        self.__contributing_controls_list: 'list[Control]' = []
+        self.__required_physical_gradients: 'dict[SupportedSensitivityFieldVariableTypes, Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor]' = {}
+
+    def GetMasterControl(self) -> MasterControl:
+        return self.__master_control
+
+    def Initialize(self):
+        """Initializes the response routine.
+
+        Raises:
+            RuntimeError: If control domain and response domain does not have any intersection.
+        """
+        # create the required physical control fields to compute gradients
+        self.__response.Initialize()
+        self.__required_physical_gradients = self.__master_control.GetPhysicalKratosVariableMap()
+
+        # now check which are the dependent physical space variables for the response, if not then remove
+        # that variable
+        list_of_independent_variables = []
+        for required_physical_variable in self.__required_physical_gradients.keys():
+            if required_physical_variable not in self.__response.GetImplementedPhysicalKratosVariables():
+                list_of_independent_variables.append(required_physical_variable)
+
+        # now remove this independent combined tensor adaptor from the require combined tensor adaptors map.
+        for independent_variable in list_of_independent_variables:
+            del self.__required_physical_gradients[independent_variable]
+
+        for control in self.__master_control.GetListOfControls():
+            # check whether control has keys given by required gradients
+            if set(control.GetPhysicalKratosVariables()).intersection(self.__required_physical_gradients.keys()):
+                self.__contributing_controls_list.append(control)
+
+        if not self.__contributing_controls_list:
+            raise RuntimeError(f"The controls does not have any influence over the response {self.GetResponseName()}.")
+
+        self.my_current_control_field = self.__master_control.GetEmptyField()
+
+    def Check(self):
+        self.__response.Check()
+
+    def Finalize(self):
+        self.__response.Finalize()
+
+    def GetResponseName(self):
+        return self.__response.GetName()
+
+    def GetReponse(self) -> ResponseFunction:
+        return self.__response
+
+    def CalculateValue(self, control_field: Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor) -> float:
+        """Calculates the value of the response.
+
+        This method updates the design with the provided control field. If a control field is updated
+        which affects the this response value, then a new value is computed. Otherwise, the previous
+        value is returned.
+
+        Args:
+            control_field (Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor): Control field of the new design.
+
+        Returns:
+            float: Response value.
+        """
+        # update using the master control and get updated states.
+        self.__master_control.Update(control_field)
+        compute_response_value_flag = False
+
+        if self.__response_value is None:
+            self.my_current_control_field = Kratos.TensorAdaptors.DoubleTensorAdaptor(control_field)
+
+        if not math.isclose(numpy.linalg.norm(self.my_current_control_field.data, ord=numpy.inf), 0.0, abs_tol=1e-16):
+            rel_diff = (self.my_current_control_field.data - control_field.data) / numpy.linalg.norm(self.my_current_control_field.data, ord=numpy.inf)
+        else:
+            rel_diff = (self.my_current_control_field.data - control_field.data)
+
+        norm = numpy.linalg.norm(rel_diff, ord=numpy.inf)
+
+        if not math.isclose(norm, 0.0, abs_tol=1e-16):
+            compute_response_value_flag = True
+
+        compute_response_value_flag = compute_response_value_flag or self.__response_value is None
+        # TODO: In the case of having two analysis with the same mesh (model parts) for two different
+        #       responses, we need to flag all the anayses which are affected by the control update_state
+        #       from the first call, otherwise the second call will not update anything, hence no execution
+        #       policies will be executed.
+
+        #       Example: Drag 1 with 10m/s, Drag 2 with 20 m/s using the same mesh and model parts with two
+        #                different analyses.
+        # now set the response value in response data container
+        # if len(modified_model_parts) > 0:
+        #     # if there are any modified model parts, then this changes state of is_executed to false
+        #     # in the execution policies which has some intersection with the modified model parts.
+        #     ChangeExecutionPolicyStates(modified_model_parts, False, self.__optimization_problem)
+
+        if compute_response_value_flag:
+            self.__response_value = self.__response.CalculateValue()
+            Kratos.Logger.PrintInfo(f"Response value is calculated for {self.GetResponseName()}.")
+        else:
+            Kratos.Logger.PrintInfo(f"The control field is not updated, hence the response value is not computed for {self.GetResponseName()}.")
+
+        # Update current control field state
+        self.my_current_control_field.data[:] = control_field.data
+
+        return self.__response_value
+
+    def CalculateGradient(self) -> Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor:
+        """Returns CombinedTensorAdaptor containing all the control space gradients for all control variable types (fields).
+
+        Notes:
+            1. It expects that the CalculateValue is called.
+            2. The gradients are computed with respect to updates from master control.
+
+        Returns:
+            Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor: Returns mapped gradients combined tensor adaptor.
+        """
+        # fills the proper physical gradients from the response
+        self.__response.CalculateGradient(self.__required_physical_gradients)
+
+        # calculate and return the control space gradients from respective controls
+        self.__mapped_gradients = self.__master_control.MapGradient(self.__required_physical_gradients)
+        return self.__mapped_gradients
+
+    def GetMappedGradients(self):
+        return self.__mapped_gradients
+
+    def GetRequiredPhysicalGradients(self) -> 'dict[SupportedSensitivityFieldVariableTypes, Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor]':
+        """Returns required physical gradients by this response
+
+        This method returns required physical gradients. The tensor adaptors may or not be empty field
+        depending on CalculateGradient is called or not.
+
+        Returns:
+            dict[SupportedSensitivityFieldVariableTypes, Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor]: Required physical gradients.
+        """
+        return self.__required_physical_gradients
+
+    def GetName(self):
+        return self.GetReponse().GetName()
+
+