KratosSystemIdentificationApplication 10.4.4__py3-none-any.whl

KratosMultiphysics/SystemIdentificationApplication/responses/damage_detection_response.py

@@ -0,0 +1,190 @@
+from typing import Optional
+import csv
+
+import KratosMultiphysics as Kratos
+import KratosMultiphysics.SystemIdentificationApplication as KratosSI
+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.execution_policies.execution_policy_decorator import ExecutionPolicyDecorator
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem import OptimizationProblem
+from KratosMultiphysics.OptimizationApplication.utilities.component_data_view import ComponentDataView
+from KratosMultiphysics.SystemIdentificationApplication.sensor_sensitivity_solvers.system_identification_static_analysis import SystemIdentificationStaticAnalysis
+from KratosMultiphysics.SystemIdentificationApplication.utilities.sensor_utils import GetSensors
+from KratosMultiphysics.SystemIdentificationApplication.utilities.sensor_utils import SetSensorNormalizationFactor
+
+def Factory(model: Kratos.Model, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem) -> ResponseFunction:
+    if not parameters.Has("name"):
+        raise RuntimeError(f"DamageDetectionResponse instantiation requires a \"name\" in parameters [ parameters = {parameters}].")
+    if not parameters.Has("settings"):
+        raise RuntimeError(f"DamageDetectionResponse instantiation requires a \"settings\" in parameters [ parameters = {parameters}].")
+    return DamageDetectionResponse(parameters["name"].GetString(), model, parameters["settings"], optimization_problem)
+
+
+class DamageDetectionResponse(ResponseFunction):
+    def __init__(self, name: str, model: Kratos.Model, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem):
+        super().__init__(name)
+
+        default_settings = Kratos.Parameters("""{
+            "sensor_group_name"          : "",
+            "p_coefficient"              : 1,
+            "adjoint_parameters"         : {},
+            "evaluated_model_part_names" : [
+                "PLEASE_PROVIDE_A_MODEL_PART_NAME"
+            ],
+            "test_analysis_list": [
+                {
+                    "primal_analysis_name": "Structure_static",
+                    "sensor_measurement_csv_file": "measurement_data.csv",
+                    "weight": 1.0,
+                    "sensor_normalization_settings": {
+                        "type": "none"
+                    },
+                    "variable_io_settings": {
+                        "model_part_name"           : "Structure",
+                        "nodal_hist_variable_names"    : [],
+                        "nodal_non_hist_variable_names": [],
+                        "condition_variable_names"     : [],
+                        "element_variable_names"       : [],
+                        "condition_property_names"     : [],
+                        "element_property_names"       : []
+                    }
+                }
+            ]
+        }""")
+        parameters.ValidateAndAssignDefaults(default_settings)
+
+        self.model = model
+        self.sensor_group_name = parameters["sensor_group_name"].GetString()
+
+        if self.sensor_group_name == "":
+            raise RuntimeError(f"The sensor group name cannot be empty.")
+
+        self.p_coefficient = parameters["p_coefficient"].GetDouble()
+
+        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 {self._GetResponsePrefix()}. [ response name = \"{self.GetName()}\"]")
+
+        # reading test analsis list
+        self.list_of_test_analysis_data: 'list[tuple[ExecutionPolicyDecorator, str, Kratos.Parameters, float]]' = []
+        for params in parameters["test_analysis_list"].values():
+            params.ValidateAndAssignDefaults(default_settings["test_analysis_list"][0])
+            primal_analysis_name = params["primal_analysis_name"].GetString()
+            sensor_measurement_data_file_name = params["sensor_measurement_csv_file"].GetString()
+            sensor_normalization_settings = params["sensor_normalization_settings"]
+            weight = params["weight"].GetDouble()
+            self.list_of_test_analysis_data.append((optimization_problem.GetExecutionPolicy(primal_analysis_name), sensor_measurement_data_file_name, sensor_normalization_settings, weight))
+
+        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.analysis_model_part_operation = ModelPartOperation(self.model, ModelPartOperation.OperationType.UNION, f"response_test_analysis_{self.GetName()}", [exec.GetAnalysisModelPart().FullName() for exec, _, _, _ in self.list_of_test_analysis_data], False)
+        self.analysis_model_part: Optional[Kratos.ModelPart] = None
+
+        self.adjoint_analysis = SystemIdentificationStaticAnalysis(self.model, parameters["adjoint_parameters"])
+
+        self.sensor_name_dict: 'dict[str, KratosSI.Sensors.Sensor]' = {}
+        self.optimization_problem = optimization_problem
+
+    def GetImplementedPhysicalKratosVariables(self) -> 'list[SupportedSensitivityFieldVariableTypes]':
+        return [Kratos.YOUNG_MODULUS]
+
+    def Initialize(self) -> None:
+        self.model_part = self.model_part_operation.GetModelPart()
+        self.analysis_model_part = self.analysis_model_part_operation.GetModelPart()
+
+        self.adjoint_analysis.Initialize()
+
+        self.damage_response_function = KratosSI.Responses.MeasurementResidualResponseFunction(self.p_coefficient)
+
+        if not self.optimization_problem.GetProblemDataContainer()["object"].HasValue(self.sensor_group_name):
+            raise RuntimeError(f"The sensor group \"{self.sensor_group_name}\" not found. Followings are available: \n\t" + "\n\t".join(self.optimization_problem.GetProblemDataContainer()["object"].GetSubItems().keys()))
+
+        sensor_group_data = ComponentDataView(self.sensor_group_name, self.optimization_problem)
+        self.list_of_sensors = GetSensors(sensor_group_data)
+        for sensor in self.list_of_sensors:
+            sensor.GetNode().SetValue(KratosSI.SENSOR_MEASURED_VALUE, 0.0)
+            sensor.GetNode().SetValue(KratosSI.SENSOR_NORMALIZATION_FACTOR, 1.0)
+            self.damage_response_function.AddSensor(sensor)
+
+        self.damage_response_function.Initialize()
+
+        for sensor in self.list_of_sensors:
+            self.sensor_name_dict[sensor.GetName()] = sensor
+
+    def Check(self) -> None:
+        pass
+
+    def Finalize(self) -> None:
+        self.adjoint_analysis.Finalize()
+
+    def GetInfluencingModelPart(self) -> Kratos.ModelPart:
+        if self.analysis_model_part is None:
+            raise RuntimeError(f"Please call {self._GetResponsePrefix()}::Initialize first.")
+        return self.analysis_model_part
+
+    def CalculateValue(self) -> float:
+        result = 0.0
+        for exec_policy, sensor_measurement_data_file_name, sensor_normalization_settings, test_case_weight in self.list_of_test_analysis_data:
+            # first run the primal analysis.
+            exec_policy.Execute()
+
+            self.__SetSensorMeasuredValue(sensor_measurement_data_file_name)
+            SetSensorNormalizationFactor(self.list_of_sensors, sensor_normalization_settings)
+
+            result += test_case_weight * self.damage_response_function.CalculateValue(exec_policy.GetAnalysisModelPart())
+            Kratos.Logger.PrintInfo(self._GetResponsePrefix(), f"Computed \"{exec_policy.GetName()}\".")
+
+        return result
+
+    def CalculateGradient(self, physical_variable_gradient_map: 'dict[SupportedSensitivityFieldVariableTypes, Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor]') -> None:
+        # make everything zeros
+        for physical_variable, cta in physical_variable_gradient_map.items():
+            cta.data[:] = 0.0
+            Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor(cta, perform_store_data_recursively=False, copy=False).StoreData()
+
+        # now compute sensitivities for each test scenario
+        for exec_policy, sensor_measurement_data_file_name, sensor_normalization_settings, test_case_weight in self.list_of_test_analysis_data:
+            # read and replace the measurement data for each test scenario
+            self.__SetSensorMeasuredValue(sensor_measurement_data_file_name)
+            SetSensorNormalizationFactor(self.list_of_sensors, sensor_normalization_settings)
+
+            # run a single adjoint for each test scenario
+            self.adjoint_analysis._GetSolver().GetComputingModelPart().ProcessInfo[KratosSI.TEST_ANALYSIS_NAME] = exec_policy.GetName()
+            self.adjoint_analysis._GetSolver().GetComputingModelPart().ProcessInfo[Kratos.STEP] = self.optimization_problem.GetStep()
+            self.adjoint_analysis.CalculateGradient(self.damage_response_function)
+
+            for physical_variable, cta in physical_variable_gradient_map.items():
+                sensitivity_variable = Kratos.KratosGlobals.GetVariable(Kratos.SensitivityUtilities.GetSensitivityVariableName(physical_variable))
+                for ta in cta.GetTensorAdaptors():
+                    current_gradient = ta.Clone()
+                    self.adjoint_analysis.GetGradient(sensitivity_variable, current_gradient)
+                    ta.data[:] -= current_gradient.data[:] * test_case_weight
+                Kratos.TensorAdaptors.DoubleCombinedTensorAdaptor(cta, perform_collect_data_recursively=False, copy=False).CollectData()
+
+    def __GetSensor(self, sensor_name: str) -> KratosSI.Sensors.Sensor:
+        return self.sensor_name_dict[sensor_name]
+
+    def __GetHeaderIndices(self, csv_stream: csv.reader) -> 'tuple[int, int]':
+        headers = [s.strip() for s in next(csv_stream)]
+        name_index = headers.index("name")
+        value_index = headers.index("value")
+        return name_index, value_index
+
+    def __SetSensorMeasuredValue(self, sensor_measurement_data_file_name: str) -> None:
+        with open(sensor_measurement_data_file_name, "r") as csv_measurement_file:
+            csv_measurement_stream = csv.reader(csv_measurement_file, delimiter=",")
+            measured_name_index, measured_value_index = self.__GetHeaderIndices(csv_measurement_stream)
+
+            for measured_row in csv_measurement_stream:
+                measured_sensor_name = measured_row[measured_name_index].strip()
+                measured_value = float(measured_row[measured_value_index])
+                if measured_sensor_name in self.sensor_name_dict:
+                    self.__GetSensor(measured_sensor_name).GetNode().SetValue(KratosSI.SENSOR_MEASURED_VALUE, measured_value)
+
+    def _GetResponsePrefix(self) -> str:
+        return "DamageDetectionResponse"
+
+    def __str__(self) -> str:
+        return f"Response [type = {self._GetResponsePrefix()}, name = {self.GetName()}, model part name = {self.model_part.FullName()}]"

