KratosOptimizationApplication 10.4.4__py3-none-any.whl

KratosMultiphysics/OptimizationApplication/filtering/implicit_filter.py

@@ -0,0 +1,192 @@
+import typing
+
+import KratosMultiphysics as Kratos
+import KratosMultiphysics.OptimizationApplication as KratosOA
+from KratosMultiphysics.OptimizationApplication.filtering.filter import Filter
+from KratosMultiphysics.OptimizationApplication.utilities.union_utilities import SupportedSensitivityFieldVariableTypes
+from KratosMultiphysics.OptimizationApplication.filtering.helmholtz_analysis import HelmholtzAnalysis
+
+def Factory(model: Kratos.Model, filtering_model_part_name: str, filtering_variable: SupportedSensitivityFieldVariableTypes, data_location: Kratos.Globals.DataLocation, parameters: Kratos.Parameters) -> Filter:
+    return ImplicitFilter(model, filtering_model_part_name, filtering_variable, data_location, parameters)
+
+class ImplicitFilter(Filter):
+    @classmethod
+    def GetDefaultParameters(cls) -> Kratos.Parameters:
+        return Kratos.Parameters("""{
+            "filter_type"                  : "implicit_filter",
+            "filter_radius"                : 0.2,
+            "filter_variable_type"         : "auto",
+            "linear_solver_settings"       : {},
+            "echo_level"                   : 0,
+            "filtering_boundary_conditions": {}
+        }""")
+
+    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]))
+
+        allowed_filter_variable_types = ["auto", "general_scalar", "general_vector", "shape"]
+        filter_variable_type = self.parameters["filter_variable_type"].GetString()
+        if not filter_variable_type in allowed_filter_variable_types:
+            raise RuntimeError(f"Unsupported filter_variable_type = \"{filter_variable_type}\". Followings are supported:\n\t" + "\n\t".join(allowed_filter_variable_types))
+
+        if filter_variable_type == "auto":
+            if isinstance(filtering_variable, Kratos.DoubleVariable):
+                self.filter_type = "general_scalar"
+            elif isinstance(filtering_variable, Kratos.Array1DVariable3):
+                if filtering_variable == KratosOA.SHAPE:
+                    self.filter_type = "shape"
+                else:
+                    self.filter_type = "general_vector"
+            else:
+                raise RuntimeError(f"Unsupported variable type [ variable name = {filtering_variable.Name()}]")
+        else:
+            self.filter_type = filter_variable_type
+
+        if self.filter_type == "general_scalar" and not isinstance(filtering_variable, Kratos.DoubleVariable):
+            raise RuntimeError(f"\"general_scalar\" only supports scalar variables [ variable name = {filtering_variable.Name()} ].")
+        if self.filter_type == "general_vector" and not isinstance(filtering_variable, Kratos.Array1DVariable3):
+            raise RuntimeError(f"\"general_vector\" only supports array3 variables [ variable name = {filtering_variable.Name()} ].")
+        if self.filter_type == "shape" and filtering_variable != KratosOA.SHAPE:
+            raise RuntimeError(f"\"shape\" only supports SHAPE variable [ variable name = {filtering_variable.Name()} ].")
+
+        helmholtz_settings = self.__GetImplicitFilterParameters(filtering_model_part_name, self.parameters)
+
+        self.filter_analysis = HelmholtzAnalysis(self.model, helmholtz_settings)
+
+        solving_var = self.filter_analysis._GetSolver().GetSolvingVariable()
+        if isinstance(solving_var, Kratos.DoubleVariable):
+            self.filter_variables = [solving_var]
+        elif isinstance(solving_var, Kratos.Array1DVariable3):
+            self.filter_variables = list(map(lambda x: Kratos.KratosGlobals.GetVariable(x), [f"{solving_var.Name()}_{suffix}" for suffix in ["X", "Y", "Z"]]))
+        else:
+            raise RuntimeError(f"Unsupported solving variable [ solving variable name = {solving_var.Name()} ].")
+
+        self.damped_model_parts: 'typing.Optional[list[list[Kratos.ModelPart]]]' = None
+
+    def Initialize(self) -> None:
+        self.filter_analysis.Initialize()
+        self.__ApplyBoundaryConditions()
+
+    def Update(self) -> None:
+        pass
+
+    def Check(self) -> None:
+        pass
+
+    def Finalize(self) -> None:
+        self.filter_analysis.Finalize()
+
+    def ForwardFilterField(self, control_field: Kratos.TensorAdaptors.DoubleTensorAdaptor) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        if self.filter_analysis._GetSolver().GetOriginModelPart()[KratosOA.NUMBER_OF_SOLVERS_USING_NODES] > 1:
+            self.__ReInitializeFilteringModelPart()
+        return self.filter_analysis.FilterField(control_field)
+
+    def BackwardFilterField(self, physical_mesh_independent_gradient_field: Kratos.TensorAdaptors.DoubleTensorAdaptor) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        if self.filter_analysis._GetSolver().GetOriginModelPart()[KratosOA.NUMBER_OF_SOLVERS_USING_NODES] > 1:
+            self.__ReInitializeFilteringModelPart()
+        return self.filter_analysis.FilterField(physical_mesh_independent_gradient_field)
+
+    def BackwardFilterIntegratedField(self, physical_mesh_dependent_gradient_field: Kratos.TensorAdaptors.DoubleTensorAdaptor) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        if self.filter_analysis._GetSolver().GetOriginModelPart()[KratosOA.NUMBER_OF_SOLVERS_USING_NODES] > 1:
+            self.__ReInitializeFilteringModelPart()
+        return self.filter_analysis.FilterIntegratedField(physical_mesh_dependent_gradient_field)
+
+    def UnfilterField(self, physical_field: Kratos.TensorAdaptors.DoubleTensorAdaptor) -> Kratos.TensorAdaptors.DoubleTensorAdaptor:
+        if self.filter_analysis._GetSolver().GetOriginModelPart()[KratosOA.NUMBER_OF_SOLVERS_USING_NODES] > 1:
+            self.__ReInitializeFilteringModelPart()
+        # now we get the current values
+        current_values_ta = Kratos.TensorAdaptors.HistoricalVariableTensorAdaptor(self.filter_analysis._GetComputingModelPart().Nodes, self.filter_analysis._GetSolver().GetSolvingVariable())
+        current_values_ta.CollectData()
+
+        # now apply the physical field
+        self.filter_analysis.AssignTensorDataToNodalSolution(physical_field)
+        unfiltered_field = self.filter_analysis.UnFilterField(physical_field)
+
+        # now apply back the original BCs
+        current_values_ta.StoreData()
+        return unfiltered_field
+
+    def GetBoundaryConditions(self) -> 'list[list[Kratos.ModelPart]]':
+        return self.damped_model_parts
+
+    def __GetImplicitFilterParameters(self, filter_variable_typel_part_name: str, parameters: Kratos.Parameters):
+        implicit_vector_filter_parameters = Kratos.Parameters("""
+        {
+            "solver_settings" : {
+                "domain_size"          : 3,
+                "echo_level"           : 0,
+                "filter_type"          : "general_vector",
+                "model_part_name"      : "",
+                "filter_radius"        : 0.0,
+                "model_import_settings": {
+                    "input_type"     : "use_input_model_part"
+                }
+            },
+            "problem_data": {
+                "echo_level"    : 0,
+                "start_time"    : 0.0,
+                "end_time"      : 1.0,
+                "parallel_type" : "OpenMP"
+            }
+        }""")
+
+        implicit_vector_filter_parameters["solver_settings"]["echo_level"].SetInt(parameters["echo_level"].GetInt())
+        implicit_vector_filter_parameters["solver_settings"]["filter_radius"].SetDouble(parameters["filter_radius"].GetDouble())
+        implicit_vector_filter_parameters["solver_settings"]["filter_type"].SetString(self.filter_type)
+        implicit_vector_filter_parameters["solver_settings"]["model_part_name"].SetString(filter_variable_typel_part_name)
+
+        linear_solver_settings = parameters["linear_solver_settings"]
+        if linear_solver_settings.Has("solver_type"):
+            implicit_vector_filter_parameters["solver_settings"].AddValue("linear_solver_settings", linear_solver_settings)
+
+        return implicit_vector_filter_parameters
+
+    def __ReInitializeFilteringModelPart(self) -> None:
+        self.filter_analysis.InitializeFilterModelPart()
+        self.__ApplyBoundaryConditions()
+
+    def __ApplyBoundaryConditions(self) -> None:
+        # first free the domain, because if the same type of filter used, that means same nodes
+        # were used before with different boundary conditions. Hence it is important to free all dofs
+        # and apply the boundary conditions again when ever filter is used.
+        # This is because, every implicit filter shares the same nodes
+        list(map(lambda filter_var: Kratos.VariableUtils().ApplyFixity(filter_var, False, self.filter_analysis._GetSolver().GetComputingModelPart().Nodes), self.filter_variables))
+
+        # now re-apply the boundary conditions
+        self.damped_model_parts = KratosOA.OptimizationUtils.GetComponentWiseModelParts(self.model, self.parameters["filtering_boundary_conditions"])
+        if len(self.filter_variables) != len(self.damped_model_parts) and len(self.damped_model_parts) != 0:
+            raise RuntimeError("Number of components mismatch.")
+        list_of_boundary_model_parts: 'list[Kratos.ModelPart]' = []
+
+        for component_index, boundary_model_parts in enumerate(self.damped_model_parts):
+            for model_part in boundary_model_parts:
+                list_of_boundary_model_parts.append(model_part)
+                Kratos.VariableUtils().ApplyFixity(self.filter_variables[component_index], True, model_part.Nodes)
+
+        # make all the boundaries to zero
+        for model_part in list_of_boundary_model_parts:
+            for filter_variable in self.filter_variables:
+                zero_field = Kratos.TensorAdaptors.HistoricalVariableTensorAdaptor(model_part.Nodes, filter_variable)
+                zero_field.data[:] = 0.0
+                zero_field.StoreData()
+
+        Kratos.Logger.PrintInfo(self.__class__.__name__, f"Applied filter boundary conditions used in \"{self.GetComponentDataView().GetComponentName()}\".")
+
+

