def _ExecuteAfterReading(self):
## Replace element and conditions
KratosMultiphysics.ReplaceElementsAndConditionsProcess(
self.main_model_part,
self.settings["element_replace_settings"]).Execute()
## Check that the input read has the shape we like
prepare_model_part_settings = KratosMultiphysics.Parameters("{}")
prepare_model_part_settings.AddValue(
"volume_model_part_name", self.settings["volume_model_part_name"])
prepare_model_part_settings.AddValue("skin_parts",
self.settings["skin_parts"])
import check_and_prepare_model_process_fluid
check_and_prepare_model_process_fluid.CheckAndPrepareModelProcess(
self.main_model_part, prepare_model_part_settings).Execute()
# Read the KINEMATIC VISCOSITY and DENSITY and we apply it to the nodes
for el in self.main_model_part.Elements:
rho = el.Properties.GetValue(KratosMultiphysics.DENSITY)
# kin_viscosity = el.Properties.GetValue(KratosMultiphysics.VISCOSITY)
break
KratosMultiphysics.VariableUtils().SetScalarVar(
KratosMultiphysics.DENSITY, rho, self.main_model_part.Nodes)
def _ExecuteCheckAndPrepare(self):
## Check that the input read has the shape we like
prepare_model_part_settings = KratosMultiphysics.Parameters("{}")
prepare_model_part_settings.AddValue("volume_model_part_name",self.settings["volume_model_part_name"])
prepare_model_part_settings.AddValue("skin_parts",self.settings["skin_parts"])
import check_and_prepare_model_process_fluid
check_and_prepare_model_process_fluid.CheckAndPrepareModelProcess(self.main_model_part, prepare_model_part_settings).Execute()
def ImportModelPart(self):
if (self.settings["model_import_settings"]["input_type"].GetString() ==
"mdpa"):
#here it would be the place to import restart data if required
kratoscore.ModelPartIO(
self.settings["model_import_settings"]
["input_filename"].GetString()).ReadModelPart(
self.main_model_part)
self.settings.AddEmptyValue("element_replace_settings")
if (self.main_model_part.ProcessInfo[
KratosMultiphysics.DOMAIN_SIZE] == 3):
self.settings[
"element_replace_settings"] = KratosMultiphysics.Parameters(
"""
{
"element_name":"StokesTwoFluid3D4N",
"condition_name": "StokesWallCondition3D"
}
""")
elif (self.main_model_part.ProcessInfo[
KratosMultiphysics.DOMAIN_SIZE] == 2):
raise Exception("sorry 2D case not implemented")
else:
raise Exception("domain size is not 2 or 3")
KratosMultiphysics.ReplaceElementsAndConditionsProcess(
self.main_model_part,
self.settings["element_replace_settings"]).Execute()
##here we shall check that the input read has the shape we like
aux_params = kratoscore.Parameters("{}")
aux_params.AddValue("volume_model_part_name",
self.settings["volume_model_part_name"])
aux_params.AddValue("skin_parts", self.settings["skin_parts"])
import check_and_prepare_model_process_fluid
check_and_prepare_model_process_fluid.CheckAndPrepareModelProcess(
self.main_model_part, aux_params).Execute()
##here we must construct correctly the constitutive law
print(
"don't forget constructing the constitutive law!!!!!!!!!!!!!!")
#if needed here we shall generate the constitutive laws
#import constitutive_law_python_utility as constitutive_law_utils
#constitutive_law = constitutive_law_utils.ConstitutiveLawUtility(main_model_part, self.settings["DomainSize"]);
#constitutive_law.Initialize();
else:
raise Exception("other input options are not yet implemented")
current_buffer_size = self.main_model_part.GetBufferSize()
if (self.GetMinimumBufferSize() > current_buffer_size):
self.main_model_part.SetBufferSize(self.GetMinimumBufferSize())
print("model reading finished")
def ImportModelPart(self):
if(self.settings["model_import_settings"]["input_type"].GetString() == "mdpa"):
# here it would be the place to import restart data if required
KratosMultiphysics.ModelPartIO(self.settings["model_import_settings"]["input_filename"].GetString()).ReadModelPart(self.main_model_part)
# here we shall check that the input read has the shape we like
aux_params = KratosMultiphysics.Parameters("{}")
aux_params.AddValue("volume_model_part_name",self.settings["volume_model_part_name"])
aux_params.AddValue("skin_parts",self.settings["skin_parts"])
# here we replace the dummy elements we read with proper elements
self.settings.AddEmptyValue("element_replace_settings")
if(self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE] == 3):
self.settings["element_replace_settings"] = KratosMultiphysics.Parameters("""
{
"element_name": "VMSAdjointElement3D",
"condition_name": "SurfaceCondition3D3N"
}
""")
elif(self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE] == 2):
self.settings["element_replace_settings"] = KratosMultiphysics.Parameters("""
{
"element_name": "VMSAdjointElement2D",
"condition_name": "LineCondition2D2N"
}
""")
else:
raise Exception("domain size is not 2 or 3")
KratosMultiphysics.ReplaceElementsAndConditionsProcess(self.main_model_part, self.settings["element_replace_settings"]).Execute()
import check_and_prepare_model_process_fluid
check_and_prepare_model_process_fluid.CheckAndPrepareModelProcess(self.main_model_part, aux_params).Execute()
#here we read the KINEMATIC VISCOSITY and DENSITY and we apply it to the nodes
for el in self.main_model_part.Elements:
rho = el.Properties.GetValue(KratosMultiphysics.DENSITY)
if el.Properties.Has(KratosMultiphysics.DYNAMIC_VISCOSITY):
dyn_viscosity = el.Properties.GetValue(KratosMultiphysics.DYNAMIC_VISCOSITY)
kin_viscosity = dyn_viscosity/rho
else:
kin_viscosity = el.Properties.GetValue(KratosMultiphysics.VISCOSITY)
break
KratosMultiphysics.VariableUtils().SetScalarVar(KratosMultiphysics.DENSITY, rho, self.main_model_part.Nodes)
KratosMultiphysics.VariableUtils().SetScalarVar(KratosMultiphysics.VISCOSITY, kin_viscosity, self.main_model_part.Nodes)
else:
raise Exception("Other input options are not yet implemented.")
current_buffer_size = self.main_model_part.GetBufferSize()
if(self.GetMinimumBufferSize() > current_buffer_size):
self.main_model_part.SetBufferSize( self.GetMinimumBufferSize() )
print ("Model reading finished.")
def _ExecuteAfterReading(self):
## Replace element and conditions
KratosMultiphysics.ReplaceElementsAndConditionsProcess(self.main_model_part, self.settings["element_replace_settings"]).Execute()
## Check that the input read has the shape we like
prepare_model_part_settings = KratosMultiphysics.Parameters("{}")
prepare_model_part_settings.AddValue("volume_model_part_name",self.settings["volume_model_part_name"])
prepare_model_part_settings.AddValue("skin_parts",self.settings["skin_parts"])
import check_and_prepare_model_process_fluid
check_and_prepare_model_process_fluid.CheckAndPrepareModelProcess(self.main_model_part, prepare_model_part_settings).Execute()
def _ExecuteCheckAndPrepare(self):
## Check that the input read has the shape we like
prepare_model_part_settings = KratosMultiphysics.Parameters("{}")
prepare_model_part_settings.AddValue("volume_model_part_name",self.settings["volume_model_part_name"])
prepare_model_part_settings.AddValue("skin_parts",self.settings["skin_parts"])
import check_and_prepare_model_process_fluid
check_and_prepare_model_process_fluid.CheckAndPrepareModelProcess(self.main_model_part, prepare_model_part_settings).Execute()
current_buffer_size = self.main_model_part.GetBufferSize()
if(self.GetMinimumBufferSize() > current_buffer_size):
self.main_model_part.SetBufferSize( self.GetMinimumBufferSize() )
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()
def ImportModelPart(self):
if (self.settings["model_import_settings"]["input_type"].GetString() ==
"mdpa"):
# here we read the already existing partitions from the primal solution.
input_filename = self.settings["model_import_settings"][
"input_filename"].GetString()
mpi_input_filename = input_filename + "_" + str(KratosMPI.mpi.rank)
self.settings["model_import_settings"]["input_filename"].SetString(
mpi_input_filename)
KratosMultiphysics.ModelPartIO(mpi_input_filename).ReadModelPart(
self.main_model_part)
# here we shall check that the input read has the shape we like
aux_params = KratosMultiphysics.Parameters("{}")
aux_params.AddValue("volume_model_part_name",
self.settings["volume_model_part_name"])
aux_params.AddValue("skin_parts", self.settings["skin_parts"])
# here we replace the dummy elements we read with proper elements
self.settings.AddEmptyValue("element_replace_settings")
if (self.main_model_part.ProcessInfo[
KratosMultiphysics.DOMAIN_SIZE] == 3):
self.settings[
"element_replace_settings"] = KratosMultiphysics.Parameters(
"""
{
"element_name": "VMSAdjointElement3D",
"condition_name": "SurfaceCondition3D3N"
}
""")
elif (self.main_model_part.ProcessInfo[
KratosMultiphysics.DOMAIN_SIZE] == 2):
self.settings[
"element_replace_settings"] = KratosMultiphysics.Parameters(
"""
{
"element_name": "VMSAdjointElement2D",
"condition_name": "LineCondition2D2N"
}
""")
else:
raise Exception("domain size is not 2 nor 3")
KratosMultiphysics.ReplaceElementsAndConditionsProcess(
self.main_model_part,
self.settings["element_replace_settings"]).Execute()
import check_and_prepare_model_process_fluid
check_and_prepare_model_process_fluid.CheckAndPrepareModelProcess(
self.main_model_part, aux_params).Execute()
# here we read the KINEMATIC VISCOSITY and DENSITY and we apply it to the nodes
for el in self.main_model_part.Elements:
rho = el.Properties.GetValue(KratosMultiphysics.DENSITY)
kin_viscosity = el.Properties.GetValue(
KratosMultiphysics.VISCOSITY)
break
KratosMultiphysics.VariableUtils().SetScalarVar(
KratosMultiphysics.DENSITY, rho, self.main_model_part.Nodes)
KratosMultiphysics.VariableUtils().SetScalarVar(
KratosMultiphysics.VISCOSITY, kin_viscosity,
self.main_model_part.Nodes)
else:
raise Exception("Other input options are not yet implemented.")
current_buffer_size = self.main_model_part.GetBufferSize()
if (self.GetMinimumBufferSize() > current_buffer_size):
self.main_model_part.SetBufferSize(self.GetMinimumBufferSize())
MetisApplication.SetMPICommunicatorProcess(
self.main_model_part).Execute()
ParallelFillCommunicator = TrilinosApplication.ParallelFillCommunicator(
self.main_model_part.GetRootModelPart())
ParallelFillCommunicator.Execute()
if KratosMPI.mpi.rank == 0:
print("MPI communicators constructed.")
print("MPI model reading finished.")
def ImportModelPart(self):
print("::[Pfem Fluid Solver]:: Model reading starts.")
self.computing_model_part_name = "fluid_computing_domain"
if(self.settings["model_import_settings"]["input_type"].GetString() == "mdpa"):
print(" Importing input model part...")
KratosMultiphysics.ModelPartIO(self.settings["model_import_settings"]["input_filename"].GetString()).ReadModelPart(self.main_model_part)
print(" Import input model part.")
# Auxiliary Kratos parameters object to be called by the CheckAndPepareModelProcess
params = KratosMultiphysics.Parameters("{}")
params.AddEmptyValue("computing_model_part_name").SetString(self.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"])
if( self.settings.Has("bodies_list") ):
params.AddValue("bodies_list",self.settings["bodies_list"])
# CheckAndPrepareModelProcess creates the fluid_computational model part
import check_and_prepare_model_process_fluid
check_and_prepare_model_process_fluid.CheckAndPrepareModelProcess(self.main_model_part, params).Execute()
# Set Properties to nodes : Deprecated
#self.SetProperties()
# Set buffer size
self.main_model_part.SetBufferSize( self.settings["buffer_size"].GetInt() )
current_buffer_size = self.main_model_part.GetBufferSize()
if(self.GetMinimumBufferSize() > current_buffer_size):
current_buffer_size = self.GetMinimumBufferSize()
self.main_model_part.SetBufferSize( current_buffer_size )
# Fill buffer
delta_time = self.main_model_part.ProcessInfo[KratosMultiphysics.DELTA_TIME]
time = self.main_model_part.ProcessInfo[KratosMultiphysics.TIME]
time = time - delta_time * (current_buffer_size)
self.main_model_part.ProcessInfo.SetValue(KratosMultiphysics.TIME, time)
for size in range(0, current_buffer_size):
step = size - (current_buffer_size -1)
self.main_model_part.ProcessInfo.SetValue(KratosMultiphysics.STEP, step)
time = time + delta_time
#delta_time is computed from previous time in process_info
self.main_model_part.CloneTimeStep(time)
self.main_model_part.ProcessInfo[KratosMultiphysics.IS_RESTARTED] = False
elif(self.settings["model_import_settings"]["input_type"].GetString() == "rest"):
problem_path = os.getcwd()
restart_path = os.path.join(problem_path, self.settings["model_import_settings"]["input_filename"].GetString() + "__" + self.settings["model_import_settings"]["input_file_label"].GetString() )
if(os.path.exists(restart_path+".rest") == False):
print(" rest file does not exist , check the restart step selected ")
print(" Load Restart file: ", self.settings["model_import_settings"]["input_filename"].GetString() + "__" + self.settings["model_import_settings"]["input_file_label"].GetString())
# set serializer flag
self.serializer_flag = SerializerTraceType.SERIALIZER_NO_TRACE # binary
# self.serializer_flag = SerializerTraceType.SERIALIZER_TRACE_ERROR # ascii
# self.serializer_flag = SerializerTraceType.SERIALIZER_TRACE_ALL # ascii
serializer = Serializer(restart_path, self.serializer_flag)
serializer.Load(self.main_model_part.Name, self.main_model_part)
print(" Load input restart file.")
self.main_model_part.ProcessInfo[KratosMultiphysics.IS_RESTARTED] = True
print(self.main_model_part)
else:
raise Exception("Other input options are not yet implemented.")
print ("::[Pfem Fluid Solver]:: Model reading finished.")
