KratosSystemIdentificationApplication 10.4.2__2-cp313-cp313-win_amd64.whl

KratosMultiphysics/SystemIdentificationApplication/__init__.py

@@ -0,0 +1,13 @@
+# Application dependent names and paths
+from KratosMultiphysics import _ImportApplication, python_registry_utilities
+from KratosSystemIdentificationApplication import *
+
+application = KratosSystemIdentificationApplication()
+application_name = "KratosSystemIdentificationApplication"
+
+_ImportApplication(application, application_name)
+
+from . import python_registry_lists
+python_registry_utilities.RegisterModelersList("KratosMultiphysics.SystemIdentificationApplication", python_registry_lists)
+python_registry_utilities.RegisterOperationsList("KratosMultiphysics.SystemIdentificationApplication", python_registry_lists)
+python_registry_utilities.RegisterProcessesList("KratosMultiphysics.SystemIdentificationApplication", python_registry_lists)

KratosMultiphysics/SystemIdentificationApplication/controls/data_values_control.py

@@ -0,0 +1,210 @@
+import math, numpy
+from typing import Optional
+
+import KratosMultiphysics as Kratos
+import KratosMultiphysics.SystemIdentificationApplication as KratosSI
+from KratosMultiphysics.OptimizationApplication.controls.control import Control
+from KratosMultiphysics.OptimizationApplication.utilities.union_utilities import SupportedSensitivityFieldVariableTypes
+from KratosMultiphysics.OptimizationApplication.utilities.model_part_utilities import ModelPartOperation
+from KratosMultiphysics.OptimizationApplication.utilities.logger_utilities import TimeLogger
+from KratosMultiphysics.OptimizationApplication.utilities.component_data_view import ComponentDataView
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem import OptimizationProblem
+from KratosMultiphysics.SystemIdentificationApplication.utilities.tensor_adaptor_utils import TensorAdaptorBoundingManager, GetTensorAdaptor
+from KratosMultiphysics.OptimizationApplication.filtering.filter import Factory as FilterFactory
+
+def Factory(model: Kratos.Model, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem) -> Control:
+    if not parameters.Has("name"):
+        raise RuntimeError(f"DataValuesControl instantiation requires a \"name\" in parameters [ parameters = {parameters}].")
+    if not parameters.Has("settings"):
+        raise RuntimeError(f"DataValuesControl instantiation requires a \"settings\" in parameters [ parameters = {parameters}].")
+
+    return DataValuesControl(parameters["name"].GetString(), model, parameters["settings"], optimization_problem)
+
+
+class DataValuesControl(Control):
+    """Data values control
+
+    This is a generic data values control which creates a control
+    for the specified control variable. This does not do any filtering.
+
+    """
+    def __init__(self, name: str, model: Kratos.Model, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem):
+        super().__init__(name)
+
+        default_settings = Kratos.Parameters("""{
+            "control_variable_name"             : "",
+            "control_variable_bounds"           : [0.0, 0.0],
+            "container_type"                    : "",
+            "output_all_fields"                 : false,
+            "filter_settings"                   : {},
+            "model_part_names": [
+                {
+                    "primal_model_part_name" : "PLEASE_PROVIDE_MODEL_PART_NAME",
+                    "adjoint_model_part_name": "PLEASE_PROVIDE_MODEL_PART_NAME"
+                }
+            ]
+        }""")
+
+        parameters.ValidateAndAssignDefaults(default_settings)
+
+        allowed_container_types = {
+            "nodal_historical": Kratos.Globals.DataLocation.NodeHistorical,
+            "nodal_nonhistorical": Kratos.Globals.DataLocation.NodeNonHistorical,
+            "condition": Kratos.Globals.DataLocation.Condition,
+            "element": Kratos.Globals.DataLocation.Element
+        }
+        container_type = parameters["container_type"].GetString()
+        if container_type not in allowed_container_types.keys():
+            raise RuntimeError(f"Unsupported container type = \"{container_type}\". Allowed container types are:\n\t" + "\n\t".join(list(allowed_container_types.keys())))
+        else:
+            self.container_type = allowed_container_types[container_type]
+
+        self.model : Kratos.Model = model
+        self.parameters = parameters
+        self.optimization_problem = optimization_problem
+
+        self.output_all_fields = parameters["output_all_fields"].GetBool()
+        control_variable_name = parameters["control_variable_name"].GetString()
+        control_variable_type = Kratos.KratosGlobals.GetVariableType(control_variable_name)
+        if control_variable_type != "Double":
+            raise RuntimeError(f"{control_variable_name} with {control_variable_type} type is not supported. Only supports double variables")
+        self.controlled_physical_variable: SupportedSensitivityFieldVariableTypes = Kratos.KratosGlobals.GetVariable(control_variable_name)
+
+        controlled_model_part_names: 'list[Kratos.Parameters]' = parameters["model_part_names"].values()
+        if len(controlled_model_part_names) == 0:
+            raise RuntimeError(f"No model parts were provided for DataValuesControl. [ control name = \"{self.GetName()}\"]")
+
+        self.primal_model_part_operation = ModelPartOperation(
+                                                self.model,
+                                                ModelPartOperation.OperationType.UNION,
+                                                f"control_primal_{self.GetName()}",
+                                                [param["primal_model_part_name"].GetString() for param in controlled_model_part_names],
+                                                False)
+        self.adjoint_model_part_operation = ModelPartOperation(
+                                                self.model,
+                                                ModelPartOperation.OperationType.UNION,
+                                                f"control_adjoint_{self.GetName()}",
+                                                [param["adjoint_model_part_name"].GetString() for param in controlled_model_part_names],
+                                                False)
+
+        # filter needs to be based on the primal model part
+        # because, filter may keep pointers for the elements to get their center positions
+        # for filtering. The adjoint model part may re-assign adjoint elements based on
+        # the primal model part rendering the filter element pointers useless and to segfault.
+        # hence filter is using the primal model part to get the locations.
+        self.filter = FilterFactory(self.model, self.primal_model_part_operation.GetModelPartFullName(), self.controlled_physical_variable, self.container_type, self.parameters["filter_settings"])
+
+        self.primal_model_part: Optional[Kratos.ModelPart] = None
+        self.adjoint_model_part: Optional[Kratos.ModelPart] = None
+
+        control_variable_bounds = parameters["control_variable_bounds"].GetVector()
+
+        # use the clamper in the unit interval
+        self.interval_bounder = TensorAdaptorBoundingManager(control_variable_bounds)
+        self.clamper = KratosSI.SmoothClamper(0, 1)
+
+    def Initialize(self) -> None:
+        self.primal_model_part = self.primal_model_part_operation.GetModelPart()
+        self.adjoint_model_part = self.adjoint_model_part_operation.GetModelPart()
+
+        # initialize the filter
+        self.filter.SetComponentDataView(ComponentDataView(self, self.optimization_problem))
+        self.filter.Initialize()
+
+        physical_field = self.GetPhysicalField()
+
+        # get the phi field which is in [0, 1] range
+        self.physical_phi_field = self.clamper.ProjectBackward(self.interval_bounder.GetBoundedTensorAdaptor(physical_field))
+
+        # compute the control phi field
+        self.control_phi_field = self.filter.UnfilterField(self.physical_phi_field)
+
+        self.physical_phi_derivative_field = self.clamper.CalculateForwardProjectionGradient(self.physical_phi_field)
+        self.physical_phi_derivative_field.data[:] *= self.interval_bounder.GetBoundGap()
+
+        self._UpdateAndOutputFields(self.GetEmptyField())
+
+    def Check(self) -> None:
+        self.filter.Check()
+
+    def Finalize(self) -> None:
+        self.filter.Finalize()
+
+    def GetPhysicalKratosVariables(self) -> 'list[SupportedSensitivityFieldVariableTypes]':
+        return [self.controlled_physical_variable]
+
+    def GetEmptyField(self) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        field = GetTensorAdaptor(self.primal_model_part, self.container_type, self.controlled_physical_variable)
+        field.data[:] = 0.0
+        return field
+
+    def GetControlField(self) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        return self.control_phi_field.Clone()
+
+    def GetPhysicalField(self) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        physical_thickness_field = GetTensorAdaptor(self.primal_model_part, self.container_type, self.controlled_physical_variable)
+        physical_thickness_field.CollectData()
+        return physical_thickness_field
+
+    def MapGradient(self, physical_variable_gradient_map: 'dict[SupportedSensitivityFieldVariableTypes, Kratos.TensorAdaptors.DoubleTensorAdaptor]') -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        with TimeLogger("DataValuesControl::MapGradient", None, "Finished",False):
+            keys = physical_variable_gradient_map.keys()
+            if len(keys) != 1:
+                raise RuntimeError(f"Provided more than required gradient fields for control \"{self.GetName()}\". Following are the variables:\n\t" + "\n\t".join([k.Name() for k in keys]))
+            if self.controlled_physical_variable not in keys:
+                raise RuntimeError(f"The required gradient for control \"{self.GetName()}\" w.r.t. {self.controlled_physical_variable.Name()} not found. Followings are the variables:\n\t" + "\n\t".join([k.Name() for k in keys]))
+
+            physical_gradient = physical_variable_gradient_map[self.controlled_physical_variable]
+            if physical_gradient.GetContainer() != self.GetEmptyField().GetContainer():
+                raise RuntimeError(f"Gradients for the required element container not found for control \"{self.GetName()}\". [ required model part name: {self.primal_model_part.FullName()} ]")
+
+            # dj/dE -> physical_gradient
+            # dj/dphi = dj/dphysical * dphysical/dphi
+            dj_dphi = physical_gradient.Clone()
+            dj_dphi.data[:] *= self.physical_phi_derivative_field.data
+            return self.filter.BackwardFilterIntegratedField(dj_dphi)
+
+    def Update(self, new_control_field: Kratos.TensorAdaptors.DoubleTensorAdaptor) -> bool:
+        if new_control_field.GetContainer() != self.GetEmptyField().GetContainer():
+            raise RuntimeError(f"Updates for the required element container not found for control \"{self.GetName()}\". [ required model part name: {self.primal_model_part.FullName()} ]")
+
+        update = new_control_field.Clone()
+        update.data[:] -= self.control_phi_field.data
+        if not math.isclose(numpy.linalg.norm(update.data), 0.0, abs_tol=1e-16):
+            with TimeLogger(self.__class__.__name__, f"Updating {self.GetName()}...", f"Finished updating of {self.GetName()}.",False):
+                # update the control thickness field
+                self.control_phi_field.data[:] = new_control_field.data
+                # now update the physical field
+                self._UpdateAndOutputFields(update)
+                return True
+        return False
+
+    def _UpdateAndOutputFields(self, update: Kratos.TensorAdaptors.DoubleTensorAdaptor) -> None:
+        # filter the control field
+        filtered_phi_field_update = self.filter.ForwardFilterField(update)
+        self.physical_phi_field.data[:] += filtered_phi_field_update.data
+
+        # project forward the filtered thickness field to get clamped physical field
+        physical_field = self.interval_bounder.GetUnboundedTensorAdaptor(self.clamper.ProjectForward(self.physical_phi_field))
+
+        # now update physical field
+        ta = GetTensorAdaptor(self.primal_model_part, self.container_type, self.controlled_physical_variable)
+        ta.data[:] = physical_field.data
+        ta.StoreData()
+
+        # compute and store projection derivatives for consistent filtering of the sensitivities
+        # this is dphi/dphysical -> physical_phi_derivative_field
+        self.physical_phi_derivative_field = self.clamper.CalculateForwardProjectionGradient(self.physical_phi_field)
+        self.physical_phi_derivative_field.data[:] *= self.interval_bounder.GetBoundGap()
+
+        # now output the fields
+        un_buffered_data = ComponentDataView(self, self.optimization_problem).GetUnBufferedData()
+        un_buffered_data.SetValue(f"{self.controlled_physical_variable.Name()}", physical_field.Clone(), overwrite=True)
+        if self.output_all_fields:
+            un_buffered_data.SetValue(f"{self.controlled_physical_variable.Name()}_physical_phi_update", filtered_phi_field_update.Clone(), overwrite=True)
+            un_buffered_data.SetValue(f"{self.controlled_physical_variable.Name()}_control_phi", self.control_phi_field.Clone(), overwrite=True)
+            un_buffered_data.SetValue(f"{self.controlled_physical_variable.Name()}_physical_phi", self.physical_phi_field.Clone(), overwrite=True)
+            un_buffered_data.SetValue(f"{self.controlled_physical_variable.Name()}_physical_phi_derivative", self.physical_phi_derivative_field.Clone(), overwrite=True)
+
+    def __str__(self) -> str:
+        return f"Control [type = {self.__class__.__name__}, name = {self.GetName()}, model part name = {self.adjoint_model_part_operation.GetModelPartFullName()}, control variable = {self.controlled_physical_variable.Name()}"

