A MechanicalContactConstraint forces the value of a variable to be the same on both sides of an interface. More...

#include <MechanicalContactConstraint.h>

Inheritance diagram for MechanicalContactConstraint:

Public Types
enum	ResidualTagType { ResidualTagType::NonReference, ResidualTagType::Reference }

typedef DataFileName	DataFileParameterType

Public Member Functions
	MechanicalContactConstraint (const InputParameters &parameters)

virtual void	timestepSetup () override

virtual void	jacobianSetup () override

virtual void	residualEnd () override

virtual bool	AugmentedLagrangianContactConverged ()

virtual void	updateAugmentedLagrangianMultiplier (bool beginning_of_step)

virtual void	updateContactStatefulData (bool beginning_of_step)

virtual Real	computeQpSecondaryValue () override

virtual Real	computeQpResidual (Moose::ConstraintType type) override

virtual void	computeJacobian () override
	Computes the jacobian for the current element. More...

virtual void	computeOffDiagJacobian (unsigned int jvar) override
	Compute off-diagonal Jacobian entries. More...

virtual Real	computeQpJacobian (Moose::ConstraintJacobianType type) override

virtual Real	computeQpOffDiagJacobian (Moose::ConstraintJacobianType type, unsigned int jvar) override
	Compute off-diagonal Jacobian entries. More...

virtual void	getConnectedDofIndices (unsigned int var_num) override
	Get the dof indices of the nodes connected to the secondary node for a specific variable. More...

bool	getCoupledVarComponent (unsigned int var_num, unsigned int &component)
	Determine whether the coupled variable is one of the displacement variables, and find its component. More...

virtual bool	addCouplingEntriesToJacobian () override

bool	shouldApply () override

void	computeContactForce (const Node &node, PenetrationInfo *pinfo, bool update_contact_set)

virtual void	computeSecondaryValue (NumericVector< Number > &current_solution)

virtual void	computeResidual () override

virtual bool	overwriteSecondaryResidual ()

virtual bool	overwriteSecondaryJacobian ()

virtual MooseVariable &	primaryVariable ()

BoundaryID	primaryBoundary () const

BoundaryID	secondaryBoundary () const

const MooseVariable &	variable () const override

Real	secondaryResidual () const

void	residualSetup () override

virtual const std::unordered_set< unsigned int > &	getMatPropDependencies () const

virtual bool	isExplicitConstraint () const

virtual void	overwriteBoundaryVariables (NumericVector< Number > &, const Node &) const

std::set< SubdomainID >	getSecondaryConnectedBlocks () const

virtual void	subdomainSetup () override final

void	prepareNeighborShapes (unsigned int var_num)

virtual void	computeResidualAndJacobian ()

virtual void	computeOffDiagJacobianScalar (unsigned int)

virtual void	computeNonlocalJacobian ()

virtual void	computeNonlocalOffDiagJacobian (unsigned int)

const SubProblem &	subProblem () const

virtual void	prepareShapes (unsigned int var_num)

virtual std::set< std::string >	additionalROVariables ()

virtual bool	enabled () const

std::shared_ptr< MooseObject >	getSharedPtr ()

std::shared_ptr< const MooseObject >	getSharedPtr () const

MooseApp &	getMooseApp () const

const std::string &	type () const

virtual const std::string &	name () const

std::string	typeAndName () const

std::string	errorPrefix (const std::string &error_type) const

void	callMooseError (std::string msg, const bool with_prefix) const

MooseObjectParameterName	uniqueParameterName (const std::string &parameter_name) const

const InputParameters &	parameters () const

MooseObjectName	uniqueName () const

const T &	getParam (const std::string &name) const

std::vector< std::pair< T1, T2 > >	getParam (const std::string &param1, const std::string &param2) const

const T *	queryParam (const std::string &name) const

const T &	getRenamedParam (const std::string &old_name, const std::string &new_name) const

T	getCheckedPointerParam (const std::string &name, const std::string &error_string="") const

bool	isParamValid (const std::string &name) const

bool	isParamSetByUser (const std::string &nm) const

void	paramError (const std::string &param, Args... args) const

void	paramWarning (const std::string &param, Args... args) const

void	paramInfo (const std::string &param, Args... args) const

void	connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const

void	mooseError (Args &&... args) const

void	mooseErrorNonPrefixed (Args &&... args) const

void	mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const

void	mooseWarning (Args &&... args) const

void	mooseWarningNonPrefixed (Args &&... args) const

void	mooseDeprecated (Args &&... args) const

void	mooseInfo (Args &&... args) const

std::string	getDataFileName (const std::string &param) const

std::string	getDataFileNameByName (const std::string &relative_path) const

std::string	getDataFilePath (const std::string &relative_path) const

virtual void	initialSetup ()

virtual void	customSetup (const ExecFlagType &)

const ExecFlagEnum &	getExecuteOnEnum () const

const Function &	getFunction (const std::string &name) const

const Function &	getFunctionByName (const FunctionName &name) const

bool	hasFunction (const std::string &param_name) const

bool	hasFunctionByName (const FunctionName &name) const

UserObjectName	getUserObjectName (const std::string &param_name) const

const T &	getUserObject (const std::string &param_name, bool is_dependency=true) const

const T &	getUserObjectByName (const UserObjectName &object_name, bool is_dependency=true) const

const UserObject &	getUserObjectBase (const std::string &param_name, bool is_dependency=true) const

const UserObject &	getUserObjectBaseByName (const UserObjectName &object_name, bool is_dependency=true) const

bool	isImplicit ()

Moose::StateArg	determineState () const

bool	isDefaultPostprocessorValue (const std::string &param_name, const unsigned int index=0) const

bool	hasPostprocessor (const std::string &param_name, const unsigned int index=0) const

bool	hasPostprocessorByName (const PostprocessorName &name) const

std::size_t	coupledPostprocessors (const std::string &param_name) const

const PostprocessorName &	getPostprocessorName (const std::string &param_name, const unsigned int index=0) const

const VectorPostprocessorValue &	getVectorPostprocessorValue (const std::string &param_name, const std::string &vector_name) const

const VectorPostprocessorValue &	getVectorPostprocessorValue (const std::string &param_name, const std::string &vector_name, bool needs_broadcast) const

const VectorPostprocessorValue &	getVectorPostprocessorValueByName (const VectorPostprocessorName &name, const std::string &vector_name) const

const VectorPostprocessorValue &	getVectorPostprocessorValueByName (const VectorPostprocessorName &name, const std::string &vector_name, bool needs_broadcast) const

const VectorPostprocessorValue &	getVectorPostprocessorValueOld (const std::string &param_name, const std::string &vector_name) const

const VectorPostprocessorValue &	getVectorPostprocessorValueOld (const std::string &param_name, const std::string &vector_name, bool needs_broadcast) const

const VectorPostprocessorValue &	getVectorPostprocessorValueOldByName (const VectorPostprocessorName &name, const std::string &vector_name) const

const VectorPostprocessorValue &	getVectorPostprocessorValueOldByName (const VectorPostprocessorName &name, const std::string &vector_name, bool needs_broadcast) const

const ScatterVectorPostprocessorValue &	getScatterVectorPostprocessorValue (const std::string &param_name, const std::string &vector_name) const

const ScatterVectorPostprocessorValue &	getScatterVectorPostprocessorValueByName (const VectorPostprocessorName &name, const std::string &vector_name) const

const ScatterVectorPostprocessorValue &	getScatterVectorPostprocessorValueOld (const std::string &param_name, const std::string &vector_name) const

const ScatterVectorPostprocessorValue &	getScatterVectorPostprocessorValueOldByName (const VectorPostprocessorName &name, const std::string &vector_name) const

bool	hasVectorPostprocessor (const std::string &param_name, const std::string &vector_name) const

bool	hasVectorPostprocessor (const std::string &param_name) const

bool	hasVectorPostprocessorByName (const VectorPostprocessorName &name, const std::string &vector_name) const

bool	hasVectorPostprocessorByName (const VectorPostprocessorName &name) const

const VectorPostprocessorName &	getVectorPostprocessorName (const std::string &param_name) const

void	setRandomResetFrequency (ExecFlagType exec_flag)

unsigned long	getRandomLong () const

Real	getRandomReal () const

unsigned int	getSeed (std::size_t id)

unsigned int	getMasterSeed () const

bool	isNodal () const

ExecFlagType	getResetOnTime () const

void	setRandomDataPointer (RandomData *random_data)

virtual void	meshChanged ()

void	useVectorTag (const TagName &tag_name, VectorTagsKey)

void	useVectorTag (TagID tag_id, VectorTagsKey)

void	useMatrixTag (const TagName &tag_name, MatrixTagsKey)

void	useMatrixTag (TagID tag_id, MatrixTagsKey)

bool	isVectorTagged ()

bool	isMatrixTagged ()

bool	hasVectorTags () const

const std::set< TagID > &	getVectorTags (VectorTagsKey) const

const std::set< TagID > &	getMatrixTags (MatrixTagsKey) const

virtual const VariableValue &	coupledNeighborValue (const std::string &var_name, unsigned int comp=0) const

std::vector< const VariableValue *>	coupledNeighborValues (const std::string &var_name) const

std::vector< const VariableValue *>	coupledNeighborValuesOld (const std::string &var_name) const

std::vector< const VariableValue *>	coupledNeighborValuesOlder (const std::string &var_name) const

virtual const ADVariableValue &	adCoupledNeighborValue (const std::string &var_name, unsigned int comp=0) const

const auto &	coupledGenericNeighborValue (const std::string &var_name, unsigned int comp=0) const

const auto &	coupledGenericNeighborGradient (const std::string &var_name, unsigned int comp=0) const

virtual const ADVariableValue &	adCoupledNeighborValueDot (const std::string &var_name, unsigned int comp=0) const

std::vector< const ADVariableValue *>	adCoupledNeighborValues (const std::string &var_name) const

virtual const ADVectorVariableValue &	adCoupledVectorNeighborValue (const std::string &var_name, unsigned int comp=0) const

virtual const VariableValue &	coupledNeighborValueDot (const std::string &var_name, unsigned int comp=0) const

virtual const VariableValue &	coupledNeighborValueDotDu (const std::string &var_name, unsigned int comp=0) const

virtual const VariableValue &	coupledNeighborValueOld (const std::string &var_name, unsigned int comp=0) const

virtual const VariableValue &	coupledNeighborValueOlder (const std::string &var_name, unsigned int comp=0) const

virtual const VariableGradient &	coupledNeighborGradient (const std::string &var_name, unsigned int comp=0) const

virtual std::vector< const VariableGradient *>	coupledNeighborGradients (const std::string &var_name) const

virtual const VariableGradient &	coupledNeighborGradientOld (const std::string &var_name, unsigned int comp=0) const

virtual const VariableGradient &	coupledNeighborGradientOlder (const std::string &var_name, unsigned int comp=0) const