KratosMultiphysics/SystemIdentificationApplication/responses/pressure_detection_response.py

@@ -0,0 +1,20 @@
+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.SystemIdentificationApplication.responses.damage_detection_response import DamageDetectionResponse
+
+def Factory(model: Kratos.Model, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem) -> ResponseFunction:
+    if not parameters.Has("name"):
+        raise RuntimeError(f"PressureDetectionResponse instantiation requires a \"name\" in parameters [ parameters = {parameters}].")
+    if not parameters.Has("settings"):
+        raise RuntimeError(f"PressureDetectionResponse instantiation requires a \"settings\" in parameters [ parameters = {parameters}].")
+    return PressureDetectionResponse(parameters["name"].GetString(), model, parameters["settings"], optimization_problem)
+
+
+class PressureDetectionResponse(DamageDetectionResponse):
+    def GetImplementedPhysicalKratosVariables(self) -> 'list[SupportedSensitivityFieldVariableTypes]':
+        return [Kratos.PRESSURE]
+
+    def _GetResponsePrefix(self) -> str:
+        return "PressureDetectionResponse"

KratosMultiphysics/SystemIdentificationApplication/responses/temperature_detection_response.py

@@ -0,0 +1,20 @@
+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.SystemIdentificationApplication.responses.damage_detection_response import DamageDetectionResponse
+
+def Factory(model: Kratos.Model, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem) -> ResponseFunction:
+    if not parameters.Has("name"):
+        raise RuntimeError(f"TemperatureDetectionResponse instantiation requires a \"name\" in parameters [ parameters = {parameters}].")
+    if not parameters.Has("settings"):
+        raise RuntimeError(f"TemperatureDetectionResponse instantiation requires a \"settings\" in parameters [ parameters = {parameters}].")
+    return TemperatureDetectionResponse(parameters["name"].GetString(), model, parameters["settings"], optimization_problem)
+
+
+class TemperatureDetectionResponse(DamageDetectionResponse):
+    def GetImplementedPhysicalKratosVariables(self) -> 'list[SupportedSensitivityFieldVariableTypes]':
+        return [Kratos.TEMPERATURE]
+
+    def _GetResponsePrefix(self) -> str:
+        return "TemperatureDetectionResponse"

