KratosOptimizationApplication 10.4.4__py3-none-any.whl

KratosMultiphysics/OptimizationApplication/execution_policies/kratos_analysis_execution_policy.py

@@ -0,0 +1,137 @@
+from importlib import import_module
+from typing import Any
+
+import KratosMultiphysics as Kratos
+import KratosMultiphysics.OptimizationApplication as KratosOA
+from KratosMultiphysics.analysis_stage import AnalysisStage
+from KratosMultiphysics.OptimizationApplication.execution_policies.execution_policy import ExecutionPolicy
+from KratosMultiphysics.OptimizationApplication.utilities.helper_utilities import GetClassModuleFromKratos
+from KratosMultiphysics.OptimizationApplication.utilities.optimization_problem import OptimizationProblem
+from KratosMultiphysics.OptimizationApplication.utilities.component_data_view import ComponentDataView
+
+def Factory(model: Kratos.Model, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem) -> ExecutionPolicy:
+    if not parameters.Has("name"):
+        raise RuntimeError(f"KratosAnalysisExecutionPolicy instantiation requires a \"name\" in parameters [ parameters = {parameters}].")
+    if not parameters.Has("settings"):
+        raise RuntimeError(f"KratosAnalysisExecutionPolicy instantiation requires a \"settings\" in parameters [ parameters = {parameters}].")
+
+    return KratosAnalysisExecutionPolicy(parameters["name"].GetString(), model, parameters["settings"], optimization_problem)
+
+class KratosAnalysisExecutionPolicy(ExecutionPolicy):
+    def __init__(self, name: str, model: Kratos.Model, parameters: Kratos.Parameters, optimization_problem: OptimizationProblem):
+        super().__init__(name)
+
+        default_settings = Kratos.Parameters("""{
+            "model_part_names" : [],
+            "analysis_module"  : "KratosMultiphysics",
+            "analysis_type"    : "",
+            "analysis_settings": {},
+            "analysis_output_settings": {
+                     "nodal_solution_step_data_variables"         : [],
+                     "nodal_data_value_variables"                 : [],
+                     "element_data_value_variables"               : [],
+                     "element_properties_value_variables"         : [],
+                     "element_integration_point_value_variables"  : [],
+                     "condition_data_value_variables"             : [],
+                     "condition_properties_value_variables"       : [],
+                     "condition_integration_point_value_variables": []
+            }
+        }""")
+        self.model = model
+        self.parameters = parameters
+        self.optimization_problem = optimization_problem
+        self.parameters.ValidateAndAssignDefaults(default_settings)
+        self.parameters["analysis_output_settings"].ValidateAndAssignDefaults(default_settings["analysis_output_settings"])
+
+        analysis_module = parameters["analysis_module"].GetString()
+        analysis_type = parameters["analysis_type"].GetString()
+        analysis_settings = parameters["analysis_settings"]
+
+        if analysis_module == "KratosMultiphysics":
+            analysis_full_module, analysis_type = GetClassModuleFromKratos(analysis_type)
+        else:
+            analysis_full_module = f"{analysis_module}.{Kratos.StringUtilities.ConvertCamelCaseToSnakeCase(analysis_type)}"
+
+        self.model_parts: 'list[Kratos.ModelPart]' = []
+        self.analysis: AnalysisStage = getattr(import_module(analysis_full_module), analysis_type)(self.model, analysis_settings.Clone())
+
+        analysis_output_settings = self.parameters["analysis_output_settings"]
+        analysis_output_settings.ValidateAndAssignDefaults(default_settings["analysis_output_settings"])
+        self.nodal_solution_step_data_variables = KratosAnalysisExecutionPolicy.__GetVariablesList(analysis_output_settings["nodal_solution_step_data_variables"].GetStringArray())
+        self.nodal_data_value_variables = KratosAnalysisExecutionPolicy.__GetVariablesList(analysis_output_settings["nodal_data_value_variables"].GetStringArray())
+        self.element_data_value_variables = KratosAnalysisExecutionPolicy.__GetVariablesList(analysis_output_settings["element_data_value_variables"].GetStringArray())
+        self.element_properties_value_variables = KratosAnalysisExecutionPolicy.__GetVariablesList(analysis_output_settings["element_properties_value_variables"].GetStringArray())
+        self.element_integration_point_value_variables = KratosAnalysisExecutionPolicy.__GetVariablesList(analysis_output_settings["element_integration_point_value_variables"].GetStringArray())
+        self.condition_data_value_variables = KratosAnalysisExecutionPolicy.__GetVariablesList(analysis_output_settings["condition_data_value_variables"].GetStringArray())
+        self.condition_properties_value_variables = KratosAnalysisExecutionPolicy.__GetVariablesList(analysis_output_settings["condition_properties_value_variables"].GetStringArray())
+        self.condition_integration_point_value_variables = KratosAnalysisExecutionPolicy.__GetVariablesList(analysis_output_settings["condition_integration_point_value_variables"].GetStringArray())
+
+    def GetAnalysisModelPart(self):
+        return self.analysis._GetSolver().GetComputingModelPart()
+
+    def Initialize(self):
+        self.analysis.Initialize()
+
+        # initialize model parts
+        self.model_parts = [self.model[model_part_name] for model_part_name in self.parameters["model_part_names"].GetStringArray()]
+
+    def Check(self) -> None:
+        pass
+
+    def Finalize(self) -> None:
+        self.analysis.Finalize()
+
+    def Execute(self):
+        self.analysis.time = self.analysis.project_parameters["problem_data"]["start_time"].GetDouble()
+        for model_part in self.model_parts:
+            model_part.ProcessInfo.SetValue(Kratos.STEP, 0)
+            model_part.ProcessInfo.SetValue(Kratos.TIME, 0)
+            model_part.ProcessInfo.SetValue(Kratos.DELTA_TIME, 0)
+        self.analysis.RunSolutionLoop()
+
+        self._OutputAnalysisData()
+
+    def _OutputAnalysisData(self):
+        unbuffered_data = ComponentDataView(self, self.optimization_problem).GetUnBufferedData()
+        for model_part in self.model_parts:
+            for variable in self.nodal_solution_step_data_variables:
+                nodal_field = Kratos.TensorAdaptors.HistoricalVariableTensorAdaptor(model_part.Nodes, variable)
+                nodal_field.CollectData()
+                unbuffered_data.SetValue(variable.Name(), nodal_field, overwrite=True)
+            for variable in self.nodal_data_value_variables:
+                nodal_field = Kratos.TensorAdaptors.VariableTensorAdaptor(model_part.Nodes, variable)
+                nodal_field.CollectData()
+                unbuffered_data.SetValue(variable.Name(), nodal_field, overwrite=True)
+
+            for variable in self.element_data_value_variables:
+                elem_field = Kratos.TensorAdaptors.VariableTensorAdaptor(model_part.Elements, variable)
+                elem_field.CollectData()
+                unbuffered_data.SetValue(variable.Name(), elem_field, overwrite=True)
+            for variable in self.element_properties_value_variables:
+                elem_field = KratosOA.TensorAdaptors.PropertiesVariableTensorAdaptor(model_part.Elements, variable)
+                elem_field.CollectData()
+                unbuffered_data.SetValue(variable.Name(), elem_field, overwrite=True)
+            for variable in self.element_integration_point_value_variables:
+                elem_field = Kratos.TensorAdaptors.GaussPointVariableTensorAdaptor(model_part.Elements, variable, model_part.ProcessInfo)
+                elem_field.CollectData()
+                unbuffered_data.SetValue(variable.Name(), elem_field, overwrite=True)
+
+            for variable in self.condition_data_value_variables:
+                cond_field = Kratos.TensorAdaptors.VariableTensorAdaptor(model_part.Conditions, variable)
+                cond_field.CollectData()
+                unbuffered_data.SetValue(variable.Name(), cond_field, overwrite=True)
+            for variable in self.condition_properties_value_variables:
+                cond_field = KratosOA.TensorAdaptors.PropertiesVariableTensorAdaptor(model_part.Conditions, variable)
+                cond_field.CollectData()
+                unbuffered_data.SetValue(variable.Name(), cond_field, overwrite=True)
+            for variable in self.condition_integration_point_value_variables:
+                cond_field = Kratos.TensorAdaptors.GaussPointVariableTensorAdaptor(model_part.Conditions, variable, model_part.ProcessInfo)
+                cond_field.CollectData()
+                unbuffered_data.SetValue(variable.Name(), cond_field, overwrite=True)
+
+    @staticmethod
+    def __GetVariablesList(variable_names_list: 'list[str]') -> 'list[Any]':
+        return [Kratos.KratosGlobals.GetVariable(variable_name) for variable_name in variable_names_list]
+
+
+

