KratosOptimizationApplication 10.4.4__py3-none-any.whl

KratosMultiphysics/OptimizationApplication/responses/additive_manufacturing_responses.py

@@ -0,0 +1,410 @@
+import KratosMultiphysics as KM
+from KratosMultiphysics import Parameters, Logger
+import KratosMultiphysics.OptimizationApplication as KOA
+from KratosMultiphysics.OptimizationApplication.responses.base_response import BaseResponseFunction
+
+import time as timer
+import numpy as np
+
+class InterfaceResponseFunction(BaseResponseFunction):
+
+    def __init__(self,response_name, response_settings,model):
+
+        self.type = "interface"
+        self.variable = "INTERFACE"
+        super().__init__(response_name, response_settings, model)
+
+        self.supported_control_types = ["material"]
+        self.gradients_variables = {"material":"D_INTERFACE_D_FD"}
+
+        if len(self.evaluated_model_parts) != 1:
+            raise RuntimeError("InterfaceResponseFunction: 'evaluated_objects' of response '{}' must have only one entry !".format(self.name))
+
+        for control_type in self.control_types:
+            if not control_type in self.supported_control_types:
+                raise RuntimeError("InterfaceResponseFunction: type {} in 'control_types' of response '{}' is not supported, supported types are {}  !".format(control_type,self.name,self.supported_control_types))
+
+
+        root_model_part_name = self.evaluated_model_parts[0].split(".")[0]
+        for evaluated_model_part in self.evaluated_model_parts:
+            if evaluated_model_part.split(".")[0] != root_model_part_name:
+                raise RuntimeError("InterfaceResponseFunction: evaluated_model_parts of mass response must have the same root model part !")
+
+        self.root_model_part = self.model.GetModelPart(root_model_part_name)
+
+        # add vars and response
+        self.response_function = KOA.InterfaceOptResponse(response_name,model,self.response_settings)
+        for control_type in self.control_types:
+            self.root_model_part.AddNodalSolutionStepVariable(KM.KratosGlobals.GetVariable(self.gradients_variables[control_type]))
+
+    def GetVariableName(self):
+        return  self.variable
+
+    def GetGradientsVariablesName(self):
+        return self.gradients_variables
+
+    def GetGradientVariableNameForType(self,control_type, raise_error=True):
+        if raise_error:
+            if not control_type in self.supported_control_types:
+                raise RuntimeError("InterfaceResponseFunction: type {} in 'control_types' of response '{}' is not supported, supported types are {}  !".format(control_type,self.name,self.supported_control_types))
+
+        return self.gradients_variables[control_type]
+
+    def Initialize(self):
+        super().Initialize()
+        self.response_function.Initialize()
+
+    def CalculateValue(self):
+        Logger.PrintInfo("InterfaceResponseFunction:CalculateValue: Starting value calculation for response ", self.name)
+        startTime = timer.time()
+        self.value = self.response_function.CalculateValue()
+        Logger.PrintInfo("InterfaceResponseFunction:CalculateValue: Time needed for calculating value ",round(timer.time() - startTime,2),"s")
+        return self.value
+
+    def CalculateGradientsForTypesAndObjects(self,control_types,controlled_objects,raise_error=True):
+
+        if raise_error:
+            for itr in range(len(controlled_objects)):
+                controlled_object = controlled_objects[itr]
+                control_type = control_types[itr]
+                found = False
+                for itr_2 in range(len(self.controlled_model_parts)):
+                    controlled_model_part = self.controlled_model_parts[itr_2]
+                    controlled_type = self.control_types[itr_2]
+                    if controlled_type==control_type and controlled_model_part==controlled_object:
+                        found = True
+                        break
+                if not found:
+                    raise RuntimeError("InterfaceResponseFunction:CalculateGradientsForTypesAndObjects: control type {} of control object {} is not in the control_types of response {}".format(control_types[itr],controlled_object,self.name))
+
+        Logger.PrintInfo("InterfaceResponseFunction", "Starting ", control_types," gradients calculation of response ", self.name," for ",controlled_objects)
+        startTime = timer.time()
+        self.response_function.CalculateGradient()
+        Logger.PrintInfo("InterfaceResponseFunction", "Time needed for calculating gradients ",round(timer.time() - startTime,2),"s")
+
+class PartitionMassResponseFunction(BaseResponseFunction):
+
+    def __init__(self,response_name, response_settings,model):
+
+        self.type = "partition_mass"
+        self.variable = "PARTITION_MASS"
+        super().__init__(response_name, response_settings, model)
+
+        self.supported_control_types = ["material"]
+        self.gradients_variables = {"material":"D_PARTITION_MASS_D_FD"}
+
+        if len(self.evaluated_model_parts) != 1:
+            raise RuntimeError("PartitionMassResponseFunction: 'evaluated_objects' of response '{}' must have only one entry !".format(self.name))
+
+        for control_type in self.control_types:
+            if not control_type in self.supported_control_types:
+                raise RuntimeError("PartitionMassResponseFunction: type {} in 'control_types' of response '{}' is not supported, supported types are {}  !".format(control_type,self.name,self.supported_control_types))
+
+
+        root_model_part_name = self.evaluated_model_parts[0].split(".")[0]
+        for evaluated_model_part in self.evaluated_model_parts:
+            if evaluated_model_part.split(".")[0] != root_model_part_name:
+                raise RuntimeError("PartitionMassResponseFunction: evaluated_model_parts of mass response must have the same root model part !")
+
+        self.root_model_part = self.model.GetModelPart(root_model_part_name)
+
+        # add vars and response
+        self.response_function = KOA.PartitionMassOptResponse(response_name,model,self.response_settings)
+        for control_type in self.control_types:
+            self.root_model_part.AddNodalSolutionStepVariable(KM.KratosGlobals.GetVariable(self.gradients_variables[control_type]))
+
+    def GetVariableName(self):
+        return  self.variable
+
+    def GetGradientsVariablesName(self):
+        return self.gradients_variables
+
+    def GetGradientVariableNameForType(self,control_type, raise_error=True):
+        if raise_error:
+            if not control_type in self.supported_control_types:
+                raise RuntimeError("PartitionMassResponseFunction: type {} in 'control_types' of response '{}' is not supported, supported types are {}  !".format(control_type,self.name,self.supported_control_types))
+
+        return self.gradients_variables[control_type]
+
+    def Initialize(self):
+        super().Initialize()
+        self.response_function.Initialize()
+
+    def CalculateValue(self):
+        Logger.PrintInfo("PartitionMassResponseFunction:CalculateValue: Starting value calculation for response ", self.name)
+        startTime = timer.time()
+        self.value = self.response_function.CalculateValue()
+        Logger.PrintInfo("PartitionMassResponseFunction:CalculateValue: Time needed for calculating value ",round(timer.time() - startTime,2),"s")
+        return self.value
+
+    def CalculateGradientsForTypesAndObjects(self,control_types,controlled_objects,raise_error=True):
+
+        if raise_error:
+            for itr in range(len(controlled_objects)):
+                controlled_object = controlled_objects[itr]
+                control_type = control_types[itr]
+                found = False
+                for itr_2 in range(len(self.controlled_model_parts)):
+                    controlled_model_part = self.controlled_model_parts[itr_2]
+                    controlled_type = self.control_types[itr_2]
+                    if controlled_type==control_type and controlled_model_part==controlled_object:
+                        found = True
+                        break
+                if not found:
+                    raise RuntimeError("PartitionMassResponseFunction:CalculateGradientsForTypesAndObjects: control type {} of control object {} is not in the control_types of response {}".format(control_types[itr],controlled_object,self.name))
+
+        Logger.PrintInfo("PartitionMassResponseFunction", "Starting ", control_types," gradients calculation of response ", self.name," for ",controlled_objects)
+        startTime = timer.time()
+        self.response_function.CalculateGradient()
+        Logger.PrintInfo("PartitionMassResponseFunction", "Time needed for calculating gradients ",round(timer.time() - startTime,2),"s")
+
+class PartitionMassResponseFunction(BaseResponseFunction):
+
+    def __init__(self,response_name, response_settings,model):
+
+        self.type = "partition_mass"
+        self.variable = "PARTITION_MASS"
+        super().__init__(response_name, response_settings, model)
+
+        self.supported_control_types = ["material"]
+        self.gradients_variables = {"material":"D_PARTITION_MASS_D_FD"}
+
+        if len(self.evaluated_model_parts) != 1:
+            raise RuntimeError("PartitionMassResponseFunction: 'evaluated_objects' of response '{}' must have only one entry !".format(self.name))
+
+        for control_type in self.control_types:
+            if not control_type in self.supported_control_types:
+                raise RuntimeError("PartitionMassResponseFunction: type {} in 'control_types' of response '{}' is not supported, supported types are {}  !".format(control_type,self.name,self.supported_control_types))
+
+
+        root_model_part_name = self.evaluated_model_parts[0].split(".")[0]
+        for evaluated_model_part in self.evaluated_model_parts:
+            if evaluated_model_part.split(".")[0] != root_model_part_name:
+                raise RuntimeError("PartitionMassResponseFunction: evaluated_model_parts of mass response must have the same root model part !")
+
+        self.root_model_part = self.model.GetModelPart(root_model_part_name)
+
+        # add vars and response
+        self.response_function = KOA.PartitionMassOptResponse(response_name,model,self.response_settings)
+        for control_type in self.control_types:
+            self.root_model_part.AddNodalSolutionStepVariable(KM.KratosGlobals.GetVariable(self.gradients_variables[control_type]))
+
+    def GetVariableName(self):
+        return  self.variable
+
+    def GetGradientsVariablesName(self):
+        return self.gradients_variables
+
+    def GetGradientVariableNameForType(self,control_type, raise_error=True):
+        if raise_error:
+            if not control_type in self.supported_control_types:
+                raise RuntimeError("PartitionMassResponseFunction: type {} in 'control_types' of response '{}' is not supported, supported types are {}  !".format(control_type,self.name,self.supported_control_types))
+
+        return self.gradients_variables[control_type]
+
+    def Initialize(self):
+        super().Initialize()
+        self.response_function.Initialize()
+
+    def CalculateValue(self):
+        Logger.PrintInfo("PartitionMassResponseFunction:CalculateValue: Starting value calculation for response ", self.name)
+        startTime = timer.time()
+        self.value = self.response_function.CalculateValue()
+        Logger.PrintInfo("PartitionMassResponseFunction:CalculateValue: Time needed for calculating value ",round(timer.time() - startTime,2),"s")
+        return self.value
+
+    def CalculateGradientsForTypesAndObjects(self,control_types,controlled_objects,raise_error=True):
+
+        if raise_error:
+            for itr in range(len(controlled_objects)):
+                controlled_object = controlled_objects[itr]
+                control_type = control_types[itr]
+                found = False
+                for itr_2 in range(len(self.controlled_model_parts)):
+                    controlled_model_part = self.controlled_model_parts[itr_2]
+                    controlled_type = self.control_types[itr_2]
+                    if controlled_type==control_type and controlled_model_part==controlled_object:
+                        found = True
+                        break
+                if not found:
+                    raise RuntimeError("PartitionMassResponseFunction:CalculateGradientsForTypesAndObjects: control type {} of control object {} is not in the control_types of response {}".format(control_types[itr],controlled_object,self.name))
+
+        Logger.PrintInfo("PartitionMassResponseFunction", "Starting ", control_types," gradients calculation of response ", self.name," for ",controlled_objects)
+        startTime = timer.time()
+        self.response_function.CalculateGradient()
+        Logger.PrintInfo("PartitionMassResponseFunction", "Time needed for calculating gradients ",round(timer.time() - startTime,2),"s")
+
+class PartitionInterfaceStressResponseFunction(BaseResponseFunction):
+
+    def __init__(self,response_name, response_settings,model):
+
+        self.type = "partition_interface_stress"
+        self.variable = "STRESS"
+        super().__init__(response_name, response_settings, model)
+
+        self.supported_control_types = ["material"]
+        self.gradients_variables = {"material":"D_STRESS_D_FD"}
+
+        if len(self.evaluated_model_parts) != 1:
+            raise RuntimeError("PartitionInterfaceStressResponseFunction: 'evaluated_objects' of response '{}' must have only one entry !".format(self.name))
+
+        for control_type in self.control_types:
+            if not control_type in self.supported_control_types:
+                raise RuntimeError("PartitionInterfaceStressResponseFunction: type {} in 'control_types' of response '{}' is not supported, supported types are {}  !".format(control_type,self.name,self.supported_control_types))
+
+
+        root_model_part_name = self.evaluated_model_parts[0].split(".")[0]
+        for evaluated_model_part in self.evaluated_model_parts:
+            if evaluated_model_part.split(".")[0] != root_model_part_name:
+                raise RuntimeError("PartitionInterfaceStressResponseFunction: evaluated_model_parts of mass response must have the same root model part !")
+
+        self.root_model_part = self.model.GetModelPart(root_model_part_name)
+
+        # add vars and response
+        self.response_function = KOA.PartitionInterfaceStressOptResponse(response_name,model,self.response_settings)
+        for control_type in self.control_types:
+            self.root_model_part.AddNodalSolutionStepVariable(KM.KratosGlobals.GetVariable(self.gradients_variables[control_type]))
+
+    def GetVariableName(self):
+        return  self.variable
+
+    def GetGradientsVariablesName(self):
+        return self.gradients_variables
+
+    def GetGradientVariableNameForType(self,control_type, raise_error=True):
+        if raise_error:
+            if not control_type in self.supported_control_types:
+                raise RuntimeError("PartitionInterfaceStressResponseFunction: type {} in 'control_types' of response '{}' is not supported, supported types are {}  !".format(control_type,self.name,self.supported_control_types))
+
+        return self.gradients_variables[control_type]
+
+    def Initialize(self):
+        super().Initialize()
+        self.response_function.Initialize()
+
+    def CalculateValue(self):
+        Logger.PrintInfo("PartitionInterfaceStressResponseFunction:CalculateValue: Starting value calculation for response ", self.name)
+        startTime = timer.time()
+        self.value = self.response_function.CalculateValue()
+        Logger.PrintInfo("PartitionInterfaceStressResponseFunction:CalculateValue: Time needed for calculating value ",round(timer.time() - startTime,2),"s")
+        return self.value
+
+    def CalculateGradientsForTypesAndObjects(self,control_types,controlled_objects,raise_error=True):
+
+        if raise_error:
+            for itr in range(len(controlled_objects)):
+                controlled_object = controlled_objects[itr]
+                control_type = control_types[itr]
+                found = False
+                for itr_2 in range(len(self.controlled_model_parts)):
+                    controlled_model_part = self.controlled_model_parts[itr_2]
+                    controlled_type = self.control_types[itr_2]
+                    if controlled_type==control_type and controlled_model_part==controlled_object:
+                        found = True
+                        break
+                if not found:
+                    raise RuntimeError("PartitionInterfaceStressResponseFunction:CalculateGradientsForTypesAndObjects: control type {} of control object {} is not in the control_types of response {}".format(control_types[itr],controlled_object,self.name))
+
+        Logger.PrintInfo("PartitionInterfaceStressResponseFunction", "Starting ", control_types," gradients calculation of response ", self.name," for ",controlled_objects)
+        startTime = timer.time()
+        self.response_function.CalculateGradient()
+        Logger.PrintInfo("PartitionInterfaceStressResponseFunction", "Time needed for calculating gradients ",round(timer.time() - startTime,2),"s")
+
+class MaxOverhangAngleResponseFunction(BaseResponseFunction):
+
+    def __init__(self,response_name, response_settings,model):
+
+        self.default_response_settings = KM.Parameters("""{
+                    "evaluated_objects": [],
+                    "control_types": [],
+                    "controlled_objects": [],
+                    "print_direction": [],
+                    "max_angle": -30.0,
+                    "heaviside_beta": 25.0,
+                    "penalty_factor": 2.0,
+                    "gradient_settings":{
+                        "step_size" : 1e-6,
+                        "gradient_mode": "finite_differencing"
+                    }
+                }""")
+
+        response_settings.RecursivelyValidateAndAssignDefaults(self.default_response_settings)
+
+        self.type = "max_overhang_angle"
+        self.variable = "MAX_OVERHANG_ANGLE"
+        super().__init__(response_name, response_settings, model)
+
+        self.supported_control_types = ["shape"]
+        self.gradients_variables = {"shape":"D_MAX_OVERHANG_ANGLE_D_X"}
+
+        if len(self.evaluated_model_parts) != 1:
+            raise RuntimeError("MaxOverhangAngleResponseFunction: 'evaluated_objects' of response '{}' must have only one entry !".format(self.name))
+
+        for control_type in self.control_types:
+            if not control_type in self.supported_control_types:
+                raise RuntimeError("MaxOverhangAngleResponseFunction: type {} in 'control_types' of response '{}' is not supported, supported types are {}  !".format(control_type,self.name,self.supported_control_types))
+
+        root_model_part_name = self.evaluated_model_parts[0].split(".")[0]
+        for evaluated_model_part in self.evaluated_model_parts:
+            if evaluated_model_part.split(".")[0] != root_model_part_name:
+                raise RuntimeError("MaxOverhangAngleResponseFunction: evaluated_model_parts of max_overhang_angle response must have the same root model part !")
+
+        self.root_model_part = self.model.GetModelPart(root_model_part_name)
+
+        # add vars and response
+        for control_type in self.control_types:
+            self.root_model_part.AddNodalSolutionStepVariable(KM.KratosGlobals.GetVariable(self.gradients_variables[control_type]))
+            self.root_model_part.AddNodalSolutionStepVariable(KM.KratosGlobals.GetVariable(self.gradients_variables[control_type]))
+
+
+    def GetVariableName(self):
+        return  self.variable
+
+    def GetGradientsVariablesName(self):
+        return self.gradients_variables
+
+    def GetGradientVariableNameForType(self,control_type, raise_error=True):
+        if raise_error:
+            if not control_type in self.supported_control_types:
+                raise RuntimeError("MaxOverhangAngleResponseFunction: type {} in 'control_types' of response '{}' is not supported, supported types are {}  !".format(control_type,self.name,self.supported_control_types))
+
+        return self.gradients_variables[control_type]
+
+    def Initialize(self):
+        super().Initialize()
+
+    def CalculateValue(self):
+        Logger.PrintInfo("MaxOverhangAngleResponseFunction:CalculateValue: Starting value calculation for response ", self.name)
+        startTime = timer.time()
+
+        r_evaluated_model_parts: 'list[KM.ModelPart]' = []
+        for model_part_name in self.evaluated_model_parts:
+            r_evaluated_model_parts.append(self.model[model_part_name])
+
+        self.value =  KOA.ResponseUtils.MaxOverhangAngleResponseUtils.CalculateValue(r_evaluated_model_parts,self.response_settings)
+
+        Logger.PrintInfo("MaxOverhangAngleResponseFunction:CalculateValue: Time needed for calculating value ",round(timer.time() - startTime,2),"s")
+        return self.value
+
+    def CalculateGradientsForTypesAndObjects(self,control_types,controlled_objects,raise_error=True):
+
+        r_evaluated_model_parts: 'list[KM.ModelPart]' = []
+        for model_part_name in self.evaluated_model_parts:
+            r_evaluated_model_parts.append(self.model[model_part_name])
+
+        r_controlled_model_parts: 'list[KM.ModelPart]' = []
+        for model_part_name in controlled_objects:
+            r_controlled_model_parts.append(self.model[model_part_name])
+
+        Logger.PrintInfo("MaxOverhangAngleResponseFunction", "Starting ", control_types," gradients calculation of response ", self.name," for ",controlled_objects)
+        startTime = timer.time()
+        KOA.ResponseUtils.MaxOverhangAngleResponseUtils.CalculateSensitivity(r_evaluated_model_parts,{KM.SHAPE_SENSITIVITY: r_controlled_model_parts},self.response_settings)
+
+        #TODO: After restructuring this copying data should be removed
+        for model_part in r_controlled_model_parts:
+            for node in model_part.Nodes:
+                shape_sens = node.GetValue(KM.SHAPE_SENSITIVITY)
+                node.SetSolutionStepValue(KM.KratosGlobals.GetVariable("D_MAX_OVERHANG_ANGLE_D_X"), shape_sens)
+
+        Logger.PrintInfo("MaxOverhangAngleResponseFunction", "Time needed for calculating gradients ",round(timer.time() - startTime,2),"s")
+