KratosMultiphysics/SystemIdentificationApplication/sensor_generator_analysis.py

@@ -0,0 +1,130 @@
+import typing
+import json
+
+import KratosMultiphysics as Kratos
+import KratosMultiphysics.SystemIdentificationApplication as KratosSI
+
+class SensorGeneratorAnalysis:
+    def __init__(self, model: Kratos.Model, parameters: Kratos.Parameters) -> None:
+        default_settings = Kratos.Parameters("""{
+            "model_part_name"     : "PLEASE_SPECIFY_MODEL_PART_NAME",
+            "mdpa_file_name"      : "PlEASE_SPECIFY_FILE_NAME",
+            "output_file_name"    : "sensor_data.json",
+            "csv_output_file_name": "sensor_data.csv",
+            "sensor_groups"   : [
+                {
+                    "generation_method": "mesh_based",
+                    "container_type"   : "elements",
+                    "location"         : "center",
+                    "sensor_settings"  : {}
+                }
+            ]
+        }""")
+
+        self.parameters = parameters
+        self.parameters.ValidateAndAssignDefaults(default_settings)
+        self.model = model
+
+        model_part_name = self.parameters["model_part_name"].GetString()
+        root_model_part = model_part_name.split(".")[0]
+        self.root_model_part = self.model.CreateModelPart(root_model_part)
+
+    def Run(self) -> None:
+        Kratos.ModelPartIO(self.parameters["mdpa_file_name"].GetString(), Kratos.ModelPartIO.READ | Kratos.ModelPartIO.MESH_ONLY).ReadModelPart(self.root_model_part)
+        self.model_part = self.model[self.parameters["model_part_name"].GetString()]
+
+        sensors_dict = {"list_of_sensors": []}
+        for sensor_group in self.parameters["sensor_groups"].values():
+            generation_method = sensor_group["generation_method"].GetString()
+            if generation_method == "mesh_based":
+                self.__GenerateMeshBased(sensors_dict, sensor_group)
+            elif generation_method == "bounding_surface":
+                self.__GenerationBoundingSurfaceBased(sensors_dict, sensor_group)
+            else:
+                raise RuntimeError("Unsupported generation method")
+
+        with open(self.parameters["output_file_name"].GetString(), "w") as file_output:
+            file_output.write(json.dumps(sensors_dict, indent=4))
+
+        with open(self.parameters["csv_output_file_name"].GetString(), "w") as file_output:
+            file_output.write("#,name,location_0,location_1,location_2\n")
+            for i, sensor_info in enumerate(sensors_dict["list_of_sensors"]):
+                name = sensor_info["name"]
+                location = sensor_info["location"]
+                file_output.write(f"{i+1},{name},{location[0]},{location[1]},{location[2]}\n")
+
+    def __GenerationBoundingSurfaceBased(self, sensors_dict, sensor_group_params: Kratos.Parameters):
+        defaults = Kratos.Parameters("""{
+                "generation_method"        : "bounding_surface",
+                "bounding_surface_corner_1": [0.0, 0.0, 0.0],
+                "bounding_surface_corner_2": [0.0, 0.0, 0.0],
+                "number_of_sensors"        : [1, 1, 1],
+                "sensor_settings"  : {}
+        }""")
+        sensor_group_params.ValidateAndAssignDefaults(defaults)
+
+        point_locator = Kratos.BruteForcePointLocator(self.model_part)
+
+        corner_1 = sensor_group_params["bounding_surface_corner_1"].GetVector()
+        corner_2 = sensor_group_params["bounding_surface_corner_2"].GetVector()
+        number_of_sensors = sensor_group_params["number_of_sensors"].GetVector()
+        number_of_sensors = [int(v) for v in number_of_sensors]
+
+        sensor_params = sensor_group_params["sensor_settings"]
+        if not sensor_params.Has("location"):
+            sensor_params.AddVector("location", Kratos.Vector())
+
+        distance = corner_2 - corner_1
+        index = 1
+        for i_x in range(number_of_sensors[0]):
+            x_coord = corner_1[0] + distance[0] * (i_x + 1) / (number_of_sensors[0] + 1)
+            for i_y in range(number_of_sensors[1]):
+                y_coord = corner_1[1] + distance[1] * (i_y + 1) / (number_of_sensors[1] + 1)
+                for i_z in range(number_of_sensors[2]):
+                    z_coord = corner_1[2] + distance[2] * (i_z + 1) / (number_of_sensors[2] + 1)
+                    loc = Kratos.Point(x_coord, y_coord, z_coord)
+                    shape_funcs = Kratos.Vector()
+                    elem_id = point_locator.FindElement(loc, shape_funcs, Kratos.Configuration.Initial, 1e-8)
+                    if elem_id != -1 and KratosSI.SensorUtils.IsPointInGeometry(loc, self.model_part.GetElement(elem_id).GetGeometry()):
+                        current_params = sensor_params.Clone()
+                        current_params["location"].SetVector(loc)
+                        json_dict = json.loads(current_params.WriteJsonString().replace("<ENTITY_ID>", str(index)))
+                        index += 1
+                        sensors_dict["list_of_sensors"].append(json_dict)
+
+    def __GenerateMeshBased(self, sensors_dict, sensor_group_params: Kratos.Parameters):
+        defaults = Kratos.Parameters("""{
+                "generation_method": "mesh_based",
+                "container_type"   : "elements",
+                "location"         : "center",
+                "sensor_settings"  : {}
+        }""")
+        sensor_group_params.ValidateAndAssignDefaults(defaults)
+        container_type = sensor_group_params["container_type"].GetString()
+        container: 'typing.Union[Kratos.ElementsArray, Kratos.ConditionsArray]'
+        if container_type == "nodes":
+            container = self.model_part.Nodes
+        elif container_type == "elements":
+            container = self.model_part.Elements
+        elif container_type == "conditions":
+            container = self.model_part.Conditions
+        else:
+            raise RuntimeError(f"Unsupported container_type = \"{container_type}\".")
+
+        sensor_params = sensor_group_params["sensor_settings"]
+        if not sensor_params.Has("location"):
+            sensor_params.AddVector("location", Kratos.Vector())
+
+        location = sensor_group_params["location"].GetString()
+        if container_type == "nodes":
+            location_retrieval = lambda x: [x.X, x.Y, x.Z]
+        elif location == "center":
+            location_retrieval = lambda x: x.GetGeometry().Center()
+        else:
+            raise RuntimeError(f"Unsupported location = \"{location}\".")
+
+        for entity in container:
+            current_params = sensor_params.Clone()
+            current_params["location"].SetVector(location_retrieval(entity))
+            json_dict = json.loads(current_params.WriteJsonString().replace("<ENTITY_ID>", str(entity.Id)))
+            sensors_dict["list_of_sensors"].append(json_dict)