KratosMultiphysics/OptimizationApplication/filtering/python_solvers_wrapper_implicit_filters.py

@@ -0,0 +1,56 @@
+import KratosMultiphysics
+from importlib import import_module
+from KratosMultiphysics.OptimizationApplication.filtering.helmholtz_solver_base import HelmholtzSolverBase
+
+def CreateSolverByParameters(model: KratosMultiphysics.Model, solver_settings: KratosMultiphysics.Parameters, parallelism: str) -> HelmholtzSolverBase:
+
+    filter_type = solver_settings["filter_type"].GetString()
+
+    # Solvers for OpenMP parallelism
+    if parallelism == "OpenMP":
+
+        if filter_type == "general_scalar":
+            solver_module_name = "helmholtz_scalar_solver"
+        elif filter_type == "general_vector":
+            solver_module_name = "helmholtz_vector_solver"
+        elif (filter_type == "bulk_surface_shape" or filter_type == "shape"):
+            solver_module_name = "helmholtz_shape_solver"
+        else:
+            err_msg =  'The requested solver type "' + filter_type + '" is not in the python solvers wrapper\n'
+            err_msg += 'Available options are: "general_scalar", "general_vector", "shape"'
+            raise Exception(err_msg)
+
+    # Solvers for MPI parallelism
+    elif parallelism == "MPI":
+        if filter_type == "general_scalar":
+            solver_module_name = "trilinos_helmholtz_general_scalar_solver"
+        elif filter_type == "general_vector":
+            solver_module_name = "trilinos_helmholtz_general_vector_solver"
+        elif (filter_type == "bulk_surface_shape" or filter_type == "shape"):
+            solver_module_name = "trilinos_helmholtz_shape_solver"
+        else:
+            err_msg =  'The requested solver type "' + filter_type + '" is not in the python solvers wrapper\n'
+            err_msg += 'Available options are: "general_scalar", "general_vector", "bulk_surface_shape", "shape"'
+            raise Exception(err_msg)
+    else:
+        err_msg =  'The requested parallel type "' + parallelism + '" is not available!\n'
+        err_msg += 'Available options are: "OpenMP", "MPI"'
+        raise Exception(err_msg)
+
+    module_full = 'KratosMultiphysics.OptimizationApplication.filtering.' + solver_module_name
+    solver = import_module(module_full).CreateSolver(model, solver_settings)
+
+    return solver
+
+def CreateSolver(model: KratosMultiphysics.Model, custom_settings: KratosMultiphysics.Parameters) -> HelmholtzSolverBase:
+
+    if not isinstance(model, KratosMultiphysics.Model):
+        raise Exception("input is expected to be provided as a Kratos Model object")#
+
+    if not isinstance(custom_settings, KratosMultiphysics.Parameters):
+        raise Exception("input is expected to be provided as a Kratos Parameters object")
+
+    solver_settings = custom_settings["solver_settings"]
+    parallelism = custom_settings["problem_data"]["parallel_type"].GetString()
+
+    return CreateSolverByParameters(model, solver_settings, parallelism)

