Contact Module

The interaction of moving bodies is a common occurrence in our world, and therefore modeling such problems is essential to accurately represent the mechanical behavior of the physical world. However, finite element methods do not have an inherent means of modeling contact. Therefore, specific contact algorithms are required. These algorithms enforce constraints between surfaces in the mesh, to prevent penetration and develop contact forces. The MOOSE contact module provides the necessary tools for modeling mechanical contact.

Theory

Mechanical contact between two deformable bodies is based on three requirements.

$var element = document.getElementById("moose-equation-7eeaf49b-1d7d-434c-b4b9-93935e653e97");katex.render("g \\le 0,", element, {displayMode:true,throwOnError:false,macros:{"\\pf":"\\frac{\\partial #1}{\\partial #2}"}});$ $var element = document.getElementById("moose-equation-82f804df-3cea-4b8f-a0f9-7965901dafbb");katex.render("t_N \\ge 0,", element, {displayMode:true,throwOnError:false,macros:{"\\pf":"\\frac{\\partial #1}{\\partial #2}"}});$ $var element = document.getElementById("moose-equation-30f0d0e5-7a31-425d-b287-3002c18d8e6e");katex.render("t_N g = 0.", element, {displayMode:true,throwOnError:false,macros:{"\\pf":"\\frac{\\partial #1}{\\partial #2}"}});$

That is, the penetration distance (typically referred to as the gap $var element = document.getElementById("moose-equation-d91eafe7-a2fb-4c3b-9e8d-771aa099099e");katex.render("g", element, {displayMode:false,throwOnError:false,macros:{"\\pf":"\\frac{\\partial #1}{\\partial #2}"}});$ in the contact literature) of one of the body into another must not be positive; the contact force $var element = document.getElementById("moose-equation-aa790113-927b-4ac3-bf27-4b8f1f7684e8");katex.render("t_N", element, {displayMode:false,throwOnError:false,macros:{"\\pf":"\\frac{\\partial #1}{\\partial #2}"}});$ opposing penetration must be positive in the normal direction; and either the penetration distance or the contact force must be zero at all times.

In the MOOSE Contact Module, these contact constraints are enforced through the use of node/face constraints. This is accomplished in a manner similar to that detailed by Heinstein and Laursen (1999). First, a geometric search determines which slave nodes have penetrated master faces. For those nodes, the internal force computed by the divergence of stress is moved to the appropriate master face at the point of contact. Those forces are distributed to master nodes by employing the finite element shape functions. Additionally, the slave nodes are constrained to remain on the master faces, preventing penetration. The module currently supports frictionless, frictional, and glued contact.

Procedure for using mechanical contact

In the contact module there are currently two systems to choose from mechanical contact : Dirac and Constraint. The Constraint system is recommended for all problems, as the Dirac system will be removed in the future. The contact block in the MOOSE input file looks like this :


[Contact]
  [./contact]
    disp_x = <variable>
    disp_y = <variable>
    disp_z = <variable>
    formulation = <string> (DEFAULT)
    friction_coefficient = <real> (0)
    master = <string>
    model = <string> (frictionless)
    normal_smoothing_distance = <real>
    normal_smoothing_method = <string> (edge_based)
    order = <string> (FIRST)
    penalty = <real> (1e8)
    normalize_penalty = <bool> (false)
    slave = <string>
    system = <string> (Dirac)
    tangential_tolerance = <real>
    tension_release = <real> (0)
  [../]
[]

The parameters descriptions are :