KratosMultiphysics/SystemIdentificationApplication/sensor_io/sensor_model_part_controller.py

@@ -0,0 +1,58 @@
+import KratosMultiphysics as Kratos
+from KratosMultiphysics.OptimizationApplication.model_part_controllers.model_part_controller import ModelPartController
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem import OptimizationProblem
+from KratosMultiphysics.SystemIdentificationApplication.utilities.sensor_utils import CreateSensors
+from KratosMultiphysics.SystemIdentificationApplication.utilities.sensor_utils import SetSensors
+from KratosMultiphysics.OptimizationApplication.utilities.component_data_view import ComponentDataView
+
+def Factory(model: Kratos.Model, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem) -> ModelPartController:
+    if not parameters.Has("settings"):
+        raise RuntimeError(f"SensorModelPartController instantiation requires a \"settings\" in parameters [ parameters = {parameters}].")
+    return SensorModelPartController(model, parameters["settings"], optimization_problem)
+
+class SensorModelPartController(ModelPartController):
+    def __init__(self, model: Kratos.Model, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem):
+        default_settings = Kratos.Parameters("""{
+            "sensor_group_name"       : "",
+            "domain_model_part_name"  : "",
+            "list_of_sensors"         : [],
+            "debug_output"            : false,
+            "debug_output_filename"   : "domain_model_part.vtu"
+        }""")
+
+        self.model = model
+        self.optimization_problem = optimization_problem
+        self.parameters = parameters
+        self.parameters.ValidateAndAssignDefaults(default_settings)
+
+        self.domain_model_part_name = parameters["domain_model_part_name"].GetString()
+        self.sensor_group_name = parameters["sensor_group_name"].GetString()
+        self.debug_output = parameters["debug_output"].GetBool()
+        self.debug_output_filename = parameters["debug_output_filename"].GetString()
+
+        if model.HasModelPart(self.sensor_group_name):
+            raise RuntimeError(f"The sensor model part name \"{self.sensor_group_name}\" already exists. Please provide a different \"sensor_group_name\".")
+        self.sensor_model_part = model.CreateModelPart(self.sensor_group_name)
+
+        # this dummy component data view is used to create the proper sensor group within the optimization problem.
+        ComponentDataView(self.sensor_group_name, self.optimization_problem)
+
+    def ImportModelPart(self) -> None:
+        self.domain_model_part = self.model[self.domain_model_part_name]
+
+        if self.debug_output:
+            vtu_output: Kratos.VtuOutput = Kratos.VtuOutput(self.domain_model_part)
+            vtu_output.PrintOutput(self.debug_output_filename)
+
+        self.list_of_sensors = CreateSensors(self.sensor_model_part, self.domain_model_part, self.parameters["list_of_sensors"].values())
+
+        # add the list of sensors to optimization problem
+        sensor_group_data = ComponentDataView(self.sensor_group_name, self.optimization_problem)
+        sensor_group_data.SetDataBuffer(1)
+
+        SetSensors(sensor_group_data, self.list_of_sensors)
+
+    def GetModelPart(self) -> Kratos.ModelPart:
+        return self.sensor_model_part
+
+

