def _initialize_search_conditions(self):
""" This method initializes some conditions values
Keyword arguments:
self -- It signifies an instance of a class.
"""
# We call to the base process
super(MPCContactProcess, self)._initialize_search_conditions()
# Assign the friction friction_coefficients
if self.is_frictional:
for key in self.settings["search_model_part"].keys():
if self.settings["search_model_part"][key].size() > 0:
sub_search_model_part_name = "ContactSub"+key
if self._get_process_model_part().HasSubModelPart(sub_search_model_part_name):
sub_search_model_part = self._get_process_model_part().GetSubModelPart(sub_search_model_part_name)
else:
sub_search_model_part = self._get_process_model_part().CreateSubModelPart(sub_search_model_part_name)
for prop in sub_search_model_part.GetProperties():
if not prop.Has(KM.FRICTION_COEFFICIENT):
prop[KM.FRICTION_COEFFICIENT] = self.contact_settings["friction_coefficients"][key].GetDouble()
else:
KM.Logger.PrintWarning("FRICTION_COEFFICIENT: ", "{:.2e}".format(prop[KM.FRICTION_COEFFICIENT]), " already defined in Properties, please define it as a condition pair property")
alm_init_var = CSMA.ALMFastInit(self._get_process_model_part())
alm_init_var.Execute()
def _initialize_search_conditions(self):
""" This method initializes some conditions values
Keyword arguments:
self -- It signifies an instance of a class.
"""
# We call to the base process
super(ALMContactProcess, self)._initialize_search_conditions()
alm_init_var = CSMA.ALMFastInit(self._get_process_model_part())
alm_init_var.Execute()
def __base_test_integration(self, input_filename, num_nodes):
KratosMultiphysics.Logger.GetDefaultOutput().SetSeverity(
KratosMultiphysics.Logger.Severity.WARNING)
self.main_model_part = KratosMultiphysics.ModelPart("Structure")
self.main_model_part.SetBufferSize(2)
self.main_model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.DISPLACEMENT)
self.main_model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.VELOCITY)
self.main_model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.ACCELERATION)
self.main_model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.REACTION)
self.main_model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.NORMAL)
self.main_model_part.AddNodalSolutionStepVariable(
ContactStructuralMechanicsApplication.
LAGRANGE_MULTIPLIER_CONTACT_PRESSURE)
self.main_model_part.AddNodalSolutionStepVariable(
ContactStructuralMechanicsApplication.WEIGHTED_GAP)
self.main_model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.NODAL_H)
KratosMultiphysics.ModelPartIO(input_filename).ReadModelPart(
self.main_model_part)
KratosMultiphysics.VariableUtils().AddDof(
KratosMultiphysics.DISPLACEMENT_X, KratosMultiphysics.REACTION_X,
self.main_model_part)
KratosMultiphysics.VariableUtils().AddDof(
KratosMultiphysics.DISPLACEMENT_Y, KratosMultiphysics.REACTION_Y,
self.main_model_part)
KratosMultiphysics.VariableUtils().AddDof(
KratosMultiphysics.DISPLACEMENT_Z, KratosMultiphysics.REACTION_Z,
self.main_model_part)
KratosMultiphysics.VariableUtils().AddDof(
ContactStructuralMechanicsApplication.
LAGRANGE_MULTIPLIER_CONTACT_PRESSURE,
ContactStructuralMechanicsApplication.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")
for node in self.contact_model_part.Nodes:
node.Set(KratosMultiphysics.SLAVE, False)
del (node)
model_part_slave = self.main_model_part.GetSubModelPart(
"Parts_Parts_Auto1")
for node in model_part_slave.Nodes:
node.Set(KratosMultiphysics.SLAVE, True)
del (node)
for prop in self.main_model_part.GetProperties():
prop[ContactStructuralMechanicsApplication.
INTEGRATION_ORDER_CONTACT] = 3
self.main_model_part.ProcessInfo[
ContactStructuralMechanicsApplication.ACTIVE_CHECK_FACTOR] = 3.0e-1
for node in self.contact_model_part.Nodes:
node.Set(KratosMultiphysics.INTERFACE, True)
Preprocess = ContactStructuralMechanicsApplication.InterfacePreprocessCondition(
self.main_model_part)
interface_parameters = KratosMultiphysics.Parameters(
"""{"simplify_geometry": false}""")
Preprocess.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 initialize the conditions
alm_init_var = ContactStructuralMechanicsApplication.ALMFastInit(
self.contact_model_part)
alm_init_var.Execute()
search_parameters = KratosMultiphysics.Parameters("""
{
"search_factor" : 3.5,
"allocation_size" : 1000,
"check_gap" : "NoCheck",
"type_search" : "InRadius"
}
""")
if (num_nodes == 3):
contact_search = ContactStructuralMechanicsApplication.TreeContactSearch3D3N(
self.main_model_part, search_parameters)
else:
contact_search = ContactStructuralMechanicsApplication.TreeContactSearch3D4N(
self.main_model_part, search_parameters)
# We initialize the search utility
contact_search.CreatePointListMortar()
contact_search.InitializeMortarConditions()
contact_search.UpdateMortarConditions()
if (num_nodes == 3):
## DEBUG
#print(self.main_model_part)
#self.__post_process()
self.exact_integration = KratosMultiphysics.ExactMortarIntegrationUtility3D3N(
3)
else:
## DEBUG
#print(self.main_model_part)
#self.__post_process()
self.exact_integration = KratosMultiphysics.ExactMortarIntegrationUtility3D4N(
3)
def ExecuteInitialize(self):
# Assigning master and slave sides
self._assign_slave_nodes()
# Appending the conditions created to the self.main_model_part
computing_model_part = self.main_model_part.GetSubModelPart(
self.computing_model_part_name)
if (computing_model_part.HasSubModelPart("Contact")):
preprocess = False
interface_model_part = computing_model_part.GetSubModelPart(
"Contact")
else:
preprocess = True
interface_model_part = computing_model_part.CreateSubModelPart(
"Contact")
# We consider frictional contact (We use the SLIP flag because was the easiest way)
if self.params["contact_type"].GetString() == "Frictional":
computing_model_part.Set(KratosMultiphysics.SLIP, True)
else:
computing_model_part.Set(KratosMultiphysics.SLIP, False)
# We recompute the normal at each iteration (false by default)
self.main_model_part.ProcessInfo[
ContactStructuralMechanicsApplication.
CONSIDER_NORMAL_VARIATION] = self.normal_variation
# We recompute the pairs at each iteration (true by default)
self.main_model_part.ProcessInfo[
ContactStructuralMechanicsApplication.
CONSIDER_PAIR_VARIATION] = self.params["pair_variation"].GetBool()
# We set the max gap factor for the gap adaptation
max_gap_factor = self.params["max_gap_factor"].GetDouble()
self.main_model_part.ProcessInfo[
ContactStructuralMechanicsApplication.ADAPT_PENALTY] = (
max_gap_factor > 0.0)
self.main_model_part.ProcessInfo[ContactStructuralMechanicsApplication.
MAX_GAP_FACTOR] = max_gap_factor
self.main_model_part.ProcessInfo[
ContactStructuralMechanicsApplication.
ACTIVE_CHECK_FACTOR] = self.params[
"active_check_factor"].GetDouble()
# We set the value that scales in the tangent direction the penalty and scale parameter
if self.params["contact_type"].GetString() == "Frictional":
self.main_model_part.ProcessInfo[
ContactStructuralMechanicsApplication.
TANGENT_FACTOR] = self.params["tangent_factor"].GetDouble()
# Copying the properties in the contact model part
self.contact_model_part.SetProperties(
computing_model_part.GetProperties())
# Setting the integration order and active check factor
for prop in computing_model_part.GetProperties():
prop[ContactStructuralMechanicsApplication.
INTEGRATION_ORDER_CONTACT] = self.params[
"integration_order"].GetInt()
for node in self.contact_model_part.Nodes:
node.Set(KratosMultiphysics.INTERFACE, True)
del (node)
#If the conditions doesn't exist we create them
if (preprocess == True):
self._interface_preprocess(computing_model_part)
else:
master_slave_process = ContactStructuralMechanicsApplication.MasterSlaveProcess(
computing_model_part)
master_slave_process.Execute()
# We initialize the contact values
self._initialize_contact_values(computing_model_part)
# When all conditions are simultaneously master and slave
self._assign_slave_conditions()
# We initialize the ALM parameters
self._initialize_alm_parameters(computing_model_part)
# We copy the conditions to the ContactSubModelPart
if (preprocess == True):
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)
# Creating the search
self._create_main_search(computing_model_part)
# We initialize the conditions
alm_init_var = ContactStructuralMechanicsApplication.ALMFastInit(
self.contact_model_part)
alm_init_var.Execute()
# We initialize the search utility
self.contact_search.CreatePointListMortar()
self.contact_search.InitializeMortarConditions()
def __base_test_mapping(self, input_filename, num_nodes, pure_implicit):
self.main_model_part = KratosMultiphysics.ModelPart("Structure")
## Creation of the Kratos model (build sub_model_parts or submeshes)
self.StructureModel = {"Structure": self.main_model_part}
self.main_model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.DISPLACEMENT)
self.main_model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.TEMPERATURE)
self.main_model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.NORMAL)
self.main_model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.NORMAL_CONTACT_STRESS)
self.main_model_part.AddNodalSolutionStepVariable(
ContactStructuralMechanicsApplication.WEIGHTED_GAP)
self.main_model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.NODAL_H)
self.main_model_part.CloneTimeStep(1.01)
KratosMultiphysics.ModelPartIO(input_filename).ReadModelPart(
self.main_model_part)
KratosMultiphysics.VariableUtils().AddDof(
KratosMultiphysics.DISPLACEMENT_X, self.main_model_part)
KratosMultiphysics.VariableUtils().AddDof(
KratosMultiphysics.DISPLACEMENT_Y, self.main_model_part)
KratosMultiphysics.VariableUtils().AddDof(
KratosMultiphysics.DISPLACEMENT_Z, self.main_model_part)
KratosMultiphysics.VariableUtils().AddDof(
KratosMultiphysics.TEMPERATURE, 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.mapping_model_part = self.main_model_part.GetSubModelPart(
"DISPLACEMENT_Displacement_Auto2")
self.model_part_slave = self.main_model_part.GetSubModelPart(
"Parts_Parts_Auto1")
for node in self.model_part_slave.Nodes:
node.Set(KratosMultiphysics.SLAVE, True)
node.Set(KratosMultiphysics.MASTER, False)
del (node)
self.model_part_master = self.main_model_part.GetSubModelPart(
"Parts_Parts_Auto2")
for node in self.model_part_master.Nodes:
node.Set(KratosMultiphysics.MASTER, True)
node.Set(KratosMultiphysics.SLAVE, False)
del (node)
for prop in self.main_model_part.GetProperties():
prop[ContactStructuralMechanicsApplication.
INTEGRATION_ORDER_CONTACT] = 3
self.main_model_part.ProcessInfo[
ContactStructuralMechanicsApplication.ACTIVE_CHECK_FACTOR] = 3.0e-1
for node in self.mapping_model_part.Nodes:
node.Set(KratosMultiphysics.INTERFACE, True)
Preprocess = ContactStructuralMechanicsApplication.InterfacePreprocessCondition(
self.main_model_part)
interface_parameters = KratosMultiphysics.Parameters(
"""{"condition_name": "", "final_string": "", "simplify_geometry": false}"""
)
interface_parameters["condition_name"].SetString(
"ALMFrictionlessMortarContact")
Preprocess.GenerateInterfacePart3D(self.main_model_part,
self.mapping_model_part,
interface_parameters)
# We copy the conditions to the ContactSubModelPart
for cond in self.mapping_model_part.Conditions:
interface_model_part.AddCondition(cond)
del (cond)
for node in self.mapping_model_part.Nodes:
interface_model_part.AddNode(node, 0)
del (node)
# We initialize the conditions
alm_init_var = ContactStructuralMechanicsApplication.ALMFastInit(
self.mapping_model_part)
alm_init_var.Execute()
search_parameters = KratosMultiphysics.Parameters("""
{
"search_factor" : 3.5,
"allocation_size" : 1000,
"type_search" : "InRadius",
"use_exact_integration" : true
}
""")
contact_search = ContactStructuralMechanicsApplication.TreeContactSearch(
self.main_model_part, search_parameters)
# We initialize the search utility
contact_search.CreatePointListMortar()
contact_search.InitializeMortarConditions()
contact_search.UpdateMortarConditions()
for node in self.model_part_master.Nodes:
x = node.X
y = node.Y
z = node.Z
node.SetSolutionStepValue(KratosMultiphysics.TEMPERATURE, z)
node.SetSolutionStepValue(KratosMultiphysics.DISPLACEMENT_X, x)
node.SetSolutionStepValue(KratosMultiphysics.DISPLACEMENT_Y, y)
node.SetSolutionStepValue(KratosMultiphysics.DISPLACEMENT_Z, z)
del (node)
map_parameters = KratosMultiphysics.Parameters("""
{
"echo_level" : 0,
"absolute_convergence_tolerance" : 1.0e-9,
"relative_convergence_tolerance" : 1.0e-4,
"max_number_iterations" : 10,
"integration_order" : 2
}
""")
if (pure_implicit == True):
#linear_solver = ExternalSolversApplication.SuperLUSolver()
linear_solver = KratosMultiphysics.SkylineLUFactorizationSolver()
if (num_nodes == 3):
self.mortar_mapping_double = KratosMultiphysics.SimpleMortarMapperProcess3D3NDoubleHistorical(
self.main_model_part, KratosMultiphysics.TEMPERATURE,
map_parameters, linear_solver)
self.mortar_mapping_vector = KratosMultiphysics.SimpleMortarMapperProcess3D3NVectorHistorical(
self.main_model_part, KratosMultiphysics.DISPLACEMENT,
map_parameters, linear_solver)
else:
self.mortar_mapping_double = KratosMultiphysics.SimpleMortarMapperProcess3D4NDoubleHistorical(
self.main_model_part, KratosMultiphysics.TEMPERATURE,
map_parameters, linear_solver)
self.mortar_mapping_vector = KratosMultiphysics.SimpleMortarMapperProcess3D4NVectorHistorical(
self.main_model_part, KratosMultiphysics.DISPLACEMENT,
map_parameters, linear_solver)
else:
if (num_nodes == 3):
self.mortar_mapping_double = KratosMultiphysics.SimpleMortarMapperProcess3D3NDoubleHistorical(
self.main_model_part, KratosMultiphysics.TEMPERATURE,
map_parameters)
self.mortar_mapping_vector = KratosMultiphysics.SimpleMortarMapperProcess3D3NVectorHistorical(
self.main_model_part, KratosMultiphysics.DISPLACEMENT,
map_parameters)
else:
self.mortar_mapping_double = KratosMultiphysics.SimpleMortarMapperProcess3D4NDoubleHistorical(
self.main_model_part, KratosMultiphysics.TEMPERATURE,
map_parameters)
self.mortar_mapping_vector = KratosMultiphysics.SimpleMortarMapperProcess3D4NVectorHistorical(
self.main_model_part, KratosMultiphysics.DISPLACEMENT,
map_parameters)
def __base_test_mapping(self, input_filename, num_nodes, pure_implicit):
KratosMultiphysics.Logger.GetDefaultOutput().SetSeverity(KratosMultiphysics.Logger.Severity.WARNING)
self.main_model_part = KratosMultiphysics.ModelPart("Structure")
self.main_model_part.SetBufferSize(2)
## Creation of the Kratos model (build sub_model_parts or submeshes)
self.StructureModel = {"Structure": self.main_model_part}
self.main_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.DISPLACEMENT)
self.main_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.VELOCITY)
self.main_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.ACCELERATION)
self.main_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.TEMPERATURE)
self.main_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.NORMAL)
self.main_model_part.AddNodalSolutionStepVariable(ContactStructuralMechanicsApplication.LAGRANGE_MULTIPLIER_CONTACT_PRESSURE)
self.main_model_part.AddNodalSolutionStepVariable(ContactStructuralMechanicsApplication.WEIGHTED_GAP)
self.main_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.NODAL_H)
self.main_model_part.CloneTimeStep(1.01)
KratosMultiphysics.ModelPartIO(input_filename).ReadModelPart(self.main_model_part)
KratosMultiphysics.VariableUtils().AddDof(KratosMultiphysics.DISPLACEMENT_X,self.main_model_part)
KratosMultiphysics.VariableUtils().AddDof(KratosMultiphysics.DISPLACEMENT_Y,self.main_model_part)
KratosMultiphysics.VariableUtils().AddDof(KratosMultiphysics.DISPLACEMENT_Z,self.main_model_part)
KratosMultiphysics.VariableUtils().AddDof(KratosMultiphysics.TEMPERATURE, 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.mapping_model_part = self.main_model_part.GetSubModelPart("DISPLACEMENT_Displacement_Auto2")
self.model_part_slave = self.main_model_part.GetSubModelPart("Parts_Parts_Auto1")
KratosMultiphysics.VariableUtils().SetFlag(KratosMultiphysics.SLAVE, True, self.model_part_slave.Nodes)
KratosMultiphysics.VariableUtils().SetFlag(KratosMultiphysics.MASTER, False, self.model_part_slave.Nodes)
self.model_part_master = self.main_model_part.GetSubModelPart("Parts_Parts_Auto2")
KratosMultiphysics.VariableUtils().SetFlag(KratosMultiphysics.SLAVE, False, self.model_part_master.Nodes)
KratosMultiphysics.VariableUtils().SetFlag(KratosMultiphysics.MASTER, True, self.model_part_master.Nodes)
for prop in self.main_model_part.GetProperties():
prop[ContactStructuralMechanicsApplication.INTEGRATION_ORDER_CONTACT] = 3
self.main_model_part.ProcessInfo[ContactStructuralMechanicsApplication.ACTIVE_CHECK_FACTOR] = 3.0e-1
for node in self.mapping_model_part.Nodes:
node.Set(KratosMultiphysics.INTERFACE, True)
Preprocess = ContactStructuralMechanicsApplication.InterfacePreprocessCondition(self.main_model_part)
interface_parameters = KratosMultiphysics.Parameters("""{"simplify_geometry": false}""")
Preprocess.GenerateInterfacePart3D(self.mapping_model_part, interface_parameters)
# We compute NODAL_H that can be used in the search and some values computation
find_nodal_h = KratosMultiphysics.FindNodalHProcess(self.mapping_model_part)
find_nodal_h.Execute()
# We copy the conditions to the ContactSubModelPart
for cond in self.mapping_model_part.Conditions:
interface_model_part.AddCondition(cond)
del(cond)
for node in self.mapping_model_part.Nodes:
interface_model_part.AddNode(node, 0)
del(node)
# We initialize the conditions
alm_init_var = ContactStructuralMechanicsApplication.ALMFastInit(self.mapping_model_part)
alm_init_var.Execute()
search_parameters = KratosMultiphysics.Parameters("""
{
"search_factor" : 3.5,
"allocation_size" : 1000,
"check_gap" : "NoCheck",
"type_search" : "InRadius"
}
""")
if (num_nodes == 3):
contact_search = ContactStructuralMechanicsApplication.TreeContactSearch3D3N(self.main_model_part, search_parameters)
else:
contact_search = ContactStructuralMechanicsApplication.TreeContactSearch3D4N(self.main_model_part, search_parameters)
# We initialize the search utility
contact_search.CreatePointListMortar()
contact_search.InitializeMortarConditions()
contact_search.UpdateMortarConditions()
for node in self.model_part_master.Nodes:
x = node.X
y = node.Y
z = node.Z
node.SetSolutionStepValue(KratosMultiphysics.TEMPERATURE, z)
node.SetSolutionStepValue(KratosMultiphysics.DISPLACEMENT_X, x)
node.SetSolutionStepValue(KratosMultiphysics.DISPLACEMENT_Y, y)
node.SetSolutionStepValue(KratosMultiphysics.DISPLACEMENT_Z, z)
del(node)
map_parameters = KratosMultiphysics.Parameters("""
{
"echo_level" : 0,
"absolute_convergence_tolerance" : 1.0e-9,
"relative_convergence_tolerance" : 1.0e-4,
"max_number_iterations" : 10,
"integration_order" : 2
}
""")
# Copy respective conditions
for cond in self.main_model_part.Conditions:
if (cond.Is(KratosMultiphysics.SLAVE)):
self.model_part_slave.AddCondition(cond)
if (cond.Is(KratosMultiphysics.MASTER)):
self.model_part_master.AddCondition(cond)
if (pure_implicit == True):
#linear_solver = ExternalSolversApplication.SuperLUSolver()
linear_solver = KratosMultiphysics.SkylineLUFactorizationSolver()
if (num_nodes == 3):
self.mortar_mapping_double = KratosMultiphysics.SimpleMortarMapperProcess3D3NDouble(self.model_part_master, self.model_part_slave, KratosMultiphysics.TEMPERATURE, map_parameters, linear_solver)
self.mortar_mapping_vector = KratosMultiphysics.SimpleMortarMapperProcess3D3NVector(self.model_part_master, self.model_part_slave, KratosMultiphysics.DISPLACEMENT, map_parameters, linear_solver)
else:
self.mortar_mapping_double = KratosMultiphysics.SimpleMortarMapperProcess3D4NDouble(self.model_part_master, self.model_part_slave, KratosMultiphysics.TEMPERATURE, map_parameters, linear_solver)
self.mortar_mapping_vector = KratosMultiphysics.SimpleMortarMapperProcess3D4NVector(self.model_part_master, self.model_part_slave, KratosMultiphysics.DISPLACEMENT, map_parameters, linear_solver)
else:
if (num_nodes == 3):
self.mortar_mapping_double = KratosMultiphysics.SimpleMortarMapperProcess3D3NDouble(self.model_part_master, self.model_part_slave, KratosMultiphysics.TEMPERATURE, map_parameters)
self.mortar_mapping_vector = KratosMultiphysics.SimpleMortarMapperProcess3D3NVector(self.model_part_master, self.model_part_slave, KratosMultiphysics.DISPLACEMENT, map_parameters)
else:
self.mortar_mapping_double = KratosMultiphysics.SimpleMortarMapperProcess3D4NDouble(self.model_part_master, self.model_part_slave, KratosMultiphysics.TEMPERATURE, map_parameters)
self.mortar_mapping_vector = KratosMultiphysics.SimpleMortarMapperProcess3D4NVector(self.model_part_master, self.model_part_slave, KratosMultiphysics.DISPLACEMENT, map_parameters)
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)
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)
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.GenerateInterfacePart(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)
for node in self.contact_model_part.Nodes:
interface_model_part.AddNode(node, 0)
# 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,
"simple_search" : false,
"normal_orientation_threshold" : 0.0
}
""")
contact_search = CSMA.ContactSearchProcess(self.main_model_part,
search_parameters)
# We initialize the search utility
contact_search.ExecuteInitialize()
contact_search.ExecuteInitializeSolutionStep()
## DEBUG
#self.__post_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.model, check_parameters)
check.ExecuteInitialize()
check.ExecuteBeforeSolutionLoop()
check.ExecuteFinalizeSolutionStep()
def ExecuteInitialize(self):
""" This method is executed at the begining to initialize the process
Keyword arguments:
self -- It signifies an instance of a class.
"""
# The computing model part
computing_model_part = self.main_model_part.GetSubModelPart(
self.computing_model_part_name)
# We compute NODAL_H that can be used in the search and some values computation
self.find_nodal_h = KM.FindNodalHProcess(computing_model_part)
self.find_nodal_h.Execute()
# Assigning master and slave sides
self._assign_slave_flags()
# Appending the conditions created to the self.main_model_part
if (computing_model_part.HasSubModelPart("Contact")):
preprocess = False
interface_model_part = computing_model_part.GetSubModelPart(
"Contact")
else:
preprocess = True
interface_model_part = computing_model_part.CreateSubModelPart(
"Contact")
# We call the process info
process_info = self.main_model_part.ProcessInfo
# We recompute the normal at each iteration (false by default)
process_info[CSMA.CONSIDER_NORMAL_VARIATION] = self.normal_variation
# Initialize ACTIVE_SET_CONVERGED
process_info[CSMA.ACTIVE_SET_CONVERGED] = True
# We set the max gap factor for the gap adaptation
max_gap_factor = self.settings["advance_ALM_parameters"][
"max_gap_factor"].GetDouble()
process_info[CSMA.ADAPT_PENALTY] = self.settings[
"advance_ALM_parameters"]["adapt_penalty"].GetBool()
process_info[CSMA.MAX_GAP_FACTOR] = max_gap_factor
process_info[CSMA.ACTIVE_CHECK_FACTOR] = self.settings[
"search_parameters"]["active_check_factor"].GetDouble()
# We set the interface flag
KM.VariableUtils().SetFlag(KM.INTERFACE, True,
self.contact_model_part.Nodes)
if (len(self.contact_model_part.Conditions) == 0):
KM.Logger.PrintInfo(
"Contact Process",
"Using nodes for interface. We recommend to use conditions instead"
)
else:
KM.VariableUtils().SetFlag(KM.INTERFACE, True,
self.contact_model_part.Conditions)
#If the conditions doesn't exist we create them
if (preprocess is True):
self._interface_preprocess(computing_model_part)
else:
master_slave_process = CSMA.MasterSlaveProcess(
computing_model_part)
master_slave_process.Execute()
# Setting the integration order and active check factor
for prop in self.contact_model_part.GetProperties():
prop[CSMA.INTEGRATION_ORDER_CONTACT] = self.settings[
"integration_order"].GetInt()
# We initialize the contact values
self._initialize_contact_values(computing_model_part)
# We initialize the ALM parameters
self._initialize_alm_parameters(computing_model_part)
# We copy the conditions to the ContactSubModelPart
if (preprocess is True):
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)
# Creating the search
self._create_main_search(computing_model_part)
# We initialize the conditions
alm_init_var = CSMA.ALMFastInit(self.contact_model_part)
alm_init_var.Execute()
# We initialize the search utility
self.contact_search.CreatePointListMortar()
self.contact_search.InitializeMortarConditions()
def ExecuteInitialize(self):
""" This method is executed at the begining to initialize the process
Keyword arguments:
self -- It signifies an instance of a class.
"""
# First we generate or identify the different model parts
if (self.computing_model_part.HasSubModelPart("Contact")):
self.preprocess = False
# We get the submodelpart
self.contact_model_part = self.computing_model_part.GetSubModelPart(
"Contact")
else:
self.preprocess = True
# We create the submodelpart
self.contact_model_part = self.computing_model_part.CreateSubModelPart(
"Contact")
# In case of no "Contact" model part we create it
if (self.preprocess is True):
# In case no model part is assigned we detect the skin
self.count_contact_model_part = 0
for key in self.settings["contact_model_part"].keys():
if (self.settings["contact_model_part"][key].size() > 0):
self.count_contact_model_part += 1
if (self.count_contact_model_part == 0):
self.__detect_skin(self.main_model_part)
else:
for key in self.settings["contact_model_part"].keys():
if (self.settings["contact_model_part"][key].size() > 0):
self.__generate_contact_model_part_from_input_list(
self.settings["contact_model_part"][key], key)
# We compute NODAL_H that can be used in the search and some values computation
self.find_nodal_h = KM.FindNodalHProcess(self.computing_model_part)
self.find_nodal_h.Execute()
## We recompute the serach factor and the check in function of the relative size of the mesh
if (self.settings["search_parameters"]["adapt_search"].GetBool() is
True):
factor = CSMA.ContactUtilities.CalculateRelativeSizeMesh(
self.computing_model_part)
KM.Logger.PrintWarning("SEARCH ADAPT FACTOR: ",
"{:.2e}".format(factor))
search_factor = self.settings["search_parameters"][
"search_factor"].GetDouble() * factor
self.settings["search_parameters"]["search_factor"].SetDouble(
search_factor)
active_check_factor = self.settings["search_parameters"][
"active_check_factor"].GetDouble() * factor
self.settings["search_parameters"][
"active_check_factor"].SetDouble(active_check_factor)
# We call the process info
process_info = self.main_model_part.ProcessInfo
# We recompute the normal at each iteration (false by default)
process_info[CSMA.CONSIDER_NORMAL_VARIATION] = self.normal_variation
# Initialize ACTIVE_SET_CONVERGED
process_info[CSMA.ACTIVE_SET_CONVERGED] = True
# We set the max gap factor for the gap adaptation
max_gap_factor = self.settings["advance_ALM_parameters"][
"max_gap_factor"].GetDouble()
process_info[CSMA.ADAPT_PENALTY] = self.settings[
"advance_ALM_parameters"]["adapt_penalty"].GetBool()
process_info[CSMA.MAX_GAP_FACTOR] = max_gap_factor
process_info[CSMA.ACTIVE_CHECK_FACTOR] = self.settings[
"search_parameters"]["active_check_factor"].GetDouble()
#If the conditions doesn't exist we create them
if (self.preprocess is False):
master_slave_process = CSMA.MasterSlaveProcess(
self.computing_model_part)
master_slave_process.Execute()
# Setting the integration order and active check factor
for prop in self.contact_model_part.GetProperties():
prop[CSMA.INTEGRATION_ORDER_CONTACT] = self.settings[
"integration_order"].GetInt()
# We initialize the contact values
self._initialize_contact_values()
# We initialize the ALM parameters
self._initialize_alm_parameters()
# Creating the search
self.contact_search = {}
for key in self.settings["contact_model_part"].keys():
if (self.settings["contact_model_part"][key].size() > 0):
self._create_main_search(key)
# We initialize the conditions
alm_init_var = CSMA.ALMFastInit(self.contact_model_part)
alm_init_var.Execute()
for key in self.settings["contact_model_part"].keys():
if (self.settings["contact_model_part"][key].size() > 0):
# We initialize the search utility
self.contact_search[key].CheckContactModelParts()
self.contact_search[key].CreatePointListMortar()
self.contact_search[key].InitializeMortarConditions()
def _dynamic_search_tests(self, input_filename, num_nodes):
KratosMultiphysics.Logger.GetDefaultOutput().SetSeverity(
KratosMultiphysics.Logger.Severity.WARNING)
self.main_model_part = KratosMultiphysics.ModelPart("Structure")
self.main_model_part.SetBufferSize(2)
## Creation of the Kratos model (build sub_model_parts or submeshes)
self.StructureModel = {"Structure": self.main_model_part}
self.main_model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.DISPLACEMENT)
self.main_model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.VELOCITY)
self.main_model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.ACCELERATION)
self.main_model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.VOLUME_ACCELERATION)
self.main_model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.REACTION)
self.main_model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.NORMAL)
self.main_model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.NORMAL_CONTACT_STRESS)
self.main_model_part.AddNodalSolutionStepVariable(
ContactStructuralMechanicsApplication.WEIGHTED_GAP)
self.main_model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.NODAL_H)
self.main_model_part.CloneTimeStep(1.01)
KratosMultiphysics.ModelPartIO(input_filename).ReadModelPart(
self.main_model_part)
KratosMultiphysics.VariableUtils().AddDof(
KratosMultiphysics.DISPLACEMENT_X, KratosMultiphysics.REACTION_X,
self.main_model_part)
KratosMultiphysics.VariableUtils().AddDof(
KratosMultiphysics.DISPLACEMENT_Y, KratosMultiphysics.REACTION_Y,
self.main_model_part)
KratosMultiphysics.VariableUtils().AddDof(
KratosMultiphysics.DISPLACEMENT_Z, KratosMultiphysics.REACTION_Z,
self.main_model_part)
KratosMultiphysics.VariableUtils().AddDof(
KratosMultiphysics.NORMAL_CONTACT_STRESS,
ContactStructuralMechanicsApplication.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")
for node in self.contact_model_part.Nodes:
node.Set(KratosMultiphysics.SLAVE, False)
del (node)
model_part_slave = self.main_model_part.GetSubModelPart(
"Parts_Parts_Auto1")
for node in model_part_slave.Nodes:
node.Set(KratosMultiphysics.SLAVE, True)
# DEBUG
#node.X -= 9.81 / 32.0
#node.SetSolutionStepValue(KratosMultiphysics.DISPLACEMENT_X, -9.81 / 32.0)
node.SetSolutionStepValue(KratosMultiphysics.ACCELERATION_X, 1,
-9.81)
del (node)
model_part_master = self.main_model_part.GetSubModelPart(
"Parts_Parts_Auto2")
for node in model_part_master.Nodes:
node.Set(KratosMultiphysics.MASTER, True)
del (node)
self.main_model_part.ProcessInfo[KratosMultiphysics.STEP] = 1
self.main_model_part.ProcessInfo[KratosMultiphysics.DELTA_TIME] = 0.5
for prop in self.main_model_part.GetProperties():
prop[ContactStructuralMechanicsApplication.
INTEGRATION_ORDER_CONTACT] = 3
self.main_model_part.ProcessInfo[
ContactStructuralMechanicsApplication.ACTIVE_CHECK_FACTOR] = 3.0e-1
for node in self.contact_model_part.Nodes:
node.Set(KratosMultiphysics.INTERFACE, True)
Preprocess = ContactStructuralMechanicsApplication.InterfacePreprocessCondition(
self.main_model_part)
interface_parameters = KratosMultiphysics.Parameters(
"""{"simplify_geometry": false}""")
Preprocess.GenerateInterfacePart3D(self.main_model_part,
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 = KratosMultiphysics.FindNodalHProcess(
self.contact_model_part)
self.find_nodal_h.Execute()
# We initialize the conditions
alm_init_var = ContactStructuralMechanicsApplication.ALMFastInit(
self.contact_model_part)
alm_init_var.Execute()
search_parameters = KratosMultiphysics.Parameters("""
{
"dynamic_search" : true,
"search_factor" : 3.5,
"allocation_size" : 1000,
"check_gap" : "MappingCheck",
"type_search" : "InRadius"
}
""")
if (num_nodes == 3):
contact_search = ContactStructuralMechanicsApplication.TreeContactSearch3D3N(
self.main_model_part, search_parameters)
else:
contact_search = ContactStructuralMechanicsApplication.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 = KratosMultiphysics.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()
def __base_test_integration(self, input_filename, num_nodes):
self.main_model_part = KratosMultiphysics.ModelPart("Structure")
self.main_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.DISPLACEMENT)
self.main_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.REACTION)
self.main_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.NORMAL)
self.main_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.NORMAL_CONTACT_STRESS)
self.main_model_part.AddNodalSolutionStepVariable(ContactStructuralMechanicsApplication.WEIGHTED_GAP)
self.main_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.NODAL_H)
KratosMultiphysics.ModelPartIO(input_filename).ReadModelPart(self.main_model_part)
KratosMultiphysics.VariableUtils().AddDof(KratosMultiphysics.DISPLACEMENT_X, KratosMultiphysics.REACTION_X,self.main_model_part)
KratosMultiphysics.VariableUtils().AddDof(KratosMultiphysics.DISPLACEMENT_Y, KratosMultiphysics.REACTION_Y,self.main_model_part)
KratosMultiphysics.VariableUtils().AddDof(KratosMultiphysics.DISPLACEMENT_Z, KratosMultiphysics.REACTION_Z,self.main_model_part)
KratosMultiphysics.VariableUtils().AddDof(KratosMultiphysics.NORMAL_CONTACT_STRESS, ContactStructuralMechanicsApplication.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")
for node in self.contact_model_part.Nodes:
node.Set(KratosMultiphysics.SLAVE, False)
del(node)
model_part_slave = self.main_model_part.GetSubModelPart("Parts_Parts_Auto1")
for node in model_part_slave.Nodes:
node.Set(KratosMultiphysics.SLAVE, True)
del(node)
for prop in self.main_model_part.GetProperties():
prop[ContactStructuralMechanicsApplication.INTEGRATION_ORDER_CONTACT] = 3
prop[ContactStructuralMechanicsApplication.ACTIVE_CHECK_FACTOR] = 3.0e-1
for node in self.contact_model_part.Nodes:
node.Set(KratosMultiphysics.INTERFACE, True)
Preprocess = ContactStructuralMechanicsApplication.InterfacePreprocessCondition(self.main_model_part)
interface_parameters = KratosMultiphysics.Parameters("""{"condition_name": "", "final_string": "", "simplify_geometry": false}""")
interface_parameters["condition_name"].SetString("ALMFrictionlessMortarContact")
Preprocess.GenerateInterfacePart3D(self.main_model_part, 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 initialize the conditions
alm_init_var = ContactStructuralMechanicsApplication.ALMFastInit(self.contact_model_part)
alm_init_var.Execute()
search_parameters = KratosMultiphysics.Parameters("""
{
"search_factor" : 3.5,
"allocation_size" : 1000,
"type_search" : "InRadius",
"use_exact_integration" : true
}
""")
contact_search = ContactStructuralMechanicsApplication.TreeContactSearch(self.main_model_part, search_parameters)
# We initialize the search utility
contact_search.CreatePointListMortar()
contact_search.InitializeMortarConditions()
contact_search.UpdateMortarConditions()
if (num_nodes == 3):
## DEBUG
#self.__post_process()
#self.exact_integration = KratosMultiphysics.ExactMortarIntegrationUtility3D3N(3, True)
#print(self.main_model_part)
self.exact_integration = KratosMultiphysics.ExactMortarIntegrationUtility3D3N(3)
else:
## DEBUG
#self.__post_process()
#self.exact_integration = KratosMultiphysics.ExactMortarIntegrationUtility3D4N(3, True)
#print(self.main_model_part)
self.exact_integration = KratosMultiphysics.ExactMortarIntegrationUtility3D4N(3)
def ExecuteInitialize(self):
# Appending the conditions created to the self.main_model_part
computing_model_part = self.main_model_part.GetSubModelPart(
self.computing_model_part_name)
if (computing_model_part.HasSubModelPart("Contact")):
interface_model_part = computing_model_part.GetSubModelPart(
"Contact")
else:
interface_model_part = computing_model_part.CreateSubModelPart(
"Contact")
# We consider frictional contact (We use the SLIP flag because was the easiest way)
if self.params["contact_type"].GetString() == "Frictional":
computing_model_part.Set(KratosMultiphysics.SLIP, True)
else:
computing_model_part.Set(KratosMultiphysics.SLIP, False)
# We recompute the normal at each iteration (false by default)
self.main_model_part.ProcessInfo[
ContactStructuralMechanicsApplication.
CONSIDER_NORMAL_VARIATION] = self.normal_variation
# We recompute the pairs at each iteration (true by default)
self.main_model_part.ProcessInfo[
ContactStructuralMechanicsApplication.
CONSIDER_PAIR_VARIATION] = self.params["pair_variation"].GetBool()
# We set the max gap factor for the gap adaptation
max_gap_factor = self.params["max_gap_factor"].GetDouble()
self.main_model_part.ProcessInfo[
ContactStructuralMechanicsApplication.ADAPT_PENALTY] = (
max_gap_factor > 0.0)
self.main_model_part.ProcessInfo[ContactStructuralMechanicsApplication.
MAX_GAP_FACTOR] = max_gap_factor
# We set the value that scales in the tangent direction the penalty and scale parameter
if self.params["contact_type"].GetString() == "Frictional":
self.main_model_part.ProcessInfo[
ContactStructuralMechanicsApplication.
TANGENT_FACTOR] = self.params["tangent_factor"].GetDouble()
# Copying the properties in the contact model part
self.contact_model_part.SetProperties(
computing_model_part.GetProperties())
# Setting the integration order and active check factor
for prop in computing_model_part.GetProperties():
prop[ContactStructuralMechanicsApplication.
INTEGRATION_ORDER_CONTACT] = self.params[
"integration_order"].GetInt()
prop[ContactStructuralMechanicsApplication.
ACTIVE_CHECK_FACTOR] = self.params[
"active_check_factor"].GetDouble()
for node in self.contact_model_part.Nodes:
node.Set(KratosMultiphysics.INTERFACE, True)
del (node)
self.Preprocess = ContactStructuralMechanicsApplication.InterfacePreprocessCondition(
computing_model_part)
if self.params["contact_type"].GetString() == "Frictionless":
if self.normal_variation == True:
if self.axisymmetric == True:
condition_name = "ALMNVFrictionlessAxisymMortarContact"
else:
condition_name = "ALMNVFrictionlessMortarContact"
else:
if self.axisymmetric == True:
condition_name = "ALMFrictionlessAxisymMortarContact"
else:
condition_name = "ALMFrictionlessMortarContact"
elif self.params["contact_type"].GetString() == "Frictional":
if self.normal_variation == True:
if self.axisymmetric == True:
condition_name = "ALMNVFrictionalAxisymMortarContact"
else:
condition_name = "ALMNVFrictionalMortarContact"
else:
if self.axisymmetric == True:
condition_name = "ALMFrictionalAxisymMortarContact"
else:
condition_name = "ALMFrictionalMortarContact"
#print("MODEL PART BEFORE CREATING INTERFACE")
#print(computing_model_part)
# It should create the conditions automatically
interface_parameters = KratosMultiphysics.Parameters(
"""{"condition_name": "", "final_string": "", "simplify_geometry": false}"""
)
interface_parameters["condition_name"].SetString(condition_name)
if (self.dimension == 2):
self.Preprocess.GenerateInterfacePart2D(computing_model_part,
self.contact_model_part,
interface_parameters)
else:
self.Preprocess.GenerateInterfacePart3D(computing_model_part,
self.contact_model_part,
interface_parameters)
# When all conditions are simultaneously master and slave
if (self.params["assume_master_slave"].GetString() == ""):
for node in self.contact_model_part.Conditions:
node.Set(KratosMultiphysics.SLAVE, True)
del (node)
for cond in self.contact_model_part.Conditions:
cond.Set(KratosMultiphysics.SLAVE, True)
del (cond)
if (self.params["manual_ALM"].GetBool() == False):
# Computing the scale factors or the penalty parameters (StiffnessFactor * E_mean/h_mean)
self.find_nodal_h = KratosMultiphysics.FindNodalHProcess(
computing_model_part)
self.find_nodal_h.Execute()
alm_var_parameters = KratosMultiphysics.Parameters("""{}""")
alm_var_parameters.AddValue("stiffness_factor",
self.params["stiffness_factor"])
alm_var_parameters.AddValue("penalty_scale_factor",
self.params["penalty_scale_factor"])
self.alm_var_process = ContactStructuralMechanicsApplication.ALMVariablesCalculationProcess(
self.contact_model_part, KratosMultiphysics.NODAL_H,
alm_var_parameters)
self.alm_var_process.Execute()
# We don't consider scale factor
if (self.params["use_scale_factor"].GetBool() == False):
self.main_model_part.ProcessInfo[
KratosMultiphysics.SCALE_FACTOR] = 1.0
else:
# We set the values in the process info
self.main_model_part.ProcessInfo[
KratosMultiphysics.
INITIAL_PENALTY] = self.params["penalty"].GetDouble()
self.main_model_part.ProcessInfo[
KratosMultiphysics.
SCALE_FACTOR] = self.params["scale_factor"].GetDouble()
# We print the parameters considered
print("The parameters considered finally are: ")
print(
"SCALE_FACTOR: ", "{:.2e}".format(self.main_model_part.ProcessInfo[
KratosMultiphysics.SCALE_FACTOR]))
print(
"INITIAL_PENALTY: ",
"{:.2e}".format(self.main_model_part.ProcessInfo[
KratosMultiphysics.INITIAL_PENALTY]))
#print("MODEL PART AFTER CREATING INTERFACE")
#print(computing_model_part)
# 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)
# Creating the search
search_parameters = KratosMultiphysics.Parameters("""{}""")
search_parameters.AddValue("type_search", self.params["type_search"])
search_parameters.AddValue("allocation_size",
self.params["max_number_results"])
search_parameters.AddValue("bucket_size", self.params["bucket_size"])
search_parameters.AddValue("search_factor",
self.params["search_factor"])
search_parameters.AddValue("dual_search_check",
self.params["dual_search_check"])
search_parameters.AddValue("strict_search_check",
self.params["strict_search_check"])
search_parameters.AddValue("use_exact_integration",
self.params["use_exact_integration"])
self.contact_search = ContactStructuralMechanicsApplication.TreeContactSearch(
computing_model_part, search_parameters)
# We initialize the conditions
self.alm_init_var = ContactStructuralMechanicsApplication.ALMFastInit(
self.contact_model_part)
self.alm_init_var.Execute()
# We initialize the search utility
self.contact_search.CreatePointListMortar()
self.contact_search.InitializeMortarConditions()
