KratosOptimizationApplication 10.4.4__py3-none-any.whl

KratosMultiphysics/OptimizationApplication/filtering/helmholtz_analysis.py

@@ -0,0 +1,139 @@
+from typing import Any, Optional
+
+# Importing Kratos
+import KratosMultiphysics as KM
+import KratosMultiphysics.OptimizationApplication as KOA
+import KratosMultiphysics.OptimizationApplication.filtering.python_solvers_wrapper_implicit_filters as implicit_filter_solvers
+
+# Importing the base class
+from KratosMultiphysics.analysis_stage import AnalysisStage
+
+class HelmholtzAnalysis(AnalysisStage):
+    """
+    This class is the main-script of the implicit filtering analysis
+    It can be imported and used as "black-box"
+    """
+    def __init__(self, model: KM.Model, project_parameters: KM.Parameters):
+        super().__init__(model, project_parameters)
+        self.__source_data: 'Optional[KM.TensorAdaptors.DoubleTensorAdaptor]' = None
+        self.__neighbour_entities: 'dict[Any, KM.TensorAdaptors.IntTensorAdaptor]' = {}
+
+    #### Internal functions ####
+    def _CreateSolver(self):
+        """ Create the Solver (and create and import the ModelPart if it is not already in the model) """
+        return implicit_filter_solvers.CreateSolver(self.model, self.project_parameters)
+
+    def _GetSimulationName(self):
+        return "::[Helmholtz/Sobolev Analysis]:: "
+
+    def _GetComputingModelPart(self):
+        return self._GetSolver().GetComputingModelPart()
+
+    def _SetSolverMode(self, invers_mode:bool = False):
+        self._GetComputingModelPart().ProcessInfo.SetValue(KOA.COMPUTE_HELMHOLTZ_INVERSE, invers_mode)
+
+    def _SetHelmHoltzSourceMode(self, integrated_field=False):
+        self._GetComputingModelPart().ProcessInfo.SetValue(KOA.HELMHOLTZ_INTEGRATED_FIELD, integrated_field)
+
+    #### Public user interface functions ####
+    def Initialize(self):
+        super().Initialize()
+        self.InitializeFilterModelPart()
+
+    def InitializeFilterModelPart(self):
+        self._SetSolverMode()
+        self._GetSolver().SetFilterRadius(self._GetSolver().GetFilterRadius())
+        self._SetHelmHoltzSourceMode()
+
+    def RunSolver(self):
+        self.InitializeSolutionStep()
+        self._GetSolver().Predict()
+        self._GetSolver().SolveSolutionStep()
+        self.FinalizeSolutionStep()
+
+    def FilterField(self, unfiltered_field: KM.TensorAdaptors.DoubleTensorAdaptor) -> KM.TensorAdaptors.DoubleTensorAdaptor:
+
+        self.__AssignTensorDataToNodalSource(unfiltered_field)
+        self._SetSolverMode(False)
+        self._SetHelmHoltzSourceMode(False)
+        self.RunSolver()
+        return self.__AssignNodalSolutionToTensorData()
+
+    def FilterIntegratedField(self, unfiltered_field: KM.TensorAdaptors.DoubleTensorAdaptor) -> KM.TensorAdaptors.DoubleTensorAdaptor:
+
+        self.__AssignTensorDataToNodalSource(unfiltered_field)
+        self._SetSolverMode(False)
+        self._SetHelmHoltzSourceMode(True)
+        self.RunSolver()
+        return self.__AssignNodalSolutionToTensorData()
+
+    def UnFilterField(self, filtered_field: KM.TensorAdaptors.DoubleTensorAdaptor) -> KM.TensorAdaptors.DoubleTensorAdaptor:
+
+        self.__AssignTensorDataToNodalSource(filtered_field)
+        self._SetSolverMode(True)
+        self._SetHelmHoltzSourceMode(False)
+        self.RunSolver()
+        return self.__AssignNodalSolutionToTensorData()
+
+    def AssignTensorDataToNodalSolution(self, data_exp: KM.TensorAdaptors.DoubleTensorAdaptor) -> None:
+        ta = KM.TensorAdaptors.DoubleTensorAdaptor(data_exp, copy=False)
+        if not isinstance(ta.GetContainer(), KM.NodesArray):
+            neighbours = self.__GetNeighbourEntities(data_exp)
+            ta = KOA.OptimizationUtils.MapContainerDataToNodalData(data_exp, neighbours.GetContainer())
+        KM.TensorAdaptors.HistoricalVariableTensorAdaptor(ta, self._GetSolver().GetSolvingVariable(), copy=False).StoreData()
+
+    def __AssignTensorDataToNodalSource(self, data_exp: KM.TensorAdaptors.DoubleTensorAdaptor):
+        self.__source_data = KM.TensorAdaptors.DoubleTensorAdaptor(data_exp)
+
+        # it is better to work on the model part of the data_exp rather than the internal
+        # model part created with ConnectivityPreserveModelPart because, then all the outputs will
+        # be written to one vtu file automatically, otherwise, there will be outputs distributed among
+        # the helmholtz model part and the original model part. This is safer because the helmholtz modelpart
+        # is created using the ConnectivityPreserveModeller which preserves the same nodes and condition/element
+        # data containers.
+
+        ta = KM.TensorAdaptors.DoubleTensorAdaptor(data_exp, copy=False)
+        if not isinstance(ta.GetContainer(), KM.NodesArray):
+            neighbours = self.__GetNeighbourEntities(data_exp)
+            ta = KOA.OptimizationUtils.MapContainerDataToNodalData(data_exp, neighbours.GetContainer())
+        KM.TensorAdaptors.VariableTensorAdaptor(ta, self._GetSolver().GetSourceVariable(), copy=False).StoreData()
+
+    def __AssignNodalSolutionToTensorData(self) -> KM.TensorAdaptors.DoubleTensorAdaptor:
+        if self.__source_data is None:
+            raise RuntimeError("The __AssignTensorDataToNodalSource should be called first.")
+
+        # it is better to work on the model part of the data_exp rather than the internal
+        # model part created with ConnectivityPreserveModelPart because, then all the outputs will
+        # be written to one vtu file automatically, otherwise, there will be outputs distributed among
+        # the helmholtz model part and the original model part. This is safer because the helmholtz modelpart
+        # is created using the ConnectivityPreserveModeller which preserves the same nodes and condition/element
+        # data containers.
+        neighbours = self.__GetNeighbourEntities(self.__source_data)
+        solution = KM.TensorAdaptors.HistoricalVariableTensorAdaptor(neighbours.GetContainer(), self._GetSolver().GetSolvingVariable())
+        solution.CollectData()
+
+        if isinstance(self.__source_data.GetContainer(), KM.NodesArray):
+            return KM.TensorAdaptors.DoubleTensorAdaptor(solution, copy=False)
+        else:
+            return KOA.OptimizationUtils.MapNodalDataToContainerData(solution, self.__source_data.GetContainer(), neighbours)
+
+    def __GetNeighbourEntities(self, data_exp: KM.TensorAdaptors.DoubleTensorAdaptor) -> KM.TensorAdaptors.IntTensorAdaptor:
+        # following makes the number of neighbours computation to be executed once
+        # per given container, hence if the mesh element/connectivity changes
+        # this computation needs to be redone. Especially in the case if MMG is
+        # used for re-meshing.
+        key = data_exp.GetContainer()
+        if key not in  self.__neighbour_entities.keys():
+            if not isinstance(key, KM.NodesArray):
+                if isinstance(data_exp.GetContainer(), KM.ConditionsArray):
+                    self.__neighbour_entities[key] = KM.TensorAdaptors.Utils.CreateNodalConditionNeighboursCountTensorAdaptor(self._GetSolver().GetComputingModelPart())
+                elif isinstance(data_exp.GetContainer(), KM.ElementsArray):
+                    self.__neighbour_entities[key] = KM.TensorAdaptors.Utils.CreateNodalElementNeighboursCountTensorAdaptor(self._GetSolver().GetComputingModelPart())
+                else:
+                    raise RuntimeError(f"Unsupported tensor adaptor container. Only supports neighbour computation for condition or element containers [ tensor adaptor = {data_exp} ]." )
+            else:
+                ta = KM.TensorAdaptors.IntTensorAdaptor(key, KM.IntNDData([len(key)]), copy=False)
+                ta.data[:] = 1
+                self.__neighbour_entities[key] = ta
+
+        return self.__neighbour_entities[key]