KratosMultiphysics/OptimizationApplication/responses/analysis_based_response_function_factory.py

@@ -0,0 +1,14 @@
+# importing the Kratos Library
+from . import structural_responses
+from . import additive_manufacturing_responses
+
+def CreateResponseFunction(response_name,response_type,response_settings, response_analysis,model):
+
+    if response_type == "strain_energy": 
+        return structural_responses.StrainEnergyResponseFunction(response_name,response_settings,response_analysis,model)
+
+    elif response_type == "stress":
+        return structural_responses.StressResponseFunction(response_name,response_settings,response_analysis,model)
+
+    elif response_type == "partition_interface_stress":
+        return additive_manufacturing_responses.PartitionInterfaceStressResponseFunction(response_name,response_settings,model)        

KratosMultiphysics/OptimizationApplication/responses/analysis_free_response_function_factory.py

@@ -0,0 +1,14 @@
+# importing the Kratos Library
+from . import structural_responses
+from . import additive_manufacturing_responses
+
+def CreateResponseFunction(response_name,response_type,response_settings,model):
+
+    if response_type == "mass":
+        return structural_responses.MassResponseFunction(response_name,response_settings,model)
+    elif response_type == "interface":
+        return additive_manufacturing_responses.InterfaceResponseFunction(response_name,response_settings,model)
+    elif response_type == "partition_mass":
+        return additive_manufacturing_responses.PartitionMassResponseFunction(response_name,response_settings,model)
+    elif response_type == "am_max_overhang_angle":
+        return additive_manufacturing_responses.MaxOverhangAngleResponseFunction(response_name,response_settings,model)