virtual const ADVariableGradient &	adCoupledNeighborGradient (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableGradient &	coupledVectorNeighborGradient (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableGradient &	coupledVectorNeighborGradientOld (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableGradient &	coupledVectorNeighborGradientOlder (const std::string &var_name, unsigned int comp=0) const

virtual const ArrayVariableValue &	coupledArrayNeighborValue (const std::string &var_name, unsigned int comp=0) const

virtual const ArrayVariableGradient &	coupledArrayNeighborGradient (const std::string &var_name, unsigned int comp=0) const

virtual const ArrayVariableGradient &	coupledArrayNeighborGradientOld (const std::string &var_name, unsigned int comp=0) const

virtual const ArrayVariableGradient &	coupledArrayNeighborGradientOlder (const std::string &var_name, unsigned int comp=0) const

virtual const VariableSecond &	coupledNeighborSecond (const std::string &var_name, unsigned int i=0) const

virtual const VariableValue &	coupledNeighborDofValues (const std::string &var_name, unsigned int comp=0) const

virtual const VariableValue &	coupledNeighborDofValuesOld (const std::string &var_name, unsigned int comp=0) const

virtual const VariableValue &	coupledNeighborDofValuesOlder (const std::string &var_name, unsigned int comp=0) const

const std::unordered_map< std::string, std::vector< MooseVariableFieldBase *> > &	getCoupledVars () const

const std::vector< MooseVariableFieldBase *> &	getCoupledMooseVars () const

const std::vector< MooseVariable *> &	getCoupledStandardMooseVars () const

const std::vector< VectorMooseVariable *> &	getCoupledVectorMooseVars () const

const std::vector< ArrayMooseVariable *> &	getCoupledArrayMooseVars () const

void	addFEVariableCoupleableVectorTag (TagID tag)

void	addFEVariableCoupleableMatrixTag (TagID tag)

std::set< TagID > &	getFEVariableCoupleableVectorTags ()

const std::set< TagID > &	getFEVariableCoupleableVectorTags () const

std::set< TagID > &	getFEVariableCoupleableMatrixTags ()

const std::set< TagID > &	getFEVariableCoupleableMatrixTags () const

auto &	getWritableCoupledVariables () const

bool	hasWritableCoupledVariables () const

const ADVariableValue *	getADDefaultValue (const std::string &var_name) const

const ADVectorVariableValue *	getADDefaultVectorValue (const std::string &var_name) const

const ADVariableGradient &	getADDefaultGradient () const

const ADVectorVariableGradient &	getADDefaultVectorGradient () const

const ADVariableSecond &	getADDefaultSecond () const

const ADVectorVariableCurl &	getADDefaultCurl () const

const std::vector< MooseVariableScalar *> &	getCoupledMooseScalarVars ()

const std::set< TagID > &	getScalarVariableCoupleableVectorTags () const

const std::set< TagID > &	getScalarVariableCoupleableMatrixTags () const

const std::set< MooseVariableFieldBase *> &	getMooseVariableDependencies () const

std::set< MooseVariableFieldBase *>	checkAllVariables (const DofObjectType &dof_object, const std::set< MooseVariableFieldBase * > &vars_to_omit={})

std::set< MooseVariableFieldBase *>	checkVariables (const DofObjectType &dof_object, const std::set< MooseVariableFieldBase * > &vars_to_check)

void	addMooseVariableDependency (MooseVariableFieldBase *var)

void	addMooseVariableDependency (const std::vector< MooseVariableFieldBase * > &vars)

MooseVariableBase *	mooseVariableBase () const

MooseVariableField< Real > &	mooseVariableField ()

MooseVariableFE< Real > *	mooseVariable () const

MooseVariableFV< Real > *	mooseVariableFV () const

MooseLinearVariableFV< Real > *	mooseLinearVariableFV () const

bool	hasUserObject (const std::string &param_name) const

bool	hasUserObject (const std::string &param_name) const

bool	hasUserObject (const std::string &param_name) const

bool	hasUserObject (const std::string &param_name) const

bool	hasUserObjectByName (const UserObjectName &object_name) const

bool	hasUserObjectByName (const UserObjectName &object_name) const

bool	hasUserObjectByName (const UserObjectName &object_name) const

bool	hasUserObjectByName (const UserObjectName &object_name) const

const PostprocessorValue &	getPostprocessorValue (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValue (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValueOld (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValueOld (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValueOlder (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValueOlder (const std::string &param_name, const unsigned int index=0) const

virtual const PostprocessorValue &	getPostprocessorValueByName (const PostprocessorName &name) const

virtual const PostprocessorValue &	getPostprocessorValueByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOldByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOldByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOlderByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOlderByName (const PostprocessorName &name) const

bool	isVectorPostprocessorDistributed (const std::string &param_name) const

bool	isVectorPostprocessorDistributed (const std::string &param_name) const

bool	isVectorPostprocessorDistributedByName (const VectorPostprocessorName &name) const

bool	isVectorPostprocessorDistributedByName (const VectorPostprocessorName &name) const

PenetrationLocator &	getPenetrationLocator (const BoundaryName &primary, const BoundaryName &secondary, Order order)

PenetrationLocator &	getQuadraturePenetrationLocator (const BoundaryName &primary, const BoundaryName &secondary, Order order)

NearestNodeLocator &	getNearestNodeLocator (const BoundaryName &primary, const BoundaryName &secondary)

NearestNodeLocator &	getQuadratureNearestNodeLocator (const BoundaryName &primary, const BoundaryName &secondary)

bool	requiresGeometricSearch () const

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Static Public Member Functions
static InputParameters	validParams ()

Public Attributes
const ConsoleStream	_console

Protected Member Functions
Real	gapOffset (const Node &node)

Real	nodalArea (const Node &node)

Real	getPenalty (const Node &node)

Real	getTangentialPenalty (const Node &node)

virtual const VariableValue &	coupledSecondaryValue (const std::string &var_name, unsigned int comp=0)

virtual const VariableValue &	coupledSecondaryValueOld (const std::string &var_name, unsigned int comp=0)

virtual const VariableValue &	coupledSecondaryValueOlder (const std::string &var_name, unsigned int comp=0)

virtual const VariableGradient &	coupledSecondaryGradient (const std::string &var_name, unsigned int comp=0)

virtual const VariableGradient &	coupledSecondaryGradientOld (const std::string &var_name, unsigned int comp=0)

virtual const VariableGradient &	coupledSecondaryGradientOlder (const std::string &var_name, unsigned int comp=0)

virtual const VariableSecond &	coupledSecondarySecond (const std::string &var_name, unsigned int comp=0)

virtual const VariableValue &	coupledPrimaryValue (const std::string &var_name, unsigned int comp=0)

virtual const VariableValue &	coupledPrimaryValueOld (const std::string &var_name, unsigned int comp=0)

virtual const VariableValue &	coupledPrimaryValueOlder (const std::string &var_name, unsigned int comp=0)

virtual const VariableGradient &	coupledPrimaryGradient (const std::string &var_name, unsigned int comp=0)

virtual const VariableGradient &	coupledPrimaryGradientOld (const std::string &var_name, unsigned int comp=0)

virtual const VariableGradient &	coupledPrimaryGradientOlder (const std::string &var_name, unsigned int comp=0)

virtual const VariableSecond &	coupledPrimarySecond (const std::string &var_name, unsigned int comp=0)

const std::set< BoundaryID > &	buildBoundaryIDs ()

virtual void	precalculateResidual ()

virtual void	precalculateJacobian ()

virtual void	precalculateOffDiagJacobian (unsigned int)

const MooseVariableFieldBase &	getVariable (unsigned int jvar_num) const

virtual void	addUserObjectDependencyHelper (const UserObject &) const

virtual void	addPostprocessorDependencyHelper (const PostprocessorName &) const

virtual void	addVectorPostprocessorDependencyHelper (const VectorPostprocessorName &) const

T &	declareRestartableData (const std::string &data_name, Args &&... args)

ManagedValue< T >	declareManagedRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)

const T &	getRestartableData (const std::string &data_name) const

T &	declareRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)

T &	declareRecoverableData (const std::string &data_name, Args &&... args)

T &	declareRestartableDataWithObjectName (const std::string &data_name, const std::string &object_name, Args &&... args)

T &	declareRestartableDataWithObjectNameWithContext (const std::string &data_name, const std::string &object_name, void *context, Args &&... args)

std::string	restartableName (const std::string &data_name) const

void	prepareVectorTag (Assembly &assembly, unsigned int ivar)

void	prepareVectorTag (Assembly &assembly, unsigned int ivar, ResidualTagType tag_type)

void	prepareVectorTag (Assembly &assembly, unsigned int ivar, ResidualTagType tag_type)

void	prepareVectorTag (Assembly &assembly, unsigned int ivar, ResidualTagType tag_type)

void	prepareVectorTag (Assembly &assembly, unsigned int ivar, ResidualTagType tag_type)

void	prepareVectorTagNeighbor (Assembly &assembly, unsigned int ivar)

void	prepareVectorTagLower (Assembly &assembly, unsigned int ivar)

void	prepareMatrixTag (Assembly &assembly, unsigned int ivar, unsigned int jvar)

void	prepareMatrixTag (Assembly &assembly, unsigned int ivar, unsigned int jvar, DenseMatrix< Number > &k) const

void	prepareMatrixTagNonlocal (Assembly &assembly, unsigned int ivar, unsigned int jvar)

void	prepareMatrixTagNeighbor (Assembly &assembly, unsigned int ivar, unsigned int jvar, Moose::DGJacobianType type)

void	prepareMatrixTagNeighbor (Assembly &assembly, unsigned int ivar, unsigned int jvar, Moose::DGJacobianType type, DenseMatrix< Number > &k) const

void	prepareMatrixTagLower (Assembly &assembly, unsigned int ivar, unsigned int jvar, Moose::ConstraintJacobianType type)

void	accumulateTaggedLocalResidual ()

void	assignTaggedLocalResidual ()

void	accumulateTaggedLocalMatrix ()

void	accumulateTaggedLocalMatrix (Assembly &assembly, unsigned int ivar, unsigned int jvar, const DenseMatrix< Number > &k)

void	accumulateTaggedLocalMatrix (Assembly &assembly, unsigned int ivar, unsigned int jvar, Moose::DGJacobianType type, const DenseMatrix< Number > &k)

void	accumulateTaggedNonlocalMatrix ()

void	assignTaggedLocalMatrix ()

void	addResiduals (Assembly &assembly, const Residuals &residuals, const Indices &dof_indices, Real scaling_factor)

void	addResiduals (Assembly &assembly, const DenseVector< T > &residuals, const Indices &dof_indices, Real scaling_factor)

void	addResiduals (Assembly &assembly, const ADResidualsPacket &packet)

void	addResidualsAndJacobian (Assembly &assembly, const Residuals &residuals, const Indices &dof_indices, Real scaling_factor)

void	addResidualsAndJacobian (Assembly &assembly, const ADResidualsPacket &packet)

void	addJacobian (Assembly &assembly, const Residuals &residuals, const Indices &dof_indices, Real scaling_factor)

void	addJacobian (Assembly &assembly, const ADResidualsPacket &packet)

void	addJacobian (Assembly &assembly, DenseMatrix< Real > &local_k, const std::vector< dof_id_type > &row_indices, const std::vector< dof_id_type > &column_indices, Real scaling_factor)

void	addResidualsWithoutConstraints (Assembly &assembly, const Residuals &residuals, const Indices &dof_indices, Real scaling_factor)

void	addResidualsAndJacobianWithoutConstraints (Assembly &assembly, const Residuals &residuals, const Indices &dof_indices, Real scaling_factor)

void	addJacobianWithoutConstraints (Assembly &assembly, const Residuals &residuals, const Indices &dof_indices, Real scaling_factor)

void	addJacobianElement (Assembly &assembly, Real value, dof_id_type row_index, dof_id_type column_index, Real scaling_factor)

void	setResidual (SystemBase &sys, const T &residual, MooseVariableFE< T > &var)

void	setResidual (SystemBase &sys, Real residual, dof_id_type dof_index)

void	setResidual (SystemBase &sys, SetResidualFunctor set_residual_functor)

virtual void	coupledCallback (const std::string &, bool) const

virtual bool	isCoupled (const std::string &var_name, unsigned int i=0) const

virtual bool	isCoupledConstant (const std::string &var_name) const

unsigned int	coupledComponents (const std::string &var_name) const

VariableName	coupledName (const std::string &var_name, unsigned int comp=0) const

std::vector< VariableName >	coupledNames (const std::string &var_name) const

virtual unsigned int	coupled (const std::string &var_name, unsigned int comp=0) const

std::vector< unsigned int >	coupledIndices (const std::string &var_name) const

virtual const VariableValue &	coupledValue (const std::string &var_name, unsigned int comp=0) const

std::vector< const VariableValue *>	coupledValues (const std::string &var_name) const

std::vector< const VectorVariableValue *>	coupledVectorValues (const std::string &var_name) const

const GenericVariableValue< is_ad > &	coupledGenericValue (const std::string &var_name, unsigned int comp=0) const

const GenericVariableValue< false > &	coupledGenericValue (const std::string &var_name, unsigned int comp) const

const GenericVariableValue< true > &	coupledGenericValue (const std::string &var_name, unsigned int comp) const

const GenericVectorVariableValue< is_ad > &	coupledGenericVectorValue (const std::string &var_name, unsigned int comp=0) const

const GenericVectorVariableValue< false > &	coupledGenericVectorValue (const std::string &var_name, unsigned int comp) const

const GenericVectorVariableValue< true > &	coupledGenericVectorValue (const std::string &var_name, unsigned int comp) const

std::vector< const GenericVariableValue< is_ad > *>	coupledGenericValues (const std::string &var_name) const

std::vector< const GenericVariableValue< false > *>	coupledGenericValues (const std::string &var_name) const

std::vector< const GenericVariableValue< true > *>	coupledGenericValues (const std::string &var_name) const

const GenericVariableValue< is_ad > &	coupledGenericDofValue (const std::string &var_name, unsigned int comp=0) const

const GenericVariableValue< false > &	coupledGenericDofValue (const std::string &var_name, unsigned int comp) const

const GenericVariableValue< true > &	coupledGenericDofValue (const std::string &var_name, unsigned int comp) const

const GenericVariableValue< is_ad > &	coupledGenericDot (const std::string &var_name, unsigned int comp=0) const

const GenericVariableValue< false > &	coupledGenericDot (const std::string &var_name, unsigned int comp) const

const GenericVariableValue< true > &	coupledGenericDot (const std::string &var_name, unsigned int comp) const

const GenericVariableValue< is_ad > &	coupledGenericDotDot (const std::string &var_name, unsigned int comp=0) const

const GenericVariableValue< false > &	coupledGenericDotDot (const std::string &var_name, unsigned int comp) const

const GenericVariableValue< true > &	coupledGenericDotDot (const std::string &var_name, unsigned int comp) const

virtual const VariableValue &	coupledValueLower (const std::string &var_name, unsigned int comp=0) const

const ADVariableValue &	adCoupledValue (const std::string &var_name, unsigned int comp=0) const

std::vector< const ADVariableValue *>	adCoupledValues (const std::string &var_name) const

const ADVariableValue &	adCoupledLowerValue (const std::string &var_name, unsigned int comp=0) const

const ADVectorVariableValue &	adCoupledVectorValue (const std::string &var_name, unsigned int comp=0) const

std::vector< const ADVectorVariableValue *>	adCoupledVectorValues (const std::string &var_name) const

virtual const VariableValue &	coupledVectorTagValue (const std::string &var_names, TagID tag, unsigned int index=0) const

virtual const VariableValue &	coupledVectorTagValue (const std::string &var_names, const std::string &tag_name, unsigned int index=0) const

std::vector< const VariableValue *>	coupledVectorTagValues (const std::string &var_names, TagID tag) const

std::vector< const VariableValue *>	coupledVectorTagValues (const std::string &var_names, const std::string &tag_name) const

virtual const ArrayVariableValue &	coupledVectorTagArrayValue (const std::string &var_names, TagID tag, unsigned int index=0) const

virtual const ArrayVariableValue &	coupledVectorTagArrayValue (const std::string &var_names, const std::string &tag_name, unsigned int index=0) const

std::vector< const ArrayVariableValue *>	coupledVectorTagArrayValues (const std::string &var_names, TagID tag) const

std::vector< const ArrayVariableValue *>	coupledVectorTagArrayValues (const std::string &var_names, const std::string &tag_name) const

virtual const VariableGradient &	coupledVectorTagGradient (const std::string &var_names, TagID tag, unsigned int index=0) const

virtual const VariableGradient &	coupledVectorTagGradient (const std::string &var_names, const std::string &tag_name, unsigned int index=0) const

std::vector< const VariableGradient *>	coupledVectorTagGradients (const std::string &var_names, TagID tag) const

std::vector< const VariableGradient *>	coupledVectorTagGradients (const std::string &var_names, const std::string &tag_name) const

virtual const ArrayVariableGradient &	coupledVectorTagArrayGradient (const std::string &var_names, TagID tag, unsigned int index=0) const

virtual const ArrayVariableGradient &	coupledVectorTagArrayGradient (const std::string &var_names, const std::string &tag_name, unsigned int index=0) const

std::vector< const ArrayVariableGradient *>	coupledVectorTagArrayGradients (const std::string &var_names, TagID tag) const

std::vector< const ArrayVariableGradient *>	coupledVectorTagArrayGradients (const std::string &var_names, const std::string &tag_name) const

virtual const VariableValue &	coupledVectorTagDofValue (const std::string &var_name, TagID tag, unsigned int index=0) const

virtual const VariableValue &	coupledVectorTagDofValue (const std::string &var_names, const std::string &tag_name, unsigned int index=0) const

const ArrayVariableValue &	coupledVectorTagArrayDofValue (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

std::vector< const VariableValue *>	coupledVectorTagDofValues (const std::string &var_names, TagID tag) const

std::vector< const VariableValue *>	coupledVectorTagDofValues (const std::string &var_names, const std::string &tag_name) const

virtual const VariableValue &	coupledMatrixTagValue (const std::string &var_names, TagID tag, unsigned int index=0) const

virtual const VariableValue &	coupledMatrixTagValue (const std::string &var_names, const std::string &tag_name, unsigned int index=0) const

std::vector< const VariableValue *>	coupledMatrixTagValues (const std::string &var_names, TagID tag) const

std::vector< const VariableValue *>	coupledMatrixTagValues (const std::string &var_names, const std::string &tag_name) const

virtual const VectorVariableValue &	coupledVectorValue (const std::string &var_name, unsigned int comp=0) const

virtual const ArrayVariableValue &	coupledArrayValue (const std::string &var_name, unsigned int comp=0) const

std::vector< const ArrayVariableValue *>	coupledArrayValues (const std::string &var_name) const

MooseWritableVariable &	writableVariable (const std::string &var_name, unsigned int comp=0)

virtual VariableValue &	writableCoupledValue (const std::string &var_name, unsigned int comp=0)

void	checkWritableVar (MooseWritableVariable *var)

virtual const VariableValue &	coupledValueOld (const std::string &var_name, unsigned int comp=0) const

std::vector< const VariableValue *>	coupledValuesOld (const std::string &var_name) const

std::vector< const VectorVariableValue *>	coupledVectorValuesOld (const std::string &var_name) const

virtual const VariableValue &	coupledValueOlder (const std::string &var_name, unsigned int comp=0) const

std::vector< const VariableValue *>	coupledValuesOlder (const std::string &var_name) const

virtual const VariableValue &	coupledValuePreviousNL (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableValue &	coupledVectorValueOld (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableValue &	coupledVectorValueOlder (const std::string &var_name, unsigned int comp=0) const

virtual const ArrayVariableValue &	coupledArrayValueOld (const std::string &var_name, unsigned int comp=0) const

virtual const ArrayVariableValue &	coupledArrayValueOlder (const std::string &var_name, unsigned int comp=0) const

virtual const VariableGradient &	coupledGradient (const std::string &var_name, unsigned int comp=0) const

std::vector< const VariableGradient *>	coupledGradients (const std::string &var_name) const

const ADVariableGradient &	adCoupledGradient (const std::string &var_name, unsigned int comp=0) const

const ADVariableGradient &	adCoupledGradientDot (const std::string &var_name, unsigned int comp=0) const

std::vector< const ADVariableGradient *>	adCoupledGradients (const std::string &var_name) const

const GenericVariableGradient< is_ad > &	coupledGenericGradient (const std::string &var_name, unsigned int comp=0) const

const GenericVariableGradient< false > &	coupledGenericGradient (const std::string &var_name, unsigned int comp) const

const GenericVariableGradient< true > &	coupledGenericGradient (const std::string &var_name, unsigned int comp) const

std::vector< const GenericVariableGradient< is_ad > *>	coupledGenericGradients (const std::string &var_name) const

std::vector< const GenericVariableGradient< false > *>	coupledGenericGradients (const std::string &var_name) const

std::vector< const GenericVariableGradient< true > *>	coupledGenericGradients (const std::string &var_name) const

const ADVectorVariableGradient &	adCoupledVectorGradient (const std::string &var_name, unsigned int comp=0) const

const ADVariableSecond &	adCoupledSecond (const std::string &var_name, unsigned int comp=0) const

const ADVectorVariableSecond &	adCoupledVectorSecond (const std::string &var_name, unsigned int comp=0) const

virtual const VariableGradient &	coupledGradientOld (const std::string &var_name, unsigned int comp=0) const

std::vector< const VariableGradient *>	coupledGradientsOld (const std::string &var_name) const

virtual const VariableGradient &	coupledGradientOlder (const std::string &var_name, unsigned int comp=0) const

virtual const VariableGradient &	coupledGradientPreviousNL (const std::string &var_name, unsigned int comp=0) const

virtual const VariableGradient &	coupledGradientDot (const std::string &var_name, unsigned int comp=0) const

virtual const VariableGradient &	coupledGradientDotDot (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableGradient &	coupledVectorGradient (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableGradient &	coupledVectorGradientOld (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableGradient &	coupledVectorGradientOlder (const std::string &var_name, unsigned int comp=0) const

virtual const ArrayVariableGradient &	coupledArrayGradient (const std::string &var_name, unsigned int comp=0) const

virtual const ArrayVariableGradient &	coupledArrayGradientOld (const std::string &var_name, unsigned int comp=0) const

virtual const ArrayVariableGradient &	coupledArrayGradientOlder (const std::string &var_name, unsigned int comp=0) const

virtual const ArrayVariableGradient &	coupledArrayGradientDot (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableCurl &	coupledCurl (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableCurl &	coupledCurlOld (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableCurl &	coupledCurlOlder (const std::string &var_name, unsigned int comp=0) const

const ADVectorVariableCurl &	adCoupledCurl (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableDivergence &	coupledDiv (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableDivergence &	coupledDivOld (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableDivergence &	coupledDivOlder (const std::string &var_name, unsigned int comp=0) const

virtual const VariableSecond &	coupledSecond (const std::string &var_name, unsigned int comp=0) const

virtual const VariableSecond &	coupledSecondOld (const std::string &var_name, unsigned int comp=0) const

virtual const VariableSecond &	coupledSecondOlder (const std::string &var_name, unsigned int comp=0) const

virtual const VariableSecond &	coupledSecondPreviousNL (const std::string &var_name, unsigned int comp=0) const

virtual const VariableValue &	coupledDot (const std::string &var_name, unsigned int comp=0) const

std::vector< const VariableValue *>	coupledDots (const std::string &var_name) const

virtual const VariableValue &	coupledDotDot (const std::string &var_name, unsigned int comp=0) const

virtual const VariableValue &	coupledDotOld (const std::string &var_name, unsigned int comp=0) const

virtual const VariableValue &	coupledDotDotOld (const std::string &var_name, unsigned int comp=0) const

const ADVariableValue &	adCoupledDot (const std::string &var_name, unsigned int comp=0) const

std::vector< const ADVariableValue *>	adCoupledDots (const std::string &var_name) const

const ADVariableValue &	adCoupledDotDot (const std::string &var_name, unsigned int comp=0) const

const ADVectorVariableValue &	adCoupledVectorDot (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableValue &	coupledVectorDot (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableValue &	coupledVectorDotDot (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableValue &	coupledVectorDotOld (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableValue &	coupledVectorDotDotOld (const std::string &var_name, unsigned int comp=0) const

virtual const VariableValue &	coupledVectorDotDu (const std::string &var_name, unsigned int comp=0) const

virtual const VariableValue &	coupledVectorDotDotDu (const std::string &var_name, unsigned int comp=0) const

virtual const ArrayVariableValue &	coupledArrayDot (const std::string &var_name, unsigned int comp=0) const

virtual const ArrayVariableValue &	coupledArrayDotDot (const std::string &var_name, unsigned int comp=0) const

virtual const ArrayVariableValue &	coupledArrayDotOld (const std::string &var_name, unsigned int comp=0) const

virtual const ArrayVariableValue &	coupledArrayDotDotOld (const std::string &var_name, unsigned int comp=0) const

virtual const VariableValue &	coupledDotDu (const std::string &var_name, unsigned int comp=0) const

virtual const VariableValue &	coupledDotDotDu (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledArrayDotDu (const std::string &var_name, unsigned int comp=0) const

const T &	coupledNodalValue (const std::string &var_name, unsigned int comp=0) const

const Moose::ADType< T >::type &	adCoupledNodalValue (const std::string &var_name, unsigned int comp=0) const

const T &	coupledNodalValueOld (const std::string &var_name, unsigned int comp=0) const

const T &	coupledNodalValueOlder (const std::string &var_name, unsigned int comp=0) const

const T &	coupledNodalValuePreviousNL (const std::string &var_name, unsigned int comp=0) const

const T &	coupledNodalDot (const std::string &var_name, unsigned int comp=0) const

virtual const VariableValue &	coupledNodalDotDot (const std::string &var_name, unsigned int comp=0) const

virtual const VariableValue &	coupledNodalDotOld (const std::string &var_name, unsigned int comp=0) const

virtual const VariableValue &	coupledNodalDotDotOld (const std::string &var_name, unsigned int comp=0) const

virtual const VariableValue &	coupledDofValues (const std::string &var_name, unsigned int comp=0) const

std::vector< const VariableValue *>	coupledAllDofValues (const std::string &var_name) const

virtual const VariableValue &	coupledDofValuesOld (const std::string &var_name, unsigned int comp=0) const

std::vector< const VariableValue *>	coupledAllDofValuesOld (const std::string &var_name) const

virtual const VariableValue &	coupledDofValuesOlder (const std::string &var_name, unsigned int comp=0) const

std::vector< const VariableValue *>	coupledAllDofValuesOlder (const std::string &var_name) const

virtual const ArrayVariableValue &	coupledArrayDofValues (const std::string &var_name, unsigned int comp=0) const

virtual const ADVariableValue &	adCoupledDofValues (const std::string &var_name, unsigned int comp=0) const

const ADVariableValue &	adZeroValue () const

const ADVariableGradient &	adZeroGradient () const

const ADVariableSecond &	adZeroSecond () const

const GenericVariableValue< is_ad > &	genericZeroValue ()

const GenericVariableValue< false > &	genericZeroValue ()

const GenericVariableValue< true > &	genericZeroValue ()

const GenericVariableGradient< is_ad > &	genericZeroGradient ()

const GenericVariableGradient< false > &	genericZeroGradient ()

const GenericVariableGradient< true > &	genericZeroGradient ()

const GenericVariableSecond< is_ad > &	genericZeroSecond ()

const GenericVariableSecond< false > &	genericZeroSecond ()

const GenericVariableSecond< true > &	genericZeroSecond ()

bool	checkVar (const std::string &var_name, unsigned int comp=0, unsigned int comp_bound=0) const

const MooseVariableFieldBase *	getFEVar (const std::string &var_name, unsigned int comp) const

const MooseVariableFieldBase *	getFieldVar (const std::string &var_name, unsigned int comp) const

MooseVariableFieldBase *	getFieldVar (const std::string &var_name, unsigned int comp)

const T *	getVarHelper (const std::string &var_name, unsigned int comp) const

T *	getVarHelper (const std::string &var_name, unsigned int comp)

MooseVariable *	getVar (const std::string &var_name, unsigned int comp)

const MooseVariable *	getVar (const std::string &var_name, unsigned int comp) const

VectorMooseVariable *	getVectorVar (const std::string &var_name, unsigned int comp)

const VectorMooseVariable *	getVectorVar (const std::string &var_name, unsigned int comp) const

ArrayMooseVariable *	getArrayVar (const std::string &var_name, unsigned int comp)

const ArrayMooseVariable *	getArrayVar (const std::string &var_name, unsigned int comp) const

void	validateExecutionerType (const std::string &name, const std::string &fn_name) const

std::vector< T >	coupledVectorHelper (const std::string &var_name, const Func &func) const

bool	isCoupledScalar (const std::string &var_name, unsigned int i=0) const

unsigned int	coupledScalarComponents (const std::string &var_name) const

unsigned int	coupledScalar (const std::string &var_name, unsigned int comp=0) const

libMesh::Order	coupledScalarOrder (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarValue (const std::string &var_name, unsigned int comp=0) const

const ADVariableValue &	adCoupledScalarValue (const std::string &var_name, unsigned int comp=0) const

const GenericVariableValue< is_ad > &	coupledGenericScalarValue (const std::string &var_name, unsigned int comp=0) const

const GenericVariableValue< false > &	coupledGenericScalarValue (const std::string &var_name, const unsigned int comp) const

const GenericVariableValue< true > &	coupledGenericScalarValue (const std::string &var_name, const unsigned int comp) const

const VariableValue &	coupledVectorTagScalarValue (const std::string &var_name, TagID tag, unsigned int comp=0) const

const VariableValue &	coupledMatrixTagScalarValue (const std::string &var_name, TagID tag, unsigned int comp=0) const

const VariableValue &	coupledScalarValueOld (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarValueOlder (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarDot (const std::string &var_name, unsigned int comp=0) const

const ADVariableValue &	adCoupledScalarDot (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarDotDot (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarDotOld (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarDotDotOld (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarDotDu (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarDotDotDu (const std::string &var_name, unsigned int comp=0) const

const MooseVariableScalar *	getScalarVar (const std::string &var_name, unsigned int comp) const

virtual const OutputTools< Real >::VariableValue &	neighborValue ()

const VectorVariableValue &	neighborValue ()

virtual const OutputTools< Real >::VariableValue &	neighborValueOld ()

const VectorVariableValue &	neighborValueOld ()

virtual const OutputTools< Real >::VariableValue &	neighborValueOlder ()

const VectorVariableValue &	neighborValueOlder ()

virtual const OutputTools< Real >::VariableGradient &	neighborGradient ()

virtual const OutputTools< Real >::VariableGradient &	neighborGradientOld ()

virtual const OutputTools< Real >::VariableGradient &	neighborGradientOlder ()

virtual const OutputTools< Real >::VariableSecond &	neighborSecond ()

virtual const OutputTools< Real >::VariableSecond &	neighborSecondOld ()

virtual const OutputTools< Real >::VariableSecond &	neighborSecondOlder ()

virtual const OutputTools< Real >::VariableTestSecond &	neighborSecondTest ()

virtual const OutputTools< Real >::VariablePhiSecond &	neighborSecondPhi ()

virtual const OutputTools< Real >::VariableValue &	value ()

virtual const OutputTools< Real >::VariableValue &	valueOld ()

virtual const OutputTools< Real >::VariableValue &	valueOlder ()

virtual const OutputTools< Real >::VariableValue &	dot ()

virtual const OutputTools< Real >::VariableValue &	dotDot ()

virtual const OutputTools< Real >::VariableValue &	dotOld ()

virtual const OutputTools< Real >::VariableValue &	dotDotOld ()

virtual const VariableValue &	dotDu ()

virtual const VariableValue &	dotDotDu ()

virtual const OutputTools< Real >::VariableGradient &	gradient ()

virtual const OutputTools< Real >::VariableGradient &	gradientOld ()

virtual const OutputTools< Real >::VariableGradient &	gradientOlder ()

virtual const OutputTools< Real >::VariableSecond &	second ()

virtual const OutputTools< Real >::VariableSecond &	secondOld ()

virtual const OutputTools< Real >::VariableSecond &	secondOlder ()

virtual const OutputTools< Real >::VariableTestSecond &	secondTest ()

virtual const OutputTools< Real >::VariableTestSecond &	secondTestFace ()

virtual const OutputTools< Real >::VariablePhiSecond &	secondPhi ()

virtual const OutputTools< Real >::VariablePhiSecond &	secondPhiFace ()

Protected Attributes
MooseSharedPointer< DisplacedProblem >	_displaced_problem

const unsigned int	_component

const ContactModel	_model

const ContactFormulation	_formulation

const bool	_normalize_penalty

const Real	_penalty

const Real	_penalty_multiplier

Real	_penalty_tangential

const Real	_friction_coefficient

const Real	_tension_release

const Real	_capture_tolerance

const unsigned int	_stick_lock_iterations

const Real	_stick_unlock_factor

bool	_update_stateful_data

NumericVector< Number > &	_residual_copy

const unsigned int	_mesh_dimension

std::vector< unsigned int >	_vars

std::vector< MooseVariable * >	_var_objects

const bool	_has_secondary_gap_offset
	gap offset from either secondary, primary or both More...

const MooseVariable *const	_secondary_gap_offset_var

const bool	_has_mapped_primary_gap_offset

const MooseVariable *const	_mapped_primary_gap_offset_var

MooseVariable *	_nodal_area_var

SystemBase &	_aux_system

const NumericVector< Number > *const	_aux_solution

const bool	_primary_secondary_jacobian
	Whether to include coupling between the primary and secondary nodes in the Jacobian. More...

const bool	_connected_secondary_nodes_jacobian
	Whether to include coupling terms with the nodes connected to the secondary nodes in the Jacobian. More...

const bool	_non_displacement_vars_jacobian
	Whether to include coupling terms with non-displacement variables in the Jacobian. More...

Real	_al_penetration_tolerance
	The tolerance of the penetration for augmented Lagrangian method. More...

Real	_al_incremental_slip_tolerance
	The tolerance of the incremental slip for augmented Lagrangian method. More...

Real	_al_frictional_force_tolerance
	The tolerance of the frictional force for augmented Lagrangian method. More...

ContactLineSearchBase *	_contact_linesearch

std::set< dof_id_type >	_current_contact_state

std::set< dof_id_type >	_old_contact_state

const bool	_print_contact_nodes

AugmentedLagrangianContactProblemInterface *const	_augmented_lagrange_problem

const unsigned int &	_lagrangian_iteration_number

DenseMatrix< Number >	_Knn

DenseMatrix< Number >	_Ken

const SparseMatrix< Number > *	_jacobian

BoundaryID	_secondary

BoundaryID	_primary

MooseVariable &	_var

const MooseArray< Point > &	_primary_q_point

const QBase *const &	_primary_qrule

std::set< BoundaryID >	_boundary_ids

PenetrationLocator &	_penetration_locator

const Node *const &	_current_node

const Elem *const &	_current_primary

const VariableValue &	_u_secondary

VariablePhiValue	_phi_secondary

VariableTestValue	_test_secondary

MooseVariable &	_primary_var

unsigned int	_primary_var_num

const VariablePhiValue &	_phi_primary

const VariablePhiGradient &	_grad_phi_primary

const VariableTestValue &	_test_primary

const VariableTestGradient &	_grad_test_primary

const VariableValue &	_u_primary

const VariableGradient &	_grad_u_primary

const DofMap &	_dof_map

const std::map< dof_id_type, std::vector< dof_id_type > > &	_node_to_elem_map

bool	_overwrite_secondary_residual

const MooseArray< Real > &	_primary_JxW

bool	_secondary_residual_computed

Real	_secondary_residual

const std::unordered_set< unsigned int >	_empty_mat_prop_deps

std::vector< dof_id_type >	_connected_dof_indices

DenseMatrix< Number >	_Kne

DenseMatrix< Number >	_Kee

unsigned int	_i

unsigned int	_j

unsigned int	_qp

SubProblem &	_subproblem

FEProblemBase &	_fe_problem

SystemBase &	_sys

THREAD_ID	_tid

Assembly &	_assembly

MooseMesh &	_mesh

const bool &	_enabled

MooseApp &	_app

const std::string	_type

const std::string	_name

const InputParameters &	_pars

Factory &	_factory

ActionFactory &	_action_factory

const ExecFlagEnum &	_execute_enum

const ExecFlagType &	_current_execute_flag

const InputParameters &	_ti_params

FEProblemBase &	_ti_feproblem

bool	_is_implicit

Real &	_t

const Real &	_t_old

int &	_t_step

Real &	_dt

Real &	_dt_old

bool	_is_transient

MooseApp &	_restartable_app

const std::string	_restartable_system_name

const THREAD_ID	_restartable_tid

const bool	_restartable_read_only

FEProblemBase &	_mci_feproblem

DenseVector< Number >	_local_re

DenseMatrix< Number >	_local_ke

DenseMatrix< Number >	_nonlocal_ke

GeometricSearchData &	_geometric_search_data

bool	_requires_geometric_search

bool	_neighbor_nodal

const InputParameters &	_c_parameters

const std::string &	_c_name

const std::string &	_c_type

FEProblemBase &	_c_fe_problem

const SystemBase *const	_c_sys

std::unordered_map< std::string, std::vector< MooseVariableFieldBase *> >	_coupled_vars

std::vector< MooseVariableFieldBase *>	_coupled_moose_vars

std::vector< MooseVariable *>	_coupled_standard_moose_vars

std::vector< VectorMooseVariable *>	_coupled_vector_moose_vars

std::vector< ArrayMooseVariable *>	_coupled_array_moose_vars

std::vector< MooseVariableFV< Real > *>	_coupled_standard_fv_moose_vars

std::vector< MooseLinearVariableFV< Real > *>	_coupled_standard_linear_fv_moose_vars

const std::unordered_map< std::string, std::string > &	_new_to_deprecated_coupled_vars

bool	_c_nodal

bool	_c_is_implicit

const bool	_c_allow_element_to_nodal_coupling

THREAD_ID	_c_tid

std::unordered_map< std::string, std::vector< std::unique_ptr< VariableValue > > >	_default_value

std::unordered_map< std::string, std::unique_ptr< MooseArray< ADReal > > >	_ad_default_value

std::unordered_map< std::string, std::unique_ptr< VectorVariableValue > >	_default_vector_value

std::unordered_map< std::string, std::unique_ptr< ArrayVariableValue > >	_default_array_value

std::unordered_map< std::string, std::unique_ptr< MooseArray< ADRealVectorValue > > >	_ad_default_vector_value

VariableValue	_default_value_zero

VariableGradient	_default_gradient

MooseArray< ADRealVectorValue >	_ad_default_gradient

MooseArray< ADRealTensorValue >	_ad_default_vector_gradient

VariableSecond	_default_second

MooseArray< ADRealTensorValue >	_ad_default_second

MooseArray< ADRealVectorValue >	_ad_default_curl

const VariableValue &	_zero

const VariablePhiValue &	_phi_zero

const MooseArray< ADReal > &	_ad_zero

const VariableGradient &	_grad_zero

const MooseArray< ADRealVectorValue > &	_ad_grad_zero

const VariablePhiGradient &	_grad_phi_zero

const VariableSecond &	_second_zero

const MooseArray< ADRealTensorValue > &	_ad_second_zero

const VariablePhiSecond &	_second_phi_zero

const VectorVariableValue &	_vector_zero

const VectorVariableCurl &	_vector_curl_zero

VectorVariableValue	_default_vector_value_zero

VectorVariableGradient	_default_vector_gradient

VectorVariableCurl	_default_vector_curl

VectorVariableDivergence	_default_div

ArrayVariableValue	_default_array_value_zero

ArrayVariableGradient	_default_array_gradient

bool	_coupleable_neighbor

FEProblemBase &	_sc_fe_problem

const THREAD_ID	_sc_tid

const Real &	_real_zero

const VariableValue &	_scalar_zero

const Point &	_point_zero

bool	_nodal

MooseVariableFE< Real > *	_variable

MooseVariableFV< Real > *	_fv_variable

MooseLinearVariableFV< Real > *	_linear_fv_variable

MooseVariableField< Real > *	_field_variable

Assembly *	_mvi_assembly

const Parallel::Communicator &	_communicator

Static Protected Attributes
static Threads::spin_mutex	_contact_set_mutex

static const unsigned int	_no_iterations = 0

Detailed Description

A MechanicalContactConstraint forces the value of a variable to be the same on both sides of an interface.

Definition at line 27 of file MechanicalContactConstraint.h.

Constructor & Destructor Documentation

◆ MechanicalContactConstraint()

MechanicalContactConstraint::MechanicalContactConstraint ( const InputParameters & parameters )

Definition at line 123 of file MechanicalContactConstraint.C.

   : NodeFaceConstraint(parameters),
     _displaced_problem(parameters.get<FEProblemBase *>("_fe_problem_base")->getDisplacedProblem()),
     _component(getParam<unsigned int>("component")),
     _model(getParam<MooseEnum>("model").getEnum<ContactModel>()),
     _formulation(getParam<MooseEnum>("formulation").getEnum<ContactFormulation>()),
     _normalize_penalty(getParam<bool>("normalize_penalty")),
     _penalty(getParam<Real>("penalty")),
     _penalty_multiplier(getParam<Real>("penalty_multiplier")),
     _friction_coefficient(getParam<Real>("friction_coefficient")),
     _tension_release(getParam<Real>("tension_release")),
     _capture_tolerance(getParam<Real>("capture_tolerance")),
     _stick_lock_iterations(getParam<unsigned int>("stick_lock_iterations")),
     _stick_unlock_factor(getParam<Real>("stick_unlock_factor")),
     _update_stateful_data(true),
     _residual_copy(_sys.residualGhosted()),
     _mesh_dimension(_mesh.dimension()),
     _vars(3, libMesh::invalid_uint),
     _var_objects(3, nullptr),
     _has_secondary_gap_offset(isCoupled("secondary_gap_offset")),
     _secondary_gap_offset_var(_has_secondary_gap_offset ? getVar("secondary_gap_offset", 0)
                                                         : nullptr),
     _has_mapped_primary_gap_offset(isCoupled("mapped_primary_gap_offset")),
     _mapped_primary_gap_offset_var(
         _has_mapped_primary_gap_offset ? getVar("mapped_primary_gap_offset", 0) : nullptr),
     _nodal_area_var(getVar("nodal_area", 0)),
     _aux_system(_nodal_area_var->sys()),
     _aux_solution(_aux_system.currentSolution()),
     _primary_secondary_jacobian(getParam<bool>("primary_secondary_jacobian")),
     _connected_secondary_nodes_jacobian(getParam<bool>("connected_secondary_nodes_jacobian")),
     _non_displacement_vars_jacobian(getParam<bool>("non_displacement_variables_jacobian")),
     _contact_linesearch(dynamic_cast<ContactLineSearchBase *>(_subproblem.getLineSearch())),
     _print_contact_nodes(getParam<bool>("print_contact_nodes")),
     _augmented_lagrange_problem(
         dynamic_cast<AugmentedLagrangianContactProblemInterface *>(&_fe_problem)),
     _lagrangian_iteration_number(_augmented_lagrange_problem
                                      ? _augmented_lagrange_problem->getLagrangianIterationNumber()
                                      : _no_iterations)
 {
   _overwrite_secondary_residual = false;
 
   if (isParamValid("displacements"))
   {
     // modern parameter scheme for displacements
     for (unsigned int i = 0; i < coupledComponents("displacements"); ++i)
     {
       _vars[i] = coupled("displacements", i);
       _var_objects[i] = getVar("displacements", i);
     }
   }
 
   if (parameters.isParamValid("tangential_tolerance"))
     _penetration_locator.setTangentialTolerance(getParam<Real>("tangential_tolerance"));
 
   if (parameters.isParamValid("normal_smoothing_distance"))
     _penetration_locator.setNormalSmoothingDistance(getParam<Real>("normal_smoothing_distance"));
 
   if (parameters.isParamValid("normal_smoothing_method"))
     _penetration_locator.setNormalSmoothingMethod(
         parameters.get<std::string>("normal_smoothing_method"));
 
   if (_formulation == ContactFormulation::TANGENTIAL_PENALTY && _model != ContactModel::COULOMB)
     mooseError("The 'tangential_penalty' formulation can only be used with the 'coulomb' model");
 
   if (_model == ContactModel::GLUED)
     _penetration_locator.setUpdate(false);
 
   if (_friction_coefficient < 0)
     mooseError("The friction coefficient must be nonnegative");
 
   // set _penalty_tangential to the value of _penalty for now
   _penalty_tangential = _penalty;
 
   if (_formulation == ContactFormulation::AUGMENTED_LAGRANGE)
   {
     if (_model == ContactModel::GLUED)
       mooseError("The Augmented Lagrangian contact formulation does not support GLUED case.");
 
     if (!_augmented_lagrange_problem)
       mooseError("The Augmented Lagrangian contact formulation must use "
                  "AugmentedLagrangianContactProblem.");
 
     if (!parameters.isParamValid("al_penetration_tolerance"))
       mooseError("For Augmented Lagrangian contact, al_penetration_tolerance must be provided.");
     else
       _al_penetration_tolerance = parameters.get<Real>("al_penetration_tolerance");
 
     if (_model != ContactModel::FRICTIONLESS)
     {
       if (!parameters.isParamValid("al_incremental_slip_tolerance") ||
           !parameters.isParamValid("al_frictional_force_tolerance"))
       {
         mooseError("For the Augmented Lagrangian frictional contact formualton, "
                    "al_incremental_slip_tolerance and "
                    "al_frictional_force_tolerance must be provided.");
       }
       else
       {
         _al_incremental_slip_tolerance = parameters.get<Real>("al_incremental_slip_tolerance");
         _al_frictional_force_tolerance = parameters.get<Real>("al_frictional_force_tolerance");
       }
     }
   }
 }

Member Function Documentation

◆ addCouplingEntriesToJacobian()

virtual bool MechanicalContactConstraint::addCouplingEntriesToJacobian ( )

inlineoverridevirtual

Reimplemented from NodeFaceConstraint.

Definition at line 84 of file MechanicalContactConstraint.h.

84 { return _primary_secondary_jacobian; }

MechanicalContactConstraint::_primary_secondary_jacobian

const bool _primary_secondary_jacobian

Whether to include coupling between the primary and secondary nodes in the Jacobian.

Definition: MechanicalContactConstraint.h:130

◆ AugmentedLagrangianContactConverged()

bool MechanicalContactConstraint::AugmentedLagrangianContactConverged ( )

virtual

Definition at line 333 of file MechanicalContactConstraint.C.

 {
   Real contactResidual = 0.0;
   unsigned int converged = 0;
 
   for (auto & [secondary_node_num, pinfo] : _penetration_locator._penetration_info)
   {
     if (!pinfo)
       continue;
 
     const auto & node = _mesh.nodeRef(secondary_node_num);
 
     // Skip this pinfo if there are no DOFs on this node.
     if (node.n_comp(_sys.number(), _vars[_component]) < 1)
       continue;
 
     const Real distance = pinfo->_normal * (pinfo->_closest_point - node) - gapOffset(node);
 
     if (pinfo->isCaptured())
     {
       if (contactResidual < std::abs(distance))
         contactResidual = std::abs(distance);
 
       // penetration < tol
       if (contactResidual > _al_penetration_tolerance)
       {
         converged = 1;
         break;
       }
 
       if (_model == ContactModel::COULOMB)
       {
         RealVectorValue contact_force_normal((pinfo->_contact_force * pinfo->_normal) *
                                              pinfo->_normal);
         RealVectorValue contact_force_tangential(pinfo->_contact_force - contact_force_normal);
 
         RealVectorValue tangential_inc_slip =
             pinfo->_incremental_slip - (pinfo->_incremental_slip * pinfo->_normal) * pinfo->_normal;
 
         const Real tan_mag(contact_force_tangential.norm());
         const Real tangential_inc_slip_mag = tangential_inc_slip.norm();
 
         RealVectorValue distance_vec =
             (pinfo->_normal * (node - pinfo->_closest_point) + gapOffset(node)) * pinfo->_normal;
 
         Real penalty = getPenalty(node);
         RealVectorValue pen_force_normal =
             penalty * distance_vec + pinfo->_lagrange_multiplier * pinfo->_normal;
 
         // Frictional capacity
         Real capacity(_friction_coefficient * (pen_force_normal * pinfo->_normal < 0
                                                    ? -pen_force_normal * pinfo->_normal
                                                    : 0.0));
 
         // incremental slip <= tol for all pinfo_pair such that tan_mag < capacity
         if (MooseUtils::absoluteFuzzyLessThan(tan_mag, capacity) &&
             pinfo->_mech_status == PenetrationInfo::MS_STICKING)
         {
           if (MooseUtils::absoluteFuzzyGreaterThan(tangential_inc_slip_mag,
                                                    _al_incremental_slip_tolerance))
           {
             converged = 2;
             break;
           }
         }
 
         // for all pinfo_pair, tag_mag should be less than (1 + tol) * (capacity + tol)
         if (tan_mag >
             (1 + _al_frictional_force_tolerance) * (capacity + _al_frictional_force_tolerance))
         {
           converged = 3;
           break;
         }
       }
     }
   }
 
   _communicator.max(converged);
 
   if (converged == 1)
     _console << "The Augmented Lagrangian contact tangential sliding enforcement is NOT satisfied "
              << std::endl;
   else if (converged == 2)
     _console << "The Augmented Lagrangian contact tangential sliding enforcement is NOT satisfied "
              << std::endl;
   else if (converged == 3)
     _console << "The Augmented Lagrangian contact frictional force enforcement is NOT satisfied "
              << std::endl;
   else
     return true;
 
   return false;
 }

◆ computeContactForce()

void MechanicalContactConstraint::computeContactForce	(	const Node &	node,
		PenetrationInfo *	pinfo,
		bool	update_contact_set
	)

Definition at line 502 of file MechanicalContactConstraint.C.

Referenced by shouldApply().

 {
   // Build up residual vector
   RealVectorValue res_vec;
   for (unsigned int i = 0; i < _mesh_dimension; ++i)
   {
     dof_id_type dof_number = node.dof_number(0, _vars[i], 0);
     res_vec(i) = _residual_copy(dof_number) / _var_objects[i]->scalingFactor();
   }
 
   RealVectorValue distance_vec(node - pinfo->_closest_point);
   if (distance_vec.norm() != 0)
     distance_vec += gapOffset(node) * pinfo->_normal * distance_vec.unit() * distance_vec.unit();
 
   const Real gap_size = -1.0 * pinfo->_normal * distance_vec;
 
   // This is for preventing an increment of pinfo->_locked_this_step for nodes that are
   // captured and released in this function
   bool newly_captured = false;
 
   // Capture nodes that are newly in contact
   if (update_contact_set && !pinfo->isCaptured() &&
       MooseUtils::absoluteFuzzyGreaterEqual(gap_size, 0.0, _capture_tolerance))
   {
     newly_captured = true;
     pinfo->capture();
 
     // Increment the lock count every time the node comes back into contact from not being in
     // contact.
     if (_formulation == ContactFormulation::KINEMATIC ||
         _formulation == ContactFormulation::TANGENTIAL_PENALTY)
       ++pinfo->_locked_this_step;
   }
 
   if (!pinfo->isCaptured())
     return;
 
   const Real penalty = getPenalty(node);
   const Real penalty_slip = getTangentialPenalty(node);
 
   RealVectorValue pen_force(penalty * distance_vec);
 
   switch (_model)
   {
     case ContactModel::FRICTIONLESS:
       switch (_formulation)
       {
         case ContactFormulation::KINEMATIC:
           pinfo->_contact_force = -pinfo->_normal * (pinfo->_normal * res_vec);
           break;
 
         case ContactFormulation::PENALTY:
           pinfo->_contact_force = pinfo->_normal * (pinfo->_normal * pen_force);
           break;
 
         case ContactFormulation::AUGMENTED_LAGRANGE:
           pinfo->_contact_force =
               (pinfo->_normal *
                (pinfo->_normal * (pen_force + pinfo->_lagrange_multiplier * pinfo->_normal)));
           break;
 
         default:
           mooseError("Invalid contact formulation");
           break;
       }
       pinfo->_mech_status = PenetrationInfo::MS_SLIPPING;
       break;
     case ContactModel::COULOMB:
       switch (_formulation)
       {
         case ContactFormulation::KINEMATIC:
         {
           // Frictional capacity
           const Real capacity(_friction_coefficient *
                               (res_vec * pinfo->_normal > 0 ? res_vec * pinfo->_normal : 0));
 
           // Normal and tangential components of predictor force
           pinfo->_contact_force = -res_vec;
           RealVectorValue contact_force_normal((pinfo->_contact_force * pinfo->_normal) *
                                                pinfo->_normal);
           RealVectorValue contact_force_tangential(pinfo->_contact_force - contact_force_normal);
 
           RealVectorValue tangential_inc_slip =
               pinfo->_incremental_slip -
               (pinfo->_incremental_slip * pinfo->_normal) * pinfo->_normal;
 
           // Magnitude of tangential predictor force
           const Real tan_mag(contact_force_tangential.norm());
           const Real tangential_inc_slip_mag = tangential_inc_slip.norm();
           const Real slip_tol = capacity / penalty;
           pinfo->_slip_tol = slip_tol;
 
           if ((tangential_inc_slip_mag > slip_tol || tan_mag > capacity) &&
               (pinfo->_stick_locked_this_step < _stick_lock_iterations ||
                tan_mag > capacity * _stick_unlock_factor))
           {
             if (pinfo->_stick_locked_this_step >= _stick_lock_iterations)
               pinfo->_stick_locked_this_step = 0;
 
             // Check for scenario where node has slipped too far in a previous iteration
             // for special treatment (only done if the incremental slip is non-trivial)
             bool slipped_too_far = false;
             RealVectorValue slip_inc_direction;
             if (tangential_inc_slip_mag > slip_tol)
             {
               slip_inc_direction = tangential_inc_slip / tangential_inc_slip_mag;
               Real slip_dot_tang_force = slip_inc_direction * contact_force_tangential;
               if (slip_dot_tang_force < capacity)
                 slipped_too_far = true;
             }
 
             if (slipped_too_far) // slip back along slip increment
               pinfo->_contact_force = contact_force_normal + capacity * slip_inc_direction;
             else
             {
               if (tan_mag > 0) // slip along tangential force direction
                 pinfo->_contact_force =
                     contact_force_normal + capacity * contact_force_tangential / tan_mag;
               else // treat as frictionless
                 pinfo->_contact_force = contact_force_normal;
             }
             if (capacity == 0)
               pinfo->_mech_status = PenetrationInfo::MS_SLIPPING;
             else
               pinfo->_mech_status = PenetrationInfo::MS_SLIPPING_FRICTION;
           }
           else
           {
             if (pinfo->_mech_status != PenetrationInfo::MS_STICKING &&
                 pinfo->_mech_status != PenetrationInfo::MS_NO_CONTACT)
               ++pinfo->_stick_locked_this_step;
             pinfo->_mech_status = PenetrationInfo::MS_STICKING;
           }
           break;
         }
 
         case ContactFormulation::PENALTY:
         {
           distance_vec =
               pinfo->_incremental_slip +
               (pinfo->_normal * (node - pinfo->_closest_point) + gapOffset(node)) * pinfo->_normal;
           pen_force = penalty * distance_vec;
 
           // Frictional capacity
           const Real capacity(_friction_coefficient *
                               (pen_force * pinfo->_normal < 0 ? -pen_force * pinfo->_normal : 0));
 
           // Elastic predictor
           pinfo->_contact_force =
               pen_force + (pinfo->_contact_force_old -
                            pinfo->_normal * (pinfo->_normal * pinfo->_contact_force_old));
           RealVectorValue contact_force_normal((pinfo->_contact_force * pinfo->_normal) *
                                                pinfo->_normal);
           RealVectorValue contact_force_tangential(pinfo->_contact_force - contact_force_normal);
 
           // Tangential magnitude of elastic predictor
           const Real tan_mag(contact_force_tangential.norm());
 
           if (tan_mag > capacity)
           {
             pinfo->_contact_force =
                 contact_force_normal + capacity * contact_force_tangential / tan_mag;
             if (MooseUtils::absoluteFuzzyEqual(capacity, 0))
               pinfo->_mech_status = PenetrationInfo::MS_SLIPPING;
             else
               pinfo->_mech_status = PenetrationInfo::MS_SLIPPING_FRICTION;
           }
           else
             pinfo->_mech_status = PenetrationInfo::MS_STICKING;
           break;
         }
 
         case ContactFormulation::AUGMENTED_LAGRANGE:
         {
           distance_vec =
               (pinfo->_normal * (node - pinfo->_closest_point) + gapOffset(node)) * pinfo->_normal;
 
           RealVectorValue contact_force_normal =
               penalty * distance_vec + pinfo->_lagrange_multiplier * pinfo->_normal;
 
           RealVectorValue tangential_inc_slip =
               pinfo->_incremental_slip -
               (pinfo->_incremental_slip * pinfo->_normal) * pinfo->_normal;
 
           RealVectorValue contact_force_tangential =
               pinfo->_lagrange_multiplier_slip +
               (pinfo->_contact_force_old -
                pinfo->_normal * (pinfo->_normal * pinfo->_contact_force_old));
 
           RealVectorValue inc_pen_force_tangential = penalty_slip * tangential_inc_slip;
 
           if (pinfo->_mech_status == PenetrationInfo::MS_STICKING)
             pinfo->_contact_force =
                 contact_force_normal + contact_force_tangential + inc_pen_force_tangential;
           else
             pinfo->_contact_force = contact_force_normal + contact_force_tangential;
 
           break;
         }
 
         case ContactFormulation::TANGENTIAL_PENALTY:
         {
           // Frictional capacity (kinematic formulation)
           const Real capacity = _friction_coefficient * std::max(res_vec * pinfo->_normal, 0.0);
 
           // Normal component of contact force (kinematic formulation)
           RealVectorValue contact_force_normal((-res_vec * pinfo->_normal) * pinfo->_normal);
 
           // Predictor tangential component of contact force (penalty formulation)
           RealVectorValue inc_pen_force_tangential = penalty * pinfo->_incremental_slip;
           RealVectorValue contact_force_tangential =
               inc_pen_force_tangential +
               (pinfo->_contact_force_old -
                pinfo->_normal * (pinfo->_normal * pinfo->_contact_force_old));
 
           // Magnitude of tangential predictor
           const Real tan_mag(contact_force_tangential.norm());
 
           if (tan_mag > capacity)
           {
             pinfo->_contact_force =
                 contact_force_normal + capacity * contact_force_tangential / tan_mag;
             if (MooseUtils::absoluteFuzzyEqual(capacity, 0))
               pinfo->_mech_status = PenetrationInfo::MS_SLIPPING;
             else
               pinfo->_mech_status = PenetrationInfo::MS_SLIPPING_FRICTION;
           }
           else
           {
             pinfo->_contact_force = contact_force_normal + contact_force_tangential;
             pinfo->_mech_status = PenetrationInfo::MS_STICKING;
           }
           break;
         }
 
         default:
           mooseError("Invalid contact formulation");
           break;
       }
       break;
 
     case ContactModel::GLUED:
       switch (_formulation)
       {
         case ContactFormulation::KINEMATIC:
           pinfo->_contact_force = -res_vec;
           break;
 
         case ContactFormulation::PENALTY:
           pinfo->_contact_force = pen_force;
           break;
 
         case ContactFormulation::AUGMENTED_LAGRANGE:
           pinfo->_contact_force =
               pen_force + pinfo->_lagrange_multiplier * distance_vec / distance_vec.norm();
           break;
 
         default:
           mooseError("Invalid contact formulation");
           break;
       }
       pinfo->_mech_status = PenetrationInfo::MS_STICKING;
       break;
 
     default:
       mooseError("Invalid or unavailable contact model");
       break;
   }
 
   // Release
   if (update_contact_set && _model != ContactModel::GLUED && pinfo->isCaptured() &&
       !newly_captured && _tension_release >= 0.0 &&
       (_contact_linesearch ? true : pinfo->_locked_this_step < 2))
   {
     const Real contact_pressure = -(pinfo->_normal * pinfo->_contact_force) / nodalArea(node);
     if (-contact_pressure >= _tension_release)
     {
       pinfo->release();
       pinfo->_contact_force.zero();
     }
   }
 }

◆ computeJacobian()

void MechanicalContactConstraint::computeJacobian ( )

overridevirtual

Computes the jacobian for the current element.

Reimplemented from NodeFaceConstraint.

Definition at line 1737 of file MechanicalContactConstraint.C.

 {
   getConnectedDofIndices(_var.number());
 
   prepareMatrixTagNeighbor(
       _assembly, _primary_var.number(), _var.number(), Moose::NeighborNeighbor, _Knn);
 
   _Kee.resize(_test_secondary.size(), _connected_dof_indices.size());
 
   for (_i = 0; _i < _test_secondary.size(); _i++)
     // Loop over the connected dof indices so we can get all the jacobian contributions
     for (_j = 0; _j < _connected_dof_indices.size(); _j++)
       _Kee(_i, _j) += computeQpJacobian(Moose::SecondarySecondary);
 
   if (_primary_secondary_jacobian)
   {
     prepareMatrixTagNeighbor(_assembly, _var.number(), _var.number(), Moose::ElementNeighbor, _Ken);
     if (_Ken.m() && _Ken.n())
     {
       for (_i = 0; _i < _test_secondary.size(); _i++)
         for (_j = 0; _j < _phi_primary.size(); _j++)
           _Ken(_i, _j) += computeQpJacobian(Moose::SecondaryPrimary);
       accumulateTaggedLocalMatrix(
           _assembly, _var.number(), _var.number(), Moose::ElementNeighbor, _Ken);
     }
 
     _Kne.resize(_test_primary.size(), _connected_dof_indices.size());
     for (_i = 0; _i < _test_primary.size(); _i++)
       // Loop over the connected dof indices so we can get all the jacobian contributions
       for (_j = 0; _j < _connected_dof_indices.size(); _j++)
         _Kne(_i, _j) += computeQpJacobian(Moose::PrimarySecondary);
   }
 
   if (_Knn.m() && _Knn.n())
   {
     for (_i = 0; _i < _test_primary.size(); _i++)
       for (_j = 0; _j < _phi_primary.size(); _j++)
         _Knn(_i, _j) += computeQpJacobian(Moose::PrimaryPrimary);
     accumulateTaggedLocalMatrix(
         _assembly, _primary_var.number(), _var.number(), Moose::NeighborNeighbor, _Knn);
   }
 }

◆ computeOffDiagJacobian()

void MechanicalContactConstraint::computeOffDiagJacobian ( unsigned int jvar )

overridevirtual

Compute off-diagonal Jacobian entries.

Parameters

jvar	The index of the coupled variable

Reimplemented from NodeFaceConstraint.

Definition at line 1781 of file MechanicalContactConstraint.C.

 {
   getConnectedDofIndices(jvar_num);
 
   _Kee.resize(_test_secondary.size(), _connected_dof_indices.size());
 
   prepareMatrixTagNeighbor(
       _assembly, _primary_var.number(), jvar_num, Moose::NeighborNeighbor, _Knn);
 
   for (_i = 0; _i < _test_secondary.size(); _i++)
     // Loop over the connected dof indices so we can get all the jacobian contributions
     for (_j = 0; _j < _connected_dof_indices.size(); _j++)
       _Kee(_i, _j) += computeQpOffDiagJacobian(Moose::SecondarySecondary, jvar_num);
 
   if (_primary_secondary_jacobian)
   {
     prepareMatrixTagNeighbor(_assembly, _var.number(), jvar_num, Moose::ElementNeighbor, _Ken);
     for (_i = 0; _i < _test_secondary.size(); _i++)
       for (_j = 0; _j < _phi_primary.size(); _j++)
         _Ken(_i, _j) += computeQpOffDiagJacobian(Moose::SecondaryPrimary, jvar_num);
     accumulateTaggedLocalMatrix(_assembly, _var.number(), jvar_num, Moose::ElementNeighbor, _Ken);
 
     _Kne.resize(_test_primary.size(), _connected_dof_indices.size());
     if (_Kne.m() && _Kne.n())
       for (_i = 0; _i < _test_primary.size(); _i++)
         // Loop over the connected dof indices so we can get all the jacobian contributions
         for (_j = 0; _j < _connected_dof_indices.size(); _j++)
           _Kne(_i, _j) += computeQpOffDiagJacobian(Moose::PrimarySecondary, jvar_num);
   }
 
   for (_i = 0; _i < _test_primary.size(); _i++)
     for (_j = 0; _j < _phi_primary.size(); _j++)
       _Knn(_i, _j) += computeQpOffDiagJacobian(Moose::PrimaryPrimary, jvar_num);
   accumulateTaggedLocalMatrix(
       _assembly, _primary_var.number(), jvar_num, Moose::NeighborNeighbor, _Knn);
 }

◆ computeQpJacobian()

Real MechanicalContactConstraint::computeQpJacobian ( Moose::ConstraintJacobianType type )

overridevirtual

Implements NodeFaceConstraint.

Definition at line 847 of file MechanicalContactConstraint.C.

Referenced by computeJacobian().

 {
   PenetrationInfo * pinfo = _penetration_locator._penetration_info[_current_node->id()];
 
   const Real penalty = getPenalty(*_current_node);
   const Real penalty_slip = getTangentialPenalty(*_current_node);
 
   switch (type)
   {
     default:
       mooseError("Unhandled ConstraintJacobianType");
 
     case Moose::SecondarySecondary:
       switch (_model)
       {
         case ContactModel::FRICTIONLESS:
           switch (_formulation)
           {
             case ContactFormulation::KINEMATIC:
             {
               RealVectorValue jac_vec;
               for (unsigned int i = 0; i < _mesh_dimension; ++i)
               {
                 dof_id_type dof_number = _current_node->dof_number(0, _vars[i], 0);
                 jac_vec(i) = (*_jacobian)(dof_number, _connected_dof_indices[_j]) /
                              _var_objects[i]->scalingFactor();
               }
               return -pinfo->_normal(_component) * (pinfo->_normal * jac_vec) +
                      (_phi_secondary[_j][_qp] * penalty * _test_secondary[_i][_qp]) *
                          pinfo->_normal(_component) * pinfo->_normal(_component);
             }
 
             case ContactFormulation::PENALTY:
             case ContactFormulation::AUGMENTED_LAGRANGE:
               return _phi_secondary[_j][_qp] * penalty * _test_secondary[_i][_qp] *
                      pinfo->_normal(_component) * pinfo->_normal(_component);
 
             default:
               mooseError("Invalid contact formulation");
           }
 
         case ContactModel::COULOMB:
           switch (_formulation)
           {
             case ContactFormulation::KINEMATIC:
             {
               if (pinfo->_mech_status == PenetrationInfo::MS_SLIPPING ||
                   pinfo->_mech_status == PenetrationInfo::MS_SLIPPING_FRICTION)
               {
                 RealVectorValue jac_vec;
                 for (unsigned int i = 0; i < _mesh_dimension; ++i)
                 {
                   dof_id_type dof_number = _current_node->dof_number(0, _vars[i], 0);
                   jac_vec(i) = (*_jacobian)(dof_number, _connected_dof_indices[_j]) /
                                _var_objects[i]->scalingFactor();
                 }
                 return -pinfo->_normal(_component) * (pinfo->_normal * jac_vec) +
                        (_phi_secondary[_j][_qp] * penalty * _test_secondary[_i][_qp]) *
                            pinfo->_normal(_component) * pinfo->_normal(_component);
               }
               else
               {
                 const Real curr_jac =
                     (*_jacobian)(_current_node->dof_number(0, _vars[_component], 0),
                                  _connected_dof_indices[_j]) /
                     _var.scalingFactor();
                 return (-curr_jac + _phi_secondary[_j][_qp] * penalty * _test_secondary[_i][_qp]);
               }
             }
 
             case ContactFormulation::PENALTY:
             {
               if (pinfo->_mech_status == PenetrationInfo::MS_SLIPPING ||
                   pinfo->_mech_status == PenetrationInfo::MS_SLIPPING_FRICTION)
                 return _phi_secondary[_j][_qp] * penalty * _test_secondary[_i][_qp] *
                        pinfo->_normal(_component) * pinfo->_normal(_component);
               else
                 return _phi_secondary[_j][_qp] * penalty * _test_secondary[_i][_qp];
             }
             case ContactFormulation::AUGMENTED_LAGRANGE:
             {
               Real normal_comp = _phi_secondary[_j][_qp] * penalty * _test_secondary[_i][_qp] *
                                  pinfo->_normal(_component) * pinfo->_normal(_component);
 
               Real tang_comp = 0.0;
               if (pinfo->_mech_status == PenetrationInfo::MS_STICKING)
                 tang_comp = _phi_secondary[_j][_qp] * penalty_slip * _test_secondary[_i][_qp] *
                             (1.0 - pinfo->_normal(_component) * pinfo->_normal(_component));
               return normal_comp + tang_comp;
             }
 
             case ContactFormulation::TANGENTIAL_PENALTY:
             {
               RealVectorValue jac_vec;
               for (unsigned int i = 0; i < _mesh_dimension; ++i)
               {
                 dof_id_type dof_number = _current_node->dof_number(0, _vars[i], 0);
                 jac_vec(i) = (*_jacobian)(dof_number, _connected_dof_indices[_j]) /
                              _var_objects[i]->scalingFactor();
               }
               Real normal_comp = -pinfo->_normal(_component) * (pinfo->_normal * jac_vec) +
                                  (_phi_secondary[_j][_qp] * penalty * _test_secondary[_i][_qp]) *
                                      pinfo->_normal(_component) * pinfo->_normal(_component);
 
               Real tang_comp = 0.0;
               if (pinfo->_mech_status == PenetrationInfo::MS_STICKING)
                 tang_comp = _phi_secondary[_j][_qp] * penalty * _test_secondary[_i][_qp] *
                             (1.0 - pinfo->_normal(_component) * pinfo->_normal(_component));
 
               return normal_comp + tang_comp;
             }
 
             default:
               mooseError("Invalid contact formulation");
           }
 
         case ContactModel::GLUED:
           switch (_formulation)
           {
             case ContactFormulation::KINEMATIC:
             {
               const Real curr_jac = (*_jacobian)(_current_node->dof_number(0, _vars[_component], 0),
                                                  _connected_dof_indices[_j]) /
                                     _var.scalingFactor();
               return (-curr_jac + _phi_secondary[_j][_qp] * penalty * _test_secondary[_i][_qp]);
             }
 
             case ContactFormulation::PENALTY:
             case ContactFormulation::AUGMENTED_LAGRANGE:
               return _phi_secondary[_j][_qp] * penalty * _test_secondary[_i][_qp];
 
             default:
               mooseError("Invalid contact formulation");
           }
         default:
           mooseError("Invalid or unavailable contact model");
       }
 
     case Moose::SecondaryPrimary:
       switch (_model)
       {
         case ContactModel::FRICTIONLESS:
           switch (_formulation)
           {
             case ContactFormulation::KINEMATIC:
             {
               const Node * curr_primary_node = _current_primary->node_ptr(_j);
 
               RealVectorValue jac_vec;
               for (unsigned int i = 0; i < _mesh_dimension; ++i)
               {
                 dof_id_type dof_number = _current_node->dof_number(0, _vars[i], 0);
                 jac_vec(i) = (*_jacobian)(dof_number,
                                           curr_primary_node->dof_number(0, _vars[_component], 0)) /
                              _var_objects[i]->scalingFactor();
               }
               return -pinfo->_normal(_component) * (pinfo->_normal * jac_vec) -
                      (_phi_primary[_j][_qp] * penalty * _test_secondary[_i][_qp]) *
                          pinfo->_normal(_component) * pinfo->_normal(_component);
             }
 
             case ContactFormulation::PENALTY:
             case ContactFormulation::AUGMENTED_LAGRANGE:
               return -_phi_primary[_j][_qp] * penalty * _test_secondary[_i][_qp] *
                      pinfo->_normal(_component) * pinfo->_normal(_component);
 
             default:
               mooseError("Invalid contact formulation");
           }
 
         case ContactModel::COULOMB:
           switch (_formulation)
           {
             case ContactFormulation::KINEMATIC:
             {
               if (pinfo->_mech_status == PenetrationInfo::MS_SLIPPING ||
                   pinfo->_mech_status == PenetrationInfo::MS_SLIPPING_FRICTION)
               {
                 const Node * curr_primary_node = _current_primary->node_ptr(_j);
 
                 RealVectorValue jac_vec;
                 for (unsigned int i = 0; i < _mesh_dimension; ++i)
                 {
                   dof_id_type dof_number = _current_node->dof_number(0, _vars[i], 0);
                   jac_vec(i) =
                       (*_jacobian)(dof_number,
                                    curr_primary_node->dof_number(0, _vars[_component], 0)) /
                       _var_objects[i]->scalingFactor();
                 }
                 return -pinfo->_normal(_component) * (pinfo->_normal * jac_vec) -
                        (_phi_primary[_j][_qp] * penalty * _test_secondary[_i][_qp]) *
                            pinfo->_normal(_component) * pinfo->_normal(_component);
               }
               else
               {
                 const Node * curr_primary_node = _current_primary->node_ptr(_j);
                 const Real curr_jac =
                     (*_jacobian)(_current_node->dof_number(0, _vars[_component], 0),
                                  curr_primary_node->dof_number(0, _vars[_component], 0)) /
                     _var.scalingFactor();
                 return (-curr_jac - _phi_primary[_j][_qp] * penalty * _test_secondary[_i][_qp]);
               }
             }
 
             case ContactFormulation::PENALTY:
             {
               if (pinfo->_mech_status == PenetrationInfo::MS_SLIPPING ||
                   pinfo->_mech_status == PenetrationInfo::MS_SLIPPING_FRICTION)
                 return -_phi_primary[_j][_qp] * penalty * _test_secondary[_i][_qp] *
                        pinfo->_normal(_component) * pinfo->_normal(_component);
               else
                 return -_phi_primary[_j][_qp] * penalty * _test_secondary[_i][_qp];
             }
             case ContactFormulation::AUGMENTED_LAGRANGE:
             {
               Real normal_comp = -_phi_primary[_j][_qp] * penalty * _test_secondary[_i][_qp] *
                                  pinfo->_normal(_component) * pinfo->_normal(_component);
 
               Real tang_comp = 0.0;
               if (pinfo->_mech_status == PenetrationInfo::MS_STICKING)
                 tang_comp = -_phi_primary[_j][_qp] * penalty_slip * _test_secondary[_i][_qp] *
                             (1.0 - pinfo->_normal(_component) * pinfo->_normal(_component));
               return normal_comp + tang_comp;
             }
 
             case ContactFormulation::TANGENTIAL_PENALTY:
             {
               const Node * curr_primary_node = _current_primary->node_ptr(_j);
 
               RealVectorValue jac_vec;
               for (unsigned int i = 0; i < _mesh_dimension; ++i)
               {
                 dof_id_type dof_number = _current_node->dof_number(0, _vars[i], 0);
                 jac_vec(i) = (*_jacobian)(dof_number,
                                           curr_primary_node->dof_number(0, _vars[_component], 0)) /
                              _var_objects[i]->scalingFactor();
               }
               Real normal_comp = -pinfo->_normal(_component) * (pinfo->_normal * jac_vec) -
                                  (_phi_primary[_j][_qp] * penalty * _test_secondary[_i][_qp]) *
                                      pinfo->_normal(_component) * pinfo->_normal(_component);
 
               Real tang_comp = 0.0;
               if (pinfo->_mech_status == PenetrationInfo::MS_STICKING)
                 tang_comp = -_phi_primary[_j][_qp] * penalty * _test_secondary[_i][_qp] *
                             (1.0 - pinfo->_normal(_component) * pinfo->_normal(_component));
 
               return normal_comp + tang_comp;
             }
 
             default:
               mooseError("Invalid contact formulation");
           }
         case ContactModel::GLUED:
           switch (_formulation)
           {
             case ContactFormulation::KINEMATIC:
             {
               const Node * curr_primary_node = _current_primary->node_ptr(_j);
               const Real curr_jac =
                   (*_jacobian)(_current_node->dof_number(0, _vars[_component], 0),
                                curr_primary_node->dof_number(0, _vars[_component], 0)) /
                   _var.scalingFactor();
               return (-curr_jac - _phi_primary[_j][_qp] * penalty * _test_secondary[_i][_qp]);
             }
 
             case ContactFormulation::PENALTY:
             case ContactFormulation::AUGMENTED_LAGRANGE:
               return -_phi_primary[_j][_qp] * penalty * _test_secondary[_i][_qp];
 
             default:
               mooseError("Invalid contact formulation");
           }
 
         default:
           mooseError("Invalid or unavailable contact model");
       }
 
     case Moose::PrimarySecondary:
       switch (_model)
       {
         case ContactModel::FRICTIONLESS:
           switch (_formulation)
           {
             case ContactFormulation::KINEMATIC:
             {
               RealVectorValue jac_vec;
               for (unsigned int i = 0; i < _mesh_dimension; ++i)
               {
                 dof_id_type dof_number = _current_node->dof_number(0, _vars[i], 0);
                 jac_vec(i) = (*_jacobian)(dof_number, _connected_dof_indices[_j]) /
                              _var_objects[i]->scalingFactor();
               }
               return pinfo->_normal(_component) * (pinfo->_normal * jac_vec) *
                      _test_primary[_i][_qp];
             }
 
             case ContactFormulation::PENALTY:
             case ContactFormulation::AUGMENTED_LAGRANGE:
               return -_test_primary[_i][_qp] * penalty * _phi_secondary[_j][_qp] *
                      pinfo->_normal(_component) * pinfo->_normal(_component);
 
             default:
               mooseError("Invalid contact formulation");
           }
         case ContactModel::COULOMB:
           switch (_formulation)
           {
             case ContactFormulation::KINEMATIC:
             {
               if (pinfo->_mech_status == PenetrationInfo::MS_SLIPPING ||
                   pinfo->_mech_status == PenetrationInfo::MS_SLIPPING_FRICTION)
               {
                 RealVectorValue jac_vec;
                 for (unsigned int i = 0; i < _mesh_dimension; ++i)
                 {
                   dof_id_type dof_number = _current_node->dof_number(0, _vars[i], 0);
                   jac_vec(i) = (*_jacobian)(dof_number, _connected_dof_indices[_j]) /
                                _var_objects[i]->scalingFactor();
                 }
                 return pinfo->_normal(_component) * (pinfo->_normal * jac_vec) *
                        _test_primary[_i][_qp];
               }
               else
               {
                 const Real secondary_jac =
                     (*_jacobian)(_current_node->dof_number(0, _vars[_component], 0),
                                  _connected_dof_indices[_j]) /
                     _var.scalingFactor();
                 return secondary_jac * _test_primary[_i][_qp];
               }
             }
 
             case ContactFormulation::PENALTY:
             {
               if (pinfo->_mech_status == PenetrationInfo::MS_SLIPPING ||
                   pinfo->_mech_status == PenetrationInfo::MS_SLIPPING_FRICTION)
                 return -_test_primary[_i][_qp] * penalty * _phi_secondary[_j][_qp] *
                        pinfo->_normal(_component) * pinfo->_normal(_component);
               else
                 return -_test_primary[_i][_qp] * penalty * _phi_secondary[_j][_qp];
             }
             case ContactFormulation::AUGMENTED_LAGRANGE:
             {
               Real normal_comp = -_phi_secondary[_j][_qp] * penalty * _test_primary[_i][_qp] *
                                  pinfo->_normal(_component) * pinfo->_normal(_component);
 
               Real tang_comp = 0.0;
               if (pinfo->_mech_status == PenetrationInfo::MS_STICKING)
                 tang_comp = -_phi_secondary[_j][_qp] * penalty_slip * _test_primary[_i][_qp] *
                             (1.0 - pinfo->_normal(_component) * pinfo->_normal(_component));
               return normal_comp + tang_comp;
             }
 
             case ContactFormulation::TANGENTIAL_PENALTY:
             {
               RealVectorValue jac_vec;
               for (unsigned int i = 0; i < _mesh_dimension; ++i)
               {
                 dof_id_type dof_number = _current_node->dof_number(0, _vars[i], 0);
                 jac_vec(i) = (*_jacobian)(dof_number, _connected_dof_indices[_j]) /
                              _var_objects[i]->scalingFactor();
               }
               Real normal_comp =
                   pinfo->_normal(_component) * (pinfo->_normal * jac_vec) * _test_primary[_i][_qp];
 
               Real tang_comp = 0.0;
               if (pinfo->_mech_status == PenetrationInfo::MS_STICKING)
                 tang_comp = -_test_primary[_i][_qp] * penalty * _phi_secondary[_j][_qp] *
                             (1.0 - pinfo->_normal(_component) * pinfo->_normal(_component));
 
               return normal_comp + tang_comp;
             }
 
             default:
               mooseError("Invalid contact formulation");
           }
 
         case ContactModel::GLUED:
           switch (_formulation)
           {
             case ContactFormulation::KINEMATIC:
             {
               const Real secondary_jac =
                   (*_jacobian)(_current_node->dof_number(0, _vars[_component], 0),
                                _connected_dof_indices[_j]) /
                   _var.scalingFactor();
               return secondary_jac * _test_primary[_i][_qp];
             }
 
             case ContactFormulation::PENALTY:
             case ContactFormulation::AUGMENTED_LAGRANGE:
               return -_test_primary[_i][_qp] * penalty * _phi_secondary[_j][_qp];
 
             default:
               mooseError("Invalid contact formulation");
           }
 
         default:
           mooseError("Invalid or unavailable contact model");
       }
 
     case Moose::PrimaryPrimary:
       switch (_model)
       {
         case ContactModel::FRICTIONLESS:
           switch (_formulation)
           {
             case ContactFormulation::KINEMATIC:
               return 0.0;
 
             case ContactFormulation::PENALTY:
             case ContactFormulation::AUGMENTED_LAGRANGE:
               return _test_primary[_i][_qp] * penalty * _phi_primary[_j][_qp] *
                      pinfo->_normal(_component) * pinfo->_normal(_component);
 
             default:
               mooseError("Invalid contact formulation");
           }
 
         case ContactModel::COULOMB:
         case ContactModel::GLUED:
           switch (_formulation)
           {
             case ContactFormulation::KINEMATIC:
               return 0.0;
 
             case ContactFormulation::PENALTY:
             {
               if (pinfo->_mech_status == PenetrationInfo::MS_SLIPPING ||
                   pinfo->_mech_status == PenetrationInfo::MS_SLIPPING_FRICTION)
                 return _test_primary[_i][_qp] * penalty * _phi_primary[_j][_qp] *
                        pinfo->_normal(_component) * pinfo->_normal(_component);
               else
                 return _test_primary[_i][_qp] * penalty * _phi_primary[_j][_qp];
             }
 
             case ContactFormulation::TANGENTIAL_PENALTY:
             {
               Real tang_comp = 0.0;
               if (pinfo->_mech_status == PenetrationInfo::MS_STICKING)
                 tang_comp = _test_primary[_i][_qp] * penalty * _phi_primary[_j][_qp] *
                             (1.0 - pinfo->_normal(_component) * pinfo->_normal(_component));
               return tang_comp; // normal component is zero
             }
 
             case ContactFormulation::AUGMENTED_LAGRANGE:
             {
               Real normal_comp = _phi_primary[_j][_qp] * penalty * _test_primary[_i][_qp] *
                                  pinfo->_normal(_component) * pinfo->_normal(_component);
 
               Real tang_comp = 0.0;
               if (pinfo->_mech_status == PenetrationInfo::MS_STICKING)
                 tang_comp = _phi_primary[_j][_qp] * penalty_slip * _test_primary[_i][_qp] *
                             (1.0 - pinfo->_normal(_component) * pinfo->_normal(_component));
               return normal_comp + tang_comp;
             }
 
             default:
               mooseError("Invalid contact formulation");
           }
 
         default:
           mooseError("Invalid or unavailable contact model");
       }
   }
 
   return 0.0;
 }

◆ computeQpOffDiagJacobian()

Real MechanicalContactConstraint::computeQpOffDiagJacobian	(	Moose::ConstraintJacobianType	type,
		unsigned int	jvar
	)

overridevirtual

Compute off-diagonal Jacobian entries.

Parameters

type	The type of coupling
jvar	The index of the coupled variable

Reimplemented from NodeFaceConstraint.

Definition at line 1317 of file MechanicalContactConstraint.C.

Referenced by computeOffDiagJacobian().

 {
   PenetrationInfo * pinfo = _penetration_locator._penetration_info[_current_node->id()];
 
   const Real penalty = getPenalty(*_current_node);
   const Real penalty_slip = getTangentialPenalty(*_current_node);
 
   unsigned int coupled_component;
   Real normal_component_in_coupled_var_dir = 1.0;
   if (getCoupledVarComponent(jvar, coupled_component))
     normal_component_in_coupled_var_dir = pinfo->_normal(coupled_component);
 
   switch (type)
   {
     default:
       mooseError("Unhandled ConstraintJacobianType");
 
     case Moose::SecondarySecondary:
       switch (_model)
       {
         case ContactModel::FRICTIONLESS:
           switch (_formulation)
           {
             case ContactFormulation::KINEMATIC:
             {
               RealVectorValue jac_vec;
               for (unsigned int i = 0; i < _mesh_dimension; ++i)
               {
                 dof_id_type dof_number = _current_node->dof_number(0, _vars[i], 0);
                 jac_vec(i) = (*_jacobian)(dof_number, _connected_dof_indices[_j]) /
                              _var_objects[i]->scalingFactor();
               }
               return -pinfo->_normal(_component) * (pinfo->_normal * jac_vec) +
                      (_phi_secondary[_j][_qp] * penalty * _test_secondary[_i][_qp]) *
                          pinfo->_normal(_component) * normal_component_in_coupled_var_dir;
             }
 
             case ContactFormulation::PENALTY:
             case ContactFormulation::AUGMENTED_LAGRANGE:
               return _phi_secondary[_j][_qp] * penalty * _test_secondary[_i][_qp] *
                      pinfo->_normal(_component) * normal_component_in_coupled_var_dir;
 
             default:
               mooseError("Invalid contact formulation");
           }
 
         case ContactModel::COULOMB:
         {
           if ((_formulation == ContactFormulation::KINEMATIC ||
                _formulation == ContactFormulation::TANGENTIAL_PENALTY) &&
               (pinfo->_mech_status == PenetrationInfo::MS_SLIPPING ||
                pinfo->_mech_status == PenetrationInfo::MS_SLIPPING_FRICTION))
           {
             RealVectorValue jac_vec;
             for (unsigned int i = 0; i < _mesh_dimension; ++i)
             {
               dof_id_type dof_number = _current_node->dof_number(0, _vars[i], 0);
               jac_vec(i) = (*_jacobian)(dof_number, _connected_dof_indices[_j]) /
                            _var_objects[i]->scalingFactor();
             }
 
             return -pinfo->_normal(_component) * (pinfo->_normal * jac_vec) +
                    (_phi_secondary[_j][_qp] * penalty * _test_secondary[_i][_qp]) *
                        pinfo->_normal(_component) * normal_component_in_coupled_var_dir;
           }
           else if ((_formulation == ContactFormulation::PENALTY) &&
                    (pinfo->_mech_status == PenetrationInfo::MS_SLIPPING ||
                     pinfo->_mech_status == PenetrationInfo::MS_SLIPPING_FRICTION))
             return _phi_secondary[_j][_qp] * penalty * _test_secondary[_i][_qp] *
                    pinfo->_normal(_component) * normal_component_in_coupled_var_dir;
           else if (_formulation == ContactFormulation::AUGMENTED_LAGRANGE)
           {
             Real normal_comp = _phi_secondary[_j][_qp] * penalty * _test_secondary[_i][_qp] *
                                pinfo->_normal(_component) * normal_component_in_coupled_var_dir;
 
             Real tang_comp = 0.0;
             if (pinfo->_mech_status == PenetrationInfo::MS_STICKING)
               tang_comp = _phi_secondary[_j][_qp] * penalty_slip * _test_secondary[_i][_qp] *
                           (-pinfo->_normal(_component) * normal_component_in_coupled_var_dir);
             return normal_comp + tang_comp;
           }
           else
           {
             const Real curr_jac = (*_jacobian)(_current_node->dof_number(0, _vars[_component], 0),
                                                _connected_dof_indices[_j]);
             return -curr_jac;
           }
         }
 
         case ContactModel::GLUED:
         {
           const Real curr_jac = (*_jacobian)(_current_node->dof_number(0, _vars[_component], 0),
                                              _connected_dof_indices[_j]);
           return -curr_jac;
         }
         default:
           mooseError("Invalid or unavailable contact model");
       }
 
     case Moose::SecondaryPrimary:
       switch (_model)
       {
         case ContactModel::FRICTIONLESS:
           switch (_formulation)
           {
             case ContactFormulation::KINEMATIC:
             {
               const Node * curr_primary_node = _current_primary->node_ptr(_j);
 
               RealVectorValue jac_vec;
               for (unsigned int i = 0; i < _mesh_dimension; ++i)
               {
                 dof_id_type dof_number = _current_node->dof_number(0, _vars[i], 0);
                 jac_vec(i) = (*_jacobian)(dof_number,
                                           curr_primary_node->dof_number(0, _vars[_component], 0)) /
                              _var_objects[i]->scalingFactor();
               }
               return -pinfo->_normal(_component) * (pinfo->_normal * jac_vec) -
                      (_phi_primary[_j][_qp] * penalty * _test_secondary[_i][_qp]) *
                          pinfo->_normal(_component) * normal_component_in_coupled_var_dir;
             }
 
             case ContactFormulation::PENALTY:
             case ContactFormulation::AUGMENTED_LAGRANGE:
               return -_phi_primary[_j][_qp] * penalty * _test_secondary[_i][_qp] *
                      pinfo->_normal(_component) * normal_component_in_coupled_var_dir;
 
             default:
               mooseError("Invalid contact formulation");
           }
 
         case ContactModel::COULOMB:
           if ((_formulation == ContactFormulation::KINEMATIC ||
                _formulation == ContactFormulation::TANGENTIAL_PENALTY) &&
               (pinfo->_mech_status == PenetrationInfo::MS_SLIPPING ||
                pinfo->_mech_status == PenetrationInfo::MS_SLIPPING_FRICTION))
           {
             const Node * curr_primary_node = _current_primary->node_ptr(_j);
 
             RealVectorValue jac_vec;
             for (unsigned int i = 0; i < _mesh_dimension; ++i)
             {
               dof_id_type dof_number = _current_node->dof_number(0, _vars[i], 0);
               jac_vec(i) =
                   (*_jacobian)(dof_number, curr_primary_node->dof_number(0, _vars[_component], 0)) /
                   _var_objects[i]->scalingFactor();
             }
 
             return -pinfo->_normal(_component) * (pinfo->_normal * jac_vec) -
                    (_phi_primary[_j][_qp] * penalty * _test_secondary[_i][_qp]) *
                        pinfo->_normal(_component) * normal_component_in_coupled_var_dir;
           }
           else if ((_formulation == ContactFormulation::PENALTY) &&
                    (pinfo->_mech_status == PenetrationInfo::MS_SLIPPING ||
                     pinfo->_mech_status == PenetrationInfo::MS_SLIPPING_FRICTION))
             return -_phi_primary[_j][_qp] * penalty * _test_secondary[_i][_qp] *
                    pinfo->_normal(_component) * normal_component_in_coupled_var_dir;
           else if (_formulation == ContactFormulation::AUGMENTED_LAGRANGE)
           {
             Real normal_comp = -_phi_primary[_j][_qp] * penalty * _test_secondary[_i][_qp] *
                                pinfo->_normal(_component) * normal_component_in_coupled_var_dir;
 
             Real tang_comp = 0.0;
             if (pinfo->_mech_status == PenetrationInfo::MS_STICKING)
               tang_comp = -_phi_primary[_j][_qp] * penalty_slip * _test_secondary[_i][_qp] *
                           (-pinfo->_normal(_component) * normal_component_in_coupled_var_dir);
             return normal_comp + tang_comp;
           }
           else
             return 0.0;
 
         case ContactModel::GLUED:
           return 0;
 
         default:
           mooseError("Invalid or unavailable contact model");
       }
 
     case Moose::PrimarySecondary:
       switch (_model)
       {
         case ContactModel::FRICTIONLESS:
           switch (_formulation)
           {
             case ContactFormulation::KINEMATIC:
             {
               RealVectorValue jac_vec;
               for (unsigned int i = 0; i < _mesh_dimension; ++i)
               {
                 dof_id_type dof_number = _current_node->dof_number(0, _vars[i], 0);
                 jac_vec(i) = (*_jacobian)(dof_number, _connected_dof_indices[_j]) /
                              _var_objects[i]->scalingFactor();
               }
               return pinfo->_normal(_component) * (pinfo->_normal * jac_vec) *
                      _test_primary[_i][_qp];
             }
 
             case ContactFormulation::PENALTY:
             case ContactFormulation::AUGMENTED_LAGRANGE:
               return -_test_primary[_i][_qp] * penalty * _phi_secondary[_j][_qp] *
                      pinfo->_normal(_component) * normal_component_in_coupled_var_dir;
 
             default:
               mooseError("Invalid contact formulation");
           }
         case ContactModel::COULOMB:
           switch (_formulation)
           {
             case ContactFormulation::KINEMATIC:
             {
               if (pinfo->_mech_status == PenetrationInfo::MS_SLIPPING ||
                   pinfo->_mech_status == PenetrationInfo::MS_SLIPPING_FRICTION)
               {
                 RealVectorValue jac_vec;
                 for (unsigned int i = 0; i < _mesh_dimension; ++i)
                 {
                   dof_id_type dof_number = _current_node->dof_number(0, _vars[i], 0);
                   jac_vec(i) = (*_jacobian)(dof_number, _connected_dof_indices[_j]) /
                                _var_objects[i]->scalingFactor();
                 }
                 return pinfo->_normal(_component) * (pinfo->_normal * jac_vec) *
                        _test_primary[_i][_qp];
               }
               else
               {
                 const Real secondary_jac =
                     (*_jacobian)(_current_node->dof_number(0, _vars[_component], 0),
                                  _connected_dof_indices[_j]) /
                     _var.scalingFactor();
                 return secondary_jac * _test_primary[_i][_qp];
               }
             }
 
             case ContactFormulation::PENALTY:
             {
               if (pinfo->_mech_status == PenetrationInfo::MS_SLIPPING ||
                   pinfo->_mech_status == PenetrationInfo::MS_SLIPPING_FRICTION)
                 return -_test_primary[_i][_qp] * penalty * _phi_secondary[_j][_qp] *
                        pinfo->_normal(_component) * normal_component_in_coupled_var_dir;
               else
                 return 0.0;
             }
             case ContactFormulation::AUGMENTED_LAGRANGE:
             {
               Real normal_comp = -_phi_secondary[_j][_qp] * penalty * _test_primary[_i][_qp] *
                                  pinfo->_normal(_component) * normal_component_in_coupled_var_dir;
 
               Real tang_comp = 0.0;
               if (pinfo->_mech_status == PenetrationInfo::MS_STICKING)
                 tang_comp = -_phi_secondary[_j][_qp] * penalty_slip * _test_primary[_i][_qp] *
                             (-pinfo->_normal(_component) * normal_component_in_coupled_var_dir);
               return normal_comp + tang_comp;
             }
             case ContactFormulation::TANGENTIAL_PENALTY:
             {
               if (pinfo->_mech_status == PenetrationInfo::MS_SLIPPING ||
                   pinfo->_mech_status == PenetrationInfo::MS_SLIPPING_FRICTION)
               {
                 RealVectorValue jac_vec;
                 for (unsigned int i = 0; i < _mesh_dimension; ++i)
                 {
                   dof_id_type dof_number = _current_node->dof_number(0, _vars[i], 0);
                   jac_vec(i) = (*_jacobian)(dof_number, _connected_dof_indices[_j]) /
                                _var_objects[i]->scalingFactor();
                 }
                 return pinfo->_normal(_component) * (pinfo->_normal * jac_vec) *
                        _test_primary[_i][_qp];
               }
               else
                 return 0.0;
             }
 
             default:
               mooseError("Invalid contact formulation");
           }
 
         case ContactModel::GLUED:
           switch (_formulation)
           {
             case ContactFormulation::KINEMATIC:
             {
               const Real secondary_jac =
                   (*_jacobian)(_current_node->dof_number(0, _vars[_component], 0),
                                _connected_dof_indices[_j]) /
                   _var.scalingFactor();
               return secondary_jac * _test_primary[_i][_qp];
             }
 
             case ContactFormulation::PENALTY:
             case ContactFormulation::AUGMENTED_LAGRANGE:
               return 0.0;
 
             default:
               mooseError("Invalid contact formulation");
           }
 
         default:
           mooseError("Invalid or unavailable contact model");
       }
 
     case Moose::PrimaryPrimary:
       switch (_model)
       {
         case ContactModel::FRICTIONLESS:
           switch (_formulation)
           {
             case ContactFormulation::KINEMATIC:
               return 0.0;
 
             case ContactFormulation::PENALTY:
             case ContactFormulation::AUGMENTED_LAGRANGE:
               return _test_primary[_i][_qp] * penalty * _phi_primary[_j][_qp] *
                      pinfo->_normal(_component) * normal_component_in_coupled_var_dir;
 
             default:
               mooseError("Invalid contact formulation");
           }
 
         case ContactModel::COULOMB:
         {
           if (_formulation == ContactFormulation::AUGMENTED_LAGRANGE)
           {
             Real normal_comp = _phi_primary[_j][_qp] * penalty * _test_primary[_i][_qp] *
                                pinfo->_normal(_component) * normal_component_in_coupled_var_dir;
 
             if (pinfo->_mech_status == PenetrationInfo::MS_SLIPPING ||
                 pinfo->_mech_status == PenetrationInfo::MS_SLIPPING_FRICTION)
               return normal_comp;
             else
               return 0.0;
           }
           else if (_formulation == ContactFormulation::PENALTY &&
                    (pinfo->_mech_status == PenetrationInfo::MS_SLIPPING ||
                     pinfo->_mech_status == PenetrationInfo::MS_SLIPPING_FRICTION))
             return _test_primary[_i][_qp] * penalty * _phi_primary[_j][_qp] *
                    pinfo->_normal(_component) * normal_component_in_coupled_var_dir;
           else
             return 0.0;
         }
 
         case ContactModel::GLUED:
           if (_formulation == ContactFormulation::PENALTY &&
               (pinfo->_mech_status == PenetrationInfo::MS_SLIPPING ||
                pinfo->_mech_status == PenetrationInfo::MS_SLIPPING_FRICTION))
             return _test_primary[_i][_qp] * penalty * _phi_primary[_j][_qp] *
                    pinfo->_normal(_component) * normal_component_in_coupled_var_dir;
           else if (_formulation == ContactFormulation::AUGMENTED_LAGRANGE)
           {
             Real normal_comp = _phi_primary[_j][_qp] * penalty * _test_primary[_i][_qp] *
                                pinfo->_normal(_component) * normal_component_in_coupled_var_dir;
 
             Real tang_comp = 0.0;
             if (pinfo->_mech_status == PenetrationInfo::MS_STICKING)
               tang_comp = _phi_primary[_j][_qp] * penalty_slip * _test_primary[_i][_qp] *
                           (-pinfo->_normal(_component) * normal_component_in_coupled_var_dir);
             return normal_comp + tang_comp;
           }
           else
             return 0.0;
 
         default:
           mooseError("Invalid or unavailable contact model");
       }
   }
 
   return 0.0;
 }

◆ computeQpResidual()

Real MechanicalContactConstraint::computeQpResidual ( Moose::ConstraintType type )

overridevirtual

Implements NodeFaceConstraint.

Definition at line 794 of file MechanicalContactConstraint.C.

 {
   PenetrationInfo * pinfo = _penetration_locator._penetration_info[_current_node->id()];
   Real resid = pinfo->_contact_force(_component);
   switch (type)
   {
     case Moose::Secondary:
       if (_formulation == ContactFormulation::KINEMATIC)
       {
         RealVectorValue distance_vec(*_current_node - pinfo->_closest_point);
         if (distance_vec.norm() != 0)
           distance_vec += gapOffset(*_current_node) * pinfo->_normal * distance_vec.unit() *
                           distance_vec.unit();
 
         const Real penalty = getPenalty(*_current_node);
         RealVectorValue pen_force(penalty * distance_vec);
 
         if (_model == ContactModel::FRICTIONLESS)
           resid += pinfo->_normal(_component) * pinfo->_normal * pen_force;
         else if (_model == ContactModel::COULOMB)
         {
           distance_vec = distance_vec - pinfo->_incremental_slip;
           pen_force = penalty * distance_vec;
           if (pinfo->_mech_status == PenetrationInfo::MS_SLIPPING ||
               pinfo->_mech_status == PenetrationInfo::MS_SLIPPING_FRICTION)
             resid += pinfo->_normal(_component) * pinfo->_normal * pen_force;
           else
             resid += pen_force(_component);
         }
         else if (_model == ContactModel::GLUED)
           resid += pen_force(_component);
       }
       else if (_formulation == ContactFormulation::TANGENTIAL_PENALTY &&
                _model == ContactModel::COULOMB)
       {
         RealVectorValue distance_vec = (pinfo->_normal * (*_current_node - pinfo->_closest_point) +
                                         gapOffset(*_current_node)) *
                                        pinfo->_normal;
 
         const Real penalty = getPenalty(*_current_node);
         RealVectorValue pen_force(penalty * distance_vec);
         resid += pinfo->_normal(_component) * pinfo->_normal * pen_force;
       }
       return _test_secondary[_i][_qp] * resid;
 
     case Moose::Primary:
       return _test_primary[_i][_qp] * -resid;
   }
 
   return 0.0;
 }

◆ computeQpSecondaryValue()

Real MechanicalContactConstraint::computeQpSecondaryValue ( )

overridevirtual

Implements NodeFaceConstraint.

Definition at line 788 of file MechanicalContactConstraint.C.

 {
   return _u_secondary[_qp];
 }

◆ gapOffset()

Real MechanicalContactConstraint::gapOffset ( const Node & node )

protected

Definition at line 1687 of file MechanicalContactConstraint.C.

Referenced by AugmentedLagrangianContactConverged(), computeContactForce(), computeQpResidual(), and updateAugmentedLagrangianMultiplier().

 {
   Real val = 0;
 
   if (_has_secondary_gap_offset)
     val += _secondary_gap_offset_var->getNodalValue(node);
 
   if (_has_mapped_primary_gap_offset)
     val += _mapped_primary_gap_offset_var->getNodalValue(node);
 
   return val;
 }

◆ getConnectedDofIndices()

void MechanicalContactConstraint::getConnectedDofIndices ( unsigned int var_num )

overridevirtual

Get the dof indices of the nodes connected to the secondary node for a specific variable.

Parameters

var_num The number of the variable for which dof indices are gathered

Returns: bool indicating whether the coupled variable is one of the displacement variables

Reimplemented from NodeFaceConstraint.

Definition at line 1819 of file MechanicalContactConstraint.C.

Referenced by computeJacobian(), and computeOffDiagJacobian().

 {
   unsigned int component;
   if (getCoupledVarComponent(var_num, component) || _non_displacement_vars_jacobian)
   {
     if (_primary_secondary_jacobian && _connected_secondary_nodes_jacobian)
       NodeFaceConstraint::getConnectedDofIndices(var_num);
     else
     {
       _connected_dof_indices.clear();
       MooseVariableFEBase & var = _sys.getVariable(0, var_num);
       _connected_dof_indices.push_back(var.nodalDofIndex());
     }
   }
 
   _phi_secondary.resize(_connected_dof_indices.size());
 
   dof_id_type current_node_var_dof_index = _sys.getVariable(0, var_num).nodalDofIndex();
   _qp = 0;
 
   // Fill up _phi_secondary so that it is 1 when j corresponds to the dof associated with this node
   // and 0 for every other dof
   // This corresponds to evaluating all of the connected shape functions at _this_ node
   for (unsigned int j = 0; j < _connected_dof_indices.size(); j++)
   {
     _phi_secondary[j].resize(1);
 
     if (_connected_dof_indices[j] == current_node_var_dof_index)
       _phi_secondary[j][_qp] = 1.0;
     else
       _phi_secondary[j][_qp] = 0.0;
   }
 }

◆ getCoupledVarComponent()

bool MechanicalContactConstraint::getCoupledVarComponent	(	unsigned int	var_num,
		unsigned int &	component
	)

Determine whether the coupled variable is one of the displacement variables, and find its component.

Parameters

var_num	The number of the variable to be checked
component	The component index computed in this routine

Returns: bool indicating whether the coupled variable is one of the displacement variables

Definition at line 1854 of file MechanicalContactConstraint.C.

Referenced by computeQpOffDiagJacobian(), and getConnectedDofIndices().

 {
   component = std::numeric_limits<unsigned int>::max();
   bool coupled_var_is_disp_var = false;
   for (const auto i : make_range(Moose::dim))
   {
     if (var_num == _vars[i])
     {
       coupled_var_is_disp_var = true;
       component = i;
       break;
     }
   }
 
   return coupled_var_is_disp_var;
 }

◆ getPenalty()

Real MechanicalContactConstraint::getPenalty ( const Node & node )

protected

Definition at line 1718 of file MechanicalContactConstraint.C.

Referenced by AugmentedLagrangianContactConverged(), computeContactForce(), computeQpJacobian(), computeQpOffDiagJacobian(), computeQpResidual(), and updateAugmentedLagrangianMultiplier().

 {
   Real penalty = _penalty;
   if (_normalize_penalty)
     penalty *= nodalArea(node);
   return penalty * MathUtils::pow(_penalty_multiplier, _lagrangian_iteration_number);
 }

◆ getTangentialPenalty()

Real MechanicalContactConstraint::getTangentialPenalty ( const Node & node )

protected

Definition at line 1727 of file MechanicalContactConstraint.C.

Referenced by computeContactForce(), computeQpJacobian(), computeQpOffDiagJacobian(), and updateAugmentedLagrangianMultiplier().

 {
   Real penalty = _penalty_tangential;
   if (_normalize_penalty)
     penalty *= nodalArea(node);
 
   return penalty * MathUtils::pow(_penalty_multiplier, _lagrangian_iteration_number);
 }

◆ jacobianSetup()

void MechanicalContactConstraint::jacobianSetup ( )

overridevirtual

Reimplemented from NodeFaceConstraint.

Definition at line 245 of file MechanicalContactConstraint.C.

 {
   if (_component == 0)
   {
     if (_update_stateful_data)
       updateContactStatefulData(/* beginning_of_step = */ false);
     _update_stateful_data = true;
   }
 }

◆ nodalArea()

Real MechanicalContactConstraint::nodalArea ( const Node & node )

protected

Definition at line 1701 of file MechanicalContactConstraint.C.

Referenced by computeContactForce(), getPenalty(), and getTangentialPenalty().

 {
   dof_id_type dof = node.dof_number(_aux_system.number(), _nodal_area_var->number(), 0);
 
   Real area = (*_aux_solution)(dof);
   if (area == 0.0)
   {
     if (_t_step > 1)
       mooseError("Zero nodal area found");
     else
       area = 1.0; // Avoid divide by zero during initialization
   }
 
   return area;
 }

◆ residualEnd()

void MechanicalContactConstraint::residualEnd ( )

overridevirtual

Reimplemented from NodeFaceConstraint.

Definition at line 1872 of file MechanicalContactConstraint.C.

 {
   if (_component == 0 && (_print_contact_nodes || _contact_linesearch))
   {
     _communicator.set_union(_current_contact_state);
     if (_print_contact_nodes)
     {
       if (_current_contact_state == _old_contact_state)
         _console << "Unchanged contact state. " << _current_contact_state.size()
                  << " nodes in contact.\n";
       else
         _console << "Changed contact state!!! " << _current_contact_state.size()
                  << " nodes in contact.\n";
     }
     if (_contact_linesearch)
       _contact_linesearch->insertSet(_current_contact_state);
     _old_contact_state.swap(_current_contact_state);
     _current_contact_state.clear();
   }
 }

◆ shouldApply()

bool MechanicalContactConstraint::shouldApply ( )

overridevirtual

Reimplemented from NodeFaceConstraint.

Definition at line 468 of file MechanicalContactConstraint.C.

 {
   bool in_contact = false;
 
   std::map<dof_id_type, PenetrationInfo *>::iterator found =
       _penetration_locator._penetration_info.find(_current_node->id());
   if (found != _penetration_locator._penetration_info.end())
   {
     PenetrationInfo * pinfo = found->second;
     if (pinfo != NULL)
     {
       bool is_nonlinear = _subproblem.computingNonlinearResid();
 
       // This computes the contact force once per constraint, rather than once per quad point
       // and for both primary and secondary cases.
       if (_component == 0)
         computeContactForce(*_current_node, pinfo, is_nonlinear);
 
       if (pinfo->isCaptured())
       {
         in_contact = true;
         if (is_nonlinear)
         {
           Threads::spin_mutex::scoped_lock lock(_contact_set_mutex);
           _current_contact_state.insert(_current_node->id());
         }
       }
     }
   }
 
   return in_contact;
 }

◆ timestepSetup()

void MechanicalContactConstraint::timestepSetup ( )

overridevirtual

Reimplemented from NodeFaceConstraint.

Definition at line 229 of file MechanicalContactConstraint.C.

 {
   if (_component == 0)
   {
     updateContactStatefulData(/* beginning_of_step = */ true);
     if (_formulation == ContactFormulation::AUGMENTED_LAGRANGE)
       updateAugmentedLagrangianMultiplier(/* beginning_of_step = */ true);
 
     _update_stateful_data = false;
 
     if (_contact_linesearch)
       _contact_linesearch->reset();
   }
 }

◆ updateAugmentedLagrangianMultiplier()

void MechanicalContactConstraint::updateAugmentedLagrangianMultiplier ( bool beginning_of_step )

virtual

Definition at line 256 of file MechanicalContactConstraint.C.

Referenced by timestepSetup().

 {
   for (auto & [secondary_node_num, pinfo] : _penetration_locator._penetration_info)
   {
     if (!pinfo)
       continue;
 
     const Node & node = _mesh.nodeRef(secondary_node_num);
     if (node.n_comp(_sys.number(), _vars[_component]) < 1)
       continue;
 
     const Real distance = pinfo->_normal * (pinfo->_closest_point - node) - gapOffset(node);
 
     if (beginning_of_step && _model == ContactModel::COULOMB)
     {
       pinfo->_lagrange_multiplier_slip.zero();
       if (pinfo->isCaptured())
         pinfo->_mech_status = PenetrationInfo::MS_STICKING;
     }
 
     if (pinfo->isCaptured())
     {
       if (_model == ContactModel::FRICTIONLESS)
         pinfo->_lagrange_multiplier -= getPenalty(node) * distance;
 
       if (_model == ContactModel::COULOMB)
       {
         if (!beginning_of_step)
         {
           Real penalty = getPenalty(node);
           RealVectorValue pen_force_normal =
               penalty * (-distance) * pinfo->_normal + pinfo->_lagrange_multiplier * pinfo->_normal;
 
           // update normal lagrangian multiplier
           pinfo->_lagrange_multiplier += penalty * (-distance);
 
           // Frictional capacity
           const Real capacity(_friction_coefficient * (pen_force_normal * pinfo->_normal < 0
                                                            ? -pen_force_normal * pinfo->_normal
                                                            : 0));
 
           RealVectorValue tangential_inc_slip =
               pinfo->_incremental_slip -
               (pinfo->_incremental_slip * pinfo->_normal) * pinfo->_normal;
 
           Real penalty_slip = getTangentialPenalty(node);
 
           RealVectorValue inc_pen_force_tangential =
               pinfo->_lagrange_multiplier_slip + penalty_slip * tangential_inc_slip;
 
           RealVectorValue tau_old = pinfo->_contact_force_old -
                                     pinfo->_normal * (pinfo->_normal * pinfo->_contact_force_old);
 
           RealVectorValue contact_force_tangential = inc_pen_force_tangential + tau_old;
           const Real tan_mag(contact_force_tangential.norm());
 
           if (tan_mag > capacity * (_al_frictional_force_tolerance + 1.0))
           {
             pinfo->_lagrange_multiplier_slip =
                 -tau_old + capacity * contact_force_tangential / tan_mag;
             if (MooseUtils::absoluteFuzzyEqual(capacity, 0.0))
               pinfo->_mech_status = PenetrationInfo::MS_SLIPPING;
             else
               pinfo->_mech_status = PenetrationInfo::MS_SLIPPING_FRICTION;
           }
           else
           {
             pinfo->_mech_status = PenetrationInfo::MS_STICKING;
             pinfo->_lagrange_multiplier_slip += penalty_slip * tangential_inc_slip;
           }
         }
       }
     }
   }
 }

◆ updateContactStatefulData()

void MechanicalContactConstraint::updateContactStatefulData ( bool beginning_of_step )

virtual

Definition at line 428 of file MechanicalContactConstraint.C.

Referenced by jacobianSetup(), and timestepSetup().

 {
   for (auto & [secondary_node_num, pinfo] : _penetration_locator._penetration_info)
   {
     if (!pinfo)
       continue;
 
     const Node & node = _mesh.nodeRef(secondary_node_num);
     if (node.n_comp(_sys.number(), _vars[_component]) < 1)
       continue;
 
     if (beginning_of_step)
     {
       if (_app.getExecutioner()->lastSolveConverged())
       {
         pinfo->_contact_force_old = pinfo->_contact_force;
         pinfo->_accumulated_slip_old = pinfo->_accumulated_slip;
         pinfo->_frictional_energy_old = pinfo->_frictional_energy;
         pinfo->_mech_status_old = pinfo->_mech_status;
       }
       else if (pinfo->_mech_status_old == PenetrationInfo::MS_NO_CONTACT &&
                pinfo->_mech_status != PenetrationInfo::MS_NO_CONTACT)
       {
         // The penetration info object could be based on a bad state so delete it
         delete pinfo;
         pinfo = NULL;
         continue;
       }
 
       pinfo->_locked_this_step = 0;
       pinfo->_stick_locked_this_step = 0;
       pinfo->_starting_elem = pinfo->_elem;
       pinfo->_starting_side_num = pinfo->_side_num;
       pinfo->_starting_closest_point_ref = pinfo->_closest_point_ref;
     }
     pinfo->_incremental_slip_prev_iter = pinfo->_incremental_slip;
   }
 }

◆ validParams()

InputParameters MechanicalContactConstraint::validParams ( )

static

Definition at line 35 of file MechanicalContactConstraint.C.

 {
   InputParameters params = NodeFaceConstraint::validParams();
   params += ContactAction::commonParameters();
 
   params.addRequiredParam<BoundaryName>("boundary", "The primary boundary");
   params.addParam<BoundaryName>("secondary", "The secondary boundary");
   params.addRequiredParam<unsigned int>("component",
                                         "An integer corresponding to the direction "
                                         "the variable this constraint acts on. (0 for x, "
                                         "1 for y, 2 for z)");
 
   params.addCoupledVar(
       "displacements",
       "The displacements appropriate for the simulation geometry and coordinate system");
 
   params.addCoupledVar("secondary_gap_offset", "offset to the gap distance from secondary side");
   params.addCoupledVar("mapped_primary_gap_offset",
                        "offset to the gap distance mapped from primary side");
   params.addRequiredCoupledVar("nodal_area", "The nodal area");
 
   params.set<bool>("use_displaced_mesh") = true;
   params.addParam<Real>(
       "penalty",
       1e8,
       "The penalty to apply.  This can vary depending on the stiffness of your materials");
   params.addParam<Real>("penalty_multiplier",
                         1.0,
                         "The growth factor for the penalty applied at the end of each augmented "
                         "Lagrange update iteration");
   params.addParam<Real>("friction_coefficient", 0, "The friction coefficient");
   params.addParam<Real>("tangential_tolerance",
                         "Tangential distance to extend edges of contact surfaces");
   params.addParam<Real>(
       "capture_tolerance", 0, "Normal distance from surface within which nodes are captured");
 
   params.addParam<Real>("tension_release",
                         0.0,
                         "Tension release threshold.  A node in contact "
                         "will not be released if its tensile load is below "
                         "this value.  No tension release if negative.");
 
   params.addParam<bool>(
       "normalize_penalty",
       false,
       "Whether to normalize the penalty parameter with the nodal area for penalty contact.");
   params.addParam<bool>(
       "primary_secondary_jacobian",
       true,
       "Whether to include jacobian entries coupling primary and secondary nodes.");
   params.addParam<bool>(
       "connected_secondary_nodes_jacobian",
       true,
       "Whether to include jacobian entries coupling nodes connected to secondary nodes.");
   params.addParam<bool>("non_displacement_variables_jacobian",
                         true,
                         "Whether to include jacobian entries coupling with variables that are not "
                         "displacement variables.");
   params.addParam<unsigned int>("stick_lock_iterations",
                                 std::numeric_limits<unsigned int>::max(),
                                 "Number of times permitted to switch between sticking and slipping "
                                 "in a solution before locking node in a sticked state.");
   params.addParam<Real>("stick_unlock_factor",
                         1.5,
                         "Factor by which frictional capacity must be "
                         "exceeded to permit stick-locked node to slip "
                         "again.");
   params.addParam<Real>("al_penetration_tolerance",
                         "The tolerance of the penetration for augmented Lagrangian method.");
   params.addParam<Real>("al_incremental_slip_tolerance",
                         "The tolerance of the incremental slip for augmented Lagrangian method.");
 
   params.addParam<Real>("al_frictional_force_tolerance",
                         "The tolerance of the frictional force for augmented Lagrangian method.");
   params.addParam<bool>(
       "print_contact_nodes", false, "Whether to print the number of nodes in contact.");
 
   params.addClassDescription(
       "Apply non-penetration constraints on the mechanical deformation "
       "using a node on face, primary/secondary algorithm, and multiple options "
       "for the physical behavior on the interface and the mathematical "
       "formulation for constraint enforcement");
 
   return params;
 }