KratosMultiphysics/OptimizationApplication/filtering/helmholtz_scalar_solver.py

@@ -0,0 +1,39 @@
+# Importing the Kratos Library
+import KratosMultiphysics as KM
+
+# Import applications
+import KratosMultiphysics.OptimizationApplication as KOA
+
+# Import baseclass
+from KratosMultiphysics.OptimizationApplication.filtering.helmholtz_solver_base import HelmholtzSolverBase
+
+def CreateSolver(model: KM.Model, custom_settings: KM.Parameters):
+    return HelmholtzScalarSolver(model, custom_settings)
+
+class HelmholtzScalarSolver(HelmholtzSolverBase):
+    def GetSolvingVariable(self) -> KM.DoubleVariable:
+        return KOA.HELMHOLTZ_SCALAR
+
+    def _GetComputingModelPartName(self) -> str:
+        return self.GetOriginModelPart().FullName().replace(".", "_") + "_helmholtz_scalar"
+
+    def SetFilterRadius(self, filter_radius: float) -> None:
+        self.GetComputingModelPart().ProcessInfo.SetValue(KOA.HELMHOLTZ_RADIUS, filter_radius)
+
+    def _FillComputingModelPart(self) -> None:
+        if self.GetOriginModelPart().NumberOfElements() > 0:
+            # here we have to replace the elements, while keeping the
+            # geometries the same. Hence using the ConnectivityPreserveModeller
+            container = self.GetOriginModelPart().Elements
+            num_nodes = self._GetContainerTypeNumNodes(container)
+            if self._IsSurfaceContainer(container):
+                KM.ConnectivityPreserveModeler().GenerateModelPart(self.GetOriginModelPart(), self.GetComputingModelPart(), f"HelmholtzSurfaceElement3D{num_nodes}N")
+            else:
+                KM.ConnectivityPreserveModeler().GenerateModelPart(self.GetOriginModelPart(), self.GetComputingModelPart(), f"HelmholtzSolidElement3D{num_nodes}N")
+        elif self.GetOriginModelPart().NumberOfConditions() > 0:
+            # here we have conditions in the origin model part. Now we have to create elements using
+            # the geometries of the conditions. There cannot be volume conditions in Kratos, therefore,
+            # there can be only surface conditions, hence only required to create surface elements.
+            KOA.OptAppModelPartUtils.GenerateModelPart(self.GetOriginModelPart().Conditions, self.GetComputingModelPart(), f"HelmholtzSurfaceElement3D{self._GetContainerTypeNumNodes(self.GetOriginModelPart().Conditions)}N")
+        else:
+            raise RuntimeError(f"No elements or conditions found in {self.GetOriginModelPart()}.")

