def __init__(self, model, parameters): super(FluidDynamicsAnalysis, self).__init__(model, parameters) self.echo_level = self.project_parameters["problem_data"][ "echo_level"].GetInt() self.parallel_type = self.project_parameters["problem_data"][ "parallel_type"].GetString() # If this is an MPI run, load the distributed memory modules if (self.parallel_type == "MPI"): from KratosMultiphysics.mpi import mpi import KratosMultiphysics.MetisApplication import KratosMultiphysics.TrilinosApplication self.is_printing_rank = (mpi.rank == 0) else: self.is_printing_rank = True ## Create model part and solver (but don't initialize them yet) model_part_name = self.project_parameters["problem_data"][ "model_part_name"].GetString() self.main_model_part = Kratos.ModelPart(model_part_name) import python_solvers_wrapper_fluid self.solver = python_solvers_wrapper_fluid.CreateSolver( self.main_model_part, self.project_parameters)
def setUpProblem(self): with WorkFolderScope(self.work_folder): with open(self.settings, 'r') as parameter_file: self.ProjectParameters = KratosMultiphysics.Parameters(parameter_file.read()) self.model = KratosMultiphysics.Model() ## Solver construction import python_solvers_wrapper_fluid self.solver = python_solvers_wrapper_fluid.CreateSolver(self.model, self.ProjectParameters) self.solver.AddVariables() ## Read the model - note that SetBufferSize is done here self.solver.ImportModelPart() self.solver.PrepareModelPart() ## Add AddDofs self.solver.AddDofs() ## Solver initialization self.solver.Initialize() ## Processes construction import process_factory self.list_of_processes = process_factory.KratosProcessFactory(self.model).ConstructListOfProcesses( self.ProjectParameters["gravity"] ) self.list_of_processes += process_factory.KratosProcessFactory(self.model).ConstructListOfProcesses( self.ProjectParameters["boundary_conditions_process_list"] ) ## Processes initialization for process in self.list_of_processes: process.ExecuteInitialize() self.main_model_part = self.model.GetModelPart(self.ProjectParameters["problem_data"]["model_part_name"].GetString())
def SetUpModel(self): '''Initialize the model part for the problem and other general model data.''' model_part_name = self.project_parameters["problem_data"][ "model_part_name"].GetString() self.main_model_part = Kratos.ModelPart(model_part_name) domain_size = self.project_parameters["problem_data"][ "domain_size"].GetInt() self.main_model_part.ProcessInfo.SetValue(Kratos.DOMAIN_SIZE, domain_size) ## Solver construction import python_solvers_wrapper_fluid self.solver = python_solvers_wrapper_fluid.CreateSolver( self.main_model_part, self.project_parameters) self._SetUpRestart() if self.load_restart: self.restart_utility.LoadRestart() else: self.solver.AddVariables() self.solver.ImportModelPart() self.solver.AddDofs() # Fill a Model instance using input self.model = Kratos.Model() self.model.AddModelPart(self.main_model_part)
def SetFluidProblem(self): ## Set the current mesh case problem info if (self.problem_type == "analytical_solution"): self.ProjectParameters["problem_data"]["problem_name"].SetString( self.input_file_name + "_manufactured") else: self.ProjectParameters["problem_data"]["problem_name"].SetString( self.input_file_name) self.ProjectParameters["solver_settings"]["model_import_settings"][ "input_filename"].SetString(self.input_file_name) ## Solver construction import python_solvers_wrapper_fluid self.solver = python_solvers_wrapper_fluid.CreateSolver( self.model, self.ProjectParameters) self.solver.AddVariables() ## Read the model - note that SetBufferSize is done here self.solver.ImportModelPart() self.solver.PrepareModelPart() self.main_model_part = self.model.GetModelPart( self.ProjectParameters["problem_data"] ["model_part_name"].GetString()) ## Add AddDofs self.solver.AddDofs() ## Initialize GiD I/O if (self.print_output): from gid_output_process import GiDOutputProcess self.gid_output = GiDOutputProcess( self.solver.GetComputingModelPart(), self.ProjectParameters["problem_data"] ["problem_name"].GetString(), self.ProjectParameters["output_configuration"]) self.gid_output.ExecuteInitialize() ## Solver initialization self.solver.Initialize() ## Compute and set the nodal area self.SetNodalArea() ## Set the distance to 1 to have full fluid elements if (self.ProjectParameters["solver_settings"] ["solver_type"].GetString() == "Embedded"): for node in self.main_model_part.Nodes: node.SetSolutionStepValue(KratosMultiphysics.DISTANCE, 0, 1.0) ## Fix the pressure in one node (bottom left corner) for node in self.main_model_part.Nodes: if ((node.X < 0.001) and (node.Y < 0.001)): node.Fix(KratosMultiphysics.PRESSURE) node.SetSolutionStepValue(KratosMultiphysics.PRESSURE, 0, 0.0)
def __init__(self, ProjectParameters): self.ProjectParameters = ProjectParameters self.main_model_part = KratosMultiphysics.ModelPart(ProjectParameters["problem_data"]["model_part_name"].GetString()) self.main_model_part.ProcessInfo.SetValue(KratosMultiphysics.DOMAIN_SIZE, ProjectParameters["problem_data"]["domain_size"].GetInt()) Model = {ProjectParameters["problem_data"]["model_part_name"].GetString() : self.main_model_part} ## Solver construction import python_solvers_wrapper_fluid self.solver = python_solvers_wrapper_fluid.CreateSolver(self.main_model_part, ProjectParameters) self.solver.AddVariables() ## Read the model - note that SetBufferSize is done here self.solver.ImportModelPart() ## Add AddDofs self.solver.AddDofs() ## Initialize GiD I/O self.output_flag = False if (self.output_flag == True): from gid_output_process import GiDOutputProcess self.gid_output = GiDOutputProcess(self.solver.GetComputingModelPart(), ProjectParameters["problem_data"]["problem_name"].GetString() , ProjectParameters["output_configuration"]) self.gid_output.ExecuteInitialize() ## Solver initialization self.solver.Initialize() ## Get the list of the skin submodel parts in the object Model for i in range(ProjectParameters["solver_settings"]["skin_parts"].size()): skin_part_name = ProjectParameters["solver_settings"]["skin_parts"][i].GetString() Model.update({skin_part_name: self.main_model_part.GetSubModelPart(skin_part_name)}) ## Get the gravity submodel part in the object Model for i in range(ProjectParameters["gravity"].size()): gravity_part_name = ProjectParameters["gravity"][i]["Parameters"]["model_part_name"].GetString() Model.update({gravity_part_name: self.main_model_part.GetSubModelPart(gravity_part_name)}) ## Processes construction import process_factory self.list_of_processes = process_factory.KratosProcessFactory(Model).ConstructListOfProcesses( ProjectParameters["gravity"] ) self.list_of_processes += process_factory.KratosProcessFactory(Model).ConstructListOfProcesses( ProjectParameters["boundary_conditions_process_list"] ) ## Processes initialization for process in self.list_of_processes: process.ExecuteInitialize()
def setUpProblem(self): with UnitTest.WorkFolderScope(self.work_folder, __file__): with open(self.settings, 'r') as parameter_file: self.ProjectParameters = KratosMultiphysics.Parameters( parameter_file.read()) self.model = KratosMultiphysics.Model() ## Solver construction import python_solvers_wrapper_fluid self.solver = python_solvers_wrapper_fluid.CreateSolver( self.model, self.ProjectParameters) ## Set the "is_slip" field in the json settings (to avoid duplication it is set to false in all tests) if self.slip_flag and self.solver.settings["formulation"].Has( "is_slip"): self.ProjectParameters["solver_settings"]["is_slip"].SetBool( True) self.solver.AddVariables() ## Read the model - note that SetBufferSize is done here self.solver.ImportModelPart() self.solver.PrepareModelPart() ## Add AddDofs self.solver.AddDofs() ## Solver initialization self.solver.Initialize() ## Processes construction import process_factory self.list_of_processes = process_factory.KratosProcessFactory( self.model).ConstructListOfProcesses( self.ProjectParameters["processes"]["gravity"]) self.list_of_processes += process_factory.KratosProcessFactory( self.model).ConstructListOfProcesses( self.ProjectParameters["processes"] ["boundary_conditions_process_list"]) ## Processes initialization for process in self.list_of_processes: process.ExecuteInitialize() self.main_model_part = self.model.GetModelPart( self.ProjectParameters["problem_data"] ["model_part_name"].GetString())
def setUpProblem(self): with WorkFolderScope(self.work_folder): with open(self.settings, 'r') as parameter_file: self.ProjectParameters = KratosMultiphysics.Parameters(parameter_file.read()) self.main_model_part = KratosMultiphysics.ModelPart(self.ProjectParameters["problem_data"]["model_part_name"].GetString()) self.main_model_part.ProcessInfo.SetValue(KratosMultiphysics.DOMAIN_SIZE, self.ProjectParameters["problem_data"]["domain_size"].GetInt()) Model = {self.ProjectParameters["problem_data"]["model_part_name"].GetString() : self.main_model_part} ## Solver construction import python_solvers_wrapper_fluid self.solver = python_solvers_wrapper_fluid.CreateSolver(self.main_model_part, self.ProjectParameters) self.solver.AddVariables() ## Read the model - note that SetBufferSize is done here self.solver.ImportModelPart() ## Add AddDofs self.solver.AddDofs() ## Solver initialization self.solver.Initialize() ## Get the list of the skin submodel parts in the object Model for i in range(self.ProjectParameters["solver_settings"]["skin_parts"].size()): skin_part_name = self.ProjectParameters["solver_settings"]["skin_parts"][i].GetString() Model.update({skin_part_name: self.main_model_part.GetSubModelPart(skin_part_name)}) ## Get the gravity submodel part in the object Model for i in range(self.ProjectParameters["gravity"].size()): gravity_part_name = self.ProjectParameters["gravity"][i]["Parameters"]["model_part_name"].GetString() Model.update({gravity_part_name: self.main_model_part.GetSubModelPart(gravity_part_name)}) ## Processes construction import process_factory self.list_of_processes = process_factory.KratosProcessFactory(Model).ConstructListOfProcesses( self.ProjectParameters["gravity"] ) self.list_of_processes += process_factory.KratosProcessFactory(Model).ConstructListOfProcesses( self.ProjectParameters["boundary_conditions_process_list"] ) ## Processes initialization for process in self.list_of_processes: process.ExecuteInitialize()
## Fluid model part definition main_model_part = ModelPart( ProjectParameters["problem_data"]["model_part_name"].GetString()) main_model_part.ProcessInfo.SetValue( DOMAIN_SIZE, ProjectParameters["problem_data"]["domain_size"].GetInt()) ###TODO replace this "model" for real one once available Model = { ProjectParameters["problem_data"]["model_part_name"].GetString(): main_model_part } ## Solver construction import python_solvers_wrapper_fluid solver = python_solvers_wrapper_fluid.CreateSolver(main_model_part, ProjectParameters) solver.AddVariables() ## Read the model - note that SetBufferSize is done here solver.ImportModelPart() ## Add AddDofs solver.AddDofs() ## Initialize GiD I/O if (parallel_type == "OpenMP"): from gid_output_process import GiDOutputProcess gid_output = GiDOutputProcess( solver.GetComputingModelPart(), ProjectParameters["problem_data"]["problem_name"].GetString(),
def __init__(self, structure_main_model_part, fluid_main_model_part, project_parameters): print("** Calling the partitioned FSI base solver constructor...") # Initial tests start_time_structure = project_parameters["structure_solver_settings"]["problem_data"]["start_time"].GetDouble() start_time_fluid = project_parameters["fluid_solver_settings"]["problem_data"]["start_time"].GetDouble() end_time_structure = project_parameters["structure_solver_settings"]["problem_data"]["end_time"].GetDouble() end_time_fluid = project_parameters["fluid_solver_settings"]["problem_data"]["end_time"].GetDouble() if start_time_structure != start_time_fluid: raise("ERROR: Different initial time among subdomains!") if end_time_structure != end_time_fluid: raise("ERROR: Different final time among subdomains!") #TODO: shall obtain the compute_model_part from the MODEL once the object is implemented self.structure_main_model_part = structure_main_model_part self.fluid_main_model_part = fluid_main_model_part # Settings string in JSON format default_settings = KratosMultiphysics.Parameters(""" { "structure_solver_settings": { "solver_type": "structural_mechanics_implicit_dynamic_solver", "model_import_settings": { "input_type": "mdpa", "input_filename": "unknown_name" }, "material_import_settings" :{ "materials_filename": "materials.json" }, "echo_level": 0, "time_integration_method": "Implicit", "analysis_type": "nonlinear", "rotation_dofs": false, "pressure_dofs": false, "stabilization_factor": 1.0, "reform_dofs_at_each_step": false, "line_search": false, "compute_reactions": true, "compute_contact_forces": false, "block_builder": false, "move_mesh_flag": true, "solution_type": "Dynamic", "scheme_type": "Newmark", "convergence_criterion": "Residual_criteria", "displacement_relative_tolerance" : 1.0e-3, "displacement_absolute_tolerance" : 1.0e-5, "residual_relative_tolerance" : 1.0e-3, "residual_absolute_tolerance" : 1.0e-5, "max_iteration": 10, "linear_solver_settings":{ "solver_type" : "SuperLUSolver", "max_iteration" : 200, "tolerance" : 1e-7, "scaling" : false, "verbosity" : 1 }, "processes_sub_model_part_list": [""], "problem_domain_sub_model_part_list": ["solid_model_part"] }, "fluid_solver_settings": { "solver_type": "navier_stokes_solver_vmsmonolithic", "model_import_settings": { "input_type": "mdpa", "input_filename": "unknown_name" }, "maximum_iterations": 10, "dynamic_tau" : 0.0, "oss_switch" : 0, "echo_level" : 0, "consider_periodic_conditions" : false, "compute_reactions" : true, "divergence_clearance_steps" : 0, "reform_dofs_at_each_step" : true, "relative_velocity_tolerance" : 1e-3, "absolute_velocity_tolerance" : 1e-5, "relative_pressure_tolerance" : 1e-3, "absolute_pressure_tolerance" : 1e-5, "linear_solver_settings" : { "solver_type" : "AMGCL", "max_iteration" : 200, "tolerance" : 1e-9, "provide_coordinates" : true, "smoother_type" : "ilu0", "krylov_type" : "gmres", "coarsening_type" : "aggregation", "scaling" : true, "verbosity" : 0 }, "volume_model_part_name" : "volume_model_part", "skin_parts" : [""], "no_skin_parts" : [""], "time_stepping" : { "automatic_time_step" : false, "time_step" : 0.1 }, "alpha" :-0.3, "move_mesh_strategy" : 0, "periodic" : "periodic", "move_mesh_flag" : false, "turbulence_model" : "None" }, "coupling_solver_settings": { "coupling_scheme" : "DirichletNeumann", "solver_type" : "partitioned_fsi_solver", "nl_tol" : 1e-5, "nl_max_it" : 50, "solve_mesh_at_each_iteration" : true, "coupling_strategy" : { "solver_type" : "Relaxation", "acceleration_type" : "Aitken", "w_0" : 0.825 }, "mesh_solver" : "mesh_solver_structural_similarity", "mesh_reform_dofs_each_step" : false, "structure_interfaces_list" : [""], "fluid_interfaces_list" : [""] }, "mapper_settings" : [{ "mapper_face" : "Unique", "positive_fluid_interface_submodelpart_name" : "Default_interface_submodelpart_name", "structure_interface_submodelpart_name" : "Default_interface_submodelpart_name" }] } """) # Time stepping checks (no sub-stepping between subdomains has been implemented yed) time_step_structure = project_parameters["structure_solver_settings"]["problem_data"]["time_step"].GetDouble() # If automatic time stepping has been selected in the fluid domain, deactivate it and use the structure time step if (project_parameters["fluid_solver_settings"]["solver_settings"]["time_stepping"]["automatic_time_step"].GetBool()): project_parameters["fluid_solver_settings"]["solver_settings"]["time_stepping"]["automatic_time_step"].SetBool(False) time_step_fluid = time_step_structure print("WARNING: Automatic fluid time stepping cannot be used. Setting structure time step as fluid time step.") else: time_step_fluid = project_parameters["fluid_solver_settings"]["solver_settings"]["time_stepping"]["time_step"].GetDouble() if time_step_structure != time_step_fluid: raise("ERROR: Different time step among subdomains! No sub-stepping implemented yet.") self.time_step = time_step_fluid # Take the each one of the solvers settings from the ProjectParameters self.settings = KratosMultiphysics.Parameters("{}") self.settings.AddValue("structure_solver_settings",project_parameters["structure_solver_settings"]["solver_settings"]) self.settings.AddValue("fluid_solver_settings",project_parameters["fluid_solver_settings"]["solver_settings"]) self.settings.AddValue("coupling_solver_settings",project_parameters["coupling_solver_settings"]["solver_settings"]) self.settings.AddValue("mapper_settings",project_parameters["coupling_solver_settings"]["mapper_settings"]) # Overwrite the default settings with user-provided parameters self.settings.RecursivelyValidateAndAssignDefaults(default_settings) # Auxiliar variables self.max_nl_it = self.settings["coupling_solver_settings"]["nl_max_it"].GetInt() self.nl_tol = self.settings["coupling_solver_settings"]["nl_tol"].GetDouble() self.solve_mesh_at_each_iteration = self.settings["coupling_solver_settings"]["solve_mesh_at_each_iteration"].GetBool() self.coupling_algorithm = self.settings["coupling_solver_settings"]["coupling_scheme"].GetString() self.fluid_interface_submodelpart_name = self.settings["coupling_solver_settings"]["fluid_interfaces_list"][0].GetString() self.structure_interface_submodelpart_name = self.settings["coupling_solver_settings"]["structure_interfaces_list"][0].GetString() coupling_utility_parameters = self.settings["coupling_solver_settings"]["coupling_strategy"] # Construct the structure solver self.structure_solver = python_solvers_wrapper_structural.CreateSolver(self.structure_main_model_part, project_parameters["structure_solver_settings"]) print("* Structure solver constructed.") # Construct the fluid solver self.fluid_solver = python_solvers_wrapper_fluid.CreateSolver(self.fluid_main_model_part, project_parameters["fluid_solver_settings"]) print("* Fluid solver constructed.") # Construct the coupling partitioned strategy import convergence_accelerator_factory self.coupling_utility = convergence_accelerator_factory.CreateConvergenceAccelerator(coupling_utility_parameters) print("* Coupling strategy constructed.") # Construct the ALE mesh solver mesh_solver_settings = KratosMultiphysics.Parameters("{}") mesh_solver_settings.AddValue("mesh_reform_dofs_each_step",self.settings["coupling_solver_settings"]["mesh_reform_dofs_each_step"]) self.mesh_solver_module = __import__(self.settings["coupling_solver_settings"]["mesh_solver"].GetString()) self.mesh_solver = self.mesh_solver_module.CreateSolver(self.fluid_solver.main_model_part, mesh_solver_settings) print("* ALE mesh solver constructed.") print("** Partitioned FSI base solver constructed.")
def __init__(self, ProjectParameters): self.ProjectParameters = ProjectParameters self.main_model_part = KratosMultiphysics.ModelPart( self.ProjectParameters["problem_data"] ["model_part_name"].GetString()) self.main_model_part.ProcessInfo.SetValue( KratosMultiphysics.DOMAIN_SIZE, self.ProjectParameters["problem_data"]["domain_size"].GetInt()) self.Model = { self.ProjectParameters["problem_data"]["model_part_name"].GetString( ): self.main_model_part } self.problem_type = self.ProjectParameters["problem_data"][ "problem_type"].GetString() self.solve_problem = self.ProjectParameters["problem_data"][ "solve_problem"].GetBool() if (self.problem_type == "fluid" and missing_external_fluid_dependencies == False): ## Solver construction import python_solvers_wrapper_fluid as fluid_wrapper self.solver = fluid_wrapper.CreateSolver(self.main_model_part, self.ProjectParameters) elif (self.problem_type == "solid" and missing_external_solid_dependencies == False): # Construct the solver (main setting methods are located in the solver_module) solver_module = __import__( self.ProjectParameters["solver_settings"] ["solver_type"].GetString()) self.solver = solver_module.CreateSolver( self.main_model_part, self.ProjectParameters["solver_settings"]) else: raise NameError( 'Problem type not defined or failing in the import') # Add variables (always before importing the model part) (it must be integrated in the ImportModelPart) # If we integrate it in the model part we cannot use combined solvers self.solver.AddVariables() self.main_model_part.AddNodalSolutionStepVariable( KratosMultiphysics.NODAL_H) self.main_model_part.AddNodalSolutionStepVariable( KratosMultiphysics.NODAL_AREA) # Read model_part (note: the buffer_size is set here) (restart can be read here) self.solver.ImportModelPart() # Add dofs (always after importing the model part) (it must be integrated in the ImportModelPart) # If we integrate it in the model part we cannot use combined solvers self.solver.AddDofs() # ### Output settings start #### self.problem_path = os.getcwd() self.problem_name = self.ProjectParameters["problem_data"][ "problem_name"].GetString() # ### Output settings start #### self.output_post = ProjectParameters.Has("output_configuration") if (self.output_post == True): from gid_output_process import GiDOutputProcess output_settings = ProjectParameters["output_configuration"] self.gid_output = GiDOutputProcess( self.solver.GetComputingModelPart(), self.problem_name, output_settings) self.gid_output.ExecuteInitialize() # Sets strategies, builders, linear solvers, schemes and solving info, and fills the buffer self.solver.Initialize() self.solver.SetEchoLevel(0) # Avoid to print anything if self.problem_type == "fluid": # Build sub_model_parts or submeshes (rearrange parts for the application of custom processes) # #Get the list of the submodel part in the object Model for i in range(self.ProjectParameters["solver_settings"] ["skin_parts"].size()): skin_part_name = self.ProjectParameters["solver_settings"][ "skin_parts"][i].GetString() self.Model.update({ skin_part_name: self.main_model_part.GetSubModelPart(skin_part_name) }) ## Get the list of the initial conditions submodel parts in the object Model for i in range( self.ProjectParameters["initial_conditions_process_list"]. size()): initial_cond_part_name = self.ProjectParameters[ "initial_conditions_process_list"][i]["Parameters"][ "model_part_name"].GetString() self.Model.update({ initial_cond_part_name: self.main_model_part.GetSubModelPart( initial_cond_part_name) }) ## Get the gravity submodel part in the object Model for i in range(self.ProjectParameters["gravity"].size()): gravity_part_name = self.ProjectParameters["gravity"][i][ "Parameters"]["model_part_name"].GetString() self.Model.update({ gravity_part_name: self.main_model_part.GetSubModelPart(gravity_part_name) }) elif self.problem_type == "solid": # Build sub_model_parts or submeshes (rearrange parts for the application of custom processes) # #Get the list of the submodel part in the object Model for i in range(self.ProjectParameters["solver_settings"] ["processes_sub_model_part_list"].size()): part_name = self.ProjectParameters["solver_settings"][ "processes_sub_model_part_list"][i].GetString() self.Model.update({ part_name: self.main_model_part.GetSubModelPart(part_name) }) ## Remeshing processes construction if (self.ProjectParameters.Has("initial_remeshing_process") == True): remeshing_processes = process_factory.KratosProcessFactory( self.Model).ConstructListOfProcesses( self.ProjectParameters["initial_remeshing_process"]) if (ProjectParameters.Has("list_other_processes") == True): remeshing_processes += process_factory.KratosProcessFactory( self.Model).ConstructListOfProcesses( self.ProjectParameters["list_other_processes"]) ## Remeshing processes initialization print("STARTING ADAPTATIVE LOOP") if (self.ProjectParameters.Has("adaptative_loop") == True): adaptative_loop = ProjectParameters["adaptative_loop"].GetInt() else: adaptative_loop = 1 for n in range(adaptative_loop): print("ADAPTATIVE INTERATION: ", n + 1) for process in reversed(remeshing_processes): process.ExecuteInitialize() # Obtain the list of the processes to be applied if self.problem_type == "fluid": self.list_of_processes = process_factory.KratosProcessFactory( self.Model).ConstructListOfProcesses( self.ProjectParameters["gravity"]) self.list_of_processes += process_factory.KratosProcessFactory( self.Model).ConstructListOfProcesses( self.ProjectParameters["initial_conditions_process_list"]) self.list_of_processes += process_factory.KratosProcessFactory( self.Model).ConstructListOfProcesses( self.ProjectParameters["boundary_conditions_process_list"]) elif self.problem_type == "solid": self.list_of_processes = process_factory.KratosProcessFactory( self.Model).ConstructListOfProcesses( self.ProjectParameters["constraints_process_list"]) self.list_of_processes += process_factory.KratosProcessFactory( self.Model).ConstructListOfProcesses( self.ProjectParameters["loads_process_list"]) if (self.ProjectParameters.Has("list_other_processes") == True): self.list_of_processes += process_factory.KratosProcessFactory( self.Model).ConstructListOfProcesses( self.ProjectParameters["list_other_processes"]) if (self.ProjectParameters.Has("json_check_process") == True): self.list_of_processes += process_factory.KratosProcessFactory( self.Model).ConstructListOfProcesses( self.ProjectParameters["json_check_process"]) if (self.ProjectParameters.Has("json_output_process") == True): self.list_of_processes += process_factory.KratosProcessFactory( self.Model).ConstructListOfProcesses( self.ProjectParameters["json_output_process"]) if (self.ProjectParameters.Has("compare_two_files_check_process") == True): self.list_of_processes += process_factory.KratosProcessFactory( self.Model).ConstructListOfProcesses( self.ProjectParameters["compare_two_files_check_process"]) if (self.ProjectParameters.Has("recursive_remeshing_process") == True): self.list_of_processes += process_factory.KratosProcessFactory( self.Model).ConstructListOfProcesses( self.ProjectParameters["recursive_remeshing_process"]) for process in self.list_of_processes: process.ExecuteInitialize() # ### START SOLUTION #### self.computing_model_part = self.solver.GetComputingModelPart() if (self.output_post == True): self.gid_output.ExecuteBeforeSolutionLoop()
def SetFluidProblem(self): ## Set the current mesh case problem info if (self.problem_type == "analytical_solution"): self.ProjectParameters["problem_data"]["problem_name"].SetString(self.input_file_name+"_manufactured") else: self.ProjectParameters["problem_data"]["problem_name"].SetString(self.input_file_name) self.ProjectParameters["solver_settings"]["model_import_settings"]["input_filename"].SetString(self.input_file_name) ## Fluid model part definition self.main_model_part = KratosMultiphysics.ModelPart(self.ProjectParameters["problem_data"]["model_part_name"].GetString()) self.main_model_part.ProcessInfo.SetValue(KratosMultiphysics.DOMAIN_SIZE, self.ProjectParameters["problem_data"]["domain_size"].GetInt()) ###TODO replace this "model" for real one once available Model = {self.ProjectParameters["problem_data"]["model_part_name"].GetString() : self.main_model_part} ## Solver construction import python_solvers_wrapper_fluid self.solver = python_solvers_wrapper_fluid.CreateSolver(self.main_model_part, self.ProjectParameters) self.solver.AddVariables() ## Read the model - note that SetBufferSize is done here self.solver.ImportModelPart() ## Add AddDofs self.solver.AddDofs() ## Initialize GiD I/O if (self.print_output): from gid_output_process import GiDOutputProcess self.gid_output = GiDOutputProcess(self.solver.GetComputingModelPart(), self.ProjectParameters["problem_data"]["problem_name"].GetString() , self.ProjectParameters["output_configuration"]) self.gid_output.ExecuteInitialize() ## Get the list of the skin submodel parts in the object Model for i in range(self.ProjectParameters["solver_settings"]["skin_parts"].size()): skin_part_name = self.ProjectParameters["solver_settings"]["skin_parts"][i].GetString() Model.update({skin_part_name: self.main_model_part.GetSubModelPart(skin_part_name)}) for i in range(self.ProjectParameters["solver_settings"]["no_skin_parts"].size()): no_skin_part_name = self.ProjectParameters["solver_settings"]["no_skin_parts"][i].GetString() Model.update({no_skin_part_name: self.main_model_part.GetSubModelPart(no_skin_part_name)}) ## Solver initialization self.solver.Initialize() ## Compute and set the nodal area self.SetNodalArea() ## Set the distance to 1 to have full fluid elements if (self.ProjectParameters["solver_settings"]["solver_type"].GetString() == "Embedded"): for node in self.main_model_part.Nodes: node.SetSolutionStepValue(KratosMultiphysics.DISTANCE, 0, 1.0) ## Fix the pressure in one node (bottom left corner) for node in self.main_model_part.Nodes: if ((node.X<0.001) and (node.Y<0.001)): node.Fix(KratosMultiphysics.PRESSURE) node.SetSolutionStepValue(KratosMultiphysics.PRESSURE, 0, 0.0)
def __init__(self, structure_main_model_part, fluid_main_model_part, project_parameters): print("** Calling the partitioned FSI base solver constructor...") # Initial tests start_time_structure = project_parameters["structure_solver_settings"]["problem_data"]["start_time"].GetDouble() start_time_fluid = project_parameters["fluid_solver_settings"]["problem_data"]["start_time"].GetDouble() end_time_structure = project_parameters["structure_solver_settings"]["problem_data"]["end_time"].GetDouble() end_time_fluid = project_parameters["fluid_solver_settings"]["problem_data"]["end_time"].GetDouble() if start_time_structure != start_time_fluid: raise("ERROR: Different initial time among subdomains!") if end_time_structure != end_time_fluid: raise("ERROR: Different final time among subdomains!") self.structure_main_model_part = structure_main_model_part self.fluid_main_model_part = fluid_main_model_part # Time stepping checks (no sub-stepping between subdomains has been implemented yed) time_step_structure = project_parameters["structure_solver_settings"]["problem_data"]["time_step"].GetDouble() # If automatic time stepping has been selected in the fluid domain, deactivate it and use the structure time step if (project_parameters["fluid_solver_settings"]["solver_settings"]["time_stepping"]["automatic_time_step"].GetBool()): project_parameters["fluid_solver_settings"]["solver_settings"]["time_stepping"]["automatic_time_step"].SetBool(False) time_step_fluid = time_step_structure print("WARNING: Automatic fluid time stepping cannot be used. Setting structure time step as fluid time step.") else: time_step_fluid = project_parameters["fluid_solver_settings"]["solver_settings"]["time_stepping"]["time_step"].GetDouble() if time_step_structure != time_step_fluid: raise("ERROR: Different time step among subdomains! No sub-stepping implemented yet.") self.time_step = time_step_fluid # Take the each one of the solvers settings from the ProjectParameters # Note that the defaults check will be performed inside each field solver self.settings = KratosMultiphysics.Parameters("{}") self.settings.AddValue("structure_solver_settings",project_parameters["structure_solver_settings"]["solver_settings"]) self.settings.AddValue("fluid_solver_settings",project_parameters["fluid_solver_settings"]["solver_settings"]) self.settings.AddValue("coupling_solver_settings",project_parameters["coupling_solver_settings"]["solver_settings"]) self.settings.AddValue("mapper_settings",project_parameters["coupling_solver_settings"]["mapper_settings"]) # Auxiliar variables self.max_nl_it = self.settings["coupling_solver_settings"]["nl_max_it"].GetInt() self.nl_tol = self.settings["coupling_solver_settings"]["nl_tol"].GetDouble() self.solve_mesh_at_each_iteration = self.settings["coupling_solver_settings"]["solve_mesh_at_each_iteration"].GetBool() self.coupling_algorithm = self.settings["coupling_solver_settings"]["coupling_scheme"].GetString() self.fluid_interface_submodelpart_name = self.settings["coupling_solver_settings"]["fluid_interfaces_list"][0].GetString() self.structure_interface_submodelpart_name = self.settings["coupling_solver_settings"]["structure_interfaces_list"][0].GetString() coupling_utility_parameters = self.settings["coupling_solver_settings"]["coupling_strategy"] # Construct the structure solver self.structure_solver = python_solvers_wrapper_structural.CreateSolver(self.structure_main_model_part, project_parameters["structure_solver_settings"]) print("* Structure solver constructed.") # Construct the fluid solver self.fluid_solver = python_solvers_wrapper_fluid.CreateSolver(self.fluid_main_model_part, project_parameters["fluid_solver_settings"]) print("* Fluid solver constructed.") # Construct the coupling partitioned strategy import convergence_accelerator_factory self.coupling_utility = convergence_accelerator_factory.CreateConvergenceAccelerator(coupling_utility_parameters) print("* Coupling strategy constructed.") # Construct the ALE mesh solver mesh_solver_settings = KratosMultiphysics.Parameters("{}") self.mesh_solver_module = __import__(self.settings["coupling_solver_settings"]["mesh_solver"].GetString()) self.mesh_solver = self.mesh_solver_module.CreateSolver(self.fluid_solver.main_model_part, mesh_solver_settings) print("* ALE mesh solver constructed.") print("** Partitioned FSI base solver constructed.")
def __init__(self, structure_main_model_part, fluid_main_model_part, project_parameters): if (KratosMPI.mpi.rank == 0): print( "** Calling the partitioned FSI Trilinos base solver constructor..." ) # Initial tests start_time_structure = project_parameters["structure_solver_settings"][ "problem_data"]["start_time"].GetDouble() start_time_fluid = project_parameters["fluid_solver_settings"][ "problem_data"]["start_time"].GetDouble() end_time_structure = project_parameters["structure_solver_settings"][ "problem_data"]["end_time"].GetDouble() end_time_fluid = project_parameters["fluid_solver_settings"][ "problem_data"]["end_time"].GetDouble() if start_time_structure != start_time_fluid: if (KratosMPI.mpi.rank == 0): raise ("ERROR: Different initial time among subdomains!") if end_time_structure != end_time_fluid: if (KratosMPI.mpi.rank == 0): raise ("ERROR: Different final time among subdomains!") self.structure_main_model_part = structure_main_model_part self.fluid_main_model_part = fluid_main_model_part # Time stepping checks (no sub-stepping between subdomains has been implemented yed) time_step_structure = project_parameters["structure_solver_settings"][ "problem_data"]["time_step"].GetDouble() # If automatic time stepping has been selected in the fluid domain, deactivate it and use the structure time step if (project_parameters["fluid_solver_settings"]["solver_settings"] ["time_stepping"]["automatic_time_step"].GetBool()): project_parameters["fluid_solver_settings"]["solver_settings"][ "time_stepping"]["automatic_time_step"].SetBool(False) time_step_fluid = time_step_structure if (KratosMPI.mpi.rank == 0): print( "WARNING: Automatic fluid time stepping cannot be used. Setting structure time step as fluid time step." ) else: time_step_fluid = project_parameters["fluid_solver_settings"][ "solver_settings"]["time_stepping"]["time_step"].GetDouble() if time_step_structure != time_step_fluid: if (KratosMPI.mpi.rank == 0): raise ( "ERROR: Different time step among subdomains! No sub-stepping implemented yet." ) self.time_step = time_step_fluid # Take the each one of the solvers settings from the ProjectParameters # Note that the defaults check will be performed inside each field solver self.settings = KratosMultiphysics.Parameters("{}") self.settings.AddValue( "structure_solver_settings", project_parameters["structure_solver_settings"]["solver_settings"]) self.settings.AddValue( "fluid_solver_settings", project_parameters["fluid_solver_settings"]["solver_settings"]) self.settings.AddValue( "coupling_solver_settings", project_parameters["coupling_solver_settings"]["solver_settings"]) self.settings.AddValue( "mapper_settings", project_parameters["coupling_solver_settings"]["mapper_settings"]) # Auxiliar variables self.max_nl_it = self.settings["coupling_solver_settings"][ "nl_max_it"].GetInt() self.nl_tol = self.settings["coupling_solver_settings"][ "nl_tol"].GetDouble() self.solve_mesh_at_each_iteration = self.settings[ "coupling_solver_settings"][ "solve_mesh_at_each_iteration"].GetBool() self.coupling_algorithm = self.settings["coupling_solver_settings"][ "coupling_scheme"].GetString() self.fluid_interface_submodelpart_name = self.settings[ "coupling_solver_settings"]["fluid_interfaces_list"][0].GetString( ) self.structure_interface_submodelpart_name = self.settings[ "coupling_solver_settings"]["structure_interfaces_list"][ 0].GetString() # Construct the structure solver self.structure_model = KratosMultiphysics.Model() structural_solver_settings = project_parameters[ "structure_solver_settings"]["solver_settings"] if not structural_solver_settings.Has("time_stepping"): KratosMultiphysics.Logger.PrintInfo( "TrilinosPartitionedFSIBaseSolver", "Using the old way to pass the time_step, this will be removed!" ) time_stepping_params = KratosMultiphysics.Parameters("{}") time_stepping_params.AddValue( "time_step", project_parameters["problem_data"]["time_step"]) solver_settings.AddValue("time_stepping", time_stepping_params) if not structural_solver_settings.Has("domain_size"): KratosMultiphysics.Logger.PrintInfo( "TrilinosPartitionedFSIBaseSolver", "Using the old way to pass the domain_size, this will be removed!" ) structural_solver_settings.AddEmptyValue("domain_size") structural_solver_settings["domain_size"].SetInt( project_parameters["structure_solver_settings"]["problem_data"] ["domain_size"].GetInt()) if not structural_solver_settings.Has("model_part_name"): KratosMultiphysics.Logger.PrintInfo( "TrilinosPartitionedFSIBaseSolver", "Using the old way to pass the model_part_name, this will be removed!" ) structural_solver_settings.AddEmptyValue("model_part_name") structural_solver_settings["model_part_name"].SetString( project_parameters["structure_solver_settings"]["problem_data"] ["model_part_name"].GetString()) self.structure_solver = python_solvers_wrapper_structural.CreateSolver( self.structure_model, project_parameters["structure_solver_settings"]) if (KratosMPI.mpi.rank == 0): print("* Structure solver constructed.") # Construct the fluid solver self.fluid_solver = python_solvers_wrapper_fluid.CreateSolver( self.fluid_main_model_part, project_parameters["fluid_solver_settings"]) if (KratosMPI.mpi.rank == 0): print("* Fluid solver constructed.") # Construct the ALE mesh solver mesh_solver_settings = KratosMultiphysics.Parameters("{}") self.mesh_solver_module = __import__( self.settings["coupling_solver_settings"] ["mesh_solver"].GetString()) self.mesh_solver = self.mesh_solver_module.CreateSolver( self.fluid_solver.main_model_part, mesh_solver_settings) if (KratosMPI.mpi.rank == 0): print("* ALE mesh solver constructed.") print("** Partitioned FSI base solver constructed.")
ProjectParameters["problem_data"]["model_part_name"].GetString()) main_model_part.ProcessInfo.SetValue( DOMAIN_SIZE, ProjectParameters["problem_data"]["domain_size"].GetInt()) Model = { ProjectParameters["problem_data"]["model_part_name"].GetString(): main_model_part } problem_type = ProjectParameters["problem_data"]["problem_type"].GetString() solve_problem = ProjectParameters["problem_data"]["solve_problem"].GetBool() ## Solver construction import python_solvers_wrapper_fluid as fluid_wrapper solver = fluid_wrapper.CreateSolver(main_model_part, ProjectParameters) # Add variables (always before importing the model part) (it must be integrated in the ImportModelPart) # If we integrate it in the model part we cannot use combined solvers solver.AddVariables() main_model_part.AddNodalSolutionStepVariable(NODAL_H) main_model_part.AddNodalSolutionStepVariable(NODAL_AREA) # Read model_part (note: the buffer_size is set here) (restart can be read here) solver.ImportModelPart() # Add dofs (always after importing the model part) (it must be integrated in the ImportModelPart) # If we integrate it in the model part we cannot use combined solvers solver.AddDofs()
def _CreateSolver(self): import python_solvers_wrapper_fluid return python_solvers_wrapper_fluid.CreateSolver(self.model, self.project_parameters)
def __init__(self, model, project_parameters): super(PartitionedFSIBaseSolver,self).__init__(model, project_parameters) # Initial tests start_time_structure = self.settings["structure_solver_settings"]["problem_data"]["start_time"].GetDouble() start_time_fluid = self.settings["fluid_solver_settings"]["problem_data"]["start_time"].GetDouble() end_time_structure = self.settings["structure_solver_settings"]["problem_data"]["end_time"].GetDouble() end_time_fluid = self.settings["fluid_solver_settings"]["problem_data"]["end_time"].GetDouble() if start_time_structure != start_time_fluid: raise Exception('Different initial time among subdomains.') if end_time_structure != end_time_fluid: raise Exception('Different final time among subdomains.') solver_settings = self.settings["fluid_solver_settings"]["solver_settings"] problem_data = self.settings["fluid_solver_settings"]["problem_data"] if solver_settings.Has("model_part_name"): self.fluid_model_part_name = solver_settings["model_part_name"].GetString() elif problem_data.Has("model_part_name"): self.fluid_model_part_name = problem_data["model_part_name"].GetString() # Backwards compatibility: copy the name to the solver section so that the fluid solver can read it solver_settings.AddEmptyValue("model_part_name") solver_settings["model_part_name"].SetString(self.fluid_model_part_name) # Backwards compatibility: copy the domain size to the solver section if not solver_settings.Has("domain_size"): solver_settings.AddEmptyValue("domain_size") solver_settings["domain_size"].SetInt(problem_data["domain_size"].GetInt()) # Time stepping checks (no sub-stepping between subdomains has been implemented yed) time_step_structure = self.settings["structure_solver_settings"]["problem_data"]["time_step"].GetDouble() # If automatic time stepping has been selected in the fluid domain, deactivate it and use the structure time step if (self.settings["fluid_solver_settings"]["solver_settings"]["time_stepping"]["automatic_time_step"].GetBool()): self.settings["fluid_solver_settings"]["solver_settings"]["time_stepping"]["automatic_time_step"].SetBool(False) time_step_fluid = time_step_structure self._PrintWarningOnRankZero("::[PartitionedFSIBaseSolver]::", "Automatic fluid time stepping cannot be used. Setting structure time step as fluid time step.") else: time_step_fluid = self.settings["fluid_solver_settings"]["solver_settings"]["time_stepping"]["time_step"].GetDouble() if time_step_structure != time_step_fluid: raise Exception('Different time step among subdomains! No sub-stepping implemented yet.') self.time_step = time_step_fluid # Auxiliar variables coupling_solver_settings = self.settings["coupling_solver_settings"]["solver_settings"] self.max_nl_it = coupling_solver_settings["nl_max_it"].GetInt() self.nl_tol = coupling_solver_settings["nl_tol"].GetDouble() self.solve_mesh_at_each_iteration = coupling_solver_settings["solve_mesh_at_each_iteration"].GetBool() self.coupling_algorithm = coupling_solver_settings["coupling_scheme"].GetString() self.fluid_interface_submodelpart_name = coupling_solver_settings["fluid_interfaces_list"][0].GetString() self.structure_interface_submodelpart_name = coupling_solver_settings["structure_interfaces_list"][0].GetString() coupling_utility_parameters = coupling_solver_settings["coupling_strategy"] # Construct the structure solver structural_solver_settings = self.settings["structure_solver_settings"]["solver_settings"] if not structural_solver_settings.Has("time_stepping"): self._PrintInfoOnRankZero("::[PartitionedFSIBaseSolver]::", "Using the old way to pass the time_step, this will be removed!") time_stepping_params = KratosMultiphysics.Parameters("{}") time_stepping_params.AddValue("time_step", self.settings["structure_solver_settings"]["problem_data"]["time_step"]) structural_solver_settings.AddValue("time_stepping", time_stepping_params) if not structural_solver_settings.Has("domain_size"): self._PrintInfoOnRankZero("::[PartitionedFSIBaseSolver]::", "Using the old way to pass the domain_size, this will be removed!") structural_solver_settings.AddEmptyValue("domain_size") structural_solver_settings["domain_size"].SetInt(self.settings["structure_solver_settings"]["problem_data"]["domain_size"].GetInt()) if not structural_solver_settings.Has("model_part_name"): self._PrintInfoOnRankZero("::[PartitionedFSIBaseSolver]::", "Using the old way to pass the model_part_name, this will be removed!") structural_solver_settings.AddEmptyValue("model_part_name") structural_solver_settings["model_part_name"].SetString(self.settings["structure_solver_settings"]["problem_data"]["model_part_name"].GetString()) self.structure_solver = python_solvers_wrapper_structural.CreateSolver(self.model, self.settings["structure_solver_settings"]) self._PrintInfoOnRankZero("::[PartitionedFSIBaseSolver]::", "Structure solver construction finished.") # Construct the fluid solver self.fluid_solver = python_solvers_wrapper_fluid.CreateSolver(self.model, self.settings["fluid_solver_settings"]) self._PrintInfoOnRankZero("::[PartitionedFSIBaseSolver]::", "Fluid solver construction finished.") # Construct the coupling partitioned strategy self.coupling_utility = convergence_accelerator_factory.CreateConvergenceAccelerator(coupling_utility_parameters) self._PrintInfoOnRankZero("::[PartitionedFSIBaseSolver]::", "Coupling strategy construction finished.") # Construct the ALE mesh solver mesh_solver_settings = KratosMultiphysics.Parameters("{}") mesh_solver_settings.AddEmptyValue("problem_data") mesh_solver_settings.AddEmptyValue("solver_settings") parallel_type = KratosMultiphysics.Parameters('''{"parallel_type" : ""}''') parallel_type["parallel_type"].SetString(self.settings["fluid_solver_settings"]["problem_data"]["parallel_type"].GetString()) mesh_solver_type = KratosMultiphysics.Parameters('''{"solver_type" : ""}''') mesh_solver_type["solver_type"].SetString(self.settings["coupling_solver_settings"]["solver_settings"]["mesh_solver"].GetString()) mesh_solver_settings["problem_data"] = parallel_type mesh_solver_settings["solver_settings"] = mesh_solver_type #TODO: UPDATE TO MODEL ONCE MESH MOVING APPLICATION SUPPORTS IT self.mesh_solver = python_solvers_wrapper_mesh_motion.CreateSolver(self.fluid_solver.main_model_part, mesh_solver_settings) self._PrintInfoOnRankZero("::[PartitionedFSIBaseSolver]::", "ALE mesh solver construction finished.") self._PrintInfoOnRankZero("::[PartitionedFSIBaseSolver]::", "Partitioned FSI base solver construction finished.")