KratosMultiphysics/OptimizationApplication/execution_policies/stepping_analysis_execution_policy.py

@@ -0,0 +1,88 @@
+from importlib import import_module
+
+import KratosMultiphysics as Kratos
+from KratosMultiphysics.analysis_stage import AnalysisStage
+from KratosMultiphysics.OptimizationApplication.execution_policies.execution_policy import ExecutionPolicy
+from KratosMultiphysics.OptimizationApplication.utilities.helper_utilities import GetClassModuleFromKratos
+
+def Factory(model: Kratos.Model, parameters: Kratos.Parameters, _) -> ExecutionPolicy:
+    if not parameters.Has("name"):
+        raise RuntimeError(f"SteppingAnalysisExecutionPolicy instantiation requires a \"name\" in parameters [ parameters = {parameters}].")
+    if not parameters.Has("settings"):
+        raise RuntimeError(f"SteppingAnalysisExecutionPolicy instantiation requires a \"settings\" in parameters [ parameters = {parameters}].")
+
+    return SteppingAnalysisExecutionPolicy(parameters["name"].GetString(), model, parameters["settings"])
+
+class SteppingAnalysisExecutionPolicy(ExecutionPolicy):
+    def __init__(self, name: str, model: Kratos.Model, parameters: Kratos.Parameters):
+        super().__init__(name)
+
+        default_settings = Kratos.Parameters("""{
+            "model_part_names" : [],
+            "analysis_module"  : "KratosMultiphysics",
+            "analysis_type"    : "",
+            "analysis_settings": {}
+        }""")
+        self.model = model
+        self.parameters = parameters
+        self.parameters.ValidateAndAssignDefaults(default_settings)
+
+        analysis_module = parameters["analysis_module"].GetString()
+        analysis_type = parameters["analysis_type"].GetString()
+        analysis_settings = parameters["analysis_settings"]
+
+        if analysis_module == "KratosMultiphysics":
+            analysis_full_module, analysis_type = GetClassModuleFromKratos(analysis_type)
+        else:
+            analysis_full_module = f"{analysis_module}.{Kratos.StringUtilities.ConvertCamelCaseToSnakeCase(analysis_type)}"
+
+        self.model_parts = []
+        self.analysis: AnalysisStage = getattr(import_module(analysis_full_module), analysis_type)(self.model, analysis_settings.Clone())
+
+    def GetAnalysisModelPart(self):
+        return self.analysis._GetSolver().GetComputingModelPart()
+
+    def Initialize(self):
+        self.analysis.Initialize()
+
+        # initialize model parts
+        self.model_parts = [self.model[model_part_name] for model_part_name in self.parameters["model_part_names"].GetStringArray()]
+
+    def Check(self) -> None:
+        pass
+
+    def Finalize(self) -> None:
+        pass
+
+    def Execute(self):
+        time_before_analysis = []
+        step_before_analysis = []
+        delta_time_before_analysis = []
+
+        for model_part in self.model_parts:
+            time_before_analysis.append(model_part.ProcessInfo[Kratos.TIME])
+            step_before_analysis.append(model_part.ProcessInfo[Kratos.STEP])
+            delta_time_before_analysis.append(model_part.ProcessInfo[Kratos.DELTA_TIME])
+
+        # Reset step/time iterators such that they match the optimization iteration after calling CalculateValue (which internally calls CloneTimeStep)
+        for index, model_part in enumerate(self.model_parts):
+            model_part.ProcessInfo.SetValue(Kratos.STEP, step_before_analysis[index] - 1)
+            model_part.ProcessInfo.SetValue(Kratos.TIME, time_before_analysis[index] - 1)
+            model_part.ProcessInfo.SetValue(Kratos.DELTA_TIME, 0)
+
+        self.analysis.time = self.analysis._GetSolver().AdvanceInTime(self.analysis.time)
+        self.analysis.InitializeSolutionStep()
+        self.analysis._GetSolver().Predict()
+        self.analysis._GetSolver().SolveSolutionStep()
+
+        self.analysis.FinalizeSolutionStep()
+        self.analysis.OutputSolutionStep()
+
+        # Clear results or modifications on model parts
+        for index, model_part in enumerate(self.model_parts):
+            model_part.ProcessInfo.SetValue(Kratos.STEP, step_before_analysis[index])
+            model_part.ProcessInfo.SetValue(Kratos.TIME, time_before_analysis[index])
+            model_part.ProcessInfo.SetValue(Kratos.DELTA_TIME, delta_time_before_analysis[index])
+
+
+

