NormalMortarMechanicalContact.C

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#include "NormalMortarMechanicalContact.h"
#include "WeightedGapUserObject.h"
 
registerMooseObject("ContactApp", NormalMortarMechanicalContact);
 
InputParameters
NormalMortarMechanicalContact::validParams()
{
  InputParameters params = ADMortarLagrangeConstraint::validParams();
  // Mechanical contact residuals use only primal values and normals
  params.set<bool>("_compute_primal_gradients") = false;
 
  MooseEnum component("x=0 y=1 z=2");
  params.addRequiredParam<MooseEnum>(
      "component", component, "The force component constraint that this object is supplying");
  params.addClassDescription(
      "This class is used to apply normal contact forces using lagrange multipliers");
  params.set<bool>("compute_lm_residual") = false;
  params.set<bool>("interpolate_normals") = false;
  params.addRequiredParam<UserObjectName>("weighted_gap_uo", "The weighted gap user object.");
  return params;
}
 
NormalMortarMechanicalContact::NormalMortarMechanicalContact(const InputParameters & parameters)
  : ADMortarLagrangeConstraint(parameters),
    _component(getParam<MooseEnum>("component")),
    _weighted_gap_uo(getUserObject<WeightedGapUserObject>("weighted_gap_uo"))
{
  if (getParam<bool>("interpolate_normals"))
    paramError("interpolate_normals",
               "Mechanical mortar contact uses normalized secondary nodal normals and cannot be "
               "combined with quadrature-point normal interpolation.");
}
 
void
NormalMortarMechanicalContact::initialSetup()
{
  ADMortarLagrangeConstraint::initialSetup();
 
  if (!_weighted_gap_uo.usesNodalNormalDerivatives())
    return;
 
  if (secondarySubdomain() != _weighted_gap_uo.secondarySubdomain() ||
      primarySubdomain() != _weighted_gap_uo.primarySubdomain())
    paramError("weighted_gap_uo",
               "'weighted_gap_uo' must be defined on the same secondary/primary subdomain pair "
               "as this constraint when nodal-normal derivatives are enabled.");
 
  if (&_secondary_var != _weighted_gap_uo.dispVar(_component))
    paramError("weighted_gap_uo",
               "'weighted_gap_uo' must use the same displacement variable as this constraint's "
               "'variable' when nodal-normal derivatives are enabled.");
 
  if (getParam<bool>("use_displaced_mesh") !=
      _weighted_gap_uo.parameters().get<bool>("use_displaced_mesh"))
    paramError(
        "weighted_gap_uo",
        "'weighted_gap_uo' must use the same 'use_displaced_mesh' setting as this constraint "
        "when nodal-normal derivatives are enabled.");
}
 
void
NormalMortarMechanicalContact::precomputeQpQuantities()
{
  // Interpolating sum_j Phi_j z_j n_j is the transpose of the weighted gap and keeps the two sides
  // of the interface in equilibrium.
  const auto & phi = _weighted_gap_uo.tractionBasis();
  const bool ad_normals = _weighted_gap_uo.shouldRecordNodalNormalDerivatives();
  _qp_traction_component = 0;
  for (const auto j : index_range(phi))
  {
    const auto nodal_pressure =
        _weighted_gap_uo.nodalContactPressure(_lower_secondary_elem->node_ref(j));
 
    if (ad_normals)
      _qp_traction_component +=
          phi[j][_qp] * nodal_pressure *
          _weighted_gap_uo.contactNormal(*_lower_secondary_elem, j)(_component);
    else
      _qp_traction_component += phi[j][_qp] * nodal_pressure * _normals[j](_component);
  }
}
 
ADReal
NormalMortarMechanicalContact::computeQpResidual(Moose::MortarType type)
{
  switch (type)
  {
    case Moose::MortarType::Secondary:
      // If the traction is positive, then this residual is positive, indicating that we have an
      // outflow of momentum, which in turn indicates that the momentum will tend to decrease at
      // this location with time, which is what we want because the force vector is in the negative
      // direction (always opposite of the normals). Conversely, if the traction is negative, then
      // this residual is negative, indicating that we have an inflow of momentum, which in turn
      // indicates the momentum will tend to increase at this location with time, which is what we
      // want because the force vector is in the positive direction (always opposite of the
      // normals).
      return _test_secondary[_i][_qp] * _qp_traction_component;
 
    case Moose::MortarType::Primary:
      // The traction is signed according to the secondary face, so we need to introduce a negative
      // sign here
      return -_test_primary[_i][_qp] * _qp_traction_component;
 
    default:
      return 0;
  }
}