Merge pull request #13647 from KratosMultiphysics/bugfix/optapp/allow_multiple_controls

sunethwarna · web-flow · commit 78cd21777eb1 · 2025-07-22T15:39:39.000+02:00
[SIApp] Bugfix for multiple controls
diff --git a/applications/SystemIdentificationApplication/python_scripts/responses/damage_detection_response.py b/applications/SystemIdentificationApplication/python_scripts/responses/damage_detection_response.py
@@ -148,12 +148,14 @@ def CalculateGradient(self, physical_variable_collective_expressions: 'dict[Supp
             # run a single adjoint for each test scenario
             self.adjoint_analysis._GetSolver().GetComputingModelPart().ProcessInfo[KratosDT.TEST_ANALYSIS_NAME] = exec_policy.GetName()
             self.adjoint_analysis._GetSolver().GetComputingModelPart().ProcessInfo[Kratos.STEP] = self.optimization_problem.GetStep()
-            sensitivities = self.adjoint_analysis.CalculateGradient(self.damage_response_function)
+            self.adjoint_analysis.CalculateGradient(self.damage_response_function)
 
             for physical_variable, collective_expression in physical_variable_collective_expressions.items():
                 sensitivity_variable = Kratos.KratosGlobals.GetVariable(Kratos.SensitivityUtilities.GetSensitivityVariableName(physical_variable))
                 for container_expression in collective_expression.GetContainerExpressions():
-                    container_expression.SetExpression((container_expression.GetExpression() - sensitivities[sensitivity_variable].GetExpression() * test_case_weight))
+                    current_gradient = container_expression.Clone()
+                    self.adjoint_analysis.GetGradient(sensitivity_variable, current_gradient)
+                    container_expression.SetExpression((container_expression.GetExpression() - current_gradient.GetExpression() * test_case_weight))
                     container_expression.SetExpression(Kratos.Expression.Utils.Collapse(container_expression).GetExpression())
 
     def __GetSensor(self, sensor_name: str) -> KratosDT.Sensors.Sensor:
diff --git a/applications/SystemIdentificationApplication/python_scripts/sensor_sensitivity_solvers/response_sensitivity_analysis.py b/applications/SystemIdentificationApplication/python_scripts/sensor_sensitivity_solvers/response_sensitivity_analysis.py
@@ -8,21 +8,28 @@
 
 class ResponseSensitivityAnalysis(AnalysisStage, abc.ABC):
     @abc.abstractmethod
-    def CalculateGradient(self, response_function: Kratos.AdjointResponseFunction) -> 'dict[SupportedSensitivityFieldVariableTypes, ContainerExpressionTypes]':
-        """Returns the gradient computed by using the provided adjoint response function.
+    def CalculateGradient(self, response_function: Kratos.AdjointResponseFunction) -> None:
+        """Calculate the gradient using the provided adjoint response function.
 
-        This method returns all the sensitivities computed from the given adjoint response function. The return
-        will be a dictionary having a pair with the variable as the key and a ContainerExpression as the value.
-        ContainerExpression will carry the sensitivity values.
+        This method calculate all the sensitivities using the given adjoint response function.
 
         Args:
             response_function (Kratos.AdjointResponseFunction): Adjoint response function to be used for sensitivity computation
-
-        Returns:
-            dict[str, ContainerExpressionTypes]: Sensitivities dictionary with variable and sensitivities as the pair.
         """
         pass
 
+    def GetGradient(self, sensitivity_variable: SupportedSensitivityFieldVariableTypes, gradient_expression: ContainerExpressionTypes) -> None:
+        """Returns the gradients in the domain represented by gradient_expression container expression.
+
+        Args:
+            sensitivity_variable (SupportedSensitivityFieldVariableTypes): Sensitivity variable
+            gradient_expression (ContainerExpressionTypes): Container expression to hold the gradients.
+        """
+        if isinstance(gradient_expression, Kratos.Expression.NodalExpression):
+            Kratos.Expression.VariableExpressionIO.Read(gradient_expression, sensitivity_variable, True)
+        else:
+            Kratos.Expression.VariableExpressionIO.Read(gradient_expression, sensitivity_variable)
+
     def GetProcessesOrder(self) -> 'list[str]':
         """The order of execution of the process categories.
 
diff --git a/applications/SystemIdentificationApplication/python_scripts/sensor_sensitivity_solvers/response_sensitivity_interface.py b/applications/SystemIdentificationApplication/python_scripts/sensor_sensitivity_solvers/response_sensitivity_interface.py
@@ -34,18 +34,3 @@ def GetSensitivityModelPart(self) -> Kratos.ModelPart:
         """
         pass
 
-    @abc.abstractmethod
-    def GetSensitivities(self) -> 'dict[SupportedSensitivityFieldVariableTypes, ExpressionUnionType]':
-        """Returns sensitivities as a dict having variable and sensitivities as a pair.
-
-        This method returns the computed sensitivities on the sensitivity model part as a pair (variable, expression).
-        The variable will be the design variable. Not the variable which is used to store the sensitivities.
-
-        Ex: The design variable may be "SHAPE", and the variable used to store the sensitivities is called "SHAPE_SENSITIVITY".
-            In this case, it returns the variable "SHAPE" along with an expression containing the sensitivities.
-
-        Returns:
-            dict[SupportedSensitivityFieldVariableTypes, ExpressionUnionType]: Dictionary of design variable and corresponding sensitivities.
-        """
-        pass
-
diff --git a/applications/SystemIdentificationApplication/python_scripts/sensor_sensitivity_solvers/sensor_sensitivity_adjoint_static_solver.py b/applications/SystemIdentificationApplication/python_scripts/sensor_sensitivity_solvers/sensor_sensitivity_adjoint_static_solver.py
@@ -51,22 +51,5 @@ def GetSensitivityModelPart(self) -> Kratos.ModelPart:
     def SolveSolutionStep(self) -> bool:
         return super(StructuralMechanicsAdjointStaticSolver, self).SolveSolutionStep()
 
-    def GetSensitivities(self) -> 'dict[SupportedSensitivityFieldVariableTypes, ExpressionUnionType]':
-        sensitivity_settings = self.settings["sensitivity_settings"]
-        sensitivities_dict: 'dict[SupportedSensitivityFieldVariableTypes, ExpressionUnionType]' = {}
-        self.__ReadSensitivities(sensitivities_dict, sensitivity_settings["nodal_solution_step_sensitivity_variables"].GetStringArray(), Kratos.Expression.NodalExpression, lambda x, y: Kratos.Expression.VariableExpressionIO.Read(x, y, True))
-        self.__ReadSensitivities(sensitivities_dict, sensitivity_settings["condition_data_value_sensitivity_variables"].GetStringArray(), Kratos.Expression.ConditionExpression, lambda x, y: Kratos.Expression.VariableExpressionIO.Read(x, y))
-        self.__ReadSensitivities(sensitivities_dict, sensitivity_settings["element_data_value_sensitivity_variables"].GetStringArray(), Kratos.Expression.ElementExpression, lambda x, y: Kratos.Expression.VariableExpressionIO.Read(x, y))
-        return sensitivities_dict
-
-    def __ReadSensitivities(self, sensitivity_dict: 'dict[SupportedSensitivityFieldVariableTypes, ExpressionUnionType]', list_of_variable_names: 'list[str]', expression_type, read_lambda) -> None:
-        for sensitivity_variable_name in list_of_variable_names:
- 
-            sensitivity_variable_name = Kratos.SensitivityUtilities.GetSensitivityVariableName(Kratos.KratosGlobals.GetVariable(sensitivity_variable_name))
-            sensitivity_variable = Kratos.KratosGlobals.GetVariable(sensitivity_variable_name)
-            exp = expression_type(self.GetSensitivityModelPart())
-            read_lambda(exp, sensitivity_variable)
-            sensitivity_dict[sensitivity_variable] = exp.Clone()
-
     def _CreateScheme(self):
         return Kratos.ResidualBasedAdjointStaticScheme(None)
diff --git a/applications/SystemIdentificationApplication/python_scripts/sensor_sensitivity_solvers/system_identification_static_analysis.py b/applications/SystemIdentificationApplication/python_scripts/sensor_sensitivity_solvers/system_identification_static_analysis.py
@@ -16,7 +16,7 @@ def _CreateSolver(self) -> SensorSensitivityAdjointStaticSolver:
     def _GetSimulationName(self) -> str:
         return "::[SystemIdentificationAnalysis]:: "
 
-    def CalculateGradient(self, response_function: Kratos.AdjointResponseFunction) -> 'dict[SupportedSensitivityFieldVariableTypes, ContainerExpressionTypes]':
+    def CalculateGradient(self, response_function: Kratos.AdjointResponseFunction) -> None:
         self._GetSolver().SetResponseFunction(response_function)
         self.InitializeSolutionStep()
         response_function.InitializeSolutionStep()
@@ -25,9 +25,6 @@ def CalculateGradient(self, response_function: Kratos.AdjointResponseFunction) -
         self.FinalizeSolutionStep()
         self.OutputSolutionStep()
 
-        gradients = self._GetSolver().GetSensitivities()
-        return gradients
-
     def PrintAnalysisStageProgressInformation(self):
         process_info = self._GetSolver().GetComputingModelPart().ProcessInfo
         Kratos.Logger.PrintInfo(self._GetSimulationName(), f"Step {process_info[Kratos.STEP]}: Computed sensitivities for response \"{process_info[KratosSI.SENSOR_NAME]}\" using \"{process_info[KratosSI.TEST_ANALYSIS_NAME]}\" analysis.")
