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.")