disp_x (Required) Variable name for displacement variable in x direction. Typically disp_x.
disp_y Variable name for displacement variable in y direction. Typically disp_y.
disp_z Variable name for displacement variable in z direction. Typically disp_z
formulation Select either DEFAULT, KINEMATIC, or PENALTY. DEFAULT is KINEMATIC.
friction_coefficient The friction coefficient.
master (Required) The boundary ID for the master surface.
model Select either frictionless, glued, or coulomb.
normal_smoothing_distance Distance from face edge in parametric coordinates over which to smooth the contact normal. $var element = document.getElementById("moose-equation-4fc0ce8c-4a60-4141-93fd-070f254e1732");katex.render("0.1", element, {displayMode:false,throwOnError:false,macros:{"\\pf":"\\frac{\\partial #1}{\\partial #2}"}});$ is a reasonable value.
normal_smoothing_method Select either edge_based or nodal_normal_based. If nodal_normal_based, must also have a NodalNormals block.
order The order of the variable. Typical values are FIRST and SECOND.
penalty The penalty stiffness value to be used in the constraint.
normalize_penalty Whether to normalize the penalty stiffness by the nodal area of the slave node.
slave (Required) The boundary ID for the slave surface.
system The system to use for constraint enforcement. Options are Dirac DiracKernel or Constraint. The default is Dirac.
tangential_tolerance Tangential distance to extend edges of contact surfaces.
tension_release Tension release threshold. A node will not be released if its tensile load is below this value. If negative, no tension release will occur.

It is good practice to make the surface with the coarser mesh to be the master surface.

The robustness and accuracy of the mechanical contact algorithm is strongly dependent on the penalty parameter. If the parameter is too small, inaccurate solutions are more likely. If the parameter is too large, the solver may struggle.

The DEFAULT option uses an enforcement algorithm that moves the internal forces at a slave node to Thu master face. The distance between the slave node and the master face is penalized, The PENALTY algorithm is the traditional penalty enforcement technique.

Mortar-Based Mechanical Contact

The mortar constraint system provides an alternative discretization technique for solving mechanical contact. Some results are summarized below.

The contact/test/tests/bouncing-block-contact directory provides a series of input files testing different algorithms for solving both normal and tangential frictional contact. Mortar contact can also be specified using the Contact block similar to pure node-face discretization contact. For normal mortar contact:

[Contact]
  [frictionless]
    mesh = simple_mesh
    master = 2
    slave = 1
    formulation = mortar
    system = constraint
  []
[]

/opt/civet/build_0/moose/modules/contact/test/tests/mechanical-small-problem/frictionless-nodal-lm-mortar-disp-action.i

[GlobalParams]
  displacements = 'disp_x disp_y'
[]

[Mesh]
  [./simple_mesh]
    type = FileMeshGenerator
    file = mesh.e
  [../]
[]

[Problem]
  kernel_coverage_check = false
[]

[Variables]
  [./disp_x]
    block = '1 2'
  [../]
  [./disp_y]
    block = '1 2'
  [../]
[]

[BCs]
  [./left_x]
    type = DirichletBC
    variable = disp_x
    boundary = 'outside_left'
    value = 0.0
  [../]
  [./left_y]
    type = DirichletBC
    variable = disp_y
    boundary = 'outside_left'
    value = 0.0
  [../]
  [./right_x]
    type = FunctionDirichletBC
    variable = disp_x
    boundary = 'outside_right'
    function = '-5e-3 * t'
  [../]
  [./right_y]
    type = FunctionDirichletBC
    variable = disp_y
    boundary = 'outside_right'
    function = 0
  [../]
[]

[Kernels]
  [disp_x]
    type = Diffusion
    variable = disp_x
    block = '1 2'
  []
  [disp_y]
    type = Diffusion
    variable = disp_y
    block = '1 2'
  []
[]

[Debug]
  show_var_residual_norms = 1
[]

[Contact]
  [frictionless]
    mesh = simple_mesh
    master = 2
    slave = 1
    formulation = mortar
    system = constraint
  []
[]

[Preconditioning]
  [./smp]
    type = SMP
    full = true
  [../]
[]