KratosMultiphysics/SystemIdentificationApplication/sensor_sensitivity_solvers/response_sensitivity_analysis.py

@@ -0,0 +1,41 @@
+import abc
+
+import KratosMultiphysics as Kratos
+
+from KratosMultiphysics.analysis_stage import AnalysisStage
+from KratosMultiphysics.OptimizationApplication.utilities.union_utilities import SupportedSensitivityFieldVariableTypes
+
+class ResponseSensitivityAnalysis(AnalysisStage, abc.ABC):
+    @abc.abstractmethod
+    def CalculateGradient(self, response_function: Kratos.AdjointResponseFunction) -> None:
+        """Calculate the gradient using the provided adjoint response function.
+
+        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
+        """
+        pass
+
+    def GetGradient(self, sensitivity_variable: SupportedSensitivityFieldVariableTypes, gradient_tensor_adaptor: Kratos.TensorAdaptors.DoubleTensorAdaptor) -> None:
+        """Returns the gradients in the domain represented by gradient_tensor_adaptor tensor adaptor.
+
+        Args:
+            sensitivity_variable (SupportedSensitivityFieldVariableTypes): Sensitivity variable
+            gradient_tensor_adaptor (Kratos.TensorAdaptors.DoubleTensorAdaptor): TensorAdaptor to hold the gradients.
+        """
+        if isinstance(gradient_tensor_adaptor.GetContainer(), Kratos.NodesArray):
+            Kratos.TensorAdaptors.HistoricalVariableTensorAdaptor(gradient_tensor_adaptor, sensitivity_variable, copy=False).CollectData()
+        else:
+            Kratos.TensorAdaptors.VariableTensorAdaptor(gradient_tensor_adaptor, sensitivity_variable, copy=False).CollectData()
+
+    def GetProcessesOrder(self) -> 'list[str]':
+        """The order of execution of the process categories.
+
+        This defines the order of execution of the processes defined under "processes"
+        in either "kratos_process" or "optimization_data_processes".
+
+        Returns:
+            list[str]: List of strings for process categories.
+        """
+        return ["auxiliary_processes", "output_processes"]

