#include <TangentialMortarLMMechanicalContact.h>

Inheritance diagram for TangentialMortarLMMechanicalContact< compute_stage >:

Public Member Functions
	TangentialMortarLMMechanicalContact (const InputParameters &parameters)

Protected Member Functions
ADReal	computeQpResidual (Moose::MortarType) final

Protected Attributes
const MooseVariableFE< Real > &	_slave_disp_y

const MooseVariableFE< Real > &	_master_disp_y

const MooseVariableFE< Real > &	_contact_pressure_var

const ADVariableValue &	_contact_pressure

const ADVariableValue &	_slave_x_dot

const ADVariableValue &	_master_x_dot

const ADVariableValue &	_slave_y_dot

const ADVariableValue &	_master_y_dot

const Real	_friction_coeff

const Real	_epsilon

const MooseEnum	_ncp_type

const Real	_c

	usingMortarConstraintMembers

Detailed Description

template<ComputeStage compute_stage>
class TangentialMortarLMMechanicalContact< compute_stage >

Definition at line 15 of file TangentialMortarLMMechanicalContact.h.

Constructor & Destructor Documentation

◆ TangentialMortarLMMechanicalContact()

template<ComputeStage compute_stage>

TangentialMortarLMMechanicalContact< compute_stage >::TangentialMortarLMMechanicalContact ( const InputParameters & parameters )

Definition at line 41 of file TangentialMortarLMMechanicalContact.C.

   : ADMortarConstraint<compute_stage>(parameters),
     _slave_disp_y(
         this->_subproblem.getStandardVariable(_tid, parameters.getMooseType("slave_disp_y"))),
     _master_disp_y(
         isParamValid("master_disp_y")
             ? this->_subproblem.getStandardVariable(_tid, parameters.getMooseType("master_disp_y"))
             : this->_subproblem.getStandardVariable(_tid, parameters.getMooseType("slave_disp_y"))),
     _contact_pressure_var(
         this->_subproblem.getStandardVariable(_tid, parameters.getMooseType("contact_pressure"))),
     _contact_pressure(_contact_pressure_var.template adSlnLower<compute_stage>()),
     _slave_x_dot(_slave_var.template adUDot<compute_stage>()),
     _master_x_dot(_master_var.template adUDotNeighbor<compute_stage>()),
     _slave_y_dot(_slave_disp_y.template adUDot<compute_stage>()),
     _master_y_dot(_master_disp_y.template adUDotNeighbor<compute_stage>()),
     _friction_coeff(getParam<Real>("friction_coefficient")),
     _epsilon(std::numeric_limits<Real>::epsilon()),
     _ncp_type(getParam<MooseEnum>("ncp_function_type")),
     _c(getParam<Real>("c"))
 {
 }

Member Function Documentation

◆ computeQpResidual()

template<ComputeStage compute_stage>

ADReal TangentialMortarLMMechanicalContact< compute_stage >::computeQpResidual ( Moose::MortarType mortar_type )

finalprotected

Definition at line 66 of file TangentialMortarLMMechanicalContact.C.

 {
   switch (mortar_type)
   {
     case Moose::MortarType::Lower:
     {
       // Check whether we project onto a master face
       if (_has_master)
       {
         // Check whether we are actually in contact
         if (_contact_pressure[_qp] > TOLERANCE * TOLERANCE)
         {
           // Build the velocity vector
           ADRealVectorValue relative_velocity(
               _slave_x_dot[_qp] - _master_x_dot[_qp], _slave_y_dot[_qp] - _master_y_dot[_qp], 0);
  
           // Get the component in the tangential direction
           auto tangential_velocity = relative_velocity * _tangents[_qp][0];
  
           // NCP part 1: requirement that either there is no slip **or** slip velocity and
           // frictional force exerted **by** the slave side are in the same direction
           ADReal a;
           if (tangential_velocity * _lambda[_qp] < 0)
             a = -std::abs(tangential_velocity);
           else
             a = std::abs(tangential_velocity);
           a *= _c;
  
           // NCP part 2: require that the frictional force can never exceed the frictional
           // coefficient times the normal force
           auto b = _friction_coeff * _contact_pressure[_qp] - std::abs(_lambda[_qp]);
  
           ADReal fb_function;
           if (_ncp_type == "fb")
             // The FB function (in its pure form) is not differentiable at (0, 0) but if we add some
             // constant > 0 into the root function, then it is
             fb_function = a + b - std::sqrt(a * a + b * b + _epsilon);
           else
             fb_function = std::min(a, b);
  
           return _test[_i][_qp] * fb_function;
         }
         else
           // If not in contact then we force the tangential lagrange multiplier to zero
           return _test[_i][_qp] * _lambda[_qp];
       }
       else
         // If not in contact then we force the tangential lagrange multiplier to zero (if we don't
         // project onto a master face, then we're definitely not in contact)
         return _test[_i][_qp] * _lambda[_qp];
     }
  
     default:
       return 0;
   }
 }