#include <NormalMortarLMMechanicalContact.h>

Inheritance diagram for NormalMortarLMMechanicalContact< compute_stage >:

Public Member Functions
	NormalMortarLMMechanicalContact (const InputParameters &parameters)

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

template<>
Real	computeQpResidual (Moose::MortarType mortar_type)

template<>
DualReal	computeQpResidual (Moose::MortarType mortar_type)

Protected Attributes
const MooseVariableFE< Real > *	_slave_disp_y

const MooseVariableFE< Real > *	_master_disp_y

bool	_computing_gap_dependence

const ADVariableValue *	_slave_disp_y_sln

const ADVariableValue *	_master_disp_y_sln

const Real	_epsilon

MooseEnum	_ncp_type

	usingMortarConstraintMembers

Detailed Description

template<ComputeStage compute_stage>
class NormalMortarLMMechanicalContact< compute_stage >

Definition at line 15 of file NormalMortarLMMechanicalContact.h.

Constructor & Destructor Documentation

◆ NormalMortarLMMechanicalContact()

template<ComputeStage compute_stage>

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

Definition at line 29 of file NormalMortarLMMechanicalContact.C.

   : ADMortarConstraint<compute_stage>(parameters),
     _slave_disp_y(isParamValid("slave_disp_y") ? &this->_subproblem.getStandardVariable(
                                                      _tid, parameters.getMooseType("slave_disp_y"))
                                                : nullptr),
     _master_disp_y(
         isParamValid("master_disp_y")
             ? &this->_subproblem.getStandardVariable(_tid, parameters.getMooseType("master_disp_y"))
             : isParamValid("slave_disp_y") ? &this->_subproblem.getStandardVariable(
                                                  _tid, parameters.getMooseType("slave_disp_y"))
                                            : nullptr),
     _computing_gap_dependence(false),
     _slave_disp_y_sln(nullptr),
     _master_disp_y_sln(nullptr),
     _epsilon(std::numeric_limits<Real>::epsilon()),
     _ncp_type(getParam<MooseEnum>("ncp_function_type"))
 {
   if (_slave_disp_y)
   {
     mooseAssert(_master_disp_y,
                 "It doesn't make any sense that we have a slave displacement variable and not a "
                 "master displacement variable");
     _computing_gap_dependence = true;
     _slave_disp_y_sln = &_slave_disp_y->template adSln<compute_stage>();
     _master_disp_y_sln = &_master_disp_y->template adSlnNeighbor<compute_stage>();
   }
 }

Member Function Documentation

◆ computeQpResidual() [1/3]

template<>

Real NormalMortarLMMechanicalContact< RESIDUAL >::computeQpResidual ( Moose::MortarType mortar_type )

protected

Definition at line 60 of file NormalMortarLMMechanicalContact.C.

 {
   switch (mortar_type)
   {
     case Moose::MortarType::Lower:
     {
       if (_has_master)
       {
         auto gap_vec = _phys_points_master[_qp] - _phys_points_slave[_qp];
         auto gap = gap_vec * _normals[_qp];
  
         const auto & a = _lambda[_qp];
         const auto & b = gap;
  
         Real 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
         return _test[_i][_qp] * _lambda[_qp];
     }
  
     default:
       return 0;
   }
 }

◆ computeQpResidual() [2/3]

template<>

DualReal NormalMortarLMMechanicalContact< JACOBIAN >::computeQpResidual ( Moose::MortarType mortar_type )

protected

Definition at line 95 of file NormalMortarLMMechanicalContact.C.

 {
   switch (mortar_type)
   {
     case Moose::MortarType::Lower:
     {
       if (_has_master)
       {
         DualRealVectorValue gap_vec = _phys_points_master[_qp] - _phys_points_slave[_qp];
         if (_computing_gap_dependence)
         {
           // Here we're assuming that the user provided the x-component as the slave/master
           // variable!
           gap_vec(0).derivatives() = _u_master[_qp].derivatives() - _u_slave[_qp].derivatives();
           gap_vec(1).derivatives() =
               (*_master_disp_y_sln)[_qp].derivatives() - (*_slave_disp_y_sln)[_qp].derivatives();
         }
  
         auto gap = gap_vec * _normals[_qp];
  
         const auto & a = _lambda[_qp];
         const auto & b = gap;
  
         DualReal 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
         return _test[_i][_qp] * _lambda[_qp];
     }
  
     default:
       return 0;
   }
 }