KratosMultiphysics/OptimizationApplication/model_part_controllers/connectivity_preserving_model_part_controller.py

@@ -0,0 +1,72 @@
+import KratosMultiphysics as Kratos
+import KratosMultiphysics.OptimizationApplication as KratosOA
+from KratosMultiphysics.OptimizationApplication.model_part_controllers.model_part_controller import ModelPartController
+
+def Factory(model: Kratos.Model, parameters: Kratos.Parameters, _) -> ModelPartController:
+    if not parameters.Has("settings"):
+        raise RuntimeError(f"ConnectivityPreservingModelPartController instantiation requires a \"settings\" in parameters [ parameters = {parameters}].")
+    return ConnectivityPreservingModelPartController(model, parameters["settings"])
+
+class ConnectivityPreservingModelPartController(ModelPartController):
+    def __init__(self, model: Kratos.Model, parameters: Kratos.Parameters):
+        default_settings = Kratos.Parameters("""{
+            "transformation_settings": [
+                {
+                    "source_model_part_name"     : "",
+                    "destination_model_part_name": "",
+                    "destination_element_name"   : "",
+                    "destination_condition_name" : ""
+                }
+            ]
+        }""")
+
+        self.model = model
+        self.parameters = parameters
+        self.parameters.ValidateAndAssignDefaults(default_settings)
+
+        for sub_model_part_settings in self.parameters["transformation_settings"].values():
+            sub_model_part_settings.ValidateAndAssignDefaults(default_settings["transformation_settings"].values()[0])
+
+    def ImportModelPart(self) -> None:
+        connectivity_preserve_modeller = Kratos.ConnectivityPreserveModeler()
+        for transformation_settings in self.parameters["transformation_settings"].values():
+            # get source and destination model parts
+            source_model_part = self.model[transformation_settings["source_model_part_name"].GetString()]
+            destination_model_part_name: str = transformation_settings["destination_model_part_name"].GetString()
+            if not self.model.HasModelPart(destination_model_part_name):
+                # if the destination model part is not there, then check whether the destination root model part is existing
+                destination_root_model_part_name = destination_model_part_name.split(".")[0]
+                if not self.model.HasModelPart(destination_root_model_part_name):
+                    # destination root model part is also not there. so we can safely assign the source model part solution variables list
+                    destination_root_model_part = self.model.CreateModelPart(destination_root_model_part_name)
+                else:
+                    # if it is existing, then check whether it has a subset of the variables list.
+                    destination_root_model_part = self.model[destination_root_model_part_name]
+                    print(source_model_part)
+                    print(destination_root_model_part)
+                    if not KratosOA.OptimizationUtils.IsSolutionStepVariablesListASubSet(source_model_part, destination_root_model_part):
+                        msg = f"The destination root model part solution step variables at {destination_root_model_part.FullName()} is not a sub set of {source_model_part.FullName()}"
+                        msg += f"\n\t{destination_root_model_part.FullName()} model part variables list:\n\t\t" + "\n\t\t".join(KratosOA.OptimizationUtils.GetSolutionStepVariableNamesList(destination_root_model_part))
+                        msg += f"\n\t{source_model_part.FullName()} model part variables list:\n\t\t" + "\n\t\t".join(KratosOA.OptimizationUtils.GetSolutionStepVariableNamesList(source_model_part))
+                        raise RuntimeError(msg)
+                KratosOA.OptimizationUtils.SetSolutionStepVariablesList(destination_root_model_part, source_model_part)
+                destination_model_part = self.model.CreateModelPart(destination_model_part_name)
+            else:
+                destination_model_part = self.model[destination_model_part_name]
+
+            element_name = transformation_settings["destination_element_name"].GetString()
+            condition_name = transformation_settings["destination_condition_name"].GetString()
+
+            if condition_name != "" and element_name != "":
+                connectivity_preserve_modeller.GenerateModelPart(source_model_part, destination_model_part, element_name, condition_name)
+            elif element_name != "":
+                connectivity_preserve_modeller.GenerateModelPart(source_model_part, destination_model_part, element_name)
+            elif condition_name != "":
+                connectivity_preserve_modeller.GenerateModelPart(source_model_part, destination_model_part, condition_name)
+            else:
+                raise RuntimeError("The element_name and the condition name cannot be empty.")
+
+            Kratos.Logger.PrintInfo(self.__class__.__name__, f"Duplicated {source_model_part.FullName()} in to {destination_model_part.FullName()}.")
+
+    def GetModelPart(self) -> Kratos.ModelPart:
+        return None