KratosMultiphysics/OptimizationApplication/filtering/explicit_filter.py

@@ -0,0 +1,124 @@
+import operator
+from itertools import accumulate
+
+import KratosMultiphysics as Kratos
+import KratosMultiphysics.OptimizationApplication as KratosOA
+from KratosMultiphysics.OptimizationApplication.filtering.filter import Filter
+from KratosMultiphysics.OptimizationApplication.filtering.filter_utils import FilterRadiusFactory
+from KratosMultiphysics.OptimizationApplication.filtering.filter_utils import ExplicitFilterDampingFactory
+from KratosMultiphysics.OptimizationApplication.utilities.union_utilities import SupportedSensitivityFieldVariableTypes
+
+def Factory(model: Kratos.Model, filtering_model_part_name: str, filtering_variable: SupportedSensitivityFieldVariableTypes, data_location: Kratos.Globals.DataLocation, parameters: Kratos.Parameters) -> Filter:
+    return ExplicitFilter(model, filtering_model_part_name, filtering_variable, data_location, parameters)
+
+class ExplicitFilter(Filter):
+    @classmethod
+    def GetDefaultParameters(cls) -> Kratos.Parameters:
+        return Kratos.Parameters("""{
+            "filter_type"               : "explicit_filter",
+            "node_cloud_mesh"           : false,
+            "filter_function_type"      : "linear",
+            "max_items_in_bucket"       : 10,
+            "echo_level"                : 0,
+            "store_filter_matrix"       : false,
+            "filter_radius_settings":{
+                "filter_radius_type": "constant",
+                "filter_radius"     : 0.2
+            },
+            "filtering_boundary_conditions": {
+                "damping_type"              : "nearest_entity",
+                "damping_function_type"     : "cosine",
+                "damped_model_part_settings": {}
+            }
+        }""")
+
+    def __init__(self, model: Kratos.Model, filtering_model_part_name: str, filtering_variable: SupportedSensitivityFieldVariableTypes, data_location: Kratos.Globals.DataLocation, parameters: Kratos.Parameters) -> None:
+        super().__init__()
+
+        self.model = model
+        self.filtering_model_part_name = filtering_model_part_name
+        self.filtering_variable = filtering_variable
+        self.data_location = data_location
+
+        self.parameters = parameters
+        self.parameters.ValidateAndAssignDefaults(self.GetDefaultParameters())
+
+        supported_data_locations = [
+            Kratos.Globals.DataLocation.NodeHistorical,
+            Kratos.Globals.DataLocation.NodeNonHistorical,
+            Kratos.Globals.DataLocation.Condition,
+            Kratos.Globals.DataLocation.Element
+        ]
+        if data_location not in supported_data_locations:
+            raise RuntimeError(f"Unsupported data location = \"{data_location.name}\" requested. Followings are supported:\n\t" + "\n\t".join([v.name for v in supported_data_locations]))
+
+        if isinstance(filtering_variable, Kratos.DoubleVariable):
+            self.filter_variable_shape = []
+        elif isinstance(filtering_variable, Kratos.Array1DVariable3):
+            self.filter_variable_shape = [3]
+        else:
+            raise RuntimeError(f"Unsupported variable = \"{filtering_variable.Name()}\". Only supports DoubleVariable and Array1DVariable3.")
+
+    def Initialize(self) -> None:
+        # get the model part
+        self.model_part = self.model.GetModelPart(self.filtering_model_part_name)
+
+        # we create the filter in the initialize to support filter to work
+        # on sub model parts.
+        filter_function_type = self.parameters["filter_function_type"].GetString()
+        max_items_in_bucket = self.parameters["max_items_in_bucket"].GetInt()
+        echo_level = self.parameters["echo_level"].GetInt()
+        node_cloud_mesh = self.parameters["node_cloud_mesh"].GetBool()
+        store_filter_matrix = self.parameters["store_filter_matrix"].GetBool()
+        if self.data_location in [Kratos.Globals.DataLocation.NodeHistorical, Kratos.Globals.DataLocation.NodeNonHistorical]:
+            self.filter_utils = KratosOA.NodeExplicitFilterUtils(self.model_part, filter_function_type, max_items_in_bucket, echo_level, node_cloud_mesh, store_filter_matrix)
+        elif self.data_location == Kratos.Globals.DataLocation.Condition:
+            if node_cloud_mesh:
+                raise RuntimeError("\"node_cloud_mesh\" flag can be only used for filtering meshes with nodes.")
+            self.filter_utils = KratosOA.ConditionExplicitFilterUtils(self.model_part, filter_function_type, max_items_in_bucket, echo_level, store_filter_matrix=store_filter_matrix)
+        elif self.data_location == Kratos.Globals.DataLocation.Element:
+            if node_cloud_mesh:
+                raise RuntimeError("\"node_cloud_mesh\" flag can be only used for filtering meshes with nodes.")
+            self.filter_utils = KratosOA.ElementExplicitFilterUtils(self.model_part, filter_function_type, max_items_in_bucket, echo_level, store_filter_matrix=store_filter_matrix)
+
+        self.Update()
+
+    def Update(self) -> None:
+        # now set the filter radius. Can be changed in future to support adaptive radius methods.
+        filter_radius = FilterRadiusFactory(self.model_part, self.data_location, self.parameters["filter_radius_settings"])
+        self.filter_utils.SetRadius(filter_radius)
+        self.GetComponentDataView().GetUnBufferedData().SetValue("filter_radius", filter_radius, overwrite=True)
+
+        # now set the damping
+        stride = max(enumerate(accumulate(self.filter_variable_shape, operator.mul, initial=1)))[1]
+        self.damping = ExplicitFilterDampingFactory(self.model, self.data_location, stride, self.parameters["filtering_boundary_conditions"])
+        self.damping.SetRadius(filter_radius)
+        self.filter_utils.SetDamping(self.damping)
+
+        # initialize the filter
+        self.damping.Update()
+        self.filter_utils.Update()
+
+    def Check(self) -> None:
+        pass
+
+    def Finalize(self) -> None:
+        pass
+
+    def ForwardFilterField(self, control_field: Kratos.TensorAdaptors.DoubleTensorAdaptor) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        return self.filter_utils.ForwardFilterField(control_field)
+
+    def BackwardFilterField(self, physical_mesh_independent_gradient_field: Kratos.TensorAdaptors.DoubleTensorAdaptor) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        return self.filter_utils.BackwardFilterField(physical_mesh_independent_gradient_field)
+
+    def BackwardFilterIntegratedField(self, physical_mesh_dependent_gradient_field: Kratos.TensorAdaptors.DoubleTensorAdaptor) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        return self.filter_utils.BackwardFilterIntegratedField(physical_mesh_dependent_gradient_field)
+
+    def UnfilterField(self, filtered_field: Kratos.TensorAdaptors.DoubleTensorAdaptor) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        # WARNING: In general explicit VM doesn't need unfiltered field because it works with changes. Hence, it returns zeros and optimization runs correctly.
+        result = Kratos.TensorAdaptors.DoubleTensorAdaptor(filtered_field)
+        result.data[:] = 0.0
+        return result
+
+    def GetBoundaryConditions(self) -> 'list[list[Kratos.ModelPart]]':
+        return self.damping.GetDampedModelParts()

