def __init__(self, model, solver_settings, parallelism): self._validate_settings_in_baseclass=True # To be removed eventually super().__init__(model, solver_settings) self.start_fluid_solution_time = self.settings["start_fluid_solution_time"].GetDouble() self.parallelism = parallelism fluid_solver_settings = self.settings["fluid_solver_settings"] mesh_motion_solver_settings = self.settings["mesh_motion_solver_settings"] fluid_model_part_name = fluid_solver_settings["model_part_name"].GetString() if not self.model.HasModelPart(fluid_model_part_name): model.CreateModelPart(fluid_model_part_name) # Derived class decides if the reactions should be computed or not self._ManipulateFluidSolverSettingsForReactionsComputation(fluid_solver_settings) # Creating the fluid solver self.fluid_solver = self._CreateFluidSolver(fluid_solver_settings, parallelism) # Creating the mesh-motion solver if not mesh_motion_solver_settings.Has("echo_level"): mesh_motion_solver_settings.AddValue("echo_level", self.settings["echo_level"]) # Making sure the settings are consistent btw fluid and mesh-motion if mesh_motion_solver_settings.Has("model_part_name"): if not fluid_model_part_name == mesh_motion_solver_settings["model_part_name"].GetString(): err_msg = 'Fluid- and Mesh-Solver have to use the same MainModelPart ("model_part_name")!\n' err_msg += 'Use "mesh_motion_parts" for specifying mesh-motion on sub-model-parts' raise Exception(err_msg) else: mesh_motion_solver_settings.AddValue("model_part_name", fluid_solver_settings["model_part_name"]) domain_size = fluid_solver_settings["domain_size"].GetInt() if mesh_motion_solver_settings.Has("domain_size"): mesh_motion_domain_size = mesh_motion_solver_settings["domain_size"].GetInt() if not domain_size == mesh_motion_domain_size: raise Exception('Fluid- and Mesh-Solver have to use the same "domain_size"!') else: mesh_motion_solver_settings.AddValue("domain_size", fluid_solver_settings["domain_size"]) # Derived class decides if the mesh velocities should be computed or not self._ManipulateMeshMotionSolverSettingsForMeshVelocityComputation(fluid_solver_settings, mesh_motion_solver_settings) # Constructing the mesh-solver with the entire mesh # if no submodelparts are specified then this is used for the computation of the mesh-motion # otherwise it only adds the dofs and the variables (to the entire ModelPart!) self.mesh_motion_solver_full_mesh = mesh_mothion_solvers_wrapper.CreateSolverByParameters( model, mesh_motion_solver_settings, parallelism) # Getting the min_buffer_size from both solvers # and assigning it to the fluid_solver, bcs this one handles the model_part self.fluid_solver.min_buffer_size = max( self.fluid_solver.GetMinimumBufferSize(), self.mesh_motion_solver_full_mesh.GetMinimumBufferSize()) KM.Logger.PrintInfo("::[AleFluidSolver]::", "Construction finished")
def Initialize(self): # Saving the ALE-interface-parts for later # this can only be done AFTER reading the ModelPart main_model_part_name = self.settings["fluid_solver_settings"][ "model_part_name"].GetString() ale_boundary_parts_params = self.settings["ale_boundary_parts"] self.ale_boundary_parts = [] for i_name in range(ale_boundary_parts_params.size()): sub_model_part_name = ale_boundary_parts_params[i_name].GetString() full_model_part_name = main_model_part_name + "." + sub_model_part_name self.ale_boundary_parts.append(self.model[full_model_part_name]) mesh_motion_parts_params = self.settings["mesh_motion_parts"] self.mesh_motion_solvers = [] if mesh_motion_parts_params.size() == 0: # the entire Fluid-ModelPart is used in the Mesh-Solver self.mesh_motion_solvers.append(self.mesh_motion_solver_full_mesh) else: # SubModelParts of the Fluid-ModelPart are used in the Mesh-Solver # each SubModelPart has its own mesh-solver # Note that these solvers do NOT need to call AddVariables and AddDofs # since this is done already for the MainModelPart for i_name in range(mesh_motion_parts_params.size()): sub_model_part_name = mesh_motion_parts_params[ i_name].GetString() if sub_model_part_name == main_model_part_name: err_msg = 'The MainModelPart cannot be used as one of the Sub-Mesh-Solvers!\n' err_msg += 'Remove "mesh_motion_parts" for specifying mesh-motion on the MainModelPart' raise Exception(err_msg) full_model_part_name = main_model_part_name + "." + sub_model_part_name sub_mesh_solver_settings = self.settings[ "mesh_motion_solver_settings"].Clone() sub_mesh_solver_settings["model_part_name"].SetString( full_model_part_name) self.mesh_motion_solvers.append( mesh_mothion_solvers_wrapper.CreateSolverByParameters( self.model, sub_mesh_solver_settings, self.parallelism)) for mesh_solver in self.mesh_motion_solvers: mesh_solver.Initialize() self.fluid_solver.Initialize() if self.is_printing_rank: KM.Logger.PrintInfo("::[AleFluidSolver]::", "Finished initialization")
def __init__(self, model, project_parameters): # Validate settings project_parameters = self._ValidateSettings(project_parameters) # Call the base Python solver constructor super(PartitionedFSIBaseSolver, self).__init__(model, project_parameters) # Auxiliar variables self.parallel_type = self.settings["parallel_type"].GetString() coupling_settings = self.settings["coupling_settings"] self.max_nl_it = coupling_settings["nl_max_it"].GetInt() self.nl_tol = coupling_settings["nl_tol"].GetDouble() self.solve_mesh_at_each_iteration = coupling_settings[ "solve_mesh_at_each_iteration"].GetBool() self.fluid_interface_submodelpart_name = coupling_settings[ "fluid_interfaces_list"][0].GetString() self.structure_interface_submodelpart_name = coupling_settings[ "structure_interfaces_list"][0].GetString() # Construct the structure solver self.structure_solver = python_solvers_wrapper_structural.CreateSolverByParameters( self.model, self.settings["structure_solver_settings"], self.parallel_type) self._PrintInfoOnRankZero("::[PartitionedFSIBaseSolver]::", "Structure solver construction finished.") # Construct the fluid solver self.fluid_solver = python_solvers_wrapper_fluid.CreateSolverByParameters( self.model, self.settings["fluid_solver_settings"], self.parallel_type) self._PrintInfoOnRankZero("::[PartitionedFSIBaseSolver]::", "Fluid solver construction finished.") # Construct the ALE mesh solver self.mesh_solver = python_solvers_wrapper_mesh_motion.CreateSolverByParameters( self.model, self.settings["mesh_solver_settings"], self.parallel_type) self._PrintInfoOnRankZero("::[PartitionedFSIBaseSolver]::", "ALE mesh solver construction finished.") self._PrintInfoOnRankZero( "::[PartitionedFSIBaseSolver]::", "Partitioned FSI base solver construction finished.")
def __init__(self, model, solver_settings, parallelism): default_settings = KM.Parameters("""{ "solver_type" : "ale_fluid", "echo_level" : 0, "ale_boundary_parts" : [ ], "mesh_motion_parts" : [ ], "fluid_solver_settings" : { }, "mesh_motion_solver_settings" : { }, "mesh_velocity_calculation" : { } }""") # cannot recursively validate because validation of fluid- and # mesh-motion-settings is done in corresponding solvers solver_settings.ValidateAndAssignDefaults(default_settings) super(AleFluidSolver, self).__init__(model, solver_settings) self.parallelism = parallelism fluid_solver_settings = self.settings["fluid_solver_settings"] mesh_motion_solver_settings = self.settings[ "mesh_motion_solver_settings"] fluid_model_part_name = fluid_solver_settings[ "model_part_name"].GetString() if not self.model.HasModelPart(fluid_model_part_name): model.CreateModelPart(fluid_model_part_name) ## Checking if reactions are being computed in the fluid if fluid_solver_settings.Has("compute_reactions"): if fluid_solver_settings["compute_reactions"].GetBool() == False: fluid_solver_settings["compute_reactions"].SetBool(True) warn_msg = '"compute_reactions" is switched off for the fluid-solver, ' warn_msg += 'switching it on!' KM.Logger.PrintWarning("::[AleFluidSolver]::", warn_msg) else: fluid_solver_settings.AddEmptyValue("compute_reactions").SetBool( True) info_msg = 'Setting "compute_reactions" to true for the fluid-solver' KM.Logger.PrintInfo("::[AleFluidSolver]::", info_msg) ## Creating the fluid solver self.fluid_solver = self._CreateFluidSolver(fluid_solver_settings, parallelism) self.is_printing_rank = self.fluid_solver._IsPrintingRank() # Doing this after the Fluid-solver-settings have been validated to access the settings self._SelectMeshVelocityCalculationSettings() self.__InitializeMeshVelocityComputation() ## Creating the mesh-motion solver if not mesh_motion_solver_settings.Has("echo_level"): mesh_motion_solver_settings.AddValue("echo_level", self.settings["echo_level"]) # Making sure the settings are consistent btw fluid and mesh-motion if mesh_motion_solver_settings.Has("model_part_name"): if not fluid_model_part_name == mesh_motion_solver_settings[ "model_part_name"].GetString(): err_msg = 'Fluid- and Mesh-Solver have to use the same MainModelPart ("model_part_name")!\n' err_msg += 'Use "mesh_motion_parts" for specifying mesh-motion on sub-model-parts' raise Exception(err_msg) else: mesh_motion_solver_settings.AddValue( "model_part_name", fluid_solver_settings["model_part_name"]) domain_size = fluid_solver_settings["domain_size"].GetInt() if mesh_motion_solver_settings.Has("domain_size"): mesh_motion_domain_size = mesh_motion_solver_settings[ "domain_size"].GetInt() if not domain_size == mesh_motion_domain_size: raise Exception( 'Fluid- and Mesh-Solver have to use the same "domain_size"!' ) else: mesh_motion_solver_settings.AddValue( "domain_size", fluid_solver_settings["domain_size"]) # TODO remove this once the mesh-vel-computation is removed from the mesh-solver! # We use the new utility, therefore explicitly setting it to false! if mesh_motion_solver_settings.Has("calculate_mesh_velocities"): mesh_motion_solver_settings["calculate_mesh_velocities"].SetBool( False) else: mesh_motion_solver_settings.AddEmptyValue( "calculate_mesh_velocities").SetBool(False) # Constructing the mesh-solver with the entire mesh # if no submodelparts are specified then this is used for the computation of the mesh-motion # otherwise it only adds the dofs and the variables (to the entire ModelPart!) self.mesh_motion_solver_full_mesh = mesh_mothion_solvers_wrapper.CreateSolverByParameters( model, mesh_motion_solver_settings, parallelism) # Getting the min_buffer_size from both solvers # and assigning it to the fluid_solver, bcs this one handles the model_part self.fluid_solver.min_buffer_size = max([ self.fluid_solver.GetMinimumBufferSize(), self.mesh_motion_solver_full_mesh.GetMinimumBufferSize(), KM.GetMinimumBufferSize(self.time_int_helper) ]) if self.is_printing_rank: KM.Logger.PrintInfo("::[AleFluidSolver]::", "Construction finished")
def __init__(self, model, project_parameters): # TODO: Remove this as soon as the MPCs are implemented in MPI # This has to be done prior to the defaults check to avoid the structural solver to throw an error in MPI if not project_parameters["structure_solver_settings"].Has( "multi_point_constraints_used"): project_parameters["structure_solver_settings"].AddEmptyValue( "multi_point_constraints_used") project_parameters["structure_solver_settings"][ "multi_point_constraints_used"].SetBool(False) # Call the base Python solver constructor # Note that default settings in GetDefaultParameters() are validated in here super().__init__(model, project_parameters) # Auxiliar variables self.parallel_type = self.settings["parallel_type"].GetString() coupling_settings = self.settings["coupling_settings"] self.max_nl_it = coupling_settings["nl_max_it"].GetInt() self.nl_tol = coupling_settings["nl_tol"].GetDouble() self.solve_mesh_at_each_iteration = coupling_settings[ "solve_mesh_at_each_iteration"].GetBool() self.fluid_interface_submodelpart_name = coupling_settings[ "fluid_interfaces_list"][0].GetString() self.structure_interface_submodelpart_name = coupling_settings[ "structure_interfaces_list"][0].GetString() ## Construct the structure solver self.structure_solver = python_solvers_wrapper_structural.CreateSolverByParameters( self.model, self.settings["structure_solver_settings"], self.parallel_type) KratosMultiphysics.Logger.PrintInfo( "::[PartitionedFSIBaseSolver]::", "Structure solver construction finished.") ## Construct the fluid solver self.fluid_solver = python_solvers_wrapper_fluid.CreateSolverByParameters( self.model, self.settings["fluid_solver_settings"], self.parallel_type) KratosMultiphysics.Logger.PrintInfo( "::[PartitionedFSIBaseSolver]::", "Fluid solver construction finished.") ## Check the ALE settings before the mesh solver construction mesh_solver_settings = self.settings["mesh_solver_settings"] fluid_solver_settings = self.settings["fluid_solver_settings"] # Check that the ALE and the fluid are the same model part fluid_model_part_name = fluid_solver_settings[ "model_part_name"].GetString() if mesh_solver_settings.Has("model_part_name"): if not fluid_model_part_name == mesh_solver_settings[ "model_part_name"].GetString(): err_msg = 'Fluid and mesh solver have to use the same MainModelPart ("model_part_name")!\n' raise Exception(err_msg) else: mesh_solver_settings.AddValue( "model_part_name", fluid_solver_settings["model_part_name"]) # Ensure that the fluid domain is not imported twice if mesh_solver_settings.Has("model_import_settings"): if mesh_solver_settings["model_import_settings"].Has("input_type"): if not mesh_solver_settings["model_import_settings"][ "input_type"].GetString() == "use_input_model_part": mesh_solver_settings["model_import_settings"][ "input_type"].SetString("use_input_model_part") else: mesh_solver_settings["model_import_settings"].AddEmptyValue( "input_type").SetString("use_input_model_part") else: mesh_solver_settings.AddEmptyValue( "model_import_settings").AddEmptyValue("input_type").SetString( "use_input_model_part") # Check that the ALE and the fluid have the sime time scheme fluid_time_scheme = fluid_solver_settings["time_scheme"].GetString() if mesh_solver_settings.Has("mesh_velocity_calculation"): if mesh_solver_settings["mesh_velocity_calculation"].Has( "time_scheme"): if not fluid_time_scheme == mesh_solver_settings[ "mesh_velocity_calculation"]["time_scheme"].GetString( ): err_msg = 'Fluid and mesh solver require to use the same time scheme ("time_scheme") for consistency!\n' raise Exception(err_msg) else: mesh_solver_settings["mesh_velocity_calculation"].AddValue( "time_scheme", fluid_solver_settings["time_scheme"]) else: mesh_solver_settings.AddEmptyValue("mesh_velocity_calculation") mesh_solver_settings["mesh_velocity_calculation"].AddValue( "time_scheme", fluid_solver_settings["time_scheme"]) # Check domain size fluid_domain_size = fluid_solver_settings["domain_size"].GetInt() if mesh_solver_settings.Has("domain_size"): if not fluid_domain_size == mesh_solver_settings[ "domain_size"].GetInt(): raise Exception( 'Fluid and mesh solver have different "domain_size"!') else: mesh_solver_settings.AddValue("domain_size", fluid_solver_settings["domain_size"]) # Ensure that the MESH_VELOCITY is computed if mesh_solver_settings.Has("calculate_mesh_velocity"): if not mesh_solver_settings["calculate_mesh_velocity"].GetBool(): mesh_solver_settings.SetValue("calculate_mesh_velocity", True) KratosMultiphysics.Logger.PrintWarning( "", "Mesh velocity calculation was deactivated. Switching \"calculate_mesh_velocity\" on" ) else: mesh_solver_settings.AddEmptyValue( "calculate_mesh_velocity").SetBool(True) ## Construct the ALE mesh solver self.mesh_solver = python_solvers_wrapper_mesh_motion.CreateSolverByParameters( self.model, self.settings["mesh_solver_settings"], self.parallel_type) KratosMultiphysics.Logger.PrintInfo( "::[PartitionedFSIBaseSolver]::", "ALE mesh solver construction finished.") KratosMultiphysics.Logger.PrintInfo( "::[PartitionedFSIBaseSolver]::", "Partitioned FSI base solver construction finished.")
def __init__(self, model, solver_settings, parallelism): self._validate_settings_in_baseclass = True # To be removed eventually super(AleFluidSolver, self).__init__(model, solver_settings) self.start_fluid_solution_time = self.settings[ "start_fluid_solution_time"].GetDouble() self.parallelism = parallelism fluid_solver_settings = self.settings["fluid_solver_settings"] mesh_motion_solver_settings = self.settings[ "mesh_motion_solver_settings"] fluid_model_part_name = fluid_solver_settings[ "model_part_name"].GetString() if not self.model.HasModelPart(fluid_model_part_name): model.CreateModelPart(fluid_model_part_name) ## Checking if reactions are being computed in the fluid if fluid_solver_settings.Has("compute_reactions"): if fluid_solver_settings["compute_reactions"].GetBool() == False: fluid_solver_settings["compute_reactions"].SetBool(True) warn_msg = '"compute_reactions" is switched off for the fluid-solver, ' warn_msg += 'switching it on!' KM.Logger.PrintWarning("::[AleFluidSolver]::", warn_msg) else: fluid_solver_settings.AddEmptyValue("compute_reactions").SetBool( True) info_msg = 'Setting "compute_reactions" to true for the fluid-solver' KM.Logger.PrintInfo("::[AleFluidSolver]::", info_msg) ## Creating the fluid solver self.fluid_solver = self._CreateFluidSolver(fluid_solver_settings, parallelism) # Doing this after the Fluid-solver-settings have been validated to access the settings self._SelectMeshVelocityCalculationSettings() self.__InitializeMeshVelocityComputation() ## Creating the mesh-motion solver if not mesh_motion_solver_settings.Has("echo_level"): mesh_motion_solver_settings.AddValue("echo_level", self.settings["echo_level"]) # Making sure the settings are consistent btw fluid and mesh-motion if mesh_motion_solver_settings.Has("model_part_name"): if not fluid_model_part_name == mesh_motion_solver_settings[ "model_part_name"].GetString(): err_msg = 'Fluid- and Mesh-Solver have to use the same MainModelPart ("model_part_name")!\n' err_msg += 'Use "mesh_motion_parts" for specifying mesh-motion on sub-model-parts' raise Exception(err_msg) else: mesh_motion_solver_settings.AddValue( "model_part_name", fluid_solver_settings["model_part_name"]) domain_size = fluid_solver_settings["domain_size"].GetInt() if mesh_motion_solver_settings.Has("domain_size"): mesh_motion_domain_size = mesh_motion_solver_settings[ "domain_size"].GetInt() if not domain_size == mesh_motion_domain_size: raise Exception( 'Fluid- and Mesh-Solver have to use the same "domain_size"!' ) else: mesh_motion_solver_settings.AddValue( "domain_size", fluid_solver_settings["domain_size"]) # Constructing the mesh-solver with the entire mesh # if no submodelparts are specified then this is used for the computation of the mesh-motion # otherwise it only adds the dofs and the variables (to the entire ModelPart!) self.mesh_motion_solver_full_mesh = mesh_mothion_solvers_wrapper.CreateSolverByParameters( model, mesh_motion_solver_settings, parallelism) # Getting the min_buffer_size from both solvers # and assigning it to the fluid_solver, bcs this one handles the model_part self.fluid_solver.min_buffer_size = max([ self.fluid_solver.GetMinimumBufferSize(), self.mesh_motion_solver_full_mesh.GetMinimumBufferSize(), KM.TimeDiscretization.GetMinimumBufferSize(self.time_int_helper) ]) KM.Logger.PrintInfo("::[AleFluidSolver]::", "Construction finished")
def __init__(self, model, project_parameters): # Validate settings project_parameters = self._ValidateSettings(project_parameters) # Call the base Python solver constructor super(PartitionedFSIBaseSolver, self).__init__(model, project_parameters) # Auxiliar variables self.parallel_type = self.settings["parallel_type"].GetString() coupling_settings = self.settings["coupling_settings"] self.max_nl_it = coupling_settings["nl_max_it"].GetInt() self.nl_tol = coupling_settings["nl_tol"].GetDouble() self.solve_mesh_at_each_iteration = coupling_settings[ "solve_mesh_at_each_iteration"].GetBool() self.fluid_interface_submodelpart_name = coupling_settings[ "fluid_interfaces_list"][0].GetString() self.structure_interface_submodelpart_name = coupling_settings[ "structure_interfaces_list"][0].GetString() ## Construct the structure solver self.structure_solver = python_solvers_wrapper_structural.CreateSolverByParameters( self.model, self.settings["structure_solver_settings"], self.parallel_type) self._PrintInfoOnRankZero("::[PartitionedFSIBaseSolver]::", "Structure solver construction finished.") ## Construct the fluid solver self.fluid_solver = python_solvers_wrapper_fluid.CreateSolverByParameters( self.model, self.settings["fluid_solver_settings"], self.parallel_type) self._PrintInfoOnRankZero("::[PartitionedFSIBaseSolver]::", "Fluid solver construction finished.") ## Check the ALE settings before the mesh solver construction mesh_solver_settings = self.settings["mesh_solver_settings"] fluid_solver_settings = self.settings["fluid_solver_settings"] # Check that the ALE and the fluid are the same model part fluid_model_part_name = fluid_solver_settings[ "model_part_name"].GetString() if mesh_solver_settings.Has("model_part_name"): if not fluid_model_part_name == mesh_solver_settings[ "model_part_name"].GetString(): err_msg = 'Fluid and mesh solver have to use the same MainModelPart ("model_part_name")!\n' raise Exception(err_msg) else: mesh_solver_settings.AddValue( "model_part_name", fluid_solver_settings["model_part_name"]) # Check that the ALE and the fluid have the sime time scheme fluid_time_scheme = fluid_solver_settings["time_scheme"].GetString() if mesh_solver_settings.Has("mesh_velocity_calculation"): if mesh_solver_settings["mesh_velocity_calculation"].Has( "time_scheme"): if not fluid_time_scheme == mesh_solver_settings[ "mesh_velocity_calculation"]["time_scheme"].GetString( ): err_msg = 'Fluid and mesh solver require to use the same time scheme ("time_scheme") for consistency!\n' raise Exception(err_msg) else: mesh_solver_settings["mesh_velocity_calculation"].AddValue( "time_scheme", fluid_solver_settings["time_scheme"]) else: mesh_solver_settings.AddEmptyValue("mesh_velocity_calculation") mesh_solver_settings["mesh_velocity_calculation"].AddValue( "time_scheme", fluid_solver_settings["time_scheme"]) # Check domain size fluid_domain_size = fluid_solver_settings["domain_size"].GetInt() if mesh_solver_settings.Has("domain_size"): if not fluid_domain_size == mesh_solver_settings[ "domain_size"].GetInt(): raise Exception( 'Fluid and mesh solver have different "domain_size"!') else: mesh_solver_settings.AddValue("domain_size", fluid_solver_settings["domain_size"]) # Ensure that the MESH_VELOCITY is computed if mesh_solver_settings.Has("calculate_mesh_velocity"): if not mesh_solver_settings["calculate_mesh_velocity"].GetBool(): mesh_solver_settings.SetValue("calculate_mesh_velocity", True) self._PrintWarningOnRankZero( "", "Mesh velocity calculation was desactivated. Switching \"calculate_mesh_velocity\" on" ) else: mesh_solver_settings.AddEmptyValue( "calculate_mesh_velocity").SetBool(True) ## Construct the ALE mesh solver self.mesh_solver = python_solvers_wrapper_mesh_motion.CreateSolverByParameters( self.model, self.settings["mesh_solver_settings"], self.parallel_type) self._PrintInfoOnRankZero("::[PartitionedFSIBaseSolver]::", "ALE mesh solver construction finished.") self._PrintInfoOnRankZero( "::[PartitionedFSIBaseSolver]::", "Partitioned FSI base solver construction finished.")
def _AuxiliaryInitOperations(self): # Auxiliar variables self.parallel_type = self.settings["parallel_type"].GetString() coupling_settings = self.settings["coupling_settings"] self.max_nl_it = coupling_settings["nl_max_it"].GetInt() self.nl_tol = coupling_settings["nl_tol"].GetDouble() self.solve_mesh_at_each_iteration = coupling_settings["solve_mesh_at_each_iteration"].GetBool() ## Save the FSI interfaces information in a dictionary mappers_settings = self.settings["coupling_settings"]["mapper_settings"] self.interfaces_dict = {} self.interfaces_dict['structure'] = coupling_settings["structure_interfaces_list"][0].GetString() if mappers_settings.size() == 1: self.double_faced_structure = False self.interfaces_dict['fluid_positive'] = mappers_settings[0]["fluid_interface_submodelpart_name"].GetString() self.interfaces_dict['fluid_negative'] = None elif mappers_settings.size() == 2: self.double_faced_structure = True for mapper_id in range(2): if (mappers_settings[mapper_id]["mapper_face"].GetString() == "Positive"): self.interfaces_dict['fluid_positive'] = mappers_settings[mapper_id]["fluid_interface_submodelpart_name"].GetString() elif (mappers_settings[mapper_id]["mapper_face"].GetString() == "Negative"): self.interfaces_dict['fluid_negative'] = mappers_settings[mapper_id]["fluid_interface_submodelpart_name"].GetString() else: err_msg = "The mapper face is not \'Positve\' nor \'Negative\'." raise Exception(err_msg) else: err_msg = "Case with more than 2 mappers has not been implemented yet.\n" err_msg += "Please, in case you are using single faced immersed bodies, set the skin entities in a unique submodelpart.\n" err_msg += "In case you are considering double faced immersed bodies (shells or membranes), set all the positive faces in a unique submodelpart and all the negative ones in another submodelpart." raise Exception(err_msg) ## Construct the structure solver self.structure_solver = python_solvers_wrapper_structural.CreateSolverByParameters(self.model, self.settings["structure_solver_settings"], self.parallel_type) KratosMultiphysics.Logger.PrintInfo("PartitionedFSIBaseSolver", "Structure solver construction finished.") ## Construct the fluid solver self.fluid_solver = python_solvers_wrapper_fluid.CreateSolverByParameters(self.model, self.settings["fluid_solver_settings"], self.parallel_type) KratosMultiphysics.Logger.PrintInfo("PartitionedFSIBaseSolver", "Fluid solver construction finished.") ## Check the ALE settings before the mesh solver construction mesh_solver_settings = self.settings["mesh_solver_settings"] fluid_solver_settings = self.settings["fluid_solver_settings"] # Check that the ALE and the fluid are the same model part fluid_model_part_name = fluid_solver_settings["model_part_name"].GetString() if mesh_solver_settings.Has("model_part_name"): if not fluid_model_part_name == mesh_solver_settings["model_part_name"].GetString(): err_msg = 'Fluid and mesh solver have to use the same MainModelPart ("model_part_name")!\n' raise Exception(err_msg) else: mesh_solver_settings.AddValue("model_part_name", fluid_solver_settings["model_part_name"]) # Ensure that the fluid domain is not imported twice if mesh_solver_settings.Has("model_import_settings"): if mesh_solver_settings["model_import_settings"].Has("input_type"): if not mesh_solver_settings["model_import_settings"]["input_type"].GetString() == "use_input_model_part": mesh_solver_settings["model_import_settings"]["input_type"].SetString("use_input_model_part") else: mesh_solver_settings["model_import_settings"].AddEmptyValue("input_type").SetString("use_input_model_part") else: mesh_solver_settings.AddEmptyValue("model_import_settings").AddEmptyValue("input_type").SetString("use_input_model_part") # Check that the ALE and the fluid have the sime time scheme if fluid_solver_settings.Has("time_scheme"): fluid_time_scheme = fluid_solver_settings["time_scheme"].GetString() if mesh_solver_settings.Has("mesh_velocity_calculation"): if mesh_solver_settings["mesh_velocity_calculation"].Has("time_scheme"): if not fluid_time_scheme == mesh_solver_settings["mesh_velocity_calculation"]["time_scheme"].GetString(): err_msg = 'Fluid and mesh solver require to use the same time scheme ("time_scheme") for consistency!\n' raise Exception(err_msg) else: mesh_solver_settings["mesh_velocity_calculation"].AddValue("time_scheme", fluid_solver_settings["time_scheme"]) else: mesh_solver_settings.AddEmptyValue("mesh_velocity_calculation") mesh_solver_settings["mesh_velocity_calculation"].AddValue("time_scheme", fluid_solver_settings["time_scheme"]) # Check domain size fluid_domain_size = fluid_solver_settings["domain_size"].GetInt() if mesh_solver_settings.Has("domain_size"): if not fluid_domain_size == mesh_solver_settings["domain_size"].GetInt(): raise Exception('Fluid and mesh solver have different "domain_size"!') else: mesh_solver_settings.AddValue("domain_size", fluid_solver_settings["domain_size"]) # Ensure that the MESH_VELOCITY is computed if mesh_solver_settings.Has("calculate_mesh_velocity"): if not mesh_solver_settings["calculate_mesh_velocity"].GetBool(): mesh_solver_settings.SetValue("calculate_mesh_velocity", True) KratosMultiphysics.Logger.PrintWarning("","Mesh velocity calculation was deactivated. Switching \"calculate_mesh_velocity\" on") else: mesh_solver_settings.AddEmptyValue("calculate_mesh_velocity").SetBool(True) ## Construct the ALE mesh solver self.mesh_solver = python_solvers_wrapper_mesh_motion.CreateSolverByParameters(self.model, self.settings["mesh_solver_settings"], self.parallel_type) KratosMultiphysics.Logger.PrintInfo("PartitionedFSIBaseSolver", "ALE mesh solver construction finished.")