KratosMultiphysics/OptimizationApplication/model_part_controllers/external_response_function_model_part_controller.py

@@ -0,0 +1,110 @@
+import KratosMultiphysics as Kratos
+import KratosMultiphysics.OptimizationApplication as KratosOA
+from KratosMultiphysics.OptimizationApplication.model_part_controllers.model_part_controller import ModelPartController
+
+def Factory(model: Kratos.Model, parameters: Kratos.Parameters, _) -> ModelPartController:
+    if not parameters.Has("settings"):
+        raise RuntimeError(f"ExternalResponseFunctionModelPartController instantiation requires a \"settings\" in parameters [ parameters = {parameters}].")
+    return ExternalResponseFunctionModelPartController(model, parameters["settings"])
+
+class LocationAgnosticDesignPoints:
+    def __init__(self, model_part: Kratos.ModelPart, parameters: Kratos.Parameters):
+        default_settings = Kratos.Parameters("""{
+            "type"                              : "location_agnostic_design_points",
+            "number_of_design_points"           : 1
+        }""")
+        parameters.ValidateAndAssignDefaults(default_settings)
+        self.model_part = model_part
+
+        self.number_of_nodes = parameters["number_of_design_points"].GetInt()
+
+    def Execute(self):
+        for i in range(self.number_of_nodes):
+            node: Kratos.Node = self.model_part.CreateNewNode(i + 1, i + 1, 0, 0)
+            node.SetValue(KratosOA.CUSTOM_DESIGN_VARIABLE, 0.0)
+
+class CSVBasedDesignPoints:
+    def __init__(self, model_part: Kratos.ModelPart, parameters: Kratos.Parameters):
+        default_settings = Kratos.Parameters("""{
+            "type"                              : "csv_based_design_points",
+            "csv_file_name"                     : "",
+            "initialize_values_with_csv_data"   : false,
+            "value_column_header"               : "",
+            "location_column_headers"           : [""]
+        }""")
+        parameters.ValidateAndAssignDefaults(default_settings)
+        self.model_part = model_part
+
+        self.csv_file_name = parameters["csv_file_name"].GetString()
+        self.location_column_headers = parameters["location_column_headers"].GetStringArray()
+
+        self.initialize_values_with_csv_data = parameters["initialize_values_with_csv_data"].GetBool()
+        self.value_column_header = parameters["value_column_header"].GetString()
+
+        if len(self.location_column_headers) > 3:
+            raise RuntimeError("Number of location column headers cannot exceed 3.")
+
+    def Execute(self):
+        with open(self.csv_file_name, "r") as file_input:
+            lines = file_input.readlines()
+
+        if len(lines) == 0:
+            raise RuntimeError(f"The provided csv file = \"{self.csv_file_name}\" is empty.")
+
+        headers = lines[0].split(",")
+        location_column_indices = [-1, -1, -1, -1]
+
+        for j, location_header in enumerate(self.location_column_headers):
+            for i, header in enumerate(headers):
+                if header.strip() == location_header:
+                    location_column_indices[j] = i
+                    break
+
+        if self.initialize_values_with_csv_data:
+            for i, header in enumerate(headers):
+                if header.strip() == self.value_column_header:
+                    location_column_indices[3] = i
+                    break
+
+        for i, line in enumerate(lines[1:]):
+            data = [float(v.strip()) for v in line[:-1].split(',')]
+            location = [
+                data[location_column_indices[0]] if location_column_indices[0] != -1 else 0.0,
+                data[location_column_indices[1]] if location_column_indices[1] != -1 else 0.0,
+                data[location_column_indices[2]] if location_column_indices[2] != -1 else 0.0
+            ]
+            node: Kratos.Node = self.model_part.CreateNewNode(i + 1, location[0], location[1], location[2])
+            node.SetValue(KratosOA.CUSTOM_DESIGN_VARIABLE, data[location_column_indices[3]] if location_column_indices[3] != -1 else 0.0)
+
+class ExternalResponseFunctionModelPartController(ModelPartController):
+    def __init__(self, model: Kratos.Model, parameters: Kratos.Parameters):
+        default_settings = Kratos.Parameters("""{
+            "model_part_name"       : "",
+            "design_point_settings" : {}
+        }""")
+
+        parameters.ValidateAndAssignDefaults(default_settings)
+
+        model_part_name = parameters["model_part_name"].GetString()
+        if model_part_name == "":
+            raise RuntimeError("Empty \"model_part_name\" is not allowed which is given with following parameters:\n" + str(parameters))
+
+        self.model_part = model.CreateModelPart(model_part_name)
+
+        design_point_settings = parameters["design_point_settings"]
+        if not design_point_settings.Has("type"):
+            raise RuntimeError(f"No design point creation method was specified. \n{design_point_settings}")
+
+        design_point_type = design_point_settings["type"].GetString()
+        if design_point_type == "location_agnostic_design_points":
+            self.design_point_creation_method = LocationAgnosticDesignPoints(self.model_part, design_point_settings)
+        elif design_point_type == "csv_based_design_points":
+            self.design_point_creation_method = CSVBasedDesignPoints(self.model_part, design_point_settings)
+        else:
+            raise RuntimeError(f"Unsupported design point creation method type = \"{design_point_type}\". Followings are supported:\n\tlocation_agnostic_design_points\n\tcsv_based_design_points")
+
+    def ImportModelPart(self) -> None:
+        self.design_point_creation_method.Execute()
+
+    def GetModelPart(self) -> Kratos.ModelPart:
+        return self.model_part