KratosMultiphysics/SystemIdentificationApplication/controls/material_properties_control.py

@@ -0,0 +1,212 @@
+import math, numpy
+from typing import Optional
+
+import KratosMultiphysics as Kratos
+import KratosMultiphysics.OptimizationApplication as KratosOA
+import KratosMultiphysics.SystemIdentificationApplication as KratosSI
+from KratosMultiphysics.OptimizationApplication.controls.control import Control
+from KratosMultiphysics.OptimizationApplication.utilities.union_utilities import SupportedSensitivityFieldVariableTypes
+from KratosMultiphysics.OptimizationApplication.utilities.model_part_utilities import ModelPartOperation
+from KratosMultiphysics.OptimizationApplication.utilities.logger_utilities import TimeLogger
+from KratosMultiphysics.OptimizationApplication.utilities.component_data_view import ComponentDataView
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem import OptimizationProblem
+from KratosMultiphysics.SystemIdentificationApplication.utilities.tensor_adaptor_utils import TensorAdaptorBoundingManager
+from KratosMultiphysics.OptimizationApplication.filtering.filter import Factory as FilterFactory
+
+def Factory(model: Kratos.Model, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem) -> Control:
+    if not parameters.Has("name"):
+        raise RuntimeError(f"MaterialPropertiesControl instantiation requires a \"name\" in parameters [ parameters = {parameters}].")
+    if not parameters.Has("settings"):
+        raise RuntimeError(f"MaterialPropertiesControl instantiation requires a \"settings\" in parameters [ parameters = {parameters}].")
+
+    return MaterialPropertiesControl(parameters["name"].GetString(), model, parameters["settings"], optimization_problem)
+
+class MaterialPropertiesControl(Control):
+    """Material properties control
+
+    This is a generic material properties control which creates a control
+    for the specified control variable. This does not do any filtering.
+
+    """
+    def __init__(self, name: str, model: Kratos.Model, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem):
+        super().__init__(name)
+
+        default_settings = Kratos.Parameters("""{
+            "control_variable_name"             : "",
+            "control_variable_bounds"           : [0.0, 0.0],
+            "output_all_fields"                 : false,
+            "consider_recursive_property_update": false,
+            "filter_settings"                   : {},
+            "model_part_names": [
+                {
+                    "primal_model_part_name" : "PLEASE_PROVIDE_MODEL_PART_NAME",
+                    "adjoint_model_part_name": "PLEASE_PROVIDE_MODEL_PART_NAME"
+                }
+            ]
+        }""")
+        parameters.ValidateAndAssignDefaults(default_settings)
+
+        self.model = model
+        self.parameters = parameters
+        self.optimization_problem = optimization_problem
+
+        self.output_all_fields = parameters["output_all_fields"].GetBool()
+        control_variable_name = parameters["control_variable_name"].GetString()
+        control_variable_type = Kratos.KratosGlobals.GetVariableType(control_variable_name)
+        if control_variable_type != "Double":
+            raise RuntimeError(f"{control_variable_name} with {control_variable_type} type is not supported. Only supports double variables")
+        self.controlled_physical_variable: SupportedSensitivityFieldVariableTypes = Kratos.KratosGlobals.GetVariable(control_variable_name)
+
+        controlled_model_part_names: 'list[Kratos.Parameters]' = parameters["model_part_names"].values()
+        if len(controlled_model_part_names) == 0:
+            raise RuntimeError(f"No model parts were provided for MaterialPropertiesControl. [ control name = \"{self.GetName()}\"]")
+
+        self.primal_model_part_operation = ModelPartOperation(
+                                                self.model,
+                                                ModelPartOperation.OperationType.UNION,
+                                                f"control_primal_{self.GetName()}",
+                                                [param["primal_model_part_name"].GetString() for param in controlled_model_part_names],
+                                                False)
+        self.adjoint_model_part_operation = ModelPartOperation(
+                                                self.model,
+                                                ModelPartOperation.OperationType.UNION,
+                                                f"control_adjoint_{self.GetName()}",
+                                                [param["adjoint_model_part_name"].GetString() for param in controlled_model_part_names],
+                                                False)
+
+        self.consider_recursive_property_update = parameters["consider_recursive_property_update"].GetBool()
+
+
+        # filter needs to be based on the primal model part
+        # because, filter may keep pointers for the elements to get their center positions
+        # for filtering. The adjoint model part may re-assign adjoint elements based on
+        # the primal model part rendering the filter element pointers useless and to segfault.
+        # hence filter is using the primal model part to get the locations.
+        self.filter = FilterFactory(self.model, self.primal_model_part_operation.GetModelPartFullName(), self.controlled_physical_variable, Kratos.Globals.DataLocation.Element, self.parameters["filter_settings"])
+
+        self.primal_model_part: Optional[Kratos.ModelPart] = None
+        self.adjoint_model_part: Optional[Kratos.ModelPart] = None
+
+        control_variable_bounds = parameters["control_variable_bounds"].GetVector()
+
+        # use the clamper in the unit interval
+        self.interval_bounder = TensorAdaptorBoundingManager(control_variable_bounds)
+        self.clamper = KratosSI.SmoothClamper(0, 1)
+
+    def Initialize(self) -> None:
+        self.primal_model_part = self.primal_model_part_operation.GetModelPart()
+        self.adjoint_model_part = self.adjoint_model_part_operation.GetModelPart()
+
+        if not KratosOA.OptAppModelPartUtils.CheckModelPartStatus(self.primal_model_part, "element_specific_properties_created"):
+            KratosOA.OptimizationUtils.CreateEntitySpecificPropertiesForContainer(self.primal_model_part, self.primal_model_part.Elements, self.consider_recursive_property_update)
+            KratosOA.OptAppModelPartUtils.LogModelPartStatus(self.primal_model_part, "element_specific_properties_created")
+
+            if self.primal_model_part != self.adjoint_model_part:
+                if KratosOA.OptAppModelPartUtils.CheckModelPartStatus(self.adjoint_model_part, "element_specific_properties_created"):
+                    raise RuntimeError(f"Trying to create element specific properties for {self.adjoint_model_part.FullName()} which already has element specific properties.")
+
+                # now assign the properties of primal to the adjoint model parts
+                KratosSI.ControlUtils.AssignEquivalentProperties(self.primal_model_part.Elements, self.adjoint_model_part.Elements)
+                KratosOA.OptAppModelPartUtils.LogModelPartStatus(self.adjoint_model_part, "element_specific_properties_created")
+
+        # initialize the filter
+        self.filter.SetComponentDataView(ComponentDataView(self, self.optimization_problem))
+        self.filter.Initialize()
+
+        physical_field = self.GetPhysicalField()
+
+        # get the phi field which is in [0, 1] range
+        self.physical_phi_field = self.clamper.ProjectBackward(self.interval_bounder.GetBoundedTensorAdaptor(physical_field))
+
+        # compute the control phi field
+        self.control_phi_field = self.filter.UnfilterField(self.physical_phi_field)
+
+        self.physical_phi_derivative_field = self.clamper.CalculateForwardProjectionGradient(self.physical_phi_field)
+        self.physical_phi_derivative_field.data[:] *= self.interval_bounder.GetBoundGap()
+
+        self._UpdateAndOutputFields(self.GetEmptyField())
+
+    def Check(self) -> None:
+        self.filter.Check()
+
+    def Finalize(self) -> None:
+        self.filter.Finalize()
+
+    def GetPhysicalKratosVariables(self) -> 'list[SupportedSensitivityFieldVariableTypes]':
+        return [self.controlled_physical_variable]
+
+    def GetEmptyField(self) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        field = Kratos.TensorAdaptors.VariableTensorAdaptor(self.primal_model_part.Elements, self.controlled_physical_variable)
+        field.data[:] = 0.0
+        return field
+
+    def GetControlField(self) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        return self.control_phi_field.Clone()
+
+    def GetPhysicalField(self) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        physical_thickness_field = KratosOA.TensorAdaptors.PropertiesVariableTensorAdaptor(self.primal_model_part.Elements, self.controlled_physical_variable)
+        physical_thickness_field.CollectData()
+        return physical_thickness_field
+
+    def MapGradient(self, physical_variable_gradient_map: 'dict[SupportedSensitivityFieldVariableTypes, Kratos.TensorAdaptors.DoubleTensorAdaptor]') -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        with TimeLogger("ShellThicknessControl::MapGradient", None, "Finished",False):
+            keys = physical_variable_gradient_map.keys()
+            if len(keys) != 1:
+                raise RuntimeError(f"Provided more than required gradient fields for control \"{self.GetName()}\". Following are the variables:\n\t" + "\n\t".join([k.Name() for k in keys]))
+            if self.controlled_physical_variable not in keys:
+                raise RuntimeError(f"The required gradient for control \"{self.GetName()}\" w.r.t. {self.controlled_physical_variable.Name()} not found. Followings are the variables:\n\t" + "\n\t".join([k.Name() for k in keys]))
+
+            physical_gradient = physical_variable_gradient_map[self.controlled_physical_variable]
+            if physical_gradient.GetContainer() != self.primal_model_part.Elements:
+                raise RuntimeError(f"Gradients for the required element container not found for control \"{self.GetName()}\". [ required model part name: {self.primal_model_part.FullName()} ]")
+
+            # dj/dE -> physical_gradient
+            # dj/dphi = dj/dphysical * dphysical/dphi
+            dj_dphi = physical_gradient.Clone()
+            dj_dphi.data[:] *= self.physical_phi_derivative_field.data
+            return self.filter.BackwardFilterIntegratedField(dj_dphi)
+
+    def Update(self, new_control_field: Kratos.TensorAdaptors.DoubleTensorAdaptor) -> bool:
+        if new_control_field.GetContainer() != self.primal_model_part.Elements:
+            raise RuntimeError(f"Updates for the required element container not found for control \"{self.GetName()}\". [ required model part name: {self.primal_model_part.FullName()} ]")
+
+        update = new_control_field.Clone()
+        update.data[:] -= self.control_phi_field.data
+        if not math.isclose(numpy.linalg.norm(update.data), 0.0, abs_tol=1e-16):
+            with TimeLogger(self.__class__.__name__, f"Updating {self.GetName()}...", f"Finished updating of {self.GetName()}.",False):
+                # update the control thickness field
+                self.control_phi_field.data[:] = new_control_field.data
+                # now update the physical field
+                self._UpdateAndOutputFields(update)
+                return True
+        return False
+
+    def _UpdateAndOutputFields(self, update: Kratos.TensorAdaptors.DoubleTensorAdaptor) -> None:
+        # filter the control field
+        filtered_phi_field_update = self.filter.ForwardFilterField(update)
+        self.physical_phi_field.data[:] += filtered_phi_field_update.data
+
+        # project forward the filtered thickness field to get clamped physical field
+        physical_field = self.interval_bounder.GetUnboundedTensorAdaptor(self.clamper.ProjectForward(self.physical_phi_field))
+
+        # now update physical field
+        KratosOA.TensorAdaptors.PropertiesVariableTensorAdaptor(physical_field, self.controlled_physical_variable, copy=False).StoreData()
+        if self.consider_recursive_property_update:
+            KratosOA.OptimizationUtils.UpdatePropertiesVariableWithRootValueRecursively(physical_field.GetContainer(), self.controlled_physical_variable)
+
+        # compute and store projection derivatives for consistent filtering of the sensitivities
+        # this is dphi/dphysical -> physical_phi_derivative_field
+        self.physical_phi_derivative_field = self.clamper.CalculateForwardProjectionGradient(self.physical_phi_field)
+        self.physical_phi_derivative_field.data[:] *= self.interval_bounder.GetBoundGap()
+
+        # now output the fields
+        un_buffered_data = ComponentDataView(self, self.optimization_problem).GetUnBufferedData()
+        un_buffered_data.SetValue(f"{self.controlled_physical_variable.Name()}", physical_field.Clone(), overwrite=True)
+        if self.output_all_fields:
+            un_buffered_data.SetValue(f"{self.controlled_physical_variable.Name()}_physical_phi_update", filtered_phi_field_update.Clone(), overwrite=True)
+            un_buffered_data.SetValue(f"{self.controlled_physical_variable.Name()}_control_phi", self.control_phi_field.Clone(), overwrite=True)
+            un_buffered_data.SetValue(f"{self.controlled_physical_variable.Name()}_physical_phi", self.physical_phi_field.Clone(), overwrite=True)
+            un_buffered_data.SetValue(f"{self.controlled_physical_variable.Name()}_physical_phi_derivative", self.physical_phi_derivative_field.Clone(), overwrite=True)
+
+    def __str__(self) -> str:
+        return f"Control [type = {self.__class__.__name__}, name = {self.GetName()}, model part name = {self.adjoint_model_part_operation.GetModelPartFullName()}, control variable = {self.controlled_physical_variable.Name()}"