KratosMultiphysics/OptimizationApplication/responses/base_response.py

@@ -0,0 +1,66 @@
+# importing the Kratos Library
+from numpy import gradient
+import KratosMultiphysics as KM
+from KratosMultiphysics import Parameters, Logger
+import KratosMultiphysics.OptimizationApplication as KOA
+
+import time as timer
+import numpy as np
+
+# ==============================================================================
+class BaseResponseFunction:
+
+    def __init__(self,response_name, response_settings, model, response_analysis=None):
+       
+        self.name = response_name
+        self.response_settings = response_settings
+        self.model = model
+        self.analysis = response_analysis
+        self.analysis_model_part = None
+        if not response_analysis == None:
+            self.analysis_model_part = self.analysis._GetSolver().GetComputingModelPart()
+
+        self.evaluated_model_parts = response_settings["evaluated_objects"].GetStringArray()
+        self.controlled_model_parts = response_settings["controlled_objects"].GetStringArray()
+        self.control_types = response_settings["control_types"].GetStringArray()  
+
+    def Initialize(self):
+
+        for evaluated_model_part in self.evaluated_model_parts:
+            if not self.analysis == None:
+                evaluated_model_part_splitted = evaluated_model_part.split(".")
+                if not evaluated_model_part_splitted[0] == self.analysis_model_part.Name:
+                    raise RuntimeError("BaseResponseFunction:Initialize: root evaluated_model_part {} of response '{}' is not the analysis model!".format(evaluated_model_part_splitted[0],self.name))
+            if not self.model.HasModelPart(evaluated_model_part): 
+                raise RuntimeError("BaseResponseFunction:Initialize: evaluated_model_part {} of response '{}' does not exist!".format(evaluated_model_part,self.name))
+
+        for controlled_model_part in self.controlled_model_parts:
+            if not self.model.HasModelPart(controlled_model_part): 
+                raise RuntimeError("BaseResponseFunction:Initialize: controlled_model_part {} of response '{}' does not exist!".format(controlled_model_part,self.name))
+
+    def CalculateValue(self):
+        raise RuntimeError("BaseResponseFunction:CalculateValue: Not implemented ! ")
+
+    def GetValue(self):
+        raise RuntimeError("BaseResponseFunction:GetValue: Not implemented ! ")
+
+    def CalculateGradients(self):
+        raise RuntimeError("BaseResponseFunction:CalculateGradients: Not implemented ! ")
+
+    def CalculateGradientsForTypeAndObjects(self,control_type,controlled_objects,raise_error=True):
+        raise RuntimeError("BaseResponseFunction:CalculateGradientsForTypeAndObjects: Not implemented ! ") 
+
+    def GetGradients(self):
+        raise RuntimeError("BaseResponseFunction:GetGradients: Not implemented ! ")
+
+    def GetType(self):
+        raise RuntimeError("BaseResponseFunction:GetValue: Not implemented ! ")        
+
+    def GetVariableName(self):
+        raise RuntimeError("BaseResponseFunction:GetVariableName: Not implemented ! ") 
+
+    def GetGradientsVariablesName(self):
+        raise RuntimeError("BaseResponseFunction:GetGradientsVariablesName: Not implemented ! ")
+
+    def GetGradientVariableNameForType(self,control_type):
+        raise RuntimeError("BaseResponseFunction:GetGradientVariableNameForType: Not implemented ! ") 

