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_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 _initialize_alm_parameters(self, computing_model_part):
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]))
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()