KratosMultiphysics/SystemIdentificationApplication/convergence_criteria/sensor_error.py

@@ -0,0 +1,93 @@
+import os
+import typing
+import KratosMultiphysics as Kratos
+import KratosMultiphysics.SystemIdentificationApplication as KratosSI
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem import OptimizationProblem
+from KratosMultiphysics.OptimizationApplication.utilities.component_data_view import ComponentDataView
+from KratosMultiphysics.OptimizationApplication.convergence_criteria.convergence_criterion import ConvergenceCriterion
+from KratosMultiphysics.OptimizationApplication.utilities.logger_utilities import time_decorator
+from KratosMultiphysics.SystemIdentificationApplication.utilities.sensor_utils import GetSensors
+
+def Factory(_: Kratos.Model, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem) -> ConvergenceCriterion:
+    if not parameters.Has("settings"):
+        raise RuntimeError(f"MaxSensorErrorCriterion instantiation requires a \"settings\" in parameters [ parameters = {parameters}].")
+    return MaxSensorErrorCriterion(parameters["settings"], optimization_problem)
+
+class MaxSensorErrorCriterion(ConvergenceCriterion):
+    """
+    MaxSensorErrorCriterion is a convergence criterion based on the maximum sensor error in a system identification problem.
+
+    This class checks whether the maximum sensor error falls below a specified tolerance,
+    indicating convergence. The criterion is configurable via parameters.
+    """
+    @classmethod
+    def GetDefaultParameters(cls):
+        return Kratos.Parameters("""{
+            "sensor_group_name": "sensors",
+            "tolerance"     : 1e-9,
+            "output_to_file" : true,
+            "sensor_error_output_file_name" : "max_sensor_error.csv"
+        }""")
+
+    def __init__(self, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem):
+        parameters.ValidateAndAssignDefaults(self.GetDefaultParameters())
+        self.__sensor_group_name = parameters["sensor_group_name"].GetString()
+        self.__tolerance = parameters["tolerance"].GetDouble()
+        self.__optimization_problem = optimization_problem
+        self.__output_to_file = parameters["output_to_file"].GetBool()
+        self.__sensor_error_output_file_name = parameters["sensor_error_output_file_name"].GetString()
+
+    def Initialize(self):
+        if self.__output_to_file:
+            with open(self.__sensor_error_output_file_name, "w") as file_output:
+                file_output.write("iteration,max_sensor_error\n")
+
+    @time_decorator()
+    def IsConverged(self) -> bool:
+        """
+        Check if the convergence criterion based on sensor error is satisfied.
+        This method evaluates convergence by comparing the maximum sensor error across
+        all sensors in the sensor group against a predefined tolerance threshold.
+        The method performs the following steps:
+        1. Retrieves sensor group data from the optimization problem
+        2. Extracts all sensors from the sensor group
+        3. Computes the maximum absolute error across all sensors
+        4. Compares the maximum error against the tolerance threshold
+        5. Writes the maximum sensor error to a file for monitoring
+        Returns:
+            bool: True if the maximum sensor error is less than or equal to the 
+                  tolerance threshold, False otherwise.
+        """
+        sensor_group_data = ComponentDataView(self.__sensor_group_name, self.__optimization_problem)
+        self.list_of_sensors = GetSensors(sensor_group_data)
+        
+        max_sensor_error = 0.0
+        for sensor in self.list_of_sensors:
+            max_sensor_error = max(max_sensor_error, abs(sensor.GetNode().GetValue(KratosSI.SENSOR_ERROR)))
+        
+        self.__max_sensor_error = max_sensor_error
+        self.__conv = self.__max_sensor_error <= self.__tolerance
+        self.WriteMaxSensorErrorToFile()
+        return self.__conv
+
+    def GetInfo(self) -> 'list[tuple[str, typing.Union[int, float, str]]]':
+        info = [
+                    ('type'          , 'sensor_error'),
+                    ('max_sensor_error', self.__max_sensor_error),
+                    ('tolerance'     , self.__tolerance),
+                    ('sensor_group_name', self.__sensor_group_name),
+                    ('status'        , str("converged" if self.__conv else "not converged"))
+               ]
+        return info
+
+    def Finalize(self):
+        pass
+
+    def WriteMaxSensorErrorToFile(self) -> None:
+        if self.__output_to_file:
+            iteration = self.__optimization_problem.GetStep()
+            file_exists = os.path.isfile(self.__sensor_error_output_file_name)
+            with open(self.__sensor_error_output_file_name, "a") as file_output:
+                if not file_exists:
+                    file_output.write("iteration,max_sensor_error\n")
+                file_output.write(f"{iteration},{self.__max_sensor_error}\n")