KratosMultiphysics/OptimizationApplication/filtering/filter.py

@@ -0,0 +1,188 @@
+import typing
+import abc
+from importlib import import_module
+
+import KratosMultiphysics as Kratos
+from KratosMultiphysics.OptimizationApplication.utilities.union_utilities import SupportedSensitivityFieldVariableTypes
+from KratosMultiphysics.OptimizationApplication.utilities.component_data_view import ComponentDataView
+
+class Filter(abc.ABC):
+    """Base filter class
+
+    This class unifies the filters used in the optimization application.
+    """
+    def __init__(self) -> None:
+        self.__component_data_view: 'typing.Optional[ComponentDataView]' = None
+
+    def SetComponentDataView(self, component_data_view: ComponentDataView) -> None:
+        """Set the component data view of the control in which this filter is being used.
+
+        This sets and allows the filter to add data/fields to space which belongs to control
+        within the optimization problem.
+
+        This component data view is not passed at the construction time because, filters are created
+        when the controls are created, hence the control data space in the optimization problem does
+        not exist until the control construction is finished.
+
+        Args:
+            component_data_view (ComponentDataView): Component data view of the control.
+        """
+        self.__component_data_view = component_data_view
+
+    def GetComponentDataView(self) -> ComponentDataView:
+        """Retrieve the component data view.
+
+        This method retrieves the component data view of the control, which can be used
+        to store data and fields.
+
+        Raises:
+            RuntimeError: If SetComponentDataView is not called first before calling this.
+
+        Returns:
+            ComponentDataView: Component data view of the control.
+        """
+        if self.__component_data_view is None:
+            raise RuntimeError("Please use SetComponentDataView first.")
+        return self.__component_data_view
+
+    @abc.abstractmethod
+    def Initialize(self) -> None:
+        """Initializes the filter.
+
+        This method initializes the filter. This is only called once in the whole optimization process.
+
+        """
+        pass
+
+    @abc.abstractmethod
+    def Check(self) -> None:
+        """Checks the filter.
+
+        This method checks the filter. This is only called once in the whole optimization process after calling the initialize.
+
+        """
+        pass
+
+    @abc.abstractmethod
+    def Finalize(self) -> None:
+        """Finalizes the filter.
+
+        This method checks the filter. This is only called once in the whole optimization process at the end.
+
+        """
+        pass
+
+    @abc.abstractmethod
+    def ForwardFilterField(self, control_field: Kratos.TensorAdaptors.DoubleTensorAdaptor) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        """Return the physical field by filtering/smoothing control field
+
+        This method filters the passed input field. control_field field is assumed to be a
+        mesh-independent field.
+
+        Args:
+            control_field (Kratos.TensorAdaptors.DoubleTensorAdaptor): Input control field
+
+        Returns:
+            Kratos.TensorAdaptors.DoubleTensorAdaptor: Physical field.
+        """
+        pass
+
+    @abc.abstractmethod
+    def BackwardFilterField(self, physical_mesh_independent_gradient_field: Kratos.TensorAdaptors.DoubleTensorAdaptor) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        """Returns mesh-independent control space gradient from mesh-independent physical space gradient.
+
+        This method filters the passed mesh-independent input field. This is not the inverse
+        operator, it uses the transpose of the ForwardFilterField matrix.
+
+        Args:
+            physical_mesh_independent_gradient_field (Kratos.TensorAdaptors.DoubleTensorAdaptor): Mesh independent gradient field in physical space.
+
+        Returns:
+            Kratos.TensorAdaptors.DoubleTensorAdaptor: Mesh-independent gradient in the control space.
+        """
+        pass
+
+    @abc.abstractmethod
+    def BackwardFilterIntegratedField(self, physical_mesh_dependent_gradient_field: Kratos.TensorAdaptors.DoubleTensorAdaptor) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        """Returns mesh-independent control space gradient from mesh-dependent physical space gradient.
+
+        This method filters the passed mesh-dependent input field. This is not the inverse
+        operator, it uses the transpose of the ForwardFilterField matrix.
+
+        Args:
+            physical_mesh_dependent_gradient_field (Kratos.TensorAdaptors.DoubleTensorAdaptor): Mesh dependent gradient field in physical space.
+
+        Returns:
+            Kratos.TensorAdaptors.DoubleTensorAdaptor: Mesh-independent gradient in the control space.
+        """
+        pass
+
+    @abc.abstractmethod
+    def UnfilterField(self, physical_field: Kratos.TensorAdaptors.DoubleTensorAdaptor) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        """Returns control space field from the physical space field using the inverse operator.
+
+        This method needs to compute the inverse of the matrix used in ForwardFilterField
+        to compute the UnfilteredField of the physical field.
+
+        Args:
+            physical_field (Kratos.TensorAdaptors.DoubleTensorAdaptor): Physical field.
+
+        Returns:
+            Kratos.TensorAdaptors.DoubleTensorAdaptor: Control field.
+        """
+        pass
+
+    @abc.abstractmethod
+    def Update(self) -> None:
+        """Updates the filter.
+
+        This method is used to update the filter state. This will be called by the control, when control changes
+        the optimization domain.
+
+        """
+        pass
+
+    @abc.abstractmethod
+    def GetBoundaryConditions(self) -> 'list[list[Kratos.ModelPart]]':
+        """Returns boundary conditions.
+
+        This returns a list of model parts where the filter is having fixed
+        boundary conditions for each component for the variable this filter
+        is being used.
+
+        Returns:
+            list[list[Kratos.ModelPart]]: list of fixed boundary condition model parts for each component.
+        """
+        pass
+
+def Factory(model: Kratos.Model, filtering_model_part_name: str, variable: SupportedSensitivityFieldVariableTypes, data_location: Kratos.Globals.DataLocation, settings: Kratos.Parameters) -> Filter:
+    """Factory method used to create filters.
+
+    This factory allows to use different types of filters in different controls. Since the filtering should
+    support sub-model parts as well, the filtering_model_part_name is passed as a string because, at the time of
+    filter construction from this factory, model part may only have root model parts.
+
+    Args:
+        model (Kratos.Model): Model of the problem
+        filtering_model_part_name (str): Model part on which the filtering is applied (Can be a sub-model part as well.)
+        variable (SupportedSensitivityFieldVariableTypes): Variable to be filtered by this filter.
+        data_location (Kratos.Globals.DataLocation): Location to be used with this filter.
+        settings (Kratos.Parameters): Filter specific settings.
+
+    Raises:
+        RuntimeError: If "filter_type" is not specified in the settings
+        RuntimeError: If the requested "filter_type" does not have the Factory method implemented.
+
+    Returns:
+        Filter: Filter specified by the "filter_type"
+    """
+    if not settings.Has("filter_type"):
+        raise RuntimeError(f"\"filter_type\" not provided in the following filter settings:\n{settings}")
+
+    filter_type = settings["filter_type"].GetString()
+    filter_module_name = f"KratosMultiphysics.OptimizationApplication.filtering.{filter_type}"
+
+    module = import_module(filter_module_name)
+    if not hasattr(module, "Factory"):
+        raise RuntimeError(f"Python module {filter_module_name} does not have a Factory method.")
+    return getattr(module, "Factory")(model, filtering_model_part_name, variable, data_location, settings)

