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 initializeProcesses(self):
import process_factory
#the process order of execution is important
self.list_of_processes = process_factory.KratosProcessFactory(
Model).ConstructListOfProcesses(
ProjectParameters["constraints_process_list"])
self.list_of_processes += process_factory.KratosProcessFactory(
Model).ConstructListOfProcesses(
ProjectParameters["loads_process_list"])
if (ProjectParameters.Has("problem_process_list")):
self.list_of_processes += process_factory.KratosProcessFactory(
Model).ConstructListOfProcesses(
ProjectParameters["problem_process_list"])
if (ProjectParameters.Has("output_process_list")):
self.list_of_processes += process_factory.KratosProcessFactory(
Model).ConstructListOfProcesses(
ProjectParameters["output_process_list"])
#print list of constructed processes
if (echo_level > 1):
for process in self.list_of_processes:
print(process)
for process in self.list_of_processes:
process.ExecuteInitialize()
def __init__(self, ProjectParameters):
self.model_part = ModelPart(
ProjectParameters["problem_data"]["model_part_name"].GetString())
self.model_part.ProcessInfo.SetValue(
DOMAIN_SIZE,
ProjectParameters["problem_data"]["domain_size"].GetInt())
###TODO replace this "model" for real one once available in kratos core
self.Model = {
ProjectParameters["problem_data"]["model_part_name"].GetString():
self.model_part
}
#construct the IGASolver (main setting methods are located in the solver_module)
solver_module = __import__(
ProjectParameters["solver_settings"]["solver_type"].GetString())
self.IGASolver = solver_module.CreateSolver(
self.model_part, ProjectParameters["solver_settings"])
import read_materials_process
read_materials_process.Factory(ProjectParameters, self.Model)
self.IGASolver.AddVariables()
self.IGASolver.ImportModelPart(ProjectParameters)
self.IGASolver.AddDofs()
for i in range(ProjectParameters["solver_settings"]
["processes_sub_model_part_list"].size()):
part_name = ProjectParameters["solver_settings"][
"processes_sub_model_part_list"][i].GetString()
self.Model.update(
{part_name: self.model_part.GetSubModelPart(part_name)})
import process_factory
self.list_of_processes = process_factory.KratosProcessFactory(
self.Model).ConstructListOfProcesses(
ProjectParameters["constraints_process_list"])
self.list_of_processes += process_factory.KratosProcessFactory(
self.Model).ConstructListOfProcesses(
ProjectParameters["loads_process_list"])
if (ProjectParameters.Has("list_other_processes") == True):
self.list_of_processes += process_factory.KratosProcessFactory(
self.Model).ConstructListOfProcesses(
ProjectParameters["list_other_processes"])
if (ProjectParameters.Has("json_check_process") == True):
self.list_of_processes += process_factory.KratosProcessFactory(
self.Model).ConstructListOfProcesses(
ProjectParameters["json_check_process"])
if (ProjectParameters.Has("json_output_process") == True):
self.list_of_processes += process_factory.KratosProcessFactory(
self.Model).ConstructListOfProcesses(
ProjectParameters["json_output_process"])
for process in self.list_of_processes:
process.ExecuteInitialize()
self.IGASolver.Initialize()
def __init__(self, ProjectParameters):
self.ProjectParameters = ProjectParameters
self.execute_solve = self.ProjectParameters["test_settings"]["execute_solve"].GetBool()
self.main_model_part = ModelPart(self.ProjectParameters["problem_data"]["model_part_name"].GetString())
self.main_model_part.ProcessInfo.SetValue(DOMAIN_SIZE, self.ProjectParameters["problem_data"]["domain_size"].GetInt())
self.Model = {self.ProjectParameters["problem_data"]["model_part_name"].GetString() : self.main_model_part}
## Solver construction
solver_module = __import__(self.ProjectParameters["solver_settings"]["solver_type"].GetString())
self.solver = solver_module.CreateSolver(self.main_model_part, self.ProjectParameters["solver_settings"])
self.solver.AddVariables()
## Read the model - note that SetBufferSize is done here
self.solver.ImportModelPart()
## Add AddDofs
self.solver.AddDofs()
## 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()
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)})
## Obtain the list of the processes to be applied
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"] )
self.list_of_processes += process_factory.KratosProcessFactory(self.Model).ConstructListOfProcesses( self.ProjectParameters["gravity"] )
if (self.ProjectParameters.Has("list_other_processes") == True):
self.list_of_processes += process_factory.KratosProcessFactory(self.Model).ConstructListOfProcesses( self.ProjectParameters["list_other_processes"] )
## Solver initialization
self.solver.Initialize()
self.solver.SetEchoLevel(0)
## Processes initialization
for process in self.list_of_processes:
process.ExecuteInitialize()
#TODO: think if there is a better way to do this
self.fluid_model_part = self.solver.GetComputingModelPart()
def __ExecuteInitialize(self):
""" Initializing the Analysis """
## ModelPart is being prepared to be used by the solver
self.solver.PrepareModelPartForSolver()
## Adds the Dofs if they don't exist
self.solver.AddDofs()
## Creation of the Kratos model (build sub_model_parts or submeshes)
self.model = KratosMultiphysics.Model()
self.model.AddModelPart(self.main_model_part)
## Print model_part and properties
if self.is_printing_rank and (self.echo_level > 1):
KratosMultiphysics.Logger.PrintInfo("ModelPart",
self.main_model_part)
## Processes construction
import process_factory
self.list_of_processes = []
if (self.ProjectParameters.Has("boundary_conditions_process_list") ==
True):
self.list_of_processes = process_factory.KratosProcessFactory(
self.model).ConstructListOfProcesses(
self.ProjectParameters["boundary_conditions_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_output_process") == True):
self.list_of_processes += process_factory.KratosProcessFactory(
self.model).ConstructListOfProcesses(
self.ProjectParameters["json_output_process"])
# Processes for tests
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("check_analytic_results_process") ==
True):
self.list_of_processes += process_factory.KratosProcessFactory(
self.model).ConstructListOfProcesses(
self.ProjectParameters["check_analytic_results_process"])
if self.is_printing_rank and (self.echo_level > 1):
count = 0
for process in self.list_of_processes:
count += 1
# KratosMultiphysics.Logger.PrintInfo("Process " + str(count), process) # FIXME
## Processes initialization
for process in self.list_of_processes:
process.ExecuteInitialize()
## Solver initialization
self.solver.Initialize()
def __init__(self, ProjectParameters):
self.ProjectParameters = ProjectParameters
self.main_model_part = ModelPart(self.ProjectParameters["problem_data"]["model_part_name"].GetString())
self.main_model_part.ProcessInfo.SetValue(DOMAIN_SIZE, self.ProjectParameters["problem_data"]["domain_size"].GetInt())
###TODO replace this "model" for real one once available in kratos core
self.Model = {self.ProjectParameters["problem_data"]["model_part_name"].GetString() : self.main_model_part}
#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"])
#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()
### Temporal
#self.main_model_part.AddNodalSolutionStepVariable(ALPHA_EAS)
#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()
#build sub_model_parts or submeshes (rearrange parts for the application of custom processes)
##TODO: replace MODEL for the Kratos one ASAP
##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)})
#obtain the list of the processes to be applied
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"] )
self.list_of_processes += process_factory.KratosProcessFactory(self.Model).ConstructListOfProcesses( self.ProjectParameters["list_other_processes"] )
for process in self.list_of_processes:
process.ExecuteInitialize()
#### START SOLUTION ####
#TODO: think if there is a better way to do this
self.computing_model_part = self.solver.GetComputeModelPart()
#### output settings start ####
self.problem_path = os.getcwd()
self.problem_name = self.ProjectParameters["problem_data"]["problem_name"].GetString()
#### output settings start ####
## Sets strategies, builders, linear solvers, schemes and solving info, and fills the buffer
self.solver.Initialize()
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 __init__(self, ProjectParameters):
self.ProjectParameters = ProjectParameters
self.vector_space = KratosMultiphysics.UblasSparseSpace()
self.structure_main_model_part = KratosMultiphysics.ModelPart(self.ProjectParameters["structure_solver_settings"]["problem_data"]["model_part_name"].GetString())
self.structure_main_model_part.ProcessInfo.SetValue(KratosMultiphysics.DOMAIN_SIZE, self.ProjectParameters["structure_solver_settings"]["problem_data"]["domain_size"].GetInt())
SolidModel = {ProjectParameters["structure_solver_settings"]["problem_data"]["model_part_name"].GetString() : self.structure_main_model_part}
# Construct the structure solver
structure_solver_module = __import__(self.ProjectParameters["structure_solver_settings"]["solver_settings"]["solver_type"].GetString())
self.structure_solver = structure_solver_module.CreateSolver(self.structure_main_model_part,
self.ProjectParameters["structure_solver_settings"]["solver_settings"])
print("* Structure solver constructed.")
# Construct the coupling partitioned strategy
import convergence_accelerator_factory
self.coupling_utility = convergence_accelerator_factory.CreateConvergenceAccelerator(self.ProjectParameters["coupling_solver_settings"]["solver_settings"]["coupling_strategy"])
print("* Coupling strategy constructed.")
self.structure_solver.AddVariables()
self.structure_solver.ImportModelPart()
self.structure_solver.AddDofs()
# Get the structure process list
for i in range(self.ProjectParameters["structure_solver_settings"]["solver_settings"]["processes_sub_model_part_list"].size()):
part_name = self.ProjectParameters["structure_solver_settings"]["solver_settings"]["processes_sub_model_part_list"][i].GetString()
SolidModel.update({part_name: self.structure_main_model_part.GetSubModelPart(part_name)})
# Structure processes construction
import process_factory
self.list_of_processes = process_factory.KratosProcessFactory(SolidModel).ConstructListOfProcesses( self.ProjectParameters["structure_solver_settings"]["constraints_process_list"] )
self.list_of_processes += process_factory.KratosProcessFactory(SolidModel).ConstructListOfProcesses( self.ProjectParameters["structure_solver_settings"]["loads_process_list"] )
# Processes initialization
for process in self.list_of_processes:
process.ExecuteInitialize()
# Structure solver initialization
self.structure_solver.Initialize()
self._SetStructureNeumannCondition()
# Coupling utility initialization
self.coupling_utility.Initialize()
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 _ExecuteInitialize(self):
""" Initializing the Analysis """
super()._ExecuteInitialize()
## Processes construction
import process_factory
if (self.ProjectParameters.Has("contact_process_list") is True):
self.list_of_processes += process_factory.KratosProcessFactory(self.structure_model).ConstructListOfProcesses(self.ProjectParameters["contact_process_list"])
#if self.is_printing_rank and self.echo_level > 1: # FIXME
#KM.Logger.PrintInfo("Process " + str(len(self.list_of_processes)), self.list_of_processes[-1])
self.list_of_processes[-1].ExecuteInitialize()
## Add the processes to the solver
self.solver.AddProcessesList(self.list_of_processes)
if (self.output_post is True):
self.solver.AddPostProcess(self.gid_output)
# Initialize the solver (again)
self.solver.Initialize()
# Setting the echo level
echo_level = self.ProjectParameters["problem_data"]["echo_level"].GetInt()
self.solver.SetEchoLevel(echo_level)
def _import_materials(self):
# Assign material to model_parts (if Materials.json exists)
import process_factory
if os.path.isfile("Materials.json"):
materials_file = open("Materials.json",'r')
MaterialParameters = KratosMultiphysics.Parameters(materials_file.read())
if(MaterialParameters.Has("material_models_list")):
import KratosMultiphysics.ConstitutiveModelsApplication as KratosMaterials
domain_model = self.model.GetModel()
assign_materials_processes = process_factory.KratosProcessFactory(domain_model).ConstructListOfProcesses( MaterialParameters["material_models_list"] )
for process in assign_materials_processes:
process.Execute()
elif os.path.isfile("materials.py"): # legacy
import constitutive_law_python_utility as constitutive_law_utils
constitutive_law = constitutive_law_utils.ConstitutiveLawUtility(self.main_model_part, self.process_info[KratosMultiphysics.SPACE_DIMENSION]);
constitutive_law.Initialize();
problem_path = os.getcwd()
print(" Reading constitutive law from file :" + os.path.join(problem_path, "materials") + ".py ")
else:
print(" No Materials.json or Materials.py found ")
def _import_materials(self):
# Assign material to model_parts (if Materials.json exists)
import process_factory
if(os.path.isfile("Materials.json") or self.input_manager.HasMaterialFile()):
MaterialParameters = self.input_manager.GetMaterialParameters()
if MaterialParameters.Has("material_models_list"):
import KratosMultiphysics.ConstitutiveModelsApplication as KratosMaterials
domain_model = self.model.GetModel()
assign_materials_processes = process_factory.KratosProcessFactory(domain_model).ConstructListOfProcesses(MaterialParameters["material_models_list"])
for process in assign_materials_processes:
process.Execute()
self.model.CleanModel()
elif os.path.isfile("materials.py"): # legacy
import constitutive_law_python_utility as constitutive_law_utils
constitutive_law = constitutive_law_utils.ConstitutiveLawUtility(self.main_model_part, self.process_info[KratosMultiphysics.SPACE_DIMENSION])
constitutive_law.Initialize()
self.model.CleanModel()
print("::[-----Material------]:: Reading file: materials.py ")
else:
print("No Materials.json or Materials.py found ")
def AddMaterials(self):
# Assign material to model_parts (if Materials.json exists)
import process_factory
if os.path.isfile("Materials.json"):
materials_file = open("Materials.json", 'r')
MaterialParameters = KratosMultiphysics.Parameters(
materials_file.read())
if (MaterialParameters.Has("material_models_list")):
## Get the list of the model_part's in the object Model
for i in range(self.ProjectParameters["solver_settings"]
["problem_domain_sub_model_part_list"].size()):
part_name = self.ProjectParameters["solver_settings"][
"problem_domain_sub_model_part_list"][i].GetString()
if (self.main_model_part.HasSubModelPart(part_name)):
self.Model.update({
part_name:
self.main_model_part.GetSubModelPart(part_name)
})
assign_materials_processes = process_factory.KratosProcessFactory(
self.Model).ConstructListOfProcesses(
MaterialParameters["material_models_list"])
for process in assign_materials_processes:
process.Execute()
else:
self.KratosPrintInfo(" No Materials.json found ")
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()
def test_rotated_system(self):
model_part = ModelPart("Main")
model_part.AddNodalSolutionStepVariable(VELOCITY)
model_part.AddNodalSolutionStepVariable(DISPLACEMENT)
model_part.AddNodalSolutionStepVariable(VISCOSITY)
model_part_io = ModelPartIO(GetFilePath("test_model_part_io_read"))
model_part_io.ReadModelPart(model_part)
#note that y and z are inverted in the rotated system
settings = Parameters("""
{
"process_list" : [
{
"python_module" : "assign_scalar_variable_process",
"kratos_module" : "KratosMultiphysics",
"process_name" : "AssignScalarVariableProcess",
"Parameters" : {
"model_part_name" : "Main",
"variable_name" : "VISCOSITY",
"interval" : [0.0, 10.0],
"constrained" : false,
"value" : "x+100.0*y*t**2",
"local_axes" :{
"origin" : [10.0, 0.0, 0.0],
"axes" : [[1.0, 0.0, 0.0], [0.0, 0.0, 1.0], [0.0, 1.0, 0.0] ]
}
}
}
]
}
""")
Model = {"Main": model_part}
import process_factory
list_of_processes = process_factory.KratosProcessFactory(
Model).ConstructListOfProcesses(settings["process_list"])
model_part.CloneTimeStep(3.0)
for process in list_of_processes:
process.ExecuteInitializeSolutionStep()
##verify the result
t = model_part.ProcessInfo[TIME]
for node in model_part.Nodes:
x = node.X - 10.0
y = node.Z
z = node.Y
self.assertEqual(node.GetSolutionStepValue(VISCOSITY),
x + 100.0 * y * t**2)
self.assertFalse(node.IsFixed(VISCOSITY))
for process in list_of_processes:
process.ExecuteFinalizeSolutionStep()
def test_assign_scalar_value_to_conditions(self):
model_part = ModelPart("Main")
model_part_io = ModelPartIO(GetFilePath("test_processes"))
model_part_io.ReadModelPart(model_part)
settings = Parameters("""
{
"process_list" : [
{
"python_module" : "assign_scalar_variable_to_conditions_process",
"kratos_module" : "KratosMultiphysics",
"process_name" : "AssignScalarVariableToConditionsProcess",
"Parameters" : {
"model_part_name":"Main",
"variable_name": "PRESSURE",
"value" : 15.0
}
},
{
"python_module" : "assign_scalar_variable_to_conditions_process",
"kratos_module" : "KratosMultiphysics",
"process_name" : "AssignScalarVariableToConditionsProcess",
"Parameters" : {
"model_part_name":"Main",
"variable_name": "VISCOSITY",
"value" : 2
}
}
]
}
""")
Model = {"Main": model_part}
import process_factory
list_of_processes = process_factory.KratosProcessFactory(
Model).ConstructListOfProcesses(settings["process_list"])
for process in list_of_processes:
process.ExecuteInitializeSolutionStep()
for cond in model_part.Conditions:
self.assertEqual(cond.GetValue(PRESSURE), 15.0)
self.assertEqual(cond.GetValue(VISCOSITY), 2)
def test_assign_scalar_field_to_conditions(self):
model_part = ModelPart("Main")
model_part_io = ModelPartIO(GetFilePath("test_processes"))
model_part_io.ReadModelPart(model_part)
settings = Parameters("""
{
"process_list" : [
{
"python_module" : "assign_scalar_variable_to_conditions_process",
"kratos_module" : "KratosMultiphysics",
"process_name" : "AssignScalarVariableToConditionsProcess",
"Parameters" : {
"model_part_name":"Main",
"variable_name": "INITIAL_STRAIN",
"value" : "x+y*t+z"
}
}
]
}
""")
Model = {"Main": model_part}
import process_factory
list_of_processes = process_factory.KratosProcessFactory(
Model).ConstructListOfProcesses(settings["process_list"])
model_part.CloneTimeStep(5.0)
for process in list_of_processes:
process.ExecuteInitializeSolutionStep()
t = model_part.ProcessInfo[TIME]
for cond in model_part.Conditions:
v = cond.GetValue(INITIAL_STRAIN)
i = 0
for node in cond.GetNodes():
self.assertEqual(v[i], node.X + node.Y * t + node.Z)
i = i + 1
def test_assign_scalar_field_component_to_conditions(self):
model_part = ModelPart("Main")
model_part_io = ModelPartIO(GetFilePath("test_processes"))
model_part_io.ReadModelPart(model_part)
settings = Parameters("""
{
"process_list" : [
{
"python_module" : "assign_scalar_to_conditions_process",
"kratos_module" : "KratosMultiphysics",
"process_name" : "AssignScalarToConditionsProcess",
"Parameters" : {
"model_part_name":"Main",
"variable_name": "DISPLACEMENT_X",
"value" : "t"
}
}
]
}
""")
Model = {"Main": model_part}
import process_factory
list_of_processes = process_factory.KratosProcessFactory(
Model).ConstructListOfProcesses(settings["process_list"])
model_part.CloneTimeStep(5.0)
for process in list_of_processes:
process.ExecuteInitializeSolutionStep()
t = model_part.ProcessInfo[TIME]
for cond in model_part.Conditions:
v = cond.GetValue(DISPLACEMENT)
self.assertEqual(v[0], t)
def __init__(self, ProjectParameters):
self.ProjectParameters = ProjectParameters
self.main_model_part = ModelPart(self.ProjectParameters["problem_data"]
["model_part_name"].GetString())
self.main_model_part.ProcessInfo.SetValue(
DOMAIN_SIZE,
self.ProjectParameters["problem_data"]["domain_size"].GetInt())
self.Model = {
self.ProjectParameters["problem_data"]["model_part_name"].GetString(
):
self.main_model_part
}
# 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"])
# 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()
# 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()
# 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)})
# Obtain the list of the processes to be applied
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 (ProjectParameters.Has("list_other_processes") == True):
self.list_of_processes += process_factory.KratosProcessFactory(
self.Model).ConstructListOfProcesses(
self.ProjectParameters["list_other_processes"])
if (ProjectParameters.Has("json_check_process") == True):
self.list_of_processes += process_factory.KratosProcessFactory(
self.Model).ConstructListOfProcesses(
self.ProjectParameters["json_check_process"])
if (ProjectParameters.Has("check_analytic_results_process") == True):
self.list_of_processes += process_factory.KratosProcessFactory(
self.Model).ConstructListOfProcesses(
self.ProjectParameters["check_analytic_results_process"])
if (ProjectParameters.Has("json_output_process") == True):
self.list_of_processes += process_factory.KratosProcessFactory(
self.Model).ConstructListOfProcesses(
self.ProjectParameters["json_output_process"])
for process in self.list_of_processes:
process.ExecuteInitialize()
# ### START SOLUTION ####
self.computing_model_part = self.solver.GetComputingModelPart()
# ### 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.computing_model_part,
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.output_post == True):
self.gid_output.ExecuteBeforeSolutionLoop()
## 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:
main_model_part.GetSubModelPart(gravity_part_name)
})
## Processes construction
import process_factory
# "list_of_processes" contains all the processes already constructed (boundary conditions, initial conditions and gravity)
# Note that the conditions are firstly constructed. Otherwise, they may overwrite the BCs information.
list_of_processes = process_factory.KratosProcessFactory(
Model).ConstructListOfProcesses(
ProjectParameters["initial_conditions_process_list"])
list_of_processes += process_factory.KratosProcessFactory(
Model).ConstructListOfProcesses(
ProjectParameters["boundary_conditions_process_list"])
list_of_processes += process_factory.KratosProcessFactory(
Model).ConstructListOfProcesses(ProjectParameters["gravity"])
list_of_processes += process_factory.KratosProcessFactory(
Model).ConstructListOfProcesses(ProjectParameters["compute_total_force"])
list_of_processes += process_factory.KratosProcessFactory(
Model).ConstructListOfProcesses(ProjectParameters["compute_level_force"])
list_of_processes += process_factory.KratosProcessFactory(
Model).ConstructListOfProcesses(ProjectParameters["aerodynamic_forces"])
list_of_processes += process_factory.KratosProcessFactory(
Model).ConstructListOfProcesses(ProjectParameters["perimeter_results"])
list_of_processes += process_factory.KratosProcessFactory(
def test_apply_custom_function_process(self):
model_part = ModelPart("Main")
model_part.AddNodalSolutionStepVariable(DISPLACEMENT)
model_part.AddNodalSolutionStepVariable(VISCOSITY)
model_part_io = ModelPartIO(GetFilePath("test_model_part_io_read"))
model_part_io.ReadModelPart(model_part)
settings = Parameters("""
{
"process_list" : [
{
"python_module" : "apply_custom_function_process",
"kratos_module" : "KratosMultiphysics",
"help" : "This process imposes the value by reading it from f(x,y,z,t) field",
"process_name" : "ApplyCustomFunctionProcess",
"Parameters" : {
"mesh_id" : 0,
"model_part_name" : "Main",
"variable_name" : "VISCOSITY",
"interval" : [0.0, 10.0],
"is_fixed" : true,
"free_outside_of_interval" : true,
"f(x,y,z,t)" : "x+100.0*y*t**2"
}
},
{
"python_module" : "apply_custom_function_process",
"kratos_module" : "KratosMultiphysics",
"help" : "This process imposes the value by reading it from f(x,y,z,t) field",
"process_name" : "ApplyCustomFunctionProcess",
"Parameters" : {
"mesh_id" : 0,
"model_part_name" : "Main",
"variable_name" : "DISPLACEMENT_X",
"interval" : [0.0, 5.0],
"is_fixed" : true,
"free_outside_of_interval" : true,
"f(x,y,z,t)" : "sqrt(x**2+y**2)*t"
}
}
]
}
""")
Model = {"Main": model_part}
import process_factory
list_of_processes = process_factory.KratosProcessFactory(
Model).ConstructListOfProcesses(settings["process_list"])
############################################################
##time = 3 - both within the active interval
model_part.CloneTimeStep(3.0)
for process in list_of_processes:
process.ExecuteInitializeSolutionStep()
##verify the result
t = model_part.ProcessInfo[TIME]
for node in model_part.Nodes:
self.assertEqual(node.GetSolutionStepValue(DISPLACEMENT_X),
math.sqrt(node.X**2 + node.Y**2) * t)
self.assertEqual(node.GetSolutionStepValue(VISCOSITY),
node.X + 100.0 * node.Y * t**2)
self.assertTrue(node.IsFixed(VISCOSITY))
self.assertTrue(node.IsFixed(DISPLACEMENT_X))
for process in list_of_processes:
process.ExecuteFinalizeSolutionStep()
##verify the result
t = model_part.ProcessInfo[TIME]
for node in model_part.Nodes:
self.assertFalse(node.IsFixed(VISCOSITY))
self.assertFalse(node.IsFixed(DISPLACEMENT_X))
############################################################
##time = 3 - DISPLACEMENT_X is not in the active interval
model_part.CloneTimeStep(6.0)
for process in list_of_processes:
process.ExecuteInitializeSolutionStep()
##verify the result
t = model_part.ProcessInfo[TIME]
for node in model_part.Nodes:
self.assertEqual(node.GetSolutionStepValue(DISPLACEMENT_X),
math.sqrt(node.X**2 + node.Y**2) *
3.0) ##still the old value
self.assertEqual(node.GetSolutionStepValue(VISCOSITY),
node.X + 100.0 * node.Y * t**2)
self.assertTrue(node.IsFixed(VISCOSITY))
self.assertFalse(
node.IsFixed(DISPLACEMENT_X)
) #it is left unfixed at the end of the previous interval
for process in list_of_processes:
process.ExecuteFinalizeSolutionStep()
##verify the result
t = model_part.ProcessInfo[TIME]
for node in model_part.Nodes:
self.assertFalse(node.IsFixed(VISCOSITY))
self.assertFalse(node.IsFixed(DISPLACEMENT_X))
def test_apply_custom_function_process(self):
model_part = ModelPart("Main")
model_part.AddNodalSolutionStepVariable(DISPLACEMENT)
model_part.AddNodalSolutionStepVariable(VISCOSITY)
model_part_io = ModelPartIO(GetFilePath("test_model_part_io_read"))
model_part_io.ReadModelPart(model_part)
#reset all data
for node in model_part.Nodes:
node.Free(DISPLACEMENT_X)
node.Free(DISPLACEMENT_Y)
node.Free(DISPLACEMENT_Z)
node.SetSolutionStepValue(DISPLACEMENT_X, 0, 0.0)
node.SetSolutionStepValue(DISPLACEMENT_Y, 0, 0.0)
node.SetSolutionStepValue(DISPLACEMENT_Z, 0, 0.0)
settings = Parameters("""
{
"process_list" : [
{
"python_module" : "experimental_assign_value_process",
"kratos_module" : "KratosMultiphysics",
"process_name" : "AssignValueProcess",
"Parameters" : {
"model_part_name" : "Main",
"variable_name" : "VISCOSITY",
"interval" : [0.0, 10.0],
"constrained" : true,
"value" : "x+100.0*y*t**2"
}
},
{
"python_module" : "experimental_assign_value_process",
"kratos_module" : "KratosMultiphysics",
"process_name" : "AssignValueProcess",
"Parameters" : {
"model_part_name" : "Main",
"variable_name" : "DISPLACEMENT_X",
"interval" : [0.0, 5.0],
"constrained" : true,
"value" : "sqrt(x**2+y**2)*t",
"local_axes" :{
"origin" : [0.0, 0.0, 0.0],
"axes" : [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0] ]
}
}
},
{
"python_module" : "experimental_assign_vector_process",
"kratos_module" : "KratosMultiphysics",
"process_name" : "AssignVectorProcess",
"Parameters" : {
"model_part_name" : "Main",
"variable_name" : "DISPLACEMENT",
"interval" : [11.0, 15.0],
"value" : [10.0, null, "t"],
"local_axes" : {}
}
},
{
"python_module" : "experimental_assign_vector_process",
"kratos_module" : "KratosMultiphysics",
"process_name" : "AssignVectorProcess",
"Parameters" : {
"model_part_name" : "Main",
"variable_name" : "DISPLACEMENT",
"interval" : [20.0, 24.0],
"constrained" : false,
"value" : [10.0, null, "t"],
"local_axes" : {}
}
},
{
"python_module" : "experimental_assign_vector_process",
"kratos_module" : "KratosMultiphysics",
"process_name" : "AssignVectorProcess",
"Parameters" : {
"model_part_name" : "Main",
"variable_name" : "DISPLACEMENT",
"interval" : [25.0, "End"],
"constrained" : [true,true,false],
"value" : [null, "x+y*t", "t"],
"local_axes" : {}
}
}
]
}
""")
Model = {"Main": model_part}
import process_factory
list_of_processes = process_factory.KratosProcessFactory(
Model).ConstructListOfProcesses(settings["process_list"])
for node in model_part.Nodes:
self.assertFalse(node.IsFixed(DISPLACEMENT_X))
self.assertFalse(node.IsFixed(DISPLACEMENT_Y))
self.assertFalse(node.IsFixed(DISPLACEMENT_Z))
############################################################
##time = 3 - both within the active interval
model_part.CloneTimeStep(3.0)
for process in list_of_processes:
process.ExecuteInitializeSolutionStep()
##verify the result
t = model_part.ProcessInfo[TIME]
for node in model_part.Nodes:
self.assertEqual(node.GetSolutionStepValue(DISPLACEMENT_X),
math.sqrt(node.X**2 + node.Y**2) * t)
self.assertEqual(node.GetSolutionStepValue(VISCOSITY),
node.X + 100.0 * node.Y * t**2)
self.assertTrue(node.IsFixed(VISCOSITY))
self.assertTrue(node.IsFixed(DISPLACEMENT_X))
self.assertFalse(node.IsFixed(DISPLACEMENT_Y))
self.assertFalse(node.IsFixed(DISPLACEMENT_Z))
for process in list_of_processes:
process.ExecuteFinalizeSolutionStep()
##verify the result
t = model_part.ProcessInfo[TIME]
for node in model_part.Nodes:
self.assertFalse(node.IsFixed(VISCOSITY))
self.assertFalse(node.IsFixed(DISPLACEMENT_X))
self.assertFalse(node.IsFixed(DISPLACEMENT_Y))
self.assertFalse(node.IsFixed(DISPLACEMENT_Z))
############################################################
##time = 3 - DISPLACEMENT_X is not in the active interval
model_part.CloneTimeStep(6.0)
for node in model_part.Nodes:
self.assertFalse(node.IsFixed(DISPLACEMENT_X))
self.assertFalse(node.IsFixed(DISPLACEMENT_Y))
self.assertFalse(node.IsFixed(DISPLACEMENT_Z))
for process in list_of_processes:
process.ExecuteInitializeSolutionStep()
##verify the result
t = model_part.ProcessInfo[TIME]
for node in model_part.Nodes:
self.assertEqual(node.GetSolutionStepValue(DISPLACEMENT_X),
math.sqrt(node.X**2 + node.Y**2) *
3.0) ##still the old value
self.assertEqual(node.GetSolutionStepValue(VISCOSITY),
node.X + 100.0 * node.Y * t**2)
self.assertTrue(node.IsFixed(VISCOSITY))
self.assertFalse(
node.IsFixed(DISPLACEMENT_X)
) #it is left unfixed at the end of the previous interval
for process in list_of_processes:
process.ExecuteFinalizeSolutionStep()
##verify the result
t = model_part.ProcessInfo[TIME]
for node in model_part.Nodes:
self.assertFalse(node.IsFixed(VISCOSITY))
self.assertFalse(node.IsFixed(DISPLACEMENT_X))
############################################################
##time = 12 - DISPLACEMENT applied as a vector. x,z components fixed, y component not imposed
model_part.CloneTimeStep(12.0)
for process in list_of_processes:
process.ExecuteInitializeSolutionStep()
##verify the result
t = model_part.ProcessInfo[TIME]
for node in model_part.Nodes:
self.assertEqual(node.GetSolutionStepValue(DISPLACEMENT_X), 10.0)
self.assertTrue(node.IsFixed(DISPLACEMENT_X))
self.assertEqual(node.GetSolutionStepValue(DISPLACEMENT_Y),
0.0) #not applied!!
self.assertFalse(node.IsFixed(DISPLACEMENT_Y))
self.assertEqual(node.GetSolutionStepValue(DISPLACEMENT_Z), 12.0)
self.assertTrue(node.IsFixed(DISPLACEMENT_Z))
#print("**********************************************")
for process in list_of_processes:
process.ExecuteFinalizeSolutionStep()
############################################################
##time >= 20 - DISPLACEMENT applied as a vector. x,z components fixed, y component not imposed
model_part.CloneTimeStep(20.1)
for process in list_of_processes:
process.ExecuteInitializeSolutionStep()
##verify the result
t = model_part.ProcessInfo[TIME]
print("Checking time = ", t)
for node in model_part.Nodes:
self.assertEqual(node.GetSolutionStepValue(DISPLACEMENT_X), 10.0)
self.assertFalse(node.IsFixed(DISPLACEMENT_X))
self.assertEqual(node.GetSolutionStepValue(DISPLACEMENT_Y),
0.0) #not applied!!
self.assertFalse(node.IsFixed(DISPLACEMENT_Y))
self.assertEqual(node.GetSolutionStepValue(DISPLACEMENT_Z), t)
self.assertFalse(node.IsFixed(DISPLACEMENT_Z))
for process in list_of_processes:
process.ExecuteFinalizeSolutionStep()
############################################################
##time >= 20 - DISPLACEMENT applied as a vector. x,z components fixed, y component not imposed
model_part.CloneTimeStep(26.0)
for process in list_of_processes:
process.ExecuteInitializeSolutionStep()
##verify the result
t = model_part.ProcessInfo[TIME]
print("Checking time = ", t)
for node in model_part.Nodes:
self.assertEqual(node.GetSolutionStepValue(DISPLACEMENT_X),
10.0) #previous value
self.assertFalse(
node.IsFixed(DISPLACEMENT_X)) #not fixed since set as null
self.assertEqual(node.GetSolutionStepValue(DISPLACEMENT_Y),
node.X + node.Y * t) #not applied!!
self.assertTrue(node.IsFixed(DISPLACEMENT_Y)) #set to true
self.assertEqual(node.GetSolutionStepValue(DISPLACEMENT_Z), t)
self.assertFalse(node.IsFixed(DISPLACEMENT_Z))
for process in list_of_processes:
process.ExecuteFinalizeSolutionStep()
main_model_part.GetSubModelPart(initial_cond_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:
main_model_part.GetSubModelPart(gravity_part_name)
})
## Remeshing processes construction
import process_factory
if (ProjectParameters.Has("mmg") == True):
remeshing_processes = process_factory.KratosProcessFactory(
Model).ConstructListOfProcesses(ProjectParameters["mmg"])
## Remeshing processes initialization
for process in remeshing_processes:
process.ExecuteInitialize()
# "list_of_processes" contains all the processes already constructed (boundary conditions, initial conditions and gravity)
# Note 1: gravity is firstly constructed. Outlet process might need its information.
# Note 2: conditions are constructed before BCs. Otherwise, they may overwrite the BCs information.
list_of_processes = process_factory.KratosProcessFactory(
Model).ConstructListOfProcesses(ProjectParameters["gravity"])
list_of_processes += process_factory.KratosProcessFactory(
Model).ConstructListOfProcesses(
ProjectParameters["initial_conditions_process_list"])
list_of_processes += process_factory.KratosProcessFactory(
for properties in fluid_main_model_part.Properties:
print(properties)
if(verbosity_structure > 1):
print("")
print(structure_main_model_part)
for properties in structure_main_model_part.Properties:
print(properties)
## Processes construction
import process_factory
# "list_of_processes" contains all the processes already constructed (boundary conditions, initial conditions and gravity)
# Note that the conditions are firstly constructed. Otherwise, they may overwrite the BCs information.
# FLUID DOMAIN PROCESSES
list_of_processes = process_factory.KratosProcessFactory(FluidModel).ConstructListOfProcesses( ProjectParameters["fluid_solver_settings"]["gravity"] )
list_of_processes += process_factory.KratosProcessFactory(FluidModel).ConstructListOfProcesses( ProjectParameters["fluid_solver_settings"]["initial_conditions_process_list"] )
list_of_processes += process_factory.KratosProcessFactory(FluidModel).ConstructListOfProcesses( ProjectParameters["fluid_solver_settings"]["boundary_conditions_process_list"] )
list_of_processes += process_factory.KratosProcessFactory(FluidModel).ConstructListOfProcesses( ProjectParameters["fluid_solver_settings"]["auxiliar_process_list"] )
# SOLID DOMAIN PROCESSES
list_of_processes += process_factory.KratosProcessFactory(SolidModel).ConstructListOfProcesses( ProjectParameters["structure_solver_settings"]["constraints_process_list"] )
list_of_processes += process_factory.KratosProcessFactory(SolidModel).ConstructListOfProcesses( ProjectParameters["structure_solver_settings"]["loads_process_list"] )
if(verbosity > 1):
for process in list_of_processes:
print(process)
## Processes initialization
for process in list_of_processes:
process.ExecuteInitialize()
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()
## Creation of the Kratos model (build sub_model_parts or submeshes)
StructureModel = Model()
StructureModel.AddModelPart(main_model_part)
## Print model_part and properties
if ((parallel_type == "OpenMP") or (mpi.rank == 0)) and (echo_level > 1):
Logger.PrintInfo("ModelPart", main_model_part)
for properties in main_model_part.Properties:
Logger.PrintInfo("Property " + str(properties.Id), properties)
## Processes construction
import process_factory
list_of_processes = process_factory.KratosProcessFactory(
StructureModel).ConstructListOfProcesses(
ProjectParameters["constraints_process_list"])
list_of_processes += process_factory.KratosProcessFactory(
StructureModel).ConstructListOfProcesses(
ProjectParameters["loads_process_list"])
if (ProjectParameters.Has("list_other_processes") == True):
list_of_processes += process_factory.KratosProcessFactory(
StructureModel).ConstructListOfProcesses(
ProjectParameters["list_other_processes"])
if (ProjectParameters.Has("json_output_process") == True):
list_of_processes += process_factory.KratosProcessFactory(
StructureModel).ConstructListOfProcesses(
ProjectParameters["json_output_process"])
if ((parallel_type == "OpenMP") or (mpi.rank == 0)) and (echo_level > 1):
count = 0
def GenereateNewModelPart(self, old_main_model_part, solver,
list_of_processes, gid_output):
### Finalize Old Model ---------------------------------------------------------------------------------------
# Finalizing output files
gid_output.ExecuteFinalize()
for process in list_of_processes:
process.ExecuteFinalize()
# Finalizing strategy
solver.Clear()
# Save old .post.list file
all_list_filename = str(self.problem_name) + "_all.post.lst"
all_list_file = open(all_list_filename, 'a')
partial_list_filename = str(self.problem_name) + ".post.lst"
with open(partial_list_filename) as partial_list_file:
next(partial_list_file)
for line in partial_list_file:
all_list_file.write(line)
all_list_file.close()
# Save old .time file
original_filename = str(self.problem_name) + ".time"
original_filepath = os.path.join(str(self.problem_path),
str(original_filename))
new_filename = str(self.problem_name) + "_" + str(
self.remesh_count) + "info.time"
new_filepath = os.path.join(str(self.problem_path), str(new_filename))
shutil.copy(str(original_filepath), str(new_filepath))
### Generate New Model ---------------------------------------------------------------------------------------
# Parsing the parameters
with open("ProjectParameters.json", 'r') as parameter_file:
ProjectParameters = KratosMultiphysics.Parameters(
parameter_file.read())
## Model part ------------------------------------------------------------------------------------------------
# Defining the model part
self.model_part_number = self.model_part_number + 1
new_model_part_name = str(self.original_model_part_name) + '_' + str(
self.model_part_number)
new_model_part = self.model.CreateModelPart(new_model_part_name, 2)
new_model_part.ProcessInfo.SetValue(KratosMultiphysics.DOMAIN_SIZE,
self.domain_size)
new_model_part.ProcessInfo.SetValue(
KratosMultiphysics.DELTA_TIME,
old_main_model_part.ProcessInfo[KratosMultiphysics.DELTA_TIME])
new_model_part.ProcessInfo.SetValue(
KratosPoro.TIME_UNIT_CONVERTER,
old_main_model_part.ProcessInfo[KratosPoro.TIME_UNIT_CONVERTER])
# Construct the solver (main setting methods are located in the solver_module)
solver_module = __import__(
ProjectParameters["solver_settings"]["solver_type"].GetString())
solver = solver_module.CreateSolver(
new_model_part, ProjectParameters["solver_settings"])
# Add problem variables
solver.AddVariables()
# Read model_part (note: the buffer_size is set here)
solver.ImportModelPart()
# Add degrees of freedom
solver.AddDofs()
# Print model_part
echo_level = ProjectParameters["solver_settings"]["echo_level"].GetInt(
)
if (echo_level > 1):
print(new_model_part)
## Initialize ------------------------------------------------------------------------------------------------
# Construct processes to be applied
import process_factory
list_of_processes = process_factory.KratosProcessFactory(
PoroModel).ConstructListOfProcesses(
ProjectParameters["constraints_process_list"])
list_of_processes += process_factory.KratosProcessFactory(
PoroModel).ConstructListOfProcesses(
ProjectParameters["loads_process_list"])
# Initialize processes
for process in list_of_processes:
process.ExecuteInitialize()
# Set TIME
new_model_part.ProcessInfo.SetValue(
KratosMultiphysics.TIME,
old_main_model_part.ProcessInfo[KratosMultiphysics.TIME])
# Initialize GiD I/O
computing_model_part = solver.GetComputingModelPart()
output_settings = ProjectParameters["output_configuration"]
from gid_output_process import GiDOutputProcess
gid_output = GiDOutputProcess(computing_model_part, self.problem_name,
output_settings)
gid_output.ExecuteInitialize()
# Initialize the solver
solver.Initialize()
# Initialize the strategy before the mapping
solver.InitializeStrategy()
# ExecuteBeforeSolutionLoop
for process in list_of_processes:
process.ExecuteBeforeSolutionLoop()
## Set results when they are written in a single file (only multiplefiles for the moment)
gid_output.ExecuteBeforeSolutionLoop()
### Mapping between old and new model parts ------------------------------------------------------------------
self.PropagationUtility.MappingModelParts(self.FracturesData,
old_main_model_part,
new_model_part,
self.move_mesh_flag)
# set ARC_LENGTH_LAMBDA and ARC_LENGTH_RADIUS_FACTOR and update loads
if ProjectParameters["solver_settings"]["strategy_type"].GetString(
) == "arc_length":
new_model_part.ProcessInfo.SetValue(
KratosPoro.ARC_LENGTH_LAMBDA,
old_main_model_part.ProcessInfo[KratosPoro.ARC_LENGTH_LAMBDA])
new_model_part.ProcessInfo.SetValue(
KratosPoro.ARC_LENGTH_RADIUS_FACTOR,
old_main_model_part.ProcessInfo[
KratosPoro.ARC_LENGTH_RADIUS_FACTOR])
solver._UpdateLoads()
# delete old model_part
old_model_part_number = self.model_part_number - 1
old_model_part_name = str(
self.original_model_part_name) + '_' + str(old_model_part_number)
self.model.DeleteModelPart(old_model_part_name)
# Check new mesh
#IsConverged = solver._CheckConvergence()
return new_model_part, solver, list_of_processes, gid_output
def testMokBenchmark(self):
with WorkFolderScope(self.work_folder):
parameter_file = open(self.settings, 'r')
self.ProjectParameters = Parameters(parameter_file.read())
## Fluid-Structure model parts definition
self.structure_main_model_part = ModelPart(
self.ProjectParameters["structure_solver_settings"]
["problem_data"]["model_part_name"].GetString())
self.structure_main_model_part.ProcessInfo.SetValue(
DOMAIN_SIZE,
self.ProjectParameters["structure_solver_settings"]
["problem_data"]["domain_size"].GetInt())
self.fluid_main_model_part = ModelPart(
self.ProjectParameters["fluid_solver_settings"]["problem_data"]
["model_part_name"].GetString())
self.fluid_main_model_part.ProcessInfo.SetValue(
DOMAIN_SIZE, self.ProjectParameters["fluid_solver_settings"]
["problem_data"]["domain_size"].GetInt())
FluidModel = {
self.ProjectParameters["fluid_solver_settings"]["problem_data"]["model_part_name"].GetString(
):
self.fluid_main_model_part
}
SolidModel = {
self.ProjectParameters["structure_solver_settings"]["problem_data"]["model_part_name"].GetString(
):
self.structure_main_model_part
}
## Solver construction
solver_module = __import__(
self.ProjectParameters["coupling_solver_settings"]
["solver_settings"]["solver_type"].GetString())
self.solver = solver_module.CreateSolver(
self.structure_main_model_part, self.fluid_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 == True):
from gid_output_process import GiDOutputProcess
self.gid_output_structure = GiDOutputProcess(
self.solver.structure_solver.GetComputingModelPart(),
self.ProjectParameters["structure_solver_settings"]
["problem_data"]["problem_name"].GetString() +
"_structure",
self.ProjectParameters["structure_solver_settings"]
["output_configuration"])
self.gid_output_fluid = GiDOutputProcess(
self.solver.fluid_solver.GetComputingModelPart(),
self.ProjectParameters["fluid_solver_settings"]
["problem_data"]["problem_name"].GetString() + "_fluid",
self.ProjectParameters["fluid_solver_settings"]
["output_configuration"])
self.gid_output_structure.ExecuteInitialize()
self.gid_output_fluid.ExecuteInitialize()
## Get the list of the skin submodel parts in the object Model (FLUID)
for i in range(self.ProjectParameters["fluid_solver_settings"]
["solver_settings"]["skin_parts"].size()):
skin_part_name = self.ProjectParameters[
"fluid_solver_settings"]["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 no-skin submodel parts in the object Model (FLUID)
for i in range(self.ProjectParameters["fluid_solver_settings"]
["solver_settings"]["no_skin_parts"].size()):
no_skin_part_name = self.ProjectParameters[
"fluid_solver_settings"]["solver_settings"][
"no_skin_parts"][i].GetString()
FluidModel.update({
no_skin_part_name:
self.fluid_main_model_part.GetSubModelPart(
no_skin_part_name)
})
## Get the list of the initial conditions submodel parts in the object Model (FLUID)
for i in range(self.ProjectParameters["fluid_solver_settings"]
["initial_conditions_process_list"].size()):
initial_cond_part_name = self.ProjectParameters[
"fluid_solver_settings"][
"initial_conditions_process_list"][i]["Parameters"][
"model_part_name"].GetString()
FluidModel.update({
initial_cond_part_name:
self.fluid_main_model_part.GetSubModelPart(
initial_cond_part_name)
})
## Get the gravity submodel part in the object Model (FLUID)
for i in range(self.ProjectParameters["fluid_solver_settings"]
["gravity"].size()):
gravity_part_name = self.ProjectParameters[
"fluid_solver_settings"]["gravity"][i]["Parameters"][
"model_part_name"].GetString()
FluidModel.update({
gravity_part_name:
self.fluid_main_model_part.GetSubModelPart(
gravity_part_name)
})
## Get the list of the submodel part in the object Model (STRUCTURE)
for i in range(
self.ProjectParameters["structure_solver_settings"]
["solver_settings"]["processes_sub_model_part_list"].size()):
part_name = self.ProjectParameters[
"structure_solver_settings"]["solver_settings"][
"processes_sub_model_part_list"][i].GetString()
SolidModel.update({
part_name:
self.structure_main_model_part.GetSubModelPart(part_name)
})
## Processes construction
import process_factory
# "list_of_processes" contains all the processes already constructed (boundary conditions, initial conditions and gravity)
# Note that the conditions are firstly constructed. Otherwise, they may overwrite the BCs information.
# FLUID DOMAIN PROCESSES
self.list_of_processes = process_factory.KratosProcessFactory(
FluidModel).ConstructListOfProcesses(
self.ProjectParameters["fluid_solver_settings"]
["initial_conditions_process_list"])
self.list_of_processes += process_factory.KratosProcessFactory(
FluidModel).ConstructListOfProcesses(
self.ProjectParameters["fluid_solver_settings"]
["boundary_conditions_process_list"])
self.list_of_processes += process_factory.KratosProcessFactory(
FluidModel).ConstructListOfProcesses(
self.ProjectParameters["fluid_solver_settings"]["gravity"])
# SOLID DOMAIN PROCESSES
self.list_of_processes += process_factory.KratosProcessFactory(
SolidModel).ConstructListOfProcesses(
self.ProjectParameters["structure_solver_settings"]
["constraints_process_list"])
self.list_of_processes += process_factory.KratosProcessFactory(
SolidModel).ConstructListOfProcesses(
self.ProjectParameters["structure_solver_settings"]
["loads_process_list"])
## Processes initialization
for process in self.list_of_processes:
process.ExecuteInitialize()
# Solver initialization moved after the processes initialization, otherwise the flag INTERFACE is not set
self.solver.Initialize()
## Time settings
end_time = self.ProjectParameters["fluid_solver_settings"][
"problem_data"]["end_time"].GetDouble()
time = 0.0
step = 0
out = 0.0
if (self.print_output == True):
self.gid_output_structure.ExecuteBeforeSolutionLoop()
self.gid_output_fluid.ExecuteBeforeSolutionLoop()
for process in self.list_of_processes:
process.ExecuteBeforeSolutionLoop()
while (time <= end_time):
Dt = (self.solver).ComputeDeltaTime()
time = time + Dt
step = step + 1
self.solver.SetTimeStep(step)
self.structure_main_model_part.CloneTimeStep(time)
self.fluid_main_model_part.CloneTimeStep(time)
for process in self.list_of_processes:
process.ExecuteInitializeSolutionStep()
if (self.print_output == True):
self.gid_output_structure.ExecuteInitializeSolutionStep()
self.gid_output_fluid.ExecuteInitializeSolutionStep()
(self.solver).Solve()
for process in self.list_of_processes:
process.ExecuteFinalizeSolutionStep()
if (self.print_output == True):
self.gid_output_structure.ExecuteFinalizeSolutionStep()
self.gid_output_fluid.ExecuteFinalizeSolutionStep()
#TODO: decide if it shall be done only when output is processed or not
for process in self.list_of_processes:
process.ExecuteBeforeOutputStep()
if (self.print_output == True):
if self.gid_output_structure.IsOutputStep():
self.gid_output_structure.PrintOutput()
if self.gid_output_fluid.IsOutputStep():
self.gid_output_fluid.PrintOutput()
for process in self.list_of_processes:
process.ExecuteAfterOutputStep()
out = out + Dt
for process in self.list_of_processes:
process.ExecuteFinalize()
if (self.print_output == True):
self.gid_output_structure.ExecuteFinalize()
self.gid_output_fluid.ExecuteFinalize()
part_name = ProjectParameters["solver_settings"][
"processes_sub_model_part_list"][i].GetString()
DamModel.AddModelPart(main_model_part.GetSubModelPart(part_name))
# Print model_part and properties
if (echo_level > 1):
print(main_model_part)
for properties in main_model_part.Properties:
print(properties)
## Initialize ------------------------------------------------------------------------------------------------
# Construct processes to be applied
import process_factory
list_of_processes = process_factory.KratosProcessFactory(
DamModel).ConstructListOfProcesses(
ProjectParameters["constraints_process_list"])
list_of_processes += process_factory.KratosProcessFactory(
DamModel).ConstructListOfProcesses(ProjectParameters["loads_process_list"])
# Print list of constructed processes
if (echo_level > 1):
for process in list_of_processes:
print(process)
# Initialize processes
for process in list_of_processes:
process.ExecuteInitialize()
# Set TIME and DELTA_TIME and fill the previous steps of the buffer with the initial conditions
time = time - (buffer_size - 1) * delta_time
def __init__(self, ProjectParameters):
self.ProjectParameters = ProjectParameters
self.parallel_type = self.ProjectParameters["problem_data"]["parallel_type"].GetString()
if (self.parallel_type == "MPI"):
import KratosMultiphysics.mpi as KratosMPI
import KratosMultiphysics.TrilinosApplication as KratosTrilinos
self.main_model_part = ModelPart(self.ProjectParameters["problem_data"]["model_part_name"].GetString())
self.main_model_part.ProcessInfo.SetValue(DOMAIN_SIZE, self.ProjectParameters["problem_data"]["domain_size"].GetInt())
self.Model = {self.ProjectParameters["problem_data"]["model_part_name"].GetString() : self.main_model_part}
self.solver_module = __import__(self.ProjectParameters["solver_settings"]["solver_type"].GetString())
self.solver = self.solver_module.CreateSolver(self.main_model_part, self.ProjectParameters["solver_settings"])
self.solver.AddVariables()
self.solver.ImportModelPart()
self.solver.AddDofs()
#if (self.parallel_type == "OpenMP"):
# from gid_output_process import GiDOutputProcess
# self.gid_output = GiDOutputProcess(self.solver.GetComputingModelPart(),
# self.ProjectParameters["problem_data"]["problem_name"].GetString(),
# self.ProjectParameters["output_configuration"])
#elif (self.parallel_type == "MPI"):
# from gid_output_process_mpi import GiDOutputProcessMPI
# self.gid_output = GiDOutputProcessMPI(self.solver.GetComputingModelPart(),
# self.ProjectParameters["problem_data"]["problem_name"].GetString(),
# self.ProjectParameters["output_configuration"])
#self.gid_output.ExecuteInitialize()
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)})
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()
self.Model.update({no_skin_part_name: self.main_model_part.GetSubModelPart(no_skin_part_name)})
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)})
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)})
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"] )
self.list_of_processes += process_factory.KratosProcessFactory(self.Model).ConstructListOfProcesses( self.ProjectParameters["auxiliar_process_list"] )
for process in self.list_of_processes:
process.ExecuteInitialize()
self.solver.Initialize()
self.fluid_model_part = self.solver.GetComputingModelPart()