KratosMultiphysics/OptimizationApplication/model_part_controllers/mdpa_model_part_controller.py

@@ -0,0 +1,44 @@
+import KratosMultiphysics as Kratos
+from KratosMultiphysics.OptimizationApplication.model_part_controllers.model_part_controller import ModelPartController
+
+def Factory(model: Kratos.Model, parameters: Kratos.Parameters, _) -> ModelPartController:
+    if not parameters.Has("settings"):
+        raise RuntimeError(f"MdpaModelPartController instantiation requires a \"settings\" in parameters [ parameters = {parameters}].")
+    return MdpaModelPartController(model, parameters["settings"])
+
+class MdpaModelPartController(ModelPartController):
+    def __init__(self, model: Kratos.Model, parameters: Kratos.Parameters):
+        default_settings = Kratos.Parameters("""{
+            "model_part_name": "",
+            "input_filename" : "",
+            "domain_size"    : -1,
+            "read_data"      : false
+        }""")
+
+        parameters.ValidateAndAssignDefaults(default_settings)
+
+        model_part_name = parameters["model_part_name"].GetString()
+        if model_part_name == "":
+            raise RuntimeError("Empty \"model_part_name\" is not allowed which is given with following parameters:\n" + str(parameters))
+
+        self.input_filename = parameters["input_filename"].GetString()
+        if self.input_filename == "":
+            raise RuntimeError("Empty \"input_filename\" is not allowed which is given with following parameters:\n" + str(parameters))
+
+        self.domain_size = parameters["domain_size"].GetInt()
+        if self.domain_size not in [1, 2, 3]:
+            raise RuntimeError("\"domain_size\"  should be either 1, 2 or 3." + str(parameters))
+
+        self.model_part = model.CreateModelPart(model_part_name)
+        self.read_data = parameters["read_data"].GetBool()
+
+    def ImportModelPart(self) -> None:
+        if self.read_data:
+            Kratos.ModelPartIO(self.input_filename, Kratos.ModelPartIO.READ).ReadModelPart(self.model_part)
+        else:
+            Kratos.ModelPartIO(self.input_filename, Kratos.ModelPartIO.READ | Kratos.ModelPartIO.MESH_ONLY).ReadModelPart(self.model_part)
+
+        self.model_part.ProcessInfo[Kratos.DOMAIN_SIZE] = self.domain_size
+
+    def GetModelPart(self) -> Kratos.ModelPart:
+        return self.model_part