[Executioner]
  solve_type = PJFNK
  type = Transient
  num_steps = 10
  dt = 1
  dtmin = 1
  petsc_options_iname = '-pc_type -snes_linesearch_type -pc_factor_shift_type -pc_factor_shift_amount'
  petsc_options_value = 'lu       basic                 NONZERO               1e-15'
[]

[Outputs]
  exodus = true
  hide = 'contact_pressure nodal_area_frictionless penetration'
[]

[Postprocessors]
  [contact]
    type = ContactDOFSetSize
    variable = frictionless_normal_lm
    subdomain = '4'
    execute_on = 'nonlinear timestep_end'
  []
[]

For normal and tangential (frictional) mortar contact:

[Contact]
  [frictional]
    mesh = revised_file_mesh
    master = 20
    slave = 10
    formulation = mortar
    system = constraint
    model = coulomb
    friction_coefficient = 0.1
  []
[]

/opt/civet/build_0/moose/modules/contact/test/tests/bouncing-block-contact/frictional-nodal-min-normal-lm-mortar-fb-tangential-lm-mortar-action.i

starting_point = 2e-1

# We offset slightly so we avoid the case where the bottom of the slave block and the top of the
# master block are perfectly vertically aligned which can cause the backtracking line search some
# issues for a coarse mesh (basic line search handles that fine)
offset = 1e-2

[GlobalParams]
  displacements = 'disp_x disp_y'
  diffusivity = 1e0
  scaling = 1e0
[]

[Mesh]
  [./original_file_mesh]
    type = FileMeshGenerator
    file = long-bottom-block-1elem-blocks-coarse.e
  [../]
  # These sidesets need to be deleted because the contact action adds them automatically. For this
  # particular mesh, the new IDs will be identical to the deleted ones and will conflict if we don't
  # remove the original ones.
  [./delete_3]
    type = BlockDeletionGenerator
    input = original_file_mesh
    block_id = 3
  [../]
  [./revised_file_mesh]
    type = BlockDeletionGenerator
    input = delete_3
    block_id = 4
  [../]
[]

[Variables]
  [./disp_x]
    block = '1 2'
    # order = SECOND
  [../]
  [./disp_y]
    block = '1 2'
    # order = SECOND
  [../]
[]

[Contact]
  [frictional]
    mesh = revised_file_mesh
    master = 20
    slave = 10
    formulation = mortar
    system = constraint
    model = coulomb
    friction_coefficient = 0.1
  []
[]

[ICs]
  [./disp_y]
    block = 2
    variable = disp_y
    value = ${fparse starting_point + offset}
    type = ConstantIC
  [../]
[]

[Kernels]
  [./disp_x]
    type = MatDiffusion
    variable = disp_x
  [../]
  [./disp_y]
    type = MatDiffusion
    variable = disp_y
  [../]
[]

[BCs]
  [./botx]
    type = DirichletBC
    variable = disp_x
    boundary = 40
    value = 0.0
  [../]
  [./boty]
    type = DirichletBC
    variable = disp_y
    boundary = 40
    value = 0.0
  [../]
  [./topy]
    type = FunctionDirichletBC
    variable = disp_y
    boundary = 30
    function = '${starting_point} * cos(2 * pi / 40 * t) + ${offset}'
  [../]
  [./leftx]
    type = FunctionDirichletBC
    variable = disp_x
    boundary = 50
    function = '1e-2 * t'
  [../]
[]

[Executioner]
  type = Transient
  end_time = 200
  dt = 5
  dtmin = .1
  solve_type = 'PJFNK'
  petsc_options = '-snes_converged_reason -ksp_converged_reason -pc_svd_monitor -snes_linesearch_monitor -snes_ksp_ew'
  petsc_options_iname = '-pc_type -pc_factor_shift_type -pc_factor_shift_amount -mat_mffd_err'
  petsc_options_value = 'lu       NONZERO               1e-15                   1e-5'
  l_max_its = 30
  nl_max_its = 20
  line_search = 'none'
[]