KratosMultiphysics/OptimizationApplication/responses/binary_operator_response_function.py

@@ -0,0 +1,103 @@
+from typing import Optional
+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.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.response_utilities import EvaluateValue
+from KratosMultiphysics.OptimizationApplication.utilities.response_utilities import EvaluateGradient
+from KratosMultiphysics.OptimizationApplication.utilities.response_utilities import BinaryOperator
+
+class BinaryOperatorResponseFunction(ResponseFunction):
+    def __init__(self, response_function_1: ResponseFunction, response_function_2: ResponseFunction, binary_operator: BinaryOperator, optimization_problem: OptimizationProblem):
+        if binary_operator == BinaryOperator.DIVIDE:
+            # this is because, the optimization_problem data container uses "/" as a path separator.
+            super().__init__(f"({response_function_1.GetName()}÷{response_function_2.GetName()})")
+        else:
+            super().__init__(f"({response_function_1.GetName()}{binary_operator.value}{response_function_2.GetName()})")
+
+        self.optimization_problem = optimization_problem
+        self.response_function_1 = response_function_1
+        self.response_function_2 = response_function_2
+        self.binary_operator = binary_operator
+        self.model_part: Optional[Kratos.ModelPart] = None
+
+    def GetImplementedPhysicalKratosVariables(self) -> 'list[SupportedSensitivityFieldVariableTypes]':
+        vars_list = self.response_function_1.GetImplementedPhysicalKratosVariables()
+        vars_list.extend(self.response_function_2.GetImplementedPhysicalKratosVariables())
+        return vars_list
+
+    def Initialize(self) -> None:
+        self.response_function_1.Initialize()
+        self.response_function_2.Initialize()
+
+        if len(self.response_function_1.GetImplementedPhysicalKratosVariables()) != 0 and len(self.response_function_2.GetImplementedPhysicalKratosVariables()) != 0:
+            self.model_part = ModelPartOperation(self.response_function_1.GetInfluencingModelPart().GetModel(), ModelPartOperation.OperationType.UNION, f"response_{self.GetName()}", [self.response_function_1.GetInfluencingModelPart().FullName(), self.response_function_2.GetInfluencingModelPart().FullName()], False).GetModelPart()
+        elif len(self.response_function_1.GetImplementedPhysicalKratosVariables()) != 0:
+            self.model_part = self.response_function_1.GetInfluencingModelPart()
+        elif len(self.response_function_2.GetImplementedPhysicalKratosVariables()) != 0:
+            self.model_part = self.response_function_2.GetInfluencingModelPart()
+
+    def Check(self) -> None:
+        self.response_function_1.Check()
+        self.response_function_2.Check()
+
+    def Finalize(self) -> None:
+        self.response_function_1.Finalize()
+        self.response_function_2.Finalize()
+
+    def GetInfluencingModelPart(self) -> Kratos.ModelPart:
+        return self.model_part
+
+    def CalculateValue(self) -> float:
+        v1 = EvaluateValue(self.response_function_1, self.optimization_problem)
+        v2 = EvaluateValue(self.response_function_2, self.optimization_problem)
+
+        # now do the binary arithmetics.
+        if self.binary_operator == BinaryOperator.ADD:
+            return v1 + v2
+        elif self.binary_operator == BinaryOperator.SUBTRACT:
+            return v1 - v2
+        elif self.binary_operator == BinaryOperator.MULTIPLY:
+            return v1 * v2
+        elif self.binary_operator == BinaryOperator.DIVIDE:
+            return v1 / v2
+        elif self.binary_operator == BinaryOperator.POWER:
+            return v1 ** v2
+
+    def CalculateGradient(self, physical_variable_gradient_map: 'dict[SupportedSensitivityFieldVariableTypes, Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor]') -> None:
+        v1 = EvaluateValue(self.response_function_1, self.optimization_problem)
+        v2 = EvaluateValue(self.response_function_2, self.optimization_problem)
+
+        resp_1_gradients = {variable: Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor(cta) for variable, cta in physical_variable_gradient_map.items()}
+        EvaluateGradient(self.response_function_1, resp_1_gradients, self.optimization_problem)
+
+        resp_2_gradients = {variable: Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor(cta) for variable, cta in physical_variable_gradient_map.items()}
+        EvaluateGradient(self.response_function_2, resp_2_gradients, self.optimization_problem)
+
+        for variable, result_cta in physical_variable_gradient_map.items():
+            g1_cta = resp_1_gradients[variable]
+            g2_cta = resp_2_gradients[variable]
+            if self.binary_operator == BinaryOperator.ADD:
+                result_cta.data = g1_cta.data + g2_cta.data
+            elif self.binary_operator == BinaryOperator.SUBTRACT:
+                result_cta.data = g1_cta.data - g2_cta.data
+            elif self.binary_operator == BinaryOperator.MULTIPLY:
+                result_cta.data = g1_cta.data * v2 + g2_cta.data * v1
+            elif self.binary_operator == BinaryOperator.DIVIDE:
+                result_cta.data = g1_cta.data / v2 - g2_cta.data * (v1 / v2 ** 2)
+            elif self.binary_operator == BinaryOperator.POWER:
+                result_cta.data = (g1_cta.data * (v2 / v1) + g2_cta.data * log(v1)) * (v1 ** v2)
+            Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor(result_cta, perform_store_data_recursively=False, copy=False).StoreData()
+
+    def GetChildResponses(self) -> 'list[ResponseFunction]':
+        return [self.response_function_1, self.response_function_2]
+
+    def __str__(self) -> str:
+        if self.model_part is not None:
+            return f"Response [type = {self.__class__.__name__}, name = {self.GetName()}, model part name = {self.model_part.FullName()}]"
+        else:
+            return f"Response [type = {self.__class__.__name__}, name = {self.GetName()}, model part name = n/a ]"