KratosMultiphysics/OptimizationApplication/filtering/helmholtz_shape_solver.py

@@ -0,0 +1,67 @@
+# Importing the Kratos Library
+import KratosMultiphysics as KM
+import KratosMultiphysics.OptimizationApplication as KOA
+
+# Import baseclass
+from KratosMultiphysics.OptimizationApplication.filtering.helmholtz_solver_base import HelmholtzSolverBase
+
+def CreateSolver(model: KM.Model, custom_settings: KM.Parameters):
+    return HelmholtzShapeSolver(model, custom_settings)
+
+class HelmholtzShapeSolver(HelmholtzSolverBase):
+    def GetSolvingVariable(self) -> KM.Array1DVariable3:
+        return KOA.HELMHOLTZ_VECTOR
+
+    def _GetComputingModelPartName(self) -> str:
+        return self.GetOriginModelPart().FullName().replace(".", "_") + "_helmholtz_shape"
+
+    def SetFilterRadius(self, filter_radius: float) -> None:
+        self.GetComputingModelPart().ProcessInfo.SetValue(KOA.HELMHOLTZ_RADIUS, filter_radius)
+        KOA.ImplicitFilterUtils.SetBulkRadiusForShapeFiltering(self.GetComputingModelPart())
+
+    def _FillComputingModelPart(self) -> None:
+        if self.GetOriginModelPart().NumberOfElements() > 0:
+            # here we have to replace the elements, while keeping the
+            # geometries the same. Hence using the ConnectivityPreserveModeller
+            container = self.GetOriginModelPart().Elements
+            num_nodes = self._GetContainerTypeNumNodes(container)
+            if self._IsSurfaceContainer(container):
+                KM.ConnectivityPreserveModeler().GenerateModelPart(self.GetOriginModelPart(), self.GetComputingModelPart(), f"HelmholtzVectorSurfaceElement3D{num_nodes}N")
+            else:
+                raise RuntimeError(f"Helmholtz shape solver found volume elements in {self.GetOriginModelPart().FullName()}. It can work with only either surface elements or surface conditions.")
+        elif self.GetOriginModelPart().NumberOfConditions() > 0:
+            # we have only conditions in the origin model part. Since this solver is used to
+            # do the mesh motion as well, then we need to work on the origin model part's root model part.
+            # here also we can use the connectivity preserve modeller.
+            element_num_nodes = self._GetContainerTypeNumNodes(self.GetOriginRootModelPart().Elements)
+            KM.ConnectivityPreserveModeler().GenerateModelPart(self.GetOriginRootModelPart(), self.GetComputingModelPart(), f"HelmholtzSolidShapeElement3D{element_num_nodes}N", f"HelmholtzSurfaceShapeCondition3D{self._GetContainerTypeNumNodes(self.GetOriginRootModelPart().Conditions)}N")
+
+            # now we have to add the material properties
+            properties = KM.Parameters("""{
+                "properties" : [
+                    {
+                        "model_part_name": \"""" + self.GetComputingModelPart().FullName() + """\",
+                        "properties_id"  : """ + str(self.GetComputingModelPart().NumberOfProperties() + 1) + """,
+                        "Material": {
+                            "constitutive_law": {
+                                "name": "HelmholtzJacobianStiffened3D"
+                            },
+                            "Variables": {
+                                "POISSON_RATIO": 0.3
+                            }
+                        }
+                    }
+                ]
+            }""")
+            KM.ReadMaterialsUtility(self.model).ReadMaterials(properties)
+
+            # now we do the tetrahedral mesh orientation check and parent element
+            # assignment.
+            if element_num_nodes == 4:
+                tmoc = KM.TetrahedralMeshOrientationCheck
+                flags = (tmoc.COMPUTE_NODAL_NORMALS).AsFalse() | (tmoc.COMPUTE_CONDITION_NORMALS).AsFalse() | tmoc.ASSIGN_NEIGHBOUR_ELEMENTS_TO_CONDITIONS
+                KM.TetrahedralMeshOrientationCheck(self.GetComputingModelPart(), False, flags).Execute()
+            else:
+                raise RuntimeError("Helmholtz shape solver only supports tetrahedral elements.")
+        else:
+            raise RuntimeError(f"No elements or conditions found in {self.GetOriginModelPart()}.")