[Debug]
  show_var_residual_norms = true
[]

[Outputs]
  exodus = true
  hide = 'contact_pressure nodal_area_frictional penetration'
[]

[Preconditioning]
  [./smp]
    type = SMP
    full = true
  [../]
[]

[Postprocessors]
  [./num_nl]
    type = NumNonlinearIterations
  [../]
  [./cumulative]
    type = CumulativeValuePostprocessor
    postprocessor = num_nl
  [../]
  [contact]
    type = ContactDOFSetSize
    variable = frictional_normal_lm
    subdomain = frictional_slave_subdomain
    execute_on = 'nonlinear timestep_end'
  []
[]

Frictionless contact algorithm comparison

Constraint	Displacement	NCP function	Time (arbitrary units)	Time steps	Nonlinear iterations
Nodal	Mortar	Min	4.164	40	104
Nodal	Mortar	FB	5.020	40	135
Nodal	Nodal	Min	3.124	41	104
Nodal	Nodal	FB	4.014	41	149
Mortar	Mortar	Min	4.461	40	106
Mortar	Mortar	FB	5.577	40	136
Nodal	Nodal	RANFS	2.700	40	99

The first column denotes the discretization algorithm used for applying the frictionless contact constraints. Nodal denotes use of a NodeFaceConstraint; Mortar denotes use of a MortarConstraint. The second column denotes the discretization used for applying the contact forces to the displacement residuals. The third column denotes the type of non-linear complimentarity problem (NCP) function used to ensure that the contact constraints are satisfied. Min indicates the canonical min function (see std::min); FB represents the Fischer-Burmeister function. RANFS denotes the Reduced Active Nonlinear Function Set scheme in which no Lagrange Multipliers are used, and instead the non-linear residual equations at the slave nodes are replaced with the gap function. The fourth column in the table is the simulation time in arbitrary units (since timings will be different across machines). The fifth column is the number of time steps required to reach the simulation end time. The final, sixth column is the cumulative number of non-linear iterations taken during the simulation (note that this does not include any non-linear iterations from failed time steps).

Notes:

Clearly having mortar mesh generation slows the simulation down, which is not surprising
The min NCP function is undeniably better for solving normal contact
For the pure nodal algorithms, the time step that did not converge featured classic ping-ponging behavior:


 5 Nonlinear |R| = 4.007951e-04
    |residual|_2 of individual variables:
                  disp_x:    0.000399808
                  disp_y:    2.75599e-05
                  normal_lm: 5.52166e-06


The number of nodes in contact is 11

      0 Linear |R| = 4.007951e-04
      1 Linear |R| = 1.287307e-04
      2 Linear |R| = 8.423398e-06
      3 Linear |R| = 1.046825e-07
      4 Linear |R| = 8.017310e-09
      5 Linear |R| = 3.053040e-10
  Linear solve converged due to CONVERGED_RTOL iterations 5
 6 Nonlinear |R| = 4.432193e-04
    |residual|_2 of individual variables:
                  disp_x:    0.000396694
                  disp_y:    0.00019545
                  normal_lm: 2.96013e-05


The number of nodes in contact is 11

      0 Linear |R| = 4.432193e-04
      1 Linear |R| = 1.355935e-04
      2 Linear |R| = 1.216010e-05
      3 Linear |R| = 6.386952e-07
      4 Linear |R| = 2.235594e-08
      5 Linear |R| = 2.884193e-10
  Linear solve converged due to CONVERGED_RTOL iterations 5
 7 Nonlinear |R| = 4.008045e-04
    |residual|_2 of individual variables:
                  disp_x:    0.000399816
                  disp_y:    2.76329e-05
                  normal_lm: 5.29313e-06


