def GetConvergenceCriteria(self, error_criteria, conv_settings):
if "_with_adaptative_remesh" in error_criteria:
conv_settings["convergence_criterion"].SetString(error_criteria.replace("_with_adaptative_remesh", ""))
import contact_convergence_criteria_factory
convergence_criterion = contact_convergence_criteria_factory.convergence_criterion(conv_settings)
# If we just use the adaptative convergence criteria
if missing_meshing_dependencies:
if "adaptative_remesh" in error_criteria:
raise NameError('The AdaptativeErrorCriteria can not be used without compiling the MeshingApplication')
else:
if error_criteria == "adaptative_remesh_criteria":
adaptative_error_criteria = CSMA.ContactErrorMeshCriteria(self.adaptative_remesh_parameters["compute_error_settings"])
convergence_criterion.mechanical_convergence_criterion = KM.AndCriteria(convergence_criterion.GetMortarCriteria(False), adaptative_error_criteria)
elif "with_adaptative_remesh" in error_criteria: # If we combine the regular convergence criteria with adaptative
adaptative_error_criteria = CSMA.ContactErrorMeshCriteria(self.adaptative_remesh_parameters["compute_error_settings"])
convergence_criterion.mechanical_convergence_criterion = KM.AndCriteria(convergence_criterion.mechanical_convergence_criterion, adaptative_error_criteria)
return convergence_criterion.mechanical_convergence_criterion
# If we combine the regular convergence criteria with adaptative
if not missing_meshing_dependencies:
if "with_adaptative_remesh" in error_criteria:
adaptative_error_criteria = CSMA.ContactErrorMeshCriteria(self.adaptative_remesh_parameters["compute_error_settings"])
convergence_criterion.mechanical_convergence_criterion = KM.AndCriteria(convergence_criterion.mechanical_convergence_criterion, adaptative_error_criteria)
return convergence_criterion.mechanical_convergence_criterion
def _GenerateErrorProcess(self):
""" This method creates an erro process to compute the metric
Keyword arguments:
self -- It signifies an instance of a class.
"""
# We compute the error
error_compute_parameters = KratosMultiphysics.Parameters("""{}""")
error_compute_parameters.AddValue(
"stress_vector_variable",
self.settings["error_strategy_parameters"]
["compute_error_extra_parameters"]["stress_vector_variable"])
error_compute_parameters.AddValue(
"penalty_normal", self.settings["error_strategy_parameters"]
["compute_error_extra_parameters"]["penalty_normal"])
error_compute_parameters.AddValue(
"penalty_tangential", self.settings["error_strategy_parameters"]
["compute_error_extra_parameters"]["penalty_tangential"])
error_compute_parameters.AddValue("echo_level",
self.settings["echo_level"])
if self.domain_size == 2:
return ContactStructuralMechanicsApplication.ContactSPRErrorProcess2D(
self.main_model_part, error_compute_parameters)
else:
return ContactStructuralMechanicsApplication.ContactSPRErrorProcess3D(
self.main_model_part, error_compute_parameters)
def _create_main_search(self, key = "0"):
""" This method creates the search process that will be use during contact search
Keyword arguments:
self -- It signifies an instance of a class.
key -- The key to identify the current pair
"""
search_parameters = KM.Parameters("""{"condition_name": "", "final_string": "", "predefined_master_slave" : true, "id_name" : ""}""")
search_parameters.AddValue("type_search", self.settings["search_parameters"]["type_search"])
search_parameters.AddValue("check_gap", self.settings["search_parameters"]["check_gap"])
search_parameters.AddValue("allocation_size", self.settings["search_parameters"]["max_number_results"])
search_parameters.AddValue("bucket_size", self.settings["search_parameters"]["bucket_size"])
search_parameters.AddValue("search_factor", self.settings["search_parameters"]["search_factor"])
search_parameters.AddValue("dynamic_search", self.settings["search_parameters"]["dynamic_search"])
search_parameters.AddValue("static_check_movement", self.settings["search_parameters"]["static_check_movement"])
search_parameters.AddValue("consider_gap_threshold", self.settings["search_parameters"]["consider_gap_threshold"])
search_parameters.AddValue("debug_mode", self.settings["search_parameters"]["debug_mode"])
search_parameters["condition_name"].SetString(self._get_condition_name())
search_parameters["final_string"].SetString(self._get_final_string())
self.__assume_master_slave(key)
search_parameters["predefined_master_slave"].SetBool(self.predefined_master_slave)
search_parameters["id_name"].SetString(key)
# We compute the number of nodes of the geometry
number_nodes, number_nodes_master = self._compute_number_nodes()
# We create the search process
simple_search = self.settings["search_parameters"]["simple_search"].GetBool()
if self.dimension == 2:
if simple_search:
self.search_search[key] = CSMA.SimpleContactSearch2D2N(self.computing_model_part, search_parameters)
else:
self.search_search[key] = CSMA.AdvancedContactSearch2D2N(self.computing_model_part, search_parameters)
else:
if number_nodes == 3:
if number_nodes_master == 3:
if simple_search:
self.search_search[key] = CSMA.SimpleContactSearch3D3N(self.computing_model_part, search_parameters)
else:
self.search_search[key] = CSMA.AdvancedContactSearch3D3N(self.computing_model_part, search_parameters)
else:
if simple_search:
self.search_search[key] = CSMA.SimpleContactSearch3D3N4N(self.computing_model_part, search_parameters)
else:
self.search_search[key] = CSMA.AdvancedContactSearch3D3N4N(self.computing_model_part, search_parameters)
elif number_nodes == 4:
if number_nodes_master == 3:
if simple_search:
self.search_search[key] = CSMA.SimpleContactSearch3D4N3N(self.computing_model_part, search_parameters)
else:
self.search_search[key] = CSMA.AdvancedContactSearch3D4N3N(self.computing_model_part, search_parameters)
else:
if simple_search:
self.search_search[key] = CSMA.SimpleContactSearch3D4N(self.computing_model_part, search_parameters)
else:
self.search_search[key] = CSMA.AdvancedContactSearch3D4N(self.computing_model_part, search_parameters)
else:
raise Exception("Geometries not compatible. Check all the geometries are linear")
def _create_builder_and_solver(self):
if self.contact_settings["mortar_type"].GetString() != "":
linear_solver = self.get_linear_solver()
if self.settings["block_builder"].GetBool():
if self.settings["multi_point_constraints_used"].GetBool():
builder_and_solver = CSMA.ContactResidualBasedBlockBuilderAndSolverWithConstraints(
linear_solver)
else:
builder_and_solver = CSMA.ContactResidualBasedBlockBuilderAndSolver(
linear_solver)
else:
# We use the elimination builder and solver
if self.settings["multi_point_constraints_used"].GetBool():
if (self.GetComputingModelPart().
NumberOfMasterSlaveConstraints() > 0):
self.GetComputingModelPart().Set(
KM.TO_SPLIT) # We set the flag for some operations
builder_and_solver = CSMA.ContactResidualBasedEliminationBuilderAndSolverWithConstraints(
linear_solver)
else:
builder_and_solver = CSMA.ContactResidualBasedEliminationBuilderAndSolver(
linear_solver)
else:
builder_and_solver = super(ContactStaticMechanicalSolver,
self)._create_builder_and_solver()
return builder_and_solver
def _create_builder_and_solver(self):
if self.contact_settings["mortar_type"].GetString() != "":
linear_solver = self.get_linear_solver()
if self.settings["block_builder"].GetBool():
if self.settings["multi_point_constraints_used"].GetBool():
builder_and_solver = CSMA.ContactResidualBasedBlockBuilderAndSolverWithConstraints(linear_solver)
else:
builder_and_solver = CSMA.ContactResidualBasedBlockBuilderAndSolver(linear_solver)
else:
raise Exception("Contact not compatible with EliminationBuilderAndSolver")
else:
builder_and_solver = super(ContactStaticMechanicalSolver, self)._create_builder_and_solver()
return builder_and_solver
def _create_builder_and_solver(self):
if self.contact_settings["mortar_type"].GetString() != "":
linear_solver = self.get_linear_solver()
if self.settings["block_builder"].GetBool():
if self.settings["multi_point_constraints_used"].GetBool():
builder_and_solver = CSMA.ContactResidualBasedBlockBuilderAndSolverWithConstraints(linear_solver)
else:
builder_and_solver = CSMA.ContactResidualBasedBlockBuilderAndSolver(linear_solver)
else:
builder_and_solver = super(ContactImplicitMechanicalSolver, self)._create_builder_and_solver()
else:
builder_and_solver = super(ContactImplicitMechanicalSolver, self)._create_builder_and_solver()
return builder_and_solver
def _create_main_search(self, key="0"):
""" This method creates the search process that will be use during contact search
Keyword arguments:
self -- It signifies an instance of a class.
key -- The key to identify the current pair
"""
search_parameters = KM.Parameters(
"""{"condition_name": "", "final_string": "", "predefined_master_slave" : true, "id_name" : ""}"""
)
search_parameters.AddValue(
"type_search", self.settings["search_parameters"]["type_search"])
search_parameters.AddValue(
"check_gap", self.settings["search_parameters"]["check_gap"])
search_parameters.AddValue(
"allocation_size",
self.settings["search_parameters"]["max_number_results"])
search_parameters.AddValue(
"bucket_size", self.settings["search_parameters"]["bucket_size"])
search_parameters.AddValue(
"search_factor",
self.settings["search_parameters"]["search_factor"])
search_parameters.AddValue(
"dynamic_search",
self.settings["search_parameters"]["dynamic_search"])
search_parameters["condition_name"].SetString(
self._get_condition_name())
search_parameters["final_string"].SetString(self._get_final_string())
self.__assume_master_slave(key)
search_parameters["predefined_master_slave"].SetBool(
self.predefined_master_slave)
search_parameters["id_name"].SetString(key)
# We compute the number of nodes of the geometry
number_nodes = len(self.computing_model_part.Conditions[1].GetNodes())
# We create the search process
if (self.dimension == 2):
self.search_search[key] = CSMA.TreeContactSearch2D2N(
self.computing_model_part, search_parameters)
else:
if (number_nodes == 3):
self.search_search[key] = CSMA.TreeContactSearch3D3N(
self.computing_model_part, search_parameters)
else:
self.search_search[key] = CSMA.TreeContactSearch3D4N(
self.computing_model_part, search_parameters)
def _create_main_search(self, key = "0"):
""" This method creates the search process that will be use during contact search
Keyword arguments:
self -- It signifies an instance of a class.
key -- The key to identify the current pair
"""
search_parameters = KM.Parameters("""{"condition_name": "", "final_string": "", "predefined_master_slave" : true, "id_name" : ""}""")
search_parameters.AddValue("simple_search", self.settings["search_parameters"]["simple_search"])
search_parameters.AddValue("type_search", self.settings["search_parameters"]["type_search"])
search_parameters.AddValue("check_gap", self.settings["search_parameters"]["check_gap"])
search_parameters.AddValue("allocation_size", self.settings["search_parameters"]["max_number_results"])
search_parameters.AddValue("bucket_size", self.settings["search_parameters"]["bucket_size"])
search_parameters.AddValue("search_factor", self.settings["search_parameters"]["search_factor"])
search_parameters.AddValue("dynamic_search", self.settings["search_parameters"]["dynamic_search"])
search_parameters.AddValue("static_check_movement", self.settings["search_parameters"]["static_check_movement"])
search_parameters.AddValue("consider_gap_threshold", self.settings["search_parameters"]["consider_gap_threshold"])
search_parameters.AddValue("debug_mode", self.settings["search_parameters"]["debug_mode"])
search_parameters["condition_name"].SetString(self._get_condition_name())
search_parameters["final_string"].SetString(self._get_final_string())
self.__assume_master_slave(key)
search_parameters["predefined_master_slave"].SetBool(self.predefined_master_slave)
search_parameters["id_name"].SetString(key)
# We create the search process
self.search_utility_list[key] = CSMA.ContactSearchProcess(self.computing_model_part, search_parameters)
def _initialize_alm_parameters(self, computing_model_part):
""" This method initializes the ALM parameters from the process info
Keyword arguments:
self -- It signifies an instance of a class.
computing_model_part -- The model part that contains the structural problem to be solved
"""
# We call the process info
process_info = self.main_model_part.ProcessInfo
if (self.settings["advance_ALM_parameters"]["manual_ALM"].GetBool() is False):
# Computing the scale factors or the penalty parameters (StiffnessFactor * E_mean/h_mean)
alm_var_parameters = KM.Parameters("""{}""")
alm_var_parameters.AddValue("stiffness_factor", self.settings["advance_ALM_parameters"]["stiffness_factor"])
alm_var_parameters.AddValue("penalty_scale_factor", self.settings["advance_ALM_parameters"]["penalty_scale_factor"])
self.alm_var_process = CSMA.ALMVariablesCalculationProcess(self.contact_model_part, KM.NODAL_H, alm_var_parameters)
self.alm_var_process.Execute()
# We don't consider scale factor
if (self.settings["advance_ALM_parameters"]["use_scale_factor"].GetBool() is False):
process_info[KM.SCALE_FACTOR] = 1.0
else:
# We set the values in the process info
process_info[KM.INITIAL_PENALTY] = self.settings["advance_ALM_parameters"]["penalty"].GetDouble()
process_info[KM.SCALE_FACTOR] = self.settings["advance_ALM_parameters"]["scale_factor"].GetDouble()
# We set a minimum value
if (process_info[KM.INITIAL_PENALTY] < sys.float_info.epsilon):
process_info[KM.INITIAL_PENALTY] = 1.0e0
if (process_info[KM.SCALE_FACTOR] < sys.float_info.epsilon):
process_info[KM.SCALE_FACTOR] = 1.0e0
# We print the parameters considered
KM.Logger.PrintInfo("SCALE_FACTOR: ", "{:.2e}".format(process_info[KM.SCALE_FACTOR]))
KM.Logger.PrintInfo("INITIAL_PENALTY: ", "{:.2e}".format(process_info[KM.INITIAL_PENALTY]))
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 ExecuteInitialize(self):
""" This method is executed at the begining to initialize the process
Keyword arguments:
self -- It signifies an instance of a class.
"""
# We call to the base process
super(ExplicitPenaltyContactProcess, self).ExecuteInitialize()
# Setting NL_ITERATION_NUMBER (used in some utilities)
process_info = self.main_model_part.ProcessInfo
process_info[KM.NL_ITERATION_NUMBER] = 1
# Setting the impact time duration
if self.contact_settings["advance_explicit_parameters"][
"manual_max_gap_theshold"].GetBool():
process_info[CSMA.MAX_GAP_THRESHOLD] = self.contact_settings[
"advance_explicit_parameters"]["max_gap_threshold"].GetDouble(
)
else:
empty_settings = KM.Parameters("""{}""")
mean_nodal_h = CSMA.ContactUtilities.CalculateMeanNodalH(
self.computing_model_part)
process_info[CSMA.MAX_GAP_THRESHOLD] = mean_nodal_h
# Create the dynamic factor process
self.dynamic_factor_process = CSMA.ComputeDynamicFactorProcess(
self.main_model_part)
self.dynamic_factor_process.ExecuteInitialize()
def _create_convergence_criterion(self):
convergence_criterion = convergence_criteria_factory.convergence_criterion(
self._get_convergence_criterion_settings())
conv_criteria = convergence_criterion.mechanical_convergence_criterion
contact_criteria = ContactStructuralMechanicsApplication.MPCContactCriteria(
)
return KratosMultiphysics.AndCriteria(conv_criteria, contact_criteria)
def test_process_factory(self):
dummy_class = DummyClass()
process_factory = ContactStructuralMechanicsApplication.ProcessFactoryUtility(
dummy_class)
#dummy_class.DummyMethod()
process_factory.ExecuteMethod("DummyMethod")
self.assertTrue(dummy_class.this_assert)
def _create_contact_newton_raphson_strategy(self):
computing_model_part = self.GetComputingModelPart()
self.mechanical_scheme = self.get_solution_scheme()
self.linear_solver = self.get_linear_solver()
self.mechanical_convergence_criterion = self.get_convergence_criterion(
)
self.builder_and_solver = self.get_builder_and_solver()
newton_parameters = KM.Parameters("""{}""")
newton_parameters.AddValue(
"adaptative_strategy",
self.contact_settings["adaptative_strategy"])
newton_parameters.AddValue("split_factor",
self.contact_settings["split_factor"])
newton_parameters.AddValue("max_number_splits",
self.contact_settings["max_number_splits"])
newton_parameters.AddValue(
"inner_loop_iterations",
self.contact_settings["inner_loop_iterations"])
return CSMA.ResidualBasedNewtonRaphsonContactStrategy(
computing_model_part, self.mechanical_scheme, self.linear_solver,
self.mechanical_convergence_criterion, self.builder_and_solver,
self.settings["max_iteration"].GetInt(),
self.settings["compute_reactions"].GetBool(),
self.settings["reform_dofs_at_each_step"].GetBool(),
self.settings["move_mesh_flag"].GetBool(), newton_parameters,
self.processes_list, self.post_process)
def _create_linear_solver(self):
linear_solver = super(ContactImplicitMechanicalSolver,
self)._create_linear_solver()
if (self.contact_settings["rescale_linear_solver"].GetBool() is True):
linear_solver = KM.ScalingSolver(linear_solver, False)
mortar_type = self.contact_settings["mortar_type"].GetString()
if (mortar_type == "ALMContactFrictional"
or mortar_type == "ALMContactFrictionlessComponents"):
if (self.contact_settings["use_mixed_ulm_solver"].GetBool() == True
):
self.print_on_rank_zero(
"::[Contact Mechanical Implicit Dynamic Solver]:: ",
"Using MixedULMLinearSolver, definition of ALM parameters recommended"
)
name_mixed_solver = self.contact_settings[
"mixed_ulm_solver_parameters"]["solver_type"].GetString()
if (name_mixed_solver == "mixed_ulm_linear_solver"):
linear_solver_name = self.settings[
"linear_solver_settings"]["solver_type"].GetString()
if (linear_solver_name == "AMGCL"
or linear_solver_name == "AMGCLSolver"):
amgcl_param = KM.Parameters("""
{
"solver_type" : "AMGCL",
"smoother_type" : "ilu0",
"krylov_type" : "lgmres",
"coarsening_type" : "aggregation",
"max_iteration" : 100,
"provide_coordinates" : false,
"gmres_krylov_space_dimension" : 100,
"verbosity" : 1,
"tolerance" : 1e-6,
"scaling" : false,
"block_size" : 3,
"use_block_matrices_if_possible" : true,
"coarse_enough" : 500
}
""")
amgcl_param["block_size"].SetInt(
self.main_model_part.ProcessInfo[KM.DOMAIN_SIZE])
self.linear_solver_settings.RecursivelyValidateAndAssignDefaults(
amgcl_param)
linear_solver = KM.AMGCLSolver(
self.linear_solver_settings)
mixed_ulm_solver = CSMA.MixedULMLinearSolver(
linear_solver,
self.contact_settings["mixed_ulm_solver_parameters"])
return mixed_ulm_solver
else:
self.print_on_rank_zero(
"::[Contact Mechanical Implicit Dynamic Solver]:: ",
"Mixed solver not available: " + name_mixed_solver +
". Using not mixed linear solver")
return linear_solver
else:
return linear_solver
else:
return linear_solver
def _normal_check_process_tests(self,
input_filename,
custom_submodel_part=""):
KM.Logger.GetDefaultOutput().SetSeverity(KM.Logger.Severity.WARNING)
self.model = KM.Model()
self.main_model_part = self.model.CreateModelPart("Main", 2)
self.main_model_part.AddNodalSolutionStepVariable(KM.NORMAL)
self.main_model_part.CloneTimeStep(1.01)
KM.ModelPartIO(input_filename).ReadModelPart(self.main_model_part)
if custom_submodel_part == "":
KM.VariableUtils().SetFlag(
KM.INTERFACE, True,
self.main_model_part.GetSubModelPart(
"CONTACT_Contact_slave_Auto1").Nodes)
KM.VariableUtils().SetFlag(
KM.INTERFACE, True,
self.main_model_part.GetSubModelPart(
"CONTACT_Contact_master_Auto1").Nodes)
else:
KM.VariableUtils().SetFlag(
KM.INTERFACE, True,
self.main_model_part.GetSubModelPart(
custom_submodel_part).Nodes)
## DEBUG
#KM.ComputeNodesMeanNormalModelPart(self.main_model_part, True)
# Check normals
check_process = CSMA.NormalCheckProcess(self.main_model_part)
check_process.Execute()
## DEBUG
#self.__post_process()
check_parameters = KM.Parameters("""
{
"check_variables" : ["NORMAL"],
"input_file_name" : "",
"model_part_name" : "Main",
"check_for_flag" : "INTERFACE",
"historical_value" : true,
"time_frequency" : 0.0
}
""")
check_parameters["input_file_name"].SetString(input_filename +
"_check_normal.json")
check = from_json_check_result_process.FromJsonCheckResultProcess(
self.model, check_parameters)
check.ExecuteInitialize()
check.ExecuteBeforeSolutionLoop()
check.ExecuteFinalizeSolutionStep()
def GetMortarCriteria(self, include_table=True):
# Adding the mortar criteria
if (self.mortar_type == "ALMContactFrictionless"):
if (include_table is True):
Mortar = CSMA.ALMFrictionlessMortarConvergenceCriteria(
self.print_convergence_criterion, self.gidio_debug)
else:
Mortar = CSMA.ALMFrictionlessMortarConvergenceCriteria()
elif (self.mortar_type == "ALMContactFrictionlessComponents"):
if (include_table is True):
Mortar = CSMA.ALMFrictionlessComponentsMortarConvergenceCriteria(
self.print_convergence_criterion, self.gidio_debug)
else:
Mortar = CSMA.ALMFrictionlessComponentsMortarConvergenceCriteria(
)
elif (self.mortar_type == "ALMContactFrictional"):
if (include_table is True):
Mortar = CSMA.ALMFrictionalMortarConvergenceCriteria(
self.print_convergence_criterion, self.gidio_debug)
else:
Mortar = CSMA.ALMFrictionalMortarConvergenceCriteria()
elif ("MeshTying" in self.mortar_type):
Mortar = CSMA.MeshTyingMortarConvergenceCriteria()
Mortar.SetEchoLevel(self.echo_level)
return Mortar
def ExecuteInitializeSolutionStep(self):
""" This method is executed in order to initialize the current step
Keyword arguments:
self -- It signifies an instance of a class.
"""
# We call to the base process
super(ExplicitPenaltyContactProcess,
self).ExecuteInitializeSolutionStep()
# Check if the contact is active
active_contact = CSMA.ContactUtilities.CheckActivity(
self.computing_model_part, False)
if active_contact:
self.computing_model_part.Set(KM.CONTACT, True)
else:
self.computing_model_part.Set(KM.CONTACT, False)
# Specific operations for explicit contact
if self._get_if_is_interval() and active_contact:
# Updating value of weighted gap
KM.VariableUtils().SetNonHistoricalVariable(
KM.NODAL_AREA, 0.0, self.computing_model_part.Nodes)
KM.VariableUtils().SetVariable(CSMA.WEIGHTED_GAP, 0.0,
self.computing_model_part.Nodes)
CSMA.ContactUtilities.ComputeExplicitContributionConditions(
self.computing_model_part)
# Calling for the active set utilities (to activate deactivate nodes)
if self.contact_settings["contact_type"].GetString(
) == "Frictionless":
CSMA.ComputePenaltyFrictionlessActiveSet(
self.computing_model_part)
else:
CSMA.ComputePenaltyFrictionalActiveSet(
self.computing_model_part)
# Activate/deactivate conditions
CSMA.ContactUtilities.ActivateConditionWithActiveNodes(
self.computing_model_part)
# Update the dynamic factors
self.dynamic_factor_process.Execute()
def test_processes_list_factory(self):
dummy_class1 = DummyClass()
dummy_class2 = DummyClass()
dummy_list = [dummy_class1, dummy_class2]
process_factory = ContactStructuralMechanicsApplication.ProcessFactoryUtility(
dummy_list)
#dummy_class.DummyMethod()
process_factory.ExecuteMethod("DummyMethod")
self.assertTrue(dummy_class1.this_assert)
self.assertTrue(dummy_class2.this_assert)
def _initialize_problem_parameters(self):
""" This method initializes the ALM parameters from the process info
Keyword arguments:
self -- It signifies an instance of a class.
"""
# We call to the base process (in fact not, to avoid writing twice the values)
#super(PenaltyContactProcess, self)._initialize_problem_parameters()
# We call the process info
process_info = self.main_model_part.ProcessInfo
if not self.contact_settings["advance_ALM_parameters"][
"manual_ALM"].GetBool():
# 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()
# Computing the scale factors or the penalty parameters (StiffnessFactor * E_mean/h_mean)
alm_var_parameters = KM.Parameters("""{}""")
alm_var_parameters.AddValue(
"stiffness_factor",
self.contact_settings["advance_ALM_parameters"]
["stiffness_factor"])
alm_var_parameters.AddValue(
"penalty_scale_factor",
self.contact_settings["advance_ALM_parameters"]
["penalty_scale_factor"])
self.alm_var_process = CSMA.ALMVariablesCalculationProcess(
self._get_process_model_part(), KM.NODAL_H, alm_var_parameters)
self.alm_var_process.Execute()
# We rescale, the process is designed for ALM formulation
process_info[
KM.INITIAL_PENALTY] = 1.0e0 * process_info[KM.INITIAL_PENALTY]
else:
# We set the values in the process info
process_info[KM.INITIAL_PENALTY] = self.contact_settings[
"advance_ALM_parameters"]["penalty"].GetDouble()
# We set a minimum value
if process_info[KM.INITIAL_PENALTY] < sys.float_info.epsilon:
process_info[KM.INITIAL_PENALTY] = 1.0e13
# Setting on nodes
initial_penalty = process_info[KM.INITIAL_PENALTY]
KM.VariableUtils().SetNonHistoricalVariable(
KM.INITIAL_PENALTY, initial_penalty,
self.computing_model_part.Nodes)
# We print the parameters considered
KM.Logger.PrintInfo("INITIAL_PENALTY: ",
"{:.2e}".format(process_info[KM.INITIAL_PENALTY]))
def _create_main_search(self, key = "0"):
""" This method creates the search process that will be use during contact search
Keyword arguments:
self -- It signifies an instance of a class.
key -- The key to identify the current pair
"""
# Create main parameters
search_parameters = self._create_search_parameters(key)
# We create the search process
self.search_utility_list[key] = CSMA.MPCContactSearchProcess(self.main_model_part, search_parameters)
def AuxiliarLineSearch(computing_model_part, mechanical_scheme, linear_solver,
mechanical_convergence_criterion, builder_and_solver,
settings, contact_settings, processes_list,
post_process):
newton_parameters = KM.Parameters("""{}""")
return CSMA.LineSearchContactStrategy(
computing_model_part, mechanical_scheme, linear_solver,
mechanical_convergence_criterion, builder_and_solver,
settings["max_iteration"].GetInt(),
settings["compute_reactions"].GetBool(),
settings["reform_dofs_at_each_step"].GetBool(),
settings["move_mesh_flag"].GetBool(), newton_parameters)
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 _create_contact_line_search_strategy(self):
computing_model_part = self.GetComputingModelPart()
mechanical_scheme = self.get_solution_scheme()
linear_solver = self.get_linear_solver()
mechanical_convergence_criterion = self.get_convergence_criterion()
builder_and_solver = self.get_builder_and_solver()
newton_parameters = KratosMultiphysics.Parameters("""{}""")
return ContactStructuralMechanicsApplication.LineSearchContactStrategy(
computing_model_part, mechanical_scheme, linear_solver,
mechanical_convergence_criterion, builder_and_solver,
self.settings["max_iteration"].GetInt(),
self.settings["compute_reactions"].GetBool(),
self.settings["reform_dofs_at_each_step"].GetBool(),
self.settings["move_mesh_flag"].GetBool(), newton_parameters)
def _interface_preprocess(self, partial_model_part, key = "0"):
""" This method creates the process used to compute the contact interface
Keyword arguments:
self -- It signifies an instance of a class.
partial_model_part -- The partial model part that contains the structural problem to be solved
"""
# We create the process for creating the interface
self.interface_preprocess = CSMA.InterfacePreprocessCondition(self.computing_model_part)
# It should create the conditions automatically
interface_parameters = KM.Parameters("""{"simplify_geometry": false, "contact_property_id": 0}""")
interface_parameters["contact_property_id"].SetInt(self.settings["search_property_ids"][key].GetInt())
self.interface_preprocess.GenerateInterfacePart(partial_model_part, interface_parameters)
def AuxiliarMPCNewton(computing_model_part, mechanical_scheme, linear_solver, mechanical_convergence_criterion, builder_and_solver, settings, contact_settings):
newton_parameters = KM.Parameters("""{}""")
newton_parameters.AddValue("inner_loop_iterations", contact_settings["inner_loop_iterations"])
newton_parameters.AddValue("update_each_nl_iteration", contact_settings["update_each_nl_iteration"])
newton_parameters.AddValue("enforce_ntn", contact_settings["enforce_ntn"])
return CSMA.ResidualBasedNewtonRaphsonMPCContactStrategy(computing_model_part,
mechanical_scheme,
linear_solver,
mechanical_convergence_criterion,
builder_and_solver,
settings["max_iteration"].GetInt(),
settings["compute_reactions"].GetBool(),
settings["reform_dofs_at_each_step"].GetBool(),
settings["move_mesh_flag"].GetBool(),
newton_parameters
)
def _create_main_search(self, computing_model_part):
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)
def AuxiliarCreateLinearSolver(main_model_part, settings, contact_settings, linear_solver_settings, linear_solver):
if contact_settings["rescale_linear_solver"].GetBool():
linear_solver = KM.ScalingSolver(linear_solver, False)
mortar_type = contact_settings["mortar_type"].GetString()
if "ALMContactFrictional" in mortar_type or mortar_type == "ALMContactFrictionlessComponents":
if contact_settings["use_mixed_ulm_solver"].GetBool():
KM.Logger.PrintInfo("::[Contact Mechanical Solver]:: ", "Using MixedULMLinearSolver, definition of ALM parameters recommended")
name_mixed_solver = contact_settings["mixed_ulm_solver_parameters"]["solver_type"].GetString()
if name_mixed_solver == "mixed_ulm_linear_solver":
if settings.Has("linear_solver_settings"):
if settings["linear_solver_settings"].Has("solver_type"):
linear_solver_name = settings["linear_solver_settings"]["solver_type"].GetString()
if linear_solver_name == "amgcl" or linear_solver_name == "AMGCL" or linear_solver_name == "AMGCLSolver":
amgcl_param = KM.Parameters("""
{
"solver_type" : "amgcl",
"smoother_type" : "ilu0",
"krylov_type" : "lgmres",
"coarsening_type" : "aggregation",
"max_iteration" : 100,
"provide_coordinates" : false,
"gmres_krylov_space_dimension" : 100,
"verbosity" : 1,
"tolerance" : 1e-6,
"scaling" : false,
"block_size" : 3,
"use_block_matrices_if_possible" : true,
"coarse_enough" : 500
}
""")
amgcl_param["block_size"].SetInt(main_model_part.ProcessInfo[KM.DOMAIN_SIZE])
linear_solver_settings.RecursivelyValidateAndAssignDefaults(amgcl_param)
linear_solver = KM.AMGCLSolver(linear_solver_settings)
mixed_ulm_solver = CSMA.MixedULMLinearSolver(linear_solver, contact_settings["mixed_ulm_solver_parameters"])
return mixed_ulm_solver
else:
return linear_solver
else:
return linear_solver
else:
KM.Logger.PrintInfo("::[Contact Mechanical Solver]:: ", "Mixed solver not available: " + name_mixed_solver + ". Using not mixed linear solver")
return linear_solver
else:
return linear_solver
else:
return linear_solver
def _interface_preprocess(self, computing_model_part):
""" This method creates the process used to compute the contact interface
Keyword arguments:
self -- It signifies an instance of a class.
computing_model_part -- The model part that contains the structural problem to be solved
"""
# We create the process for creating the interface
self.interface_preprocess = CSMA.InterfacePreprocessCondition(computing_model_part)
# It should create the conditions automatically
interface_parameters = KM.Parameters("""{"simplify_geometry": false}""")
if (self.dimension == 2):
self.interface_preprocess.GenerateInterfacePart2D(self.contact_model_part, interface_parameters)
else:
self.interface_preprocess.GenerateInterfacePart3D(self.contact_model_part, interface_parameters)
def _interface_preprocess(self, computing_model_part):
self.interface_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.interface_preprocess.GenerateInterfacePart2D(
computing_model_part, self.contact_model_part,
interface_parameters)
else:
self.interface_preprocess.GenerateInterfacePart3D(
computing_model_part, self.contact_model_part,
interface_parameters)