KratosMultiphysics/SystemIdentificationApplication/sensor_sensitivity_solvers/response_sensitivity_interface.py

@@ -0,0 +1,34 @@
+import abc
+import KratosMultiphysics as Kratos
+
+class ResponseSensitivityInterface(abc.ABC):
+    @abc.abstractmethod
+    def SetResponseFunction(self, response_function: Kratos.AdjointResponseFunction) -> None:
+        """Set the response function to compute the sensitivities using adjoint method.
+
+        Args:
+            response_function (Kratos.AdjointResponseFunction): Response function to be used to compute the sensitivities.
+        """
+        pass
+
+    @abc.abstractmethod
+    def GetResponseFunction(self) -> Kratos.AdjointResponseFunction:
+        """Returns the response function used to compute the sensitivities.
+
+        Returns:
+            Kratos.AdjointResponseFunction: Adjoint response function used in adjoint based sensitivity computation.
+        """
+        pass
+
+    @abc.abstractmethod
+    def GetSensitivityModelPart(self) -> Kratos.ModelPart:
+        """Returns the model part used on which the sensitivities are computed.
+
+        This is the model part on which the sensitivities are computed, not the model part on which
+        the adjoint solution is computed.
+
+        Returns:
+            Kratos.ModelPart: Sensitivity model part on which the sensitivities are computed.
+        """
+        pass
+

