def _mapper_tests(self, input_filename, num_nodes, pure_implicit=False):
self.__base_test_mapping(input_filename, num_nodes, pure_implicit)
self.mortar_mapping_double.Execute()
self.mortar_mapping_vector.Execute()
## DEBUG
#self.__post_process()
import from_json_check_result_process
check_parameters = KratosMultiphysics.Parameters("""
{
"check_variables" : ["TEMPERATURE","DISPLACEMENT"],
"input_file_name" : "",
"model_part_name" : "Structure",
"sub_model_part_name" : "Parts_Parts_Auto1"
}
""")
check_parameters["input_file_name"].SetString(input_filename + ".json")
check = from_json_check_result_process.FromJsonCheckResultProcess(
self.StructureModel, check_parameters)
check.ExecuteInitialize()
check.ExecuteBeforeSolutionLoop()
check.ExecuteFinalizeSolutionStep()
def _mapper_tests(self,
input_filename,
num_nodes,
master_num_nodes,
pure_implicit=False,
inverted=False,
discontinuous=False,
origin_are_conditions=True,
destination_are_conditions=True):
self.__base_test_mapping(input_filename, num_nodes, master_num_nodes,
pure_implicit, inverted, discontinuous,
origin_are_conditions,
destination_are_conditions)
self.mortar_mapping_double.Execute()
self.mortar_mapping_vector.Execute()
# Debug postprocess file
#self.__post_process()
import from_json_check_result_process
check_parameters = KratosMultiphysics.Parameters("""
{
"check_variables" : ["TEMPERATURE","DISPLACEMENT"],
"input_file_name" : "",
"model_part_name" : "Main",
"sub_model_part_name" : "Parts_Parts_Auto1"
}
""")
if inverted:
check_parameters["input_file_name"].SetString(input_filename +
"_inverted.json")
else:
check_parameters["input_file_name"].SetString(input_filename +
".json")
check = from_json_check_result_process.FromJsonCheckResultProcess(
self.model, check_parameters)
check.ExecuteInitialize()
check.ExecuteBeforeSolutionLoop()
check.ExecuteFinalizeSolutionStep()
def _create_check_outputs(current_model):
import from_json_check_result_process
check_parameters = KratosMultiphysics.Parameters("""
{
"gauss_points_check_variables": ["VON_MISES_STRESS"],
"input_file_name" : "",
"time_frequency" : 0.01,
"model_part_name" : "solid_part",
"sub_model_part_name" : "Body"
}
""")
check_parameters["input_file_name"].SetString(
GetFilePath(
"cl_test/test_perfect_plasticity_implementation_verification_reference.json"
))
check = from_json_check_result_process.FromJsonCheckResultProcess(
current_model, check_parameters)
check.ExecuteInitialize()
check.ExecuteBeforeSolutionLoop()
return check
def test_remesh_sphere_skin(self):
KratosMultiphysics.Logger.GetDefaultOutput().SetSeverity(
KratosMultiphysics.Logger.Severity.WARNING)
# We create the model part
current_model = KratosMultiphysics.Model()
main_model_part = current_model.CreateModelPart("MainModelPart")
main_model_part.ProcessInfo.SetValue(KratosMultiphysics.DOMAIN_SIZE, 3)
main_model_part.ProcessInfo.SetValue(KratosMultiphysics.TIME, 0.0)
main_model_part.ProcessInfo.SetValue(KratosMultiphysics.DELTA_TIME,
1.0)
#main_model_part.ProcessInfo.SetValue(KratosMultiphysics.STEP, 1)
# We add the variables needed
main_model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.DISTANCE)
# We import the model main_model_part
file_path = os.path.dirname(os.path.realpath(__file__))
KratosMultiphysics.ModelPartIO(
file_path +
"/mmg_eulerian_test/coarse_sphere_skin_test").ReadModelPart(
main_model_part)
for node in main_model_part.Nodes:
node.SetSolutionStepValue(KratosMultiphysics.DISTANCE, abs(node.X))
# We calculate the gradient of the distance variable
KratosMultiphysics.VariableUtils().SetNonHistoricalVariable(
KratosMultiphysics.NODAL_H, 0.0, main_model_part.Nodes)
find_nodal_h = KratosMultiphysics.FindNodalHNonHistoricalProcess(
main_model_part)
find_nodal_h.Execute()
# We set to zero the metric
metric_vector = KratosMultiphysics.Vector(6)
metric_vector[0] = 1.0
metric_vector[1] = 1.0
metric_vector[2] = 1.0
metric_vector[3] = 0.0
metric_vector[4] = 0.0
metric_vector[5] = 0.0
for node in main_model_part.Nodes:
node.SetValue(MeshingApplication.METRIC_TENSOR_3D, metric_vector)
mmg_parameters = KratosMultiphysics.Parameters("""
{
"filename" : "mmg_eulerian_test/coarse_sphere_skin_test",
"save_external_files" : true,
"echo_level" : 0
}
""")
# We create the remeshing utility
mmg_parameters["filename"].SetString(
file_path + "/" + mmg_parameters["filename"].GetString())
mmg_process = MeshingApplication.MmgProcess3DSurfaces(
main_model_part, mmg_parameters)
# We remesh
mmg_process.Execute()
# Finally we export to GiD
from gid_output_process import GiDOutputProcess
gid_output = GiDOutputProcess(
main_model_part, "gid_output",
KratosMultiphysics.Parameters("""
{
"result_file_configuration" : {
"gidpost_flags": {
"GiDPostMode": "GiD_PostBinary",
"WriteDeformedMeshFlag": "WriteUndeformed",
"WriteConditionsFlag": "WriteConditions",
"MultiFileFlag": "SingleFile"
},
"nodal_results" : ["DISTANCE"]
}
}
"""))
#gid_output.ExecuteInitialize()
#gid_output.ExecuteBeforeSolutionLoop()
#gid_output.ExecuteInitializeSolutionStep()
#gid_output.PrintOutput()
#gid_output.ExecuteFinalizeSolutionStep()
#gid_output.ExecuteFinalize()
from compare_two_files_check_process import CompareTwoFilesCheckProcess
check_parameters = KratosMultiphysics.Parameters("""
{
"reference_file_name" : "mmg_eulerian_test/coarse_sphere_skin_test_result.sol",
"output_file_name" : "mmg_eulerian_test/coarse_sphere_skin_test_step=0.sol",
"dimension" : 3,
"comparison_type" : "sol_file"
}
""")
check_parameters["reference_file_name"].SetString(
file_path + "/" +
check_parameters["reference_file_name"].GetString())
check_parameters["output_file_name"].SetString(
file_path + "/" + check_parameters["output_file_name"].GetString())
check_files = CompareTwoFilesCheckProcess(check_parameters)
check_files.ExecuteInitialize()
check_files.ExecuteBeforeSolutionLoop()
check_files.ExecuteInitializeSolutionStep()
check_files.ExecuteFinalizeSolutionStep()
check_files.ExecuteFinalize()
import from_json_check_result_process
check_parameters = KratosMultiphysics.Parameters("""
{
"check_variables" : ["DISTANCE"],
"input_file_name" : "mmg_eulerian_test/distante_extrapolation_skin.json",
"model_part_name" : "MainModelPart",
"time_frequency" : 0.0
}
""")
check_parameters["input_file_name"].SetString(
os.path.join(file_path,
check_parameters["input_file_name"].GetString()))
check = from_json_check_result_process.FromJsonCheckResultProcess(
current_model, check_parameters)
check.ExecuteInitialize()
check.ExecuteBeforeSolutionLoop()
check.ExecuteFinalizeSolutionStep()
def test_remesh_sphere(self):
KratosMultiphysics.Logger.GetDefaultOutput().SetSeverity(
KratosMultiphysics.Logger.Severity.WARNING)
# We create the model part
current_model = KratosMultiphysics.Model()
main_model_part = current_model.CreateModelPart("MainModelPart")
main_model_part.ProcessInfo.SetValue(KratosMultiphysics.DOMAIN_SIZE, 3)
main_model_part.ProcessInfo.SetValue(KratosMultiphysics.TIME, 0.0)
main_model_part.ProcessInfo.SetValue(KratosMultiphysics.DELTA_TIME,
1.0)
#main_model_part.ProcessInfo.SetValue(KratosMultiphysics.STEP, 1)
# We add the variables needed
main_model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.DISTANCE)
main_model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.DISTANCE_GRADIENT)
main_model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.NODAL_H)
main_model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.NODAL_AREA)
# We import the model main_model_part
file_path = os.path.dirname(os.path.realpath(__file__))
KratosMultiphysics.ModelPartIO(file_path +
"/mmg_eulerian_test/coarse_sphere_test"
).ReadModelPart(main_model_part)
# We calculate the gradient of the distance variable
find_nodal_h = KratosMultiphysics.FindNodalHProcess(main_model_part)
find_nodal_h.Execute()
local_gradient = KratosMultiphysics.ComputeNodalGradientProcess3D(
main_model_part, KratosMultiphysics.DISTANCE,
KratosMultiphysics.DISTANCE_GRADIENT,
KratosMultiphysics.NODAL_AREA)
local_gradient.Execute()
# We set to zero the metric
ZeroVector = KratosMultiphysics.Vector(6)
ZeroVector[0] = 0.0
ZeroVector[1] = 0.0
ZeroVector[2] = 0.0
ZeroVector[3] = 0.0
ZeroVector[4] = 0.0
ZeroVector[5] = 0.0
for node in main_model_part.Nodes:
node.SetValue(MeshingApplication.METRIC_TENSOR_3D, ZeroVector)
# We define a metric using the ComputeLevelSetSolMetricProcess
MetricParameters = KratosMultiphysics.Parameters("""
{
"minimal_size" : 1.0e-1,
"enforce_current" : false,
"anisotropy_remeshing" : false,
"anisotropy_parameters" :{
"hmin_over_hmax_anisotropic_ratio" : 0.15,
"boundary_layer_max_distance" : 1.0e-4,
"interpolation" : "Linear"
}
}
""")
metric_process = MeshingApplication.ComputeLevelSetSolMetricProcess3D(
main_model_part, KratosMultiphysics.DISTANCE_GRADIENT,
MetricParameters)
metric_process.Execute()
mmg_parameters = KratosMultiphysics.Parameters("""
{
"filename" : "mmg_eulerian_test/coarse_sphere_test",
"save_external_files" : true,
"echo_level" : 0
}
""")
# We create the remeshing utility
mmg_parameters["filename"].SetString(
file_path + "/" + mmg_parameters["filename"].GetString())
mmg_process = MeshingApplication.MmgProcess3D(main_model_part,
mmg_parameters)
# We remesh
mmg_process.Execute()
# Finally we export to GiD
from gid_output_process import GiDOutputProcess
gid_output = GiDOutputProcess(
main_model_part, "gid_output",
KratosMultiphysics.Parameters("""
{
"result_file_configuration" : {
"gidpost_flags": {
"GiDPostMode": "GiD_PostBinary",
"WriteDeformedMeshFlag": "WriteUndeformed",
"WriteConditionsFlag": "WriteConditions",
"MultiFileFlag": "SingleFile"
},
"nodal_results" : ["DISTANCE"]
}
}
"""))
#gid_output.ExecuteInitialize()
#gid_output.ExecuteBeforeSolutionLoop()
#gid_output.ExecuteInitializeSolutionStep()
#gid_output.PrintOutput()
#gid_output.ExecuteFinalizeSolutionStep()
#gid_output.ExecuteFinalize()
from compare_two_files_check_process import CompareTwoFilesCheckProcess
check_parameters = KratosMultiphysics.Parameters("""
{
"reference_file_name" : "mmg_eulerian_test/coarse_sphere_test_result.sol",
"output_file_name" : "mmg_eulerian_test/coarse_sphere_test_step=0.sol",
"dimension" : 3,
"comparison_type" : "sol_file"
}
""")
check_parameters["reference_file_name"].SetString(
file_path + "/" +
check_parameters["reference_file_name"].GetString())
check_parameters["output_file_name"].SetString(
file_path + "/" + check_parameters["output_file_name"].GetString())
check_files = CompareTwoFilesCheckProcess(check_parameters)
check_files.ExecuteInitialize()
check_files.ExecuteBeforeSolutionLoop()
check_files.ExecuteInitializeSolutionStep()
check_files.ExecuteFinalizeSolutionStep()
check_files.ExecuteFinalize()
import from_json_check_result_process
check_parameters = KratosMultiphysics.Parameters("""
{
"check_variables" : ["DISTANCE"],
"input_file_name" : "mmg_eulerian_test/distante_extrapolation.json",
"model_part_name" : "MainModelPart",
"time_frequency" : 0.0
}
""")
check_parameters["input_file_name"].SetString(
file_path + "/" + check_parameters["input_file_name"].GetString())
check = from_json_check_result_process.FromJsonCheckResultProcess(
current_model, check_parameters)
check.ExecuteInitialize()
check.ExecuteBeforeSolutionLoop()
check.ExecuteFinalizeSolutionStep()
def _dynamic_search_tests(self, input_filename, num_nodes):
KM.Logger.GetDefaultOutput().SetSeverity(KM.Logger.Severity.WARNING)
self.model = KM.Model()
self.main_model_part = self.model.CreateModelPart("Structure", 2)
## Creation of the Kratos model (build sub_model_parts or submeshes)
self.StructureModel = {"Structure": self.main_model_part}
self.main_model_part.AddNodalSolutionStepVariable(KM.DISPLACEMENT)
self.main_model_part.AddNodalSolutionStepVariable(KM.VELOCITY)
self.main_model_part.AddNodalSolutionStepVariable(KM.ACCELERATION)
self.main_model_part.AddNodalSolutionStepVariable(
KM.VOLUME_ACCELERATION)
self.main_model_part.AddNodalSolutionStepVariable(KM.REACTION)
self.main_model_part.AddNodalSolutionStepVariable(KM.NORMAL)
self.main_model_part.AddNodalSolutionStepVariable(
CSMA.LAGRANGE_MULTIPLIER_CONTACT_PRESSURE)
self.main_model_part.AddNodalSolutionStepVariable(CSMA.WEIGHTED_GAP)
self.main_model_part.AddNodalSolutionStepVariable(KM.NODAL_H)
self.main_model_part.CloneTimeStep(1.01)
KM.ModelPartIO(input_filename).ReadModelPart(self.main_model_part)
KM.VariableUtils().AddDof(KM.DISPLACEMENT_X, KM.REACTION_X,
self.main_model_part)
KM.VariableUtils().AddDof(KM.DISPLACEMENT_Y, KM.REACTION_Y,
self.main_model_part)
KM.VariableUtils().AddDof(KM.DISPLACEMENT_Z, KM.REACTION_Z,
self.main_model_part)
KM.VariableUtils().AddDof(CSMA.LAGRANGE_MULTIPLIER_CONTACT_PRESSURE,
CSMA.WEIGHTED_GAP, self.main_model_part)
if (self.main_model_part.HasSubModelPart("Contact")):
interface_model_part = self.main_model_part.GetSubModelPart(
"Contact")
else:
interface_model_part = self.main_model_part.CreateSubModelPart(
"Contact")
self.contact_model_part = self.main_model_part.GetSubModelPart(
"DISPLACEMENT_Displacement_Auto2")
model_part_slave = self.main_model_part.GetSubModelPart(
"Parts_Parts_Auto1")
model_part_master = self.main_model_part.GetSubModelPart(
"Parts_Parts_Auto2")
KM.VariableUtils().SetFlag(KM.SLAVE, False,
self.contact_model_part.Nodes)
KM.VariableUtils().SetFlag(KM.MASTER, True,
self.contact_model_part.Nodes)
KM.VariableUtils().SetFlag(KM.SLAVE, True, model_part_slave.Nodes)
KM.VariableUtils().SetFlag(KM.MASTER, False, model_part_slave.Nodes)
for node in model_part_slave.Nodes:
# DEBUG
#node.X -= 9.81 / 32.0
#node.SetSolutionStepValue(KM.DISPLACEMENT_X, -9.81 / 32.0)
node.SetSolutionStepValue(KM.ACCELERATION_X, 1, -9.81)
del (node)
self.main_model_part.ProcessInfo[KM.STEP] = 1
self.main_model_part.ProcessInfo[KM.DELTA_TIME] = 0.5
for prop in self.main_model_part.GetProperties():
prop[CSMA.INTEGRATION_ORDER_CONTACT] = 3
self.main_model_part.ProcessInfo[CSMA.ACTIVE_CHECK_FACTOR] = 3.0e-1
KM.VariableUtils().SetFlag(KM.INTERFACE, True,
self.contact_model_part.Nodes)
pre_process = CSMA.InterfacePreprocessCondition(self.main_model_part)
interface_parameters = KM.Parameters(
"""{"simplify_geometry": false}""")
pre_process.GenerateInterfacePart3D(self.contact_model_part,
interface_parameters)
# We copy the conditions to the ContactSubModelPart
for cond in self.contact_model_part.Conditions:
interface_model_part.AddCondition(cond)
del (cond)
for node in self.contact_model_part.Nodes:
interface_model_part.AddNode(node, 0)
del (node)
# We compute NODAL_H that can be used in the search and some values computation
self.find_nodal_h = KM.FindNodalHProcess(self.contact_model_part)
self.find_nodal_h.Execute()
# We initialize the conditions
alm_init_var = CSMA.ALMFastInit(self.contact_model_part)
alm_init_var.Execute()
search_parameters = KM.Parameters("""
{
"dynamic_search" : true
}
""")
if (num_nodes == 3):
contact_search = CSMA.TreeContactSearch3D3N(
self.main_model_part, search_parameters)
else:
contact_search = CSMA.TreeContactSearch3D4N(
self.main_model_part, search_parameters)
# We initialize the search utility
contact_search.CreatePointListMortar()
contact_search.InitializeMortarConditions()
contact_search.UpdateMortarConditions()
## DEBUG
#self.__post_process()
import from_json_check_result_process
check_parameters = KM.Parameters("""
{
"check_variables" : ["NORMAL_GAP"],
"input_file_name" : "",
"model_part_name" : "Structure",
"historical_value" : false,
"time_frequency" : 0.0,
"sub_model_part_name" : "Parts_Parts_Auto1"
}
""")
check_parameters["input_file_name"].SetString(input_filename +
"_dynamic_search.json")
check = from_json_check_result_process.FromJsonCheckResultProcess(
self.StructureModel, check_parameters)
check.ExecuteInitialize()
check.ExecuteBeforeSolutionLoop()
check.ExecuteFinalizeSolutionStep()
