def _execute_after_reading(self):
"""Prepare computing model part and import constitutive laws. """
# Auxiliary parameters object for the CheckAndPepareModelProcess
params = KratosMultiphysics.Parameters("{}")
params.AddValue("model_part_name", self.settings["model_part_name"])
params.AddValue("computing_model_part_name",
self.settings["computing_model_part_name"])
params.AddValue("problem_domain_sub_model_part_list",
self.settings["problem_domain_sub_model_part_list"])
params.AddValue("processes_sub_model_part_list",
self.settings["processes_sub_model_part_list"])
# Assign mesh entities from domain and process sub model parts to the computing model part.
import check_and_prepare_model_process_structural
check_and_prepare_model_process_structural.CheckAndPrepareModelProcess(
self.model, params).Execute()
# Import constitutive laws.
materials_imported = self.import_constitutive_laws()
if materials_imported:
self.print_on_rank_zero(
"::[MechanicalSolver]:: ",
"Constitutive law was successfully imported.")
else:
self.print_on_rank_zero("::[MechanicalSolver]:: ",
"Constitutive law was not imported.")
def _execute_after_reading(self):
"""Prepare computing model part and import constitutive laws. """
# Auxiliary parameters object for the CheckAndPepareModelProcess
params = KratosMultiphysics.Parameters("{}")
params.AddValue("computing_model_part_name",
self.settings["computing_model_part_name"])
params.AddValue("problem_domain_sub_model_part_list",
self.settings["problem_domain_sub_model_part_list"])
params.AddValue("processes_sub_model_part_list",
self.settings["processes_sub_model_part_list"])
# Assign mesh entities from domain and process sub model parts to the computing model part.
import check_and_prepare_model_process_structural
check_and_prepare_model_process_structural.CheckAndPrepareModelProcess(
self.main_model_part, params).Execute()
# This will be removed once the Model is fully supported! => It wont e necessary anymore
# NOTE: We do this here in case the model is empty, so the properties can be assigned
if not self.model.HasModelPart(self.main_model_part.Name):
self.model.AddModelPart(self.main_model_part)
# Import constitutive laws.
materials_imported = self.import_constitutive_laws()
if materials_imported:
self.print_on_rank_zero(
"::[MechanicalSolver]:: ",
"Constitutive law was successfully imported.")
else:
self.print_on_rank_zero("::[MechanicalSolver]:: ",
"Constitutive law was not imported.")
def __init__(self, ProjectParameters):
# Json format solvers settings
ProjectParametersFluid = ProjectParameters["fluid_solver_settings"]
ProjectParametersSolid = ProjectParameters["structure_solver_settings"]
# Defining a model part for the fluid and one for the structure
self.structure_main_model_part = ModelPart("structure_part")
self.fluid_main_model_part = ModelPart("fluid_part")
# Set the domain size (2D or 3D test)
self.structure_main_model_part.ProcessInfo.SetValue(
DOMAIN_SIZE,
ProjectParametersFluid["problem_data"]["domain_size"].GetInt())
self.fluid_main_model_part.ProcessInfo.SetValue(
DOMAIN_SIZE,
ProjectParametersSolid["problem_data"]["domain_size"].GetInt())
# Set the fluid and solid models
FluidModel = {
ProjectParametersFluid["problem_data"]["model_part_name"].GetString(
):
self.structure_main_model_part
}
SolidModel = {
ProjectParametersSolid["problem_data"]["model_part_name"].GetString(
):
self.fluid_main_model_part
}
# Fluid model part variables addition
self.fluid_main_model_part.AddNodalSolutionStepVariable(VELOCITY)
self.fluid_main_model_part.AddNodalSolutionStepVariable(PRESSURE)
self.fluid_main_model_part.AddNodalSolutionStepVariable(REACTION)
# Structure model part variables addition
self.structure_main_model_part.AddNodalSolutionStepVariable(VELOCITY)
self.structure_main_model_part.AddNodalSolutionStepVariable(PRESSURE)
self.structure_main_model_part.AddNodalSolutionStepVariable(POINT_LOAD)
# Mapper variables addition
NonConformant_OneSideMap.AddVariables(self.fluid_main_model_part,
self.structure_main_model_part)
# Fluid domain model reading
ModelPartIO(
ProjectParametersFluid["solver_settings"]["model_import_settings"]
["input_filename"].GetString()).ReadModelPart(
self.fluid_main_model_part)
prepare_model_part_settings_fluid = Parameters("{}")
prepare_model_part_settings_fluid.AddValue(
"volume_model_part_name", ProjectParametersFluid["solver_settings"]
["volume_model_part_name"])
prepare_model_part_settings_fluid.AddValue(
"skin_parts",
ProjectParametersFluid["solver_settings"]["skin_parts"])
import check_and_prepare_model_process_fluid
check_and_prepare_model_process_fluid.CheckAndPrepareModelProcess(
self.fluid_main_model_part,
prepare_model_part_settings_fluid).Execute()
# Solid domain model reading
computing_model_part_name = "computing_domain"
ModelPartIO(
ProjectParametersSolid["solver_settings"]["model_import_settings"]
["input_filename"].GetString()).ReadModelPart(
self.structure_main_model_part)
prepare_model_part_settings_structure = Parameters("{}")
prepare_model_part_settings_structure.AddEmptyValue(
"computing_model_part_name").SetString(computing_model_part_name)
prepare_model_part_settings_structure.AddValue(
"problem_domain_sub_model_part_list",
ProjectParametersSolid["solver_settings"]
["problem_domain_sub_model_part_list"])
prepare_model_part_settings_structure.AddValue(
"processes_sub_model_part_list",
ProjectParametersSolid["solver_settings"]
["processes_sub_model_part_list"])
import check_and_prepare_model_process_structural
check_and_prepare_model_process_structural.CheckAndPrepareModelProcess(
self.structure_main_model_part,
prepare_model_part_settings_structure).Execute()
# Get the list of the skin submodel parts where the fluid interface submodel part is stored
for i in range(ProjectParametersFluid["solver_settings"]
["skin_parts"].size()):
skin_part_name = ProjectParametersFluid["solver_settings"][
"skin_parts"][i].GetString()
FluidModel.update({
skin_part_name:
self.fluid_main_model_part.GetSubModelPart(skin_part_name)
})
# Get the list of the submodel parts where the structure interface is stored
for i in range(ProjectParametersSolid["solver_settings"]
["processes_sub_model_part_list"].size()):
part_name = ProjectParametersSolid["solver_settings"][
"processes_sub_model_part_list"][i].GetString()
SolidModel.update({
part_name:
self.structure_main_model_part.GetSubModelPart(part_name)
})
# Construct processes
self.list_of_processes = process_factory.KratosProcessFactory(
FluidModel).ConstructListOfProcesses(
ProjectParametersFluid["boundary_conditions_process_list"])
self.list_of_processes += process_factory.KratosProcessFactory(
SolidModel).ConstructListOfProcesses(
ProjectParametersSolid["constraints_process_list"])
# Set fluid and structure interfaces
for node in self.fluid_main_model_part.GetSubModelPart(
"Fluid_interface").Nodes:
node.Set(INTERFACE, True)
for node in self.structure_main_model_part.GetSubModelPart(
"Structure_interface").Nodes:
node.Set(INTERFACE, True)
for process in self.list_of_processes:
process.ExecuteInitialize()
# Mapper construction
search_radius_factor = 2.0
mapper_max_iterations = 200
mapper_tolerance = 1e-12
self.mapper = NonConformant_OneSideMap.NonConformant_OneSideMap(
self.fluid_main_model_part, self.structure_main_model_part,
search_radius_factor, mapper_max_iterations, mapper_tolerance)
# Output settings
self.output_post = False # Set this variable to True if it is need to print the results for debugging purposes
self.problem_path = os.getcwd()
if (self.output_post == True):
from gid_output_process import GiDOutputProcess
self.gid_output_structure = GiDOutputProcess(
self.structure_main_model_part,
ProjectParametersSolid["problem_data"]
["problem_name"].GetString() + "_structure",
ProjectParametersSolid["output_configuration"])
self.gid_output_fluid = GiDOutputProcess(
self.fluid_main_model_part,
ProjectParametersFluid["problem_data"]
["problem_name"].GetString() + "_fluid",
ProjectParametersFluid["output_configuration"])
self.gid_output_structure.ExecuteInitialize()
self.gid_output_fluid.ExecuteInitialize()