The number of nodes in contact is 11

      0 Linear |R| = 4.008045e-04
      1 Linear |R| = 1.287272e-04
      2 Linear |R| = 8.423081e-06
      3 Linear |R| = 1.047782e-07
      4 Linear |R| = 8.054781e-09
      5 Linear |R| = 3.046073e-10
  Linear solve converged due to CONVERGED_RTOL iterations 5
 8 Nonlinear |R| = 4.432194e-04

Frictional contact algorithm comparison

LM normal	LM tangential	Displacement	NCP function normal	NCP function tangential	Time (arbitrary units)	Time steps	Nonlinear iterations	CLI PETSc options
Mortar	Mortar	Mortar	FB	FB	8.241	40	175	None
Mortar	Mortar	Mortar	Min	FB	7.928	40	159	None
Nodal	Mortar	Mortar	Min	FB	7.459	40	152	None
Mortar	Mortar	Mortar	Min	Min	11.237	41	234	None
Nodal	Nodal	Mortar	Min	Min	39.409	55	275	`-snes_ksp_ew 0`
Nodal	Nodal	Mortar	FB	FB	NA	NA	NA	None

Notes:

NA: solve did not converge
Timings run on a different machine than the frictionless cases
The most performant case uses a NodeFaceConstraint discretization for enforcing the normal contact conditions and MortarConstraint discretizations for enforcement of the Coulomb frictional constraints and application of forces to the displacement residuals. Interestingly, this performant case uses different NCP functions for normal and tangential constraints: std::min for the former and Fischer-Burmeister for the latter. This performant case is used for comparison with the node-face penalty algorithm, shown below:

NCP-LM-Mortar vs Penalty-NodeFace

The table below compares the timing and solver performance of NCP-LM-Mortar and Penalty-NodeFace algorithms. NCP-LM refers to use of an NCP function for contact constraint enforcement on a lagrange multiplier. The "Mortar" designation denotes that a mortar discretization is used for enforcing the tangential Coulomb friction conditions and applying contact forces to the displacement residuals.

/modules/combined/test/tests/sliding_block/in_and_out/constraint/frictional_lm.i

[Mesh]
  patch_size = 80
  [file]
    type = FileMeshGenerator
    file = sliding_elastic_blocks_2d.e
  []
  [slave]
    input = file
    type = LowerDBlockFromSidesetGenerator
    sidesets = '3'
    new_block_id = '30'
  []
  [master]
    input = slave
    type = LowerDBlockFromSidesetGenerator
    sidesets = '2'
    new_block_id = '20'
  []
[]

[GlobalParams]
  volumetric_locking_correction = false
  displacements = 'disp_x disp_y'
[]

[Variables]
  [normal_lm]
    block = '30'
  []
  [tangential_lm]
    block = '30'
    family = MONOMIAL
    order = CONSTANT
  []
[]

[BCs]
  [./left_x]
    type = DirichletBC
    variable = disp_x
    boundary = 1
    value = 0.0
  [../]
  [./left_y]
    type = DirichletBC
    variable = disp_y
    boundary = 1
    value = 0.0
  [../]
  [./right_x]
    type = FunctionDirichletBC
    variable = disp_x
    boundary = 4
    function = horizontal_movement
  [../]
  [./right_y]
    type = FunctionDirichletBC
    variable = disp_y
    boundary = 4
    function = vertical_movement
  [../]
[]

[Modules/TensorMechanics/Master]
  [./all]
    add_variables = true
    strain = FINITE
    block = '1 2'
  [../]
[]

[Materials]
  [./tensor]
    type = ComputeIsotropicElasticityTensor
    block = '1 2'
    youngs_modulus = 1e6
    poissons_ratio = 0.3
  [../]
  [./stress]
    type = ComputeFiniteStrainElasticStress
    block = '1 2'
  [../]
[]

[Preconditioning]
  [smp]
    type = SMP
    full = true
  []
[]