KratosMultiphysics/OptimizationApplication/filtering/filter_utils.py

@@ -0,0 +1,55 @@
+import typing
+
+import KratosMultiphysics as Kratos
+import KratosMultiphysics.OptimizationApplication as KratosOA
+
+def FilterRadiusFactory(model_part: Kratos.ModelPart, container_type: Kratos.Globals.DataLocation, filter_radius_settings: Kratos.Parameters) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+    if not filter_radius_settings.Has("filter_radius_type"):
+        raise RuntimeError(f"\"filter_radius_type\" not specified in the following settings:\n{filter_radius_settings}")
+
+    filter_radius_type = filter_radius_settings["filter_radius_type"].GetString()
+    if filter_radius_type == "constant":
+        defaults = Kratos.Parameters("""{
+            "filter_radius_type": "constant",
+            "filter_radius"     : 0.2
+        }""")
+        filter_radius_settings.ValidateAndAssignDefaults(defaults)
+
+        if container_type == Kratos.Globals.DataLocation.NodeHistorical or container_type == Kratos.Globals.DataLocation.NodeNonHistorical:
+            return Kratos.TensorAdaptors.DoubleTensorAdaptor(model_part.Nodes, Kratos.DoubleNDData([model_part.NumberOfNodes()], filter_radius_settings["filter_radius"].GetDouble()), copy=False)
+        elif container_type == Kratos.Globals.DataLocation.Condition:
+            return Kratos.TensorAdaptors.DoubleTensorAdaptor(model_part.Conditions, Kratos.DoubleNDData([model_part.NumberOfConditions()], filter_radius_settings["filter_radius"].GetDouble()), copy=False)
+        elif container_type == Kratos.Globals.DataLocation.Element:
+            return Kratos.TensorAdaptors.DoubleTensorAdaptor(model_part.Elements, Kratos.DoubleNDData([model_part.NumberOfElements()], filter_radius_settings["filter_radius"].GetDouble()), copy=False)
+        else:
+            raise RuntimeError(f"Unsupported container_type.")
+    else:
+        raise RuntimeError(f"Unsupported filter_radius_type = \"{filter_radius_type}\".")
+
+def ExplicitFilterDampingFactory(model: Kratos.Model, data_location: Kratos.Globals.DataLocation, stride: int, parameters: Kratos.Parameters) -> 'typing.Union[KratosOA.NodeExplicitDamping, KratosOA.ConditionExplicitDamping, KratosOA.ElementExplicitDamping]':
+        if not parameters.Has("damping_type"):
+            raise RuntimeError(f"\"damping_type\" not specified in the following settings:\n{parameters}")
+
+        damping_types_dict: 'dict[Kratos.Globals.DataLocation, dict[str, typing.Type[typing.Union[KratosOA.NodeExplicitDamping, KratosOA.ConditionExplicitDamping, KratosOA.ElementExplicitDamping]]]]' = {
+            Kratos.Globals.DataLocation.NodeHistorical: {
+                "nearest_entity": KratosOA.NearestNodeExplicitDamping,
+                "integrated_nearest_entity": KratosOA.IntegratedNearestNodeExplicitDamping
+            },
+            Kratos.Globals.DataLocation.NodeNonHistorical: {
+                "nearest_entity": KratosOA.NearestNodeExplicitDamping,
+                "integrated_nearest_entity": KratosOA.IntegratedNearestNodeExplicitDamping
+            },
+            Kratos.Globals.DataLocation.Condition: {
+                "nearest_entity": KratosOA.NearestConditionExplicitDamping,
+                "integrated_nearest_entity": KratosOA.IntegratedNearestConditionExplicitDamping
+            },
+            Kratos.Globals.DataLocation.Element: {
+                "nearest_entity": KratosOA.NearestElementExplicitDamping,
+                "integrated_nearest_entity": KratosOA.IntegratedNearestElementExplicitDamping
+            }
+        }
+
+        damping_type = parameters["damping_type"].GetString()
+        if damping_type not in damping_types_dict[data_location].keys():
+            raise RuntimeError(f"Unsupported damping_type = \"{damping_type}\". Followings are supported:\n\t" + "\n\t".join(damping_types_dict[data_location].keys()))
+        return damping_types_dict[data_location][damping_type](model, parameters, stride)