KratosMultiphysics/SystemIdentificationApplication/sensor_sensitivity_solvers/sensor_sensitivity_adjoint_static_solver.py

@@ -0,0 +1,50 @@
+import KratosMultiphysics as Kratos
+import KratosMultiphysics.SystemIdentificationApplication as KratosSI
+from KratosMultiphysics.StructuralMechanicsApplication.structural_mechanics_adjoint_static_solver import StructuralMechanicsAdjointStaticSolver
+from KratosMultiphysics.SystemIdentificationApplication.sensor_sensitivity_solvers.response_sensitivity_interface import ResponseSensitivityInterface
+
+class SensorSensitivityAdjointStaticSolver(StructuralMechanicsAdjointStaticSolver, ResponseSensitivityInterface):
+    def __init__(self, model: Kratos.Model, custom_settings: Kratos.Parameters):
+        super().__init__(model, custom_settings)
+        self.sensitivity_builder_initialized = False
+
+        default_response_function_settings = Kratos.Parameters("""{
+            "perturbation_size"      : 1e-8,
+            "adapt_perturbation_size": true
+        }""")
+        self.settings["response_function_settings"].ValidateAndAssignDefaults(default_response_function_settings)
+
+    def Initialize(self) -> None:
+        model_part = self.GetComputingModelPart()
+
+        response_function_settings: Kratos.Parameters = self.settings["response_function_settings"]
+        model_part.ProcessInfo[KratosSI.PERTURBATION_SIZE] = response_function_settings["perturbation_size"].GetDouble()
+        model_part.ProcessInfo[KratosSI.ADAPT_PERTURBATION_SIZE] = response_function_settings["adapt_perturbation_size"].GetBool()
+
+        # create sensitivity builder
+        self.sensitivity_builder = Kratos.SensitivityBuilder(self.settings["sensitivity_settings"], self.main_model_part, None)
+
+        # skip calling Initialize of StructuralMechanicsAdjointStaticSolver and call the its base class Initialize
+        super(StructuralMechanicsAdjointStaticSolver, self).Initialize()
+
+        Kratos.Logger.PrintInfo(self.__class__.__name__, "Finished initialization.")
+
+    def SetResponseFunction(self, response_function: Kratos.AdjointResponseFunction) -> None:
+        self.response_function = response_function
+        self.sensitivity_builder.SetResponseFunction(response_function)
+        self._GetScheme().SetResponseFunction(response_function)
+        if not self.sensitivity_builder_initialized:
+            self.sensitivity_builder.Initialize()
+            self.sensitivity_builder_initialized = True
+
+    def GetResponseFunction(self) -> Kratos.AdjointResponseFunction:
+        return self._GetScheme().GetResponseFunction()
+
+    def GetSensitivityModelPart(self) -> Kratos.ModelPart:
+        return self.main_model_part.GetSubModelPart(self.settings["sensitivity_settings"]["sensitivity_model_part_name"].GetString())
+
+    def SolveSolutionStep(self) -> bool:
+        return super(StructuralMechanicsAdjointStaticSolver, self).SolveSolutionStep()
+
+    def _CreateScheme(self):
+        return Kratos.ResidualBasedAdjointStaticScheme(None)