KratosMultiphysics/OptimizationApplication/filtering/helmholtz_solver_base.py

@@ -0,0 +1,275 @@
+import abc
+import typing
+import numpy
+
+# Importing the Kratos Library
+import KratosMultiphysics
+import KratosMultiphysics.OptimizationApplication as KOA
+from KratosMultiphysics.OptimizationApplication.utilities.union_utilities import SupportedSensitivityFieldVariableTypes
+
+# Other imports
+from KratosMultiphysics.python_solver import PythonSolver
+from KratosMultiphysics.python_linear_solver_factory import ConstructSolver
+
+class HelmholtzSolverBase(PythonSolver):
+    """The base class for Helmholtz-based solvers.
+
+    This class defines the user interface to Helmholtz solvers.
+
+    """
+    def __init__(self, model: KratosMultiphysics.Model, custom_settings: KratosMultiphysics.Parameters):
+        self._validate_settings_in_baseclass=True # To be removed eventually
+        super().__init__(model, custom_settings)
+
+        # Either retrieve the model part from the model or create a new one
+        self.filtering_model_part_name = self.settings["model_part_name"].GetString()
+
+        if self.filtering_model_part_name == "":
+            raise Exception('Please provide the model part name as the "model_part_name" (string) parameter!')
+
+        # the filtering_model_part_name can be a sub model part. Hence we need the main model part
+        # for variable and dof addition.
+        root_model_part_name = self.filtering_model_part_name.split(".")[0]
+        if self.model.HasModelPart(root_model_part_name):
+            self.origin_root_model_part = self.model.GetModelPart(root_model_part_name)
+        else:
+            self.origin_root_model_part = model.CreateModelPart(root_model_part_name)
+
+        domain_size = self.settings["domain_size"].GetInt()
+        if domain_size == -1:
+            raise Exception('Please provide the domain size as the "domain_size" (int) parameter!')
+        self.origin_root_model_part.ProcessInfo.SetValue(KratosMultiphysics.DOMAIN_SIZE, domain_size)
+
+        # we don't create the helmholtz model part here, because
+        # we need to have unique model parts for different filtering variable types
+        # hence, it cannot be determined at this point.
+        self.helmholtz_model_part: 'typing.Optional[KratosMultiphysics.ModelPart]' = None
+
+        # Get the filter radius
+        self.filter_radius = self.settings["filter_radius"].GetDouble()
+
+        KratosMultiphysics.Logger.PrintInfo("::[HelmholtzSolverBase]:: Construction finished")
+
+    @classmethod
+    def GetDefaultParameters(cls) -> KratosMultiphysics.Parameters:
+        this_defaults = KratosMultiphysics.Parameters("""{
+            "solver_type"           : "helmholtz_solver_base",
+            "domain_size"           : -1,
+            "filter_type"     : "",
+            "filter_radius"     : 0.0,
+            "model_part_name"       : "",
+            "time_stepping" : {
+                "time_step"       : 1.0
+            },
+            "model_import_settings" : {
+                "input_type"     : "mdpa",
+                "input_filename" : "unknown_name"
+            },
+            "linear_solver_settings" : {
+                "solver_type" : "amgcl",
+                "smoother_type":"ilu0",
+                "krylov_type": "gmres",
+                "coarsening_type": "aggregation",
+                "max_iteration": 200,
+                "provide_coordinates": false,
+                "gmres_krylov_space_dimension": 100,
+                "verbosity" : 0,
+                "tolerance": 1e-7,
+                "scaling": false,
+                "block_size": 1,
+                "use_block_matrices_if_possible" : true,
+                "coarse_enough" : 5000
+            },
+            "material_properties": {}
+        }""")
+        this_defaults.AddMissingParameters(super().GetDefaultParameters())
+        return this_defaults
+
+    #### Public user interface functions ####
+
+    @abc.abstractmethod
+    def _GetComputingModelPartName(self) -> str:
+        pass
+
+    @abc.abstractmethod
+    def _FillComputingModelPart(self) -> None:
+        pass
+
+    @abc.abstractmethod
+    def GetSolvingVariable(self) -> SupportedSensitivityFieldVariableTypes:
+        pass
+
+    @abc.abstractmethod
+    def SetFilterRadius(self, filter_radius: float) -> None:
+        pass
+
+    def AddVariables(self) -> None:
+        self.GetOriginRootModelPart().AddNodalSolutionStepVariable(self.GetSolvingVariable())
+        KratosMultiphysics.Logger.PrintInfo("::[HelmholtzSolverBase]:: Variables ADDED.")
+
+    def AddDofs(self) -> None:
+        if isinstance(self.GetSolvingVariable(), KratosMultiphysics.DoubleVariable):
+            KratosMultiphysics.VariableUtils().AddDof(self.GetSolvingVariable(), self.GetOriginRootModelPart())
+        elif isinstance(self.GetSolvingVariable(), KratosMultiphysics.Array1DVariable3):
+            KratosMultiphysics.VariableUtils().AddDof(KratosMultiphysics.KratosGlobals.GetVariable(f"{self.GetSolvingVariable().Name()}_X"), self.GetOriginRootModelPart())
+            KratosMultiphysics.VariableUtils().AddDof(KratosMultiphysics.KratosGlobals.GetVariable(f"{self.GetSolvingVariable().Name()}_Y"), self.GetOriginRootModelPart())
+            KratosMultiphysics.VariableUtils().AddDof(KratosMultiphysics.KratosGlobals.GetVariable(f"{self.GetSolvingVariable().Name()}_Z"), self.GetOriginRootModelPart())
+        else:
+            raise RuntimeError("Unsupported solving variable type.")
+        KratosMultiphysics.Logger.PrintInfo("::[HelmholtzSolverBase]:: DOFs ADDED.")
+
+    def AdvanceInTime(self, current_time: float) -> float:
+        dt = self.settings["time_stepping"]["time_step"].GetDouble()
+        new_time = current_time + dt
+        self.helmholtz_model_part.ProcessInfo[KratosMultiphysics.STEP] += 1
+        self.helmholtz_model_part.CloneTimeStep(new_time)
+
+        return new_time
+
+    def Initialize(self) -> None:
+        self._GetSolutionStrategy().Initialize()
+        neighbours_ta_int = KratosMultiphysics.TensorAdaptors.Utils.CreateNodalElementNeighboursCountTensorAdaptor(self.helmholtz_model_part)
+
+        writing_ta = KratosMultiphysics.TensorAdaptors.VariableTensorAdaptor(neighbours_ta_int.GetContainer(), KratosMultiphysics.NUMBER_OF_NEIGHBOUR_ELEMENTS)
+        writing_ta.SetData(neighbours_ta_int.data)
+        writing_ta.StoreData()
+        KratosMultiphysics.Logger.PrintInfo("::[HelmholtzSolverBase]:: Finished initialization.")
+
+    def InitializeSolutionStep(self) -> None:
+        self._GetSolutionStrategy().InitializeSolutionStep()
+
+    def FinalizeSolutionStep(self) -> None:
+        self._GetSolutionStrategy().FinalizeSolutionStep()
+
+    def Predict(self) -> None:
+        self._GetSolutionStrategy().Predict()
+
+    def SolveSolutionStep(self) -> None:
+        is_converged = bool(self._GetSolutionStrategy().Solve())
+        return is_converged
+
+    def SetEchoLevel(self, level: int) -> None:
+        self._GetSolutionStrategy().SetEchoLevel(level)
+
+    def GetEchoLevel(self) -> int:
+        self._GetSolutionStrategy().GetEchoLevel()
+
+    def Clear(self) -> None:
+        self._GetSolutionStrategy().Clear()
+
+    def ImportModelPart(self) -> None:
+        self._ImportModelPart(self.origin_root_model_part, self.settings["model_import_settings"])
+
+    def GetComputingModelPart(self) -> KratosMultiphysics.ModelPart:
+        return self.helmholtz_model_part
+
+    def GetOriginRootModelPart(self) -> KratosMultiphysics.ModelPart:
+        return self.origin_root_model_part
+
+    def GetOriginModelPart(self) -> KratosMultiphysics.ModelPart:
+        return self.model[self.filtering_model_part_name]
+
+    def GetFilterRadius(self) -> str:
+        return self.filter_radius
+
+    #### Protected functions ####
+
+    #### Specific internal functions ####
+
+    def _GetScheme(self):
+        if not hasattr(self, '_solution_scheme'):
+            self._solution_scheme = self._CreateScheme()
+        return self._solution_scheme
+
+    def _GetLinearSolver(self):
+        if not hasattr(self, '_linear_solver'):
+            self._linear_solver = self._CreateLinearSolver()
+        return self._linear_solver
+
+    def _GetBuilderAndSolver(self):
+        if not hasattr(self, '_builder_and_solver'):
+            self._builder_and_solver = self._CreateBuilderAndSolver()
+        return self._builder_and_solver
+
+    def _GetSolutionStrategy(self):
+        if not hasattr(self, '_solution_strategy'):
+            self._solution_strategy = self._CreateSolutionStrategy()
+        return self._solution_strategy
+
+    def _CreateBuilderAndSolver(self):
+        linear_solver = self._GetLinearSolver()
+        return KratosMultiphysics.ResidualBasedBlockBuilderAndSolver(linear_solver)
+
+    def _CreateLinearSolver(self):
+        return ConstructSolver(self.settings["linear_solver_settings"])
+
+    def _CreateScheme(self):
+        return KratosMultiphysics.ResidualBasedIncrementalUpdateStaticScheme()
+
+    def _CreateSolutionStrategy(self):
+        computing_model_part = self.GetComputingModelPart()
+        scheme = self._GetScheme()
+        builder_and_solver = self._GetBuilderAndSolver()
+        return KratosMultiphysics.ResidualBasedLinearStrategy(computing_model_part,
+                                                              scheme,
+                                                              builder_and_solver,
+                                                              False,
+                                                              False,
+                                                              False,
+                                                              False)
+
+    def _GetContainerTypeNumNodes(self, container: 'typing.Union[KratosMultiphysics.ConditionsArray, KratosMultiphysics.ElementsArray]') -> int:
+        num_nodes = None
+        for cont_type in container:
+            return len(cont_type.GetNodes())
+        return num_nodes
+
+    def _IsSurfaceContainer(self, container: 'typing.Union[KratosMultiphysics.ConditionsArray, KratosMultiphysics.ElementsArray]') -> bool:
+        return any(map(lambda x: x.GetGeometry().WorkingSpaceDimension() != x.GetGeometry().LocalSpaceDimension(), container))
+
+    def GetSourceVariable(self) -> SupportedSensitivityFieldVariableTypes:
+        if isinstance(self.GetSolvingVariable(), KratosMultiphysics.DoubleVariable):
+            return KOA.HELMHOLTZ_SCALAR_SOURCE
+        elif isinstance(self.GetSolvingVariable(), KratosMultiphysics.Array1DVariable3):
+            return KOA.HELMHOLTZ_VECTOR_SOURCE
+        else:
+            raise RuntimeError("Unsupported solving variable.")
+
+    def PrepareModelPart(self) -> str:
+        computing_model_part_name = self._GetComputingModelPartName()
+
+        if self.model.HasModelPart(computing_model_part_name):
+            # a same model part with same entities were already created by some other filter
+            # hence reusing it
+            self.helmholtz_model_part = self.model[computing_model_part_name]
+        else:
+            # the model part needs to be created.
+            self.helmholtz_model_part = self.model.CreateModelPart(computing_model_part_name)
+            KOA.OptimizationUtils.SetSolutionStepVariablesList(self.helmholtz_model_part, self.GetOriginRootModelPart())
+
+            # now fill with the appropriate elements and conditions
+            self._FillComputingModelPart()
+
+        self.__IncrementModelPartUsageCounter()
+
+    def __IncrementModelPartUsageCounter(self) -> None:
+        # we increase the usage number of filters using the model part.
+        # this is required to know whether we need to apply boundary conditions
+        # every time filter is used so that we don't mix-up different BCs from
+        # different filters and mesh motion solvers
+
+        # in here, the origin model part and its parents are updated. This is because,
+        # the computing model part shares nodes with the origin model part.
+        def increase_counter(model_part: KratosMultiphysics.ModelPart) -> None:
+            if not model_part.Has(KOA.NUMBER_OF_SOLVERS_USING_NODES):
+                model_part[KOA.NUMBER_OF_SOLVERS_USING_NODES] = 0
+            model_part[KOA.NUMBER_OF_SOLVERS_USING_NODES] += 1
+
+        current_model_part = self.GetOriginModelPart()
+        increase_counter(current_model_part)
+
+        # now increase the usage counter in all parent model parts.
+        while current_model_part != current_model_part.GetParentModelPart():
+            current_model_part = current_model_part.GetParentModelPart()
+            increase_counter(current_model_part)
+