[Executioner]
  type = Transient
  solve_type = 'PJFNK'
  petsc_options = '-snes_converged_reason -ksp_converged_reason -snes_ksp_ew'
  petsc_options_iname = '-pc_type -mat_mffd_err -pc_factor_shift_type -pc_factor_shift_amount'
  petsc_options_value = 'lu       1e-5          NONZERO               1e-15'
  end_time = 15
  dt = 0.1
  dtmin = 0.01
  l_max_its = 30
  nl_max_its = 20
  line_search = 'none'
  timestep_tolerance = 1e-6

  [./Predictor]
    type = SimplePredictor
    scale = 1.0
  [../]
[]

[Debug]
  show_var_residual_norms = true
[]

[Outputs]
  sync_times = '1 2 3 4 5 6 7 8 9 10 11 12 13 14 15'
  [out]
    type = Exodus
    sync_only = true
  []
  [dof]
    execute_on = 'initial'
    type = DOFMap
  []
  [csv]
    type = CSV
    execute_on = 'nonlinear timestep_end'
  []
[]

[Functions]
  [./vertical_movement]
    type = ParsedFunction
    value = -t
  [../]
  [./horizontal_movement]
    type = ParsedFunction
    value = -0.04*sin(4*t)+0.02
  [../]
[]

[Constraints]
  [./lm]
    type = NormalNodalLMMechanicalContact
    slave = 3
    master = 2
    variable = normal_lm
    master_variable = disp_x
    disp_y = disp_y
    ncp_function_type = min
    use_displaced_mesh = true
    c = 1e6 # relative scale difference between pressure and gap
  [../]
  [normal_x]
    type = NormalMortarMechanicalContact
    master_boundary = '2'
    slave_boundary = '3'
    master_subdomain = '20'
    slave_subdomain = '30'
    variable = normal_lm
    slave_variable = disp_x
    component = x
    use_displaced_mesh = true
    compute_lm_residuals = false
  []
  [normal_y]
    type = NormalMortarMechanicalContact
    master_boundary = '2'
    slave_boundary = '3'
    master_subdomain = '20'
    slave_subdomain = '30'
    variable = normal_lm
    slave_variable = disp_y
    component = y
    use_displaced_mesh = true
    compute_lm_residuals = false
  []
  [tangential_lm]
    type = TangentialMortarLMMechanicalContact
    master_boundary = '2'
    slave_boundary = '3'
    master_subdomain = '20'
    slave_subdomain = '30'
    variable = tangential_lm
    slave_variable = disp_x
    slave_disp_y = disp_y
    use_displaced_mesh = true
    compute_primal_residuals = false
    contact_pressure = normal_lm
    friction_coefficient = .4
    ncp_function_type = fb
    c = 1000 # relative scale difference between pressure and velocity
  []
  [tangential_x]
    type = TangentialMortarMechanicalContact
    master_boundary = '2'
    slave_boundary = '3'
    master_subdomain = '20'
    slave_subdomain = '30'
    variable = tangential_lm
    slave_variable = disp_x
    component = x
    use_displaced_mesh = true
    compute_lm_residuals = false
  []
  [tangential_y]
    type = TangentialMortarMechanicalContact
    master_boundary = '2'
    slave_boundary = '3'
    master_subdomain = '20'
    slave_subdomain = '30'
    variable = tangential_lm
    slave_variable = disp_y
    component = y
    use_displaced_mesh = true
    compute_lm_residuals = false
  []
[]

[Postprocessors]
  [./num_nl]
    type = NumNonlinearIterations
  [../]
  [./cumulative]
    type = CumulativeValuePostprocessor
    postprocessor = num_nl
  [../]
  [lin]
    type = NumLinearIterations
  []
  [cum_lin]
    type = CumulativeValuePostprocessor
    postprocessor = lin
  []
  [contact]
    type = ContactDOFSetSize
    variable = normal_lm
    subdomain = '30'
    execute_on = 'nonlinear timestep_end'
  []
[]