KratosMultiphysics/SystemIdentificationApplication/sensor_sensitivity_solvers/system_identification_static_analysis.py

@@ -0,0 +1,52 @@
+import KratosMultiphysics as Kratos
+import KratosMultiphysics.SystemIdentificationApplication as KratosSI
+
+from KratosMultiphysics.SystemIdentificationApplication.sensor_sensitivity_solvers.response_sensitivity_analysis import ResponseSensitivityAnalysis
+from KratosMultiphysics.SystemIdentificationApplication.sensor_sensitivity_solvers.sensor_sensitivity_adjoint_static_solver import SensorSensitivityAdjointStaticSolver
+
+def Factory(model: Kratos.Model, parameters: Kratos.Parameters, _):
+    return SystemIdentificationStaticAnalysis(model, parameters["settings"])
+
+class SystemIdentificationStaticAnalysis(ResponseSensitivityAnalysis):
+    def _CreateSolver(self) -> SensorSensitivityAdjointStaticSolver:
+        return SensorSensitivityAdjointStaticSolver(self.model, self.project_parameters["solver_settings"])
+
+    def _GetSimulationName(self) -> str:
+        return "::[SystemIdentificationAnalysis]:: "
+
+    def CalculateGradient(self, response_function: Kratos.AdjointResponseFunction) -> None:
+        self._GetSolver().SetResponseFunction(response_function)
+        self.InitializeSolutionStep()
+        response_function.InitializeSolutionStep()
+        self._GetSolver().SolveSolutionStep()
+        response_function.FinalizeSolutionStep()
+        self.FinalizeSolutionStep()
+        self.OutputSolutionStep()
+
+    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.")
+
+if __name__ == "__main__":
+    from sys import argv
+
+    if len(argv) > 2:
+        err_msg =  'Too many input arguments!\n'
+        err_msg += 'Use this script in the following way:\n'
+        err_msg += '- With default ProjectParameters (read from "ProjectParameters.json"):\n'
+        err_msg += '    "python3 structural_mechanics_analysis.py"\n'
+        err_msg += '- With custom ProjectParameters:\n'
+        err_msg += '    "python3 structural_mechanics_analysis.py CustomProjectParameters.json"\n'
+        raise Exception(err_msg)
+
+    if len(argv) == 2: # ProjectParameters is being passed from outside
+        project_parameters_file_name = argv[1]
+    else: # using default name
+        project_parameters_file_name = "ProjectParameters.json"
+
+    with open(project_parameters_file_name,'r') as parameter_file:
+        parameters = Kratos.Parameters(parameter_file.read())
+
+    model = Kratos.Model()
+    simulation = SystemIdentificationStaticAnalysis(model, parameters)
+    simulation.Run()