KratosMultiphysics/OptimizationApplication/filtering/helmholtz_vector_solver.py

@@ -0,0 +1,39 @@
+# Importing the Kratos Library
+import KratosMultiphysics as KM
+
+# Import applications
+import KratosMultiphysics.OptimizationApplication as KOA
+
+# Import baseclass
+from KratosMultiphysics.OptimizationApplication.filtering.helmholtz_solver_base import HelmholtzSolverBase
+
+def CreateSolver(model: KM.Model, custom_settings: KM.Parameters):
+    return HelmholtzVectorSolver(model, custom_settings)
+
+class HelmholtzVectorSolver(HelmholtzSolverBase):
+    def GetSolvingVariable(self) -> KM.Array1DVariable3:
+        return KOA.HELMHOLTZ_VECTOR
+
+    def _GetComputingModelPartName(self) -> str:
+        return self.GetOriginModelPart().FullName().replace(".", "_") + "_helmholtz_vector"
+
+    def SetFilterRadius(self, filter_radius: float) -> None:
+        self.GetComputingModelPart().ProcessInfo.SetValue(KOA.HELMHOLTZ_RADIUS, filter_radius)
+
+    def _FillComputingModelPart(self) -> None:
+        if self.GetOriginModelPart().NumberOfElements() > 0:
+            # here we have to replace the elements, while keeping the
+            # geometries the same. Hence using the ConnectivityPreserveModeller
+            container = self.GetOriginModelPart().Elements
+            num_nodes = self._GetContainerTypeNumNodes(container)
+            if self._IsSurfaceContainer(container):
+                KM.ConnectivityPreserveModeler().GenerateModelPart(self.GetOriginModelPart(), self.GetComputingModelPart(), f"HelmholtzVectorSurfaceElement3D{num_nodes}N")
+            else:
+                KM.ConnectivityPreserveModeler().GenerateModelPart(self.GetOriginModelPart(), self.GetComputingModelPart(), f"HelmholtzVectorSolidElement3D{num_nodes}N")
+        elif self.GetOriginModelPart().NumberOfConditions() > 0:
+            # here we have conditions in the origin model part. Now we have to create elements using
+            # the geometries of the conditions. There cannot be volume conditions in Kratos, therefore,
+            # there can be only surface conditions, hence only required to create surface elements.
+            KOA.OptAppModelPartUtils.GenerateModelPart(self.GetOriginModelPart().Conditions, self.GetComputingModelPart(), f"HelmholtzVectorSurfaceElement3D{self._GetContainerTypeNumNodes(self.GetOriginModelPart().Conditions)}N")
+        else:
+            raise RuntimeError(f"No elements or conditions found in {self.GetOriginModelPart()}.")