Algorithm	Time (arb. units)	Time steps to end time	Cumulative non-linear iterations
NCP-LM-Mortar	13.901	151	476
Penalty-NodeFace	20.711	151	938

There's a cost associated with generation of the mortar segment mesh that partially offsets the fact that the mortar case takes nearly half the non-linear iterations of the penalty case.

Petsc options for contact

Recommended PETSc options for use with mortar based frictional contact are:


[Executioner]
  petsc_options = '-snes_converged_reason -ksp_converged_reason -snes_ksp_ew'
  petsc_options_iname = '-pc_type -mat_mffd_err -pc_factor_shift_type -pc_factor_shift_amount'
  petsc_options_value = 'lu       1e-5          NONZERO               1e-15'
[]

Using Eisenstat-Walker is advantageous for frictional contact because time is not wasted in the linear solve in early non-linear iterations while the contact set and stick/slip conditions are being resolved. Later in the non-linear solve when the set of constraints has been resolved, more linear iterations will be used as the non-linear solver moves through the quadratic basin. Experience has shown that a choice of 1e-5 for the matrix free finite differencing parameter works well for many problems. However, the user may want to experiment with values anywhere between 1e-8 and 1e-4 depending on their multi-physics. A very small non-zero shift is used to avoid zero pivots during the LU decomposition. This may be extraneous in many cases. Note that the Jacobian entries for mortar based contact are accurate and complete enough that incomplete factorization may be used in serial or as a sub-block solver for block jacobi or additive schwarz in parallel. This may be necessary for large problems where lu does not scale.

The recommended PETSc options for use with NodeFaceConstraint based contact are shown below :


[Executioner]
  ...
  petsc_options_iname = '-pc_type -sub_pc_type -pc_asm_overlap
                        -ksp_gmres_restart'
  petsc_options_value = 'asm lu 20 101'
  ...
[../]

Objects, Actions, and Syntax

AuxKernels

Contact App
ContactPressureAux

Constraints

Contact App
GluedContactConstraint
MechanicalContactConstraint
MultiDContactConstraint
NormalMortarLMMechanicalContact
NormalNodalMechanicalContact
OneDContactConstraint
RANFSNormalMechanicalContactApplies the Reduced Active Nonlinear Function Set scheme in which the slave node's non-linear residual function is replaced by the zero penetration constraint equation when the constraint is active
SparsityBasedContactConstraint
TangentialNodalLMMechanicalContactImplements the KKT conditions for frictional Coulomb contact using an NCP function. Requires that either the relative tangential velocity is zero or the tangential stress is equal to the friction coefficient times the normal contact pressure.

Contact

Dampers

Contact App
ContactSlipDamper

DiracKernels

Postprocessors

Contact App
ContactDOFSetSizeOutputs the number of dofs greater than a tolerance threshold indicating mechanical contact

Preconditioning

Contact App
ContactSplit

Problem

Contact App
AugmentedLagrangianContactProblemProblem that checks for convergence relative to a user-supplied reference quantity rather than the initial residual

UserObjects

Contact App
NodalArea

Martin W. Heinstein and Tod A. Laursen. An algorithm for the matrix-free solution of quasistatic frictional contact problems. International Journal for Numerical Methods in Engineering, 44(9):1205–1226, March 1999.

@article{heinstein_algorithm_1999,
    Author = "Heinstein, Martin W. and Laursen, Tod A.",
    Journal = "International Journal for Numerical Methods in Engineering",
    Month = "March",
    Number = "9",
    Pages = "1205--1226",
    Title = "An algorithm for the matrix-free solution of quasistatic frictional contact problems",
    Volume = "44",
    Year = "1999"
}

Theory
Procedure for using mechanical contact
Mortar - Based Mechanical Contact
Petsc options for contact
Objects , Actions , and Syntax

Application Usage

Physics and Syntax

Application Development

Framework Development

MOOSEDocs

Infrastructure

Questions

Information and Tools