KratosMultiphysics/SystemIdentificationApplication/processes/sensor_output_process.py

@@ -0,0 +1,83 @@
+from pathlib import Path
+import typing
+import KratosMultiphysics as Kratos
+import KratosMultiphysics.SystemIdentificationApplication as KratosSI
+
+from KratosMultiphysics.SystemIdentificationApplication.utilities.sensor_utils import CreateSensors
+from KratosMultiphysics.SystemIdentificationApplication.utilities.sensor_utils import PrintSensorListToCSV
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem import OptimizationProblem
+from KratosMultiphysics.OptimizationApplication.utilities.component_data_view import ComponentDataView
+from KratosMultiphysics.OptimizationApplication.responses.response_function import ResponseFunction
+
+def Factory(arg1: Kratos.Parameters, arg2: Kratos.Model, optimization_problem: 'typing.Optional[OptimizationProblem]' = None):
+    if isinstance(arg1, Kratos.Parameters) and isinstance(arg2, Kratos.Model):
+        # this is to use SensorOutputProcess as a normal kratos process
+        return SensorOutputProcess(arg2, arg1["Parameters"], optimization_problem)
+    elif isinstance(arg1, Kratos.Model) and isinstance(arg2, Kratos.Parameters):
+        # this is to use SensorOutputProcess as a process for optimization application where optimization_problem cannot be none
+        return SensorOutputProcess(arg1, arg2["settings"], optimization_problem)
+    else:
+        raise RuntimeError("Argument mismatch.")
+
+class SensorOutputProcess(Kratos.OutputProcess):
+    def __init__(self, model: Kratos.Model, settings: Kratos.Parameters, optimization_problem: 'typing.Optional[OptimizationProblem]' = None):
+        Kratos.OutputProcess.__init__(self)
+
+        default_settings = Kratos.Parameters("""{
+            "model_part_name" : "PLEASE_PROVIDE_A_MODEL_PART_NAME",
+            "sensor_model_part_name": "SensorModelPart",
+            "output_file_name": "",
+            "properties_list": [
+                "type",
+                "name",
+                "location",
+                "value"
+            ],
+            "list_of_sensors": []
+        }""")
+
+        if optimization_problem is not None:
+            default_settings.RemoveValue("list_of_sensors")
+            default_settings.AddEmptyValue("response_name")
+            default_settings["response_name"].SetString("")
+        settings.ValidateAndAssignDefaults(default_settings)
+
+        self.model_part = model[settings["model_part_name"].GetString()]
+        self.properties_list: 'list[str]' = settings["properties_list"].GetStringArray()
+        self.output_file_name = Path(settings["output_file_name"].GetString())
+        self.optimization_problem = optimization_problem
+
+        self.list_of_sensors: 'list[KratosSI.Sensors.Sensor]' = []
+        if optimization_problem is None:
+            self.initialized_sensors = True
+            self.compute_sensor_value = True
+            sensor_model_part_name = settings["sensor_model_part_name"].GetString()
+            if not model.HasModelPart(sensor_model_part_name):
+                model.CreateModelPart(sensor_model_part_name)
+            self.list_of_sensors = CreateSensors(model[sensor_model_part_name], self.model_part, settings["list_of_sensors"].values())
+        else:
+            self.initialized_sensors = False
+            self.compute_sensor_value = False
+            self.response_name = settings["response_name"].GetString()
+
+    def PrintOutput(self) -> None:
+        s_name = str(self.output_file_name)
+
+        if not self.initialized_sensors:
+            self.list_of_sensors = ComponentDataView(self.optimization_problem.GetComponent(self.response_name, ResponseFunction), self.optimization_problem).GetUnBufferedData().GetValue("sensors")
+            self.initialized_sensors = True
+            s_name = s_name.replace("<step>", f"{self.optimization_problem.GetStep():06d}")
+        else:
+            s_name = s_name.replace("<step>", f"{self.model_part.ProcessInfo[Kratos.STEP]:06d}")
+
+        # calculate and assign values for each sensor
+        if self.compute_sensor_value:
+            for sensor in self.list_of_sensors:
+                sensor.SetSensorValue(sensor.CalculateValue(self.model_part))
+
+        PrintSensorListToCSV(Path(s_name), self.list_of_sensors, self.properties_list)
+
+
+
+
+

KratosMultiphysics/SystemIdentificationApplication/python_registry_lists.py

@@ -0,0 +1,9 @@
+python_modelers_to_be_registered = []
+
+python_operations_to_be_registered = []
+
+python_processes_to_be_registered = []
+
+python_stages_to_be_registered = []
+
+python_orchestrators_to_be_registered = []