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()