KratosMultiphysics/OptimizationApplication/model_part_controllers/model_part_controller.py

@@ -0,0 +1,19 @@
+from abc import ABC, abstractmethod
+import KratosMultiphysics as Kratos
+
+class ModelPartController(ABC):
+    def Initialize(self) -> None:
+        pass
+
+    def Finalize(self) -> None:
+        pass
+
+    @abstractmethod
+    def ImportModelPart(self) -> None:
+        pass
+
+    @abstractmethod
+    def GetModelPart(self) -> Kratos.ModelPart:
+        pass
+
+

KratosMultiphysics/OptimizationApplication/model_parts_controller.py

@@ -0,0 +1,92 @@
+# ==============================================================================
+#  KratosOptimizationApplication
+#
+#  License:         BSD License
+#                   license: OptimizationApplication/license.txt
+#
+#  Main authors:    Reza Najian Asl, https://github.com/RezaNajian
+#
+# ==============================================================================
+
+# importing the Kratos Library
+import KratosMultiphysics as KM
+from KratosMultiphysics.OptimizationApplication.model_part_controllers.mdpa_model_part_controller import MdpaModelPartController
+
+# ==============================================================================
+def CreateController(model_parts_settings: KM.Parameters, model: KM.Model):
+    return ModelPartsController(model_parts_settings, model)
+
+# ==============================================================================
+class ModelPartsController:
+    # --------------------------------------------------------------------------
+    def __init__(self, model_parts_settings: KM.Parameters, model: KM.Model):
+
+        self.model_parts_settings = model_parts_settings
+        self.model = model
+
+        self.mdpa_model_part_controllers: 'list[MdpaModelPartController]' = []
+        for params in self.model_parts_settings:
+            params["settings"].AddString("model_part_name", params["name"].GetString())
+            self.mdpa_model_part_controllers.append(MdpaModelPartController(model, params["settings"]))
+
+    # --------------------------------------------------------------------------
+    def Initialize(self) -> None:
+        for mdpa_model_part_controller in self.mdpa_model_part_controllers:
+            mdpa_model_part_controller.ImportModelPart()
+
+    # --------------------------------------------------------------------------
+    def CheckIfRootModelPartsExist(self, root_model_parts_name: 'list[str]', raise_error = True) -> bool:
+        if not isinstance(root_model_parts_name, list):
+            raise RuntimeError("ModelPartsController: CheckIfRootModelPartsExist requires list of model parts")
+
+        if_exist = True
+        for root_model_part_name in root_model_parts_name:
+            extracted_root_model_part_name = root_model_part_name.split(".")[0]
+            if not self.model.HasModelPart(extracted_root_model_part_name):
+                if raise_error:
+                    raise RuntimeError("ModelPartsController: CheckIfRootModelPartsExist: Root model part {} does not exist!".format(extracted_root_model_part_name))
+                else:
+                    if_exist = False
+                    break
+
+        return if_exist
+    # --------------------------------------------------------------------------
+    def GetModelPart(self, model_part_name: str) -> KM.ModelPart:
+        if not model_part_name in self.model.GetModelPartNames():
+            raise RuntimeError("ModelPartsController: Try to get model part {} which does not exist.".format(model_part_name))
+        else:
+            return self.model.GetModelPart(model_part_name)
+    # --------------------------------------------------------------------------
+    def GetRootModelPart(self, root_model_part_name: str) -> KM.ModelPart:
+        extracted_root_model_part_name = root_model_part_name.split(".")[0]
+        if not self.model.HasModelPart(extracted_root_model_part_name):
+            raise RuntimeError("ModelPartsController: Try to get root model part {} which does not exist.".format(root_model_part_name))
+        else:
+            return self.model[extracted_root_model_part_name]
+    # --------------------------------------------------------------------------
+    def GetRootModelParts(self, root_model_parts_name: 'list[str]') -> 'list[KM.ModelPart]':
+        if not isinstance(root_model_parts_name, list):
+            raise RuntimeError("ModelPartsController: GetRootModelParts requires list of model parts name")
+
+        list_root_model_parts = []
+        for root_model_part_name in root_model_parts_name:
+            extracted_root_model_part_name = root_model_part_name.split(".")[0]
+            if not self.model.HasModelPart(extracted_root_model_part_name):
+                raise RuntimeError("ModelPartsController: GetRootModelParts: Root model part {} does not exist!".format(extracted_root_model_part_name))
+            else:
+                list_root_model_parts.append(self.model[extracted_root_model_part_name])
+
+        return list_root_model_parts
+
+    # --------------------------------------------------------------------------
+    def UpdateTimeStep(self, step: int) -> None:
+        for mdpa_odel_part_controller in self.mdpa_model_part_controllers:
+            mdpa_odel_part_controller.GetModelPart().CloneTimeStep(step)
+            mdpa_odel_part_controller.GetModelPart().ProcessInfo.SetValue(KM.STEP, step)
+    # --------------------------------------------------------------------------
+    def SetMinimalBufferSize(self, buffer_size: int) -> None:
+        for mdpa_odel_part_controller in self.mdpa_model_part_controllers:
+            if mdpa_odel_part_controller.GetModelPart().GetBufferSize() < buffer_size:
+                mdpa_odel_part_controller.GetModelPart().SetBufferSize(buffer_size)
+
+# ==============================================================================