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

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.

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

virtual Real	computeQpJacobian (Moose::ConstraintJacobianType type) override

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

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

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

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

bool	isKokkosObject () const

MooseApp &	getMooseApp () const

const std::string &	type () const

const std::string &	name () const

std::string	typeAndName () const

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

MooseObjectName	uniqueName () const

const InputParameters &	parameters () const

const hit::Node *	getHitNode () const

bool	hasBase () const

const std::string &	getBase () 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 &name) const

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

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

void	paramWarning (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

std::string	messagePrefix (const bool hit_prefix=true) const

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

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

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

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

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

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

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

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

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

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

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

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

void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) 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

Moose::Kokkos::Function	getKokkosFunction (const std::string &name) const

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

Moose::Kokkos::Function	getKokkosFunctionByName (const FunctionName &name) const

const T &	getKokkosFunctionByName (const FunctionName &name) const

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

bool	hasKokkosFunctionByName (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 UserObjectBase &	getUserObjectBase (const std::string &param_name, bool is_dependency=true) const

const UserObjectBase &	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

Moose::Kokkos::VariableValue	kokkosCoupledVectorTagValueByName (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledVectorTagValuesByName (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::VariableGradient	kokkosCoupledVectorTagGradientByName (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

Moose::Kokkos::VariableGradient	kokkosCoupledVectorTagGradientsByName (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::VariableValue	kokkosCoupledVectorTagNodalValueByName (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledVectorTagNodalValuesByName (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::VariableValue	kokkosCoupledVectorTagDofValueByName (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledVectorTagDofValuesByName (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::VariableValue	kokkosCoupledVectorTagValue (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledVectorTagValues (const std::string &var_name, const std::string &tag_param_name) const

Moose::Kokkos::VariableGradient	kokkosCoupledVectorTagGradient (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const

Moose::Kokkos::VariableGradient	kokkosCoupledVectorTagGradients (const std::string &var_name, const std::string &tag_param_name) const

Moose::Kokkos::VariableValue	kokkosCoupledVectorTagNodalValue (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledVectorTagNodalValues (const std::string &var_name, const std::string &tag_param_name) const

Moose::Kokkos::VariableValue	kokkosCoupledVectorTagDofValue (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledVectorTagDofValues (const std::string &var_name, const std::string &tag_param_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorTagVectorValueByName (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorTagVectorValuesByName (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::VectorVariableGradient	kokkosCoupledVectorTagVectorGradientByName (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableGradient	kokkosCoupledVectorTagVectorGradientsByName (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorTagVectorNodalValueByName (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorTagVectorNodalValuesByName (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorTagVectorDofValueByName (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorTagVectorDofValuesByName (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorTagVectorValue (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorTagVectorValues (const std::string &var_name, const std::string &tag_param_name) const

Moose::Kokkos::VectorVariableGradient	kokkosCoupledVectorTagVectorGradient (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableGradient	kokkosCoupledVectorTagVectorGradients (const std::string &var_name, const std::string &tag_param_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorTagVectorNodalValue (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorTagVectorNodalValues (const std::string &var_name, const std::string &tag_param_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorTagVectorDofValue (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorTagVectorDofValues (const std::string &var_name, const std::string &tag_param_name) const

Moose::Kokkos::VariableValue	kokkosCoupledValue (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledValues (const std::string &var_name) const

Moose::Kokkos::VariableGradient	kokkosCoupledGradient (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableGradient	kokkosCoupledGradients (const std::string &var_name) const

Moose::Kokkos::VariableValue	kokkosCoupledNodalValue (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledNodalValues (const std::string &var_name) const

Moose::Kokkos::VariableValue	kokkosCoupledDofValue (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledDofValues (const std::string &var_name) const

Moose::Kokkos::VariableValue	kokkosCoupledValueOld (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledValuesOld (const std::string &var_name) const

Moose::Kokkos::VariableGradient	kokkosCoupledGradientOld (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableGradient	kokkosCoupledGradientsOld (const std::string &var_name) const

Moose::Kokkos::VariableValue	kokkosCoupledNodalValueOld (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledNodalValuesOld (const std::string &var_name) const

Moose::Kokkos::VariableValue	kokkosCoupledDofValueOld (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledDofValuesOld (const std::string &var_name) const

Moose::Kokkos::VariableValue	kokkosCoupledValueOlder (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledValuesOlder (const std::string &var_name) const

Moose::Kokkos::VariableGradient	kokkosCoupledGradientOlder (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableGradient	kokkosCoupledGradientsOlder (const std::string &var_name) const

Moose::Kokkos::VariableValue	kokkosCoupledNodalValueOlder (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledNodalValuesOlder (const std::string &var_name) const

Moose::Kokkos::VariableValue	kokkosCoupledDofValueOlder (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledDofValuesOlder (const std::string &var_name) const

Moose::Kokkos::VariableValue	kokkosCoupledDot (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledDots (const std::string &var_name) const

Moose::Kokkos::VariableValue	kokkosCoupledNodalDot (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledNodalDots (const std::string &var_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorValue (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableGradient	kokkosCoupledVectorGradient (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorNodalValue (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorDofValue (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorValues (const std::string &var_name) const

Moose::Kokkos::VectorVariableGradient	kokkosCoupledVectorGradients (const std::string &var_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorNodalValues (const std::string &var_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorDofValues (const std::string &var_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorValueOld (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableGradient	kokkosCoupledVectorGradientOld (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorNodalValueOld (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorDofValueOld (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorValuesOld (const std::string &var_name) const

Moose::Kokkos::VectorVariableGradient	kokkosCoupledVectorGradientsOld (const std::string &var_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorNodalValuesOld (const std::string &var_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorDofValuesOld (const std::string &var_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorValueOlder (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableGradient	kokkosCoupledVectorGradientOlder (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorNodalValueOlder (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorDofValueOlder (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorValuesOlder (const std::string &var_name) const

Moose::Kokkos::VectorVariableGradient	kokkosCoupledVectorGradientsOlder (const std::string &var_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorNodalValuesOlder (const std::string &var_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorDofValuesOlder (const std::string &var_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorDot (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorNodalDot (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorDots (const std::string &var_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorNodalDots (const std::string &var_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledVectorTagValueByName (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledVectorTagValuesByName (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::ADVariableGradient	kokkosADCoupledVectorTagGradientByName (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableGradient	kokkosADCoupledVectorTagGradientsByName (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledVectorTagNodalValueByName (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledVectorTagNodalValuesByName (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledVectorTagDofValueByName (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledVectorTagDofValuesByName (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledVectorTagValue (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledVectorTagValues (const std::string &var_name, const std::string &tag_param_name) const

Moose::Kokkos::ADVariableGradient	kokkosADCoupledVectorTagGradient (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableGradient	kokkosADCoupledVectorTagGradients (const std::string &var_name, const std::string &tag_param_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledVectorTagNodalValue (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledVectorTagNodalValues (const std::string &var_name, const std::string &tag_param_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledVectorTagDofValue (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledVectorTagDofValues (const std::string &var_name, const std::string &tag_param_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledValue (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledValues (const std::string &var_name) const

Moose::Kokkos::ADVariableGradient	kokkosADCoupledGradient (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableGradient	kokkosADCoupledGradients (const std::string &var_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledNodalValue (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledNodalValues (const std::string &var_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledDofValue (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledDofValues (const std::string &var_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledValueOld (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledValuesOld (const std::string &var_name) const

Moose::Kokkos::ADVariableGradient	kokkosADCoupledGradientOld (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableGradient	kokkosADCoupledGradientsOld (const std::string &var_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledNodalValueOld (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledNodalValuesOld (const std::string &var_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledDofValueOld (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledDofValuesOld (const std::string &var_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledValueOlder (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledValuesOlder (const std::string &var_name) const

Moose::Kokkos::ADVariableGradient	kokkosADCoupledGradientOlder (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableGradient	kokkosADCoupledGradientsOlder (const std::string &var_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledNodalValueOlder (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledNodalValuesOlder (const std::string &var_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledDofValueOlder (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledDofValuesOlder (const std::string &var_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledDot (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledDots (const std::string &var_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledNodalDot (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledNodalDots (const std::string &var_name) const

Moose::Kokkos::Scalar< const Real >	kokkosCoupledDotDu (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosZeroValue () const

Moose::Kokkos::VariableGradient	kokkosZeroGradient () const

Moose::Kokkos::VariableValue	kokkosZeroNodalValue () 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={})

virtual std::set< MooseVariableFieldBase * >	checkVariables (const libMesh::Node &node, const std::set< MooseVariableFieldBase * > &vars_to_check)

std::set< MooseVariableFieldBase * >	checkVariables (const libMesh::Elem &element, const std::set< MooseVariableFieldBase * > &vars_to_check)

void	addMooseVariableDependency (MooseVariableFieldBase *var)

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

MooseVariableBase *	mooseVariableBase () const

MooseVariableField< T > &	mooseVariableField ()

MooseVariableFE< T > *	mooseVariable () const

MooseVariableFV< T > *	mooseVariableFV () const

MooseLinearVariableFV< T > *	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 ()

static void	callMooseError (MooseApp const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node node, const bool show_trace=true)

Public Attributes
	usingCombinedWarningSolutionWarnings

const ConsoleStream	_console

Static Public Attributes
static const std::string	type_param

static const std::string	name_param

static const std::string	unique_name_param

static const std::string	app_param

static const std::string	moose_base_param

static const std::string	kokkos_object_param

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

void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const

InvalidSolutionID	registerInvalidSolutionInternal (const std::string &message, const bool warning) const

virtual void	addUserObjectDependencyHelper (const UserObjectBase &) 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	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 Residuals &residuals, const Indices &dof_indices, const std::vector< Real > &scaling_factors)

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 Residuals &residuals, const Indices &dof_indices, const std::vector< Real > &scaling_factors)

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

void	addJacobian (Assembly &assembly, const 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)

std::vector< const MooseVariableFieldBase * >	getFieldVars (const std::string &var_name) const

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

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

std::vector< const T * >	getVarsHelper (const std::string &var_name) const

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< T >::VariableValue &	value ()

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

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

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

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

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

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

virtual const VariableValue &	dotDu ()

virtual const VariableValue &	dotDotDu ()

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

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

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

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

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

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

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

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

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

virtual const OutputTools< T >::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

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.

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

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

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

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

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

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::unordered_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

Factory &	_factory

ActionFactory &	_action_factory

const std::string &	_type

const std::string &	_name

const InputParameters &	_pars

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< MooseVariableField< Real > * >	_coupled_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< T > *	_variable

MooseVariableFV< T > *	_fv_variable

MooseLinearVariableFV< T > *	_linear_fv_variable

MooseVariableField< T > *	_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

Private Types
enum	FuncAge

enum	VarType

Private Member Functions
const Moose::FunctionBase *	getKokkosFunctionByNameHelper (const FunctionName &name) const

const UserObjectBase &	getUserObjectFromFEProblem (const UserObjectName &object_name, const THREAD_ID tid=0) const

const T &	castUserObject (const UserObjectBase &uo_base, const std::string &param_name="") const

void	mooseObjectError (const std::string &param_name, std::stringstream &oss) const

const std::string &	userObjectType (const UserObjectBase &uo) const

const std::string &	userObjectName (const UserObjectBase &uo) const

const PostprocessorName &	getPostprocessorNameInternal (const std::string &param_name, const unsigned int index, const bool allow_default_value=true) const

bool	isDefaultPostprocessorValueByName (const PostprocessorName &name) const

PostprocessorValue	getDefaultPostprocessorValueByName (const PostprocessorName &name) const

void	checkParam (const std::string &param_name, const unsigned int index=std::numeric_limits< unsigned int >::max()) const

bool	postprocessorsAdded () const

const VectorPostprocessorValue &	getVectorPostprocessorByNameHelper (const VectorPostprocessorName &name, const std::string &vector_name, bool broadcast, std::size_t t_index) const

const VectorPostprocessorContext< VectorPostprocessorValue > &	getVectorPostprocessorContextByNameHelper (const VectorPostprocessorName &name, const std::string &vector_name) const

bool	vectorPostprocessorsAdded () const

RestartableDataValue &	registerRestartableDataOnApp (std::unique_ptr< RestartableDataValue > data, THREAD_ID tid) const

void	registerRestartableNameWithFilterOnApp (const std::string &name, Moose::RESTARTABLE_FILTER filter)

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

void	prepareVectorTagInternal (Assembly &assembly, unsigned int ivar, const std::set< TagID > &vector_tags, const std::set< TagID > &absolute_value_vector_tags)

void	checkForNans () const

const OutputTools< T >::VariableValue &	vectorTagValueHelper (const std::string &var_names, TagID tag, unsigned int index=0) const

const OutputTools< T >::VariableValue &	vectorTagValueHelper (const std::string &var_names, const std::string &tag_name, unsigned int index=0) const

const OutputTools< T >::VariableValue &	vectorTagDofValueHelper (const std::string &var_name, TagID tag, unsigned int comp=0) const

const OutputTools< T >::VariableValue &	vectorTagDofValueHelper (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

void	requestStates (const std::string &var_name, const TagName &tag_name, const unsigned int comp)

void	checkFuncType (const std::string var_name, VarType t, FuncAge age) const

const VariableValue *	getDefaultValue (const std::string &var_name, unsigned int comp) const

const VectorVariableValue *	getDefaultVectorValue (const std::string &var_name) const

const ArrayVariableValue *	getDefaultArrayValue (const std::string &var_name) const

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

const RealVectorValue &	getDefaultNodalValue (const std::string &var_name, unsigned int) const

const RealEigenVector &	getDefaultNodalValue (const std::string &var_name, unsigned int) const

const Moose::Functor< T > &	getDefaultFunctor (const std::string &var_name) const

Moose::Kokkos::Variable	kokkosCoupledVectorTagVariable (const std::string &var_name, const std::string &tag_name, unsigned int comp) const

Moose::Kokkos::Variable	kokkosCoupledVectorTagVariables (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::Variable	kokkosCoupledVectorTagVectorVariable (const std::string &var_name, const std::string &tag_name, unsigned int comp) const

Moose::Kokkos::Variable	kokkosCoupledVectorTagVectorVariables (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::Variable	kokkosZeroVariable () const

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

const PostprocessorValue &	getPostprocessorValueInternal (const std::string &param_name, unsigned int index, std::size_t t_index) const

const PostprocessorValue &	getPostprocessorValueInternal (const std::string &param_name, unsigned int index, std::size_t t_index) const

const PostprocessorValue &	getPostprocessorValueByNameInternal (const PostprocessorName &name, std::size_t t_index) const

const PostprocessorValue &	getPostprocessorValueByNameInternal (const PostprocessorName &name, std::size_t t_index) const

void	possiblyCheckHasVectorPostprocessor (const std::string &param_name, const std::string &vector_name) const

void	possiblyCheckHasVectorPostprocessor (const std::string &param_name, const std::string &vector_name) const

void	possiblyCheckHasVectorPostprocessorByName (const VectorPostprocessorName &name, const std::string &vector_name) const

void	possiblyCheckHasVectorPostprocessorByName (const VectorPostprocessorName &name, const std::string &vector_name) const

Static Private Member Functions
static const hit::Node *	getHitNode (const InputParameters &params)

static std::string	messagePrefix (const InputParameters &params, const bool hit_prefix)

Private Attributes
const ParallelParamObject &	_parent

const MooseBase &	_si_moose_base

const FEProblemBase *	_si_problem

ExecFlagEnum	_empty_execute_enum

const MooseObject &	_fni_object

const InputParameters &	_fni_params

FEProblemBase &	_fni_feproblem

const THREAD_ID	_fni_tid

const MooseObject &	_uoi_moose_object

const FEProblemBase &	_uoi_feproblem

const THREAD_ID	_uoi_tid

const std::string	_ti_name

const MooseObject &	_ppi_moose_object

const InputParameters &	_ppi_params

const FEProblemBase &	_ppi_feproblem

std::map< PostprocessorName, std::unique_ptr< PostprocessorValue > >	_default_values

const bool	_broadcast_by_default

const MooseObject &	_vpi_moose_object

const FEProblemBase &	_vpi_feproblem

const THREAD_ID	_vpi_tid

RandomData *	_random_data

MooseRandom *	_generator

FEProblemBase &	_ri_problem

const std::string	_ri_name

unsigned int	_master_seed

bool	_is_nodal

ExecFlagType	_reset_on

const Node *const &	_curr_node

const Elem *const &	_curr_element

const RestartableDataMapName	_metaname

std::string	_restartable_name

std::set< TagID >	_vector_tags

std::set< TagID >	_abs_vector_tags

std::set< TagID >	_matrix_tags

std::set< TagID >	_non_ref_vector_tags

std::set< TagID >	_non_ref_abs_vector_tags

std::set< TagID >	_ref_vector_tags

std::set< TagID >	_ref_abs_vector_tags

const MooseObject &	_moose_object

const InputParameters &	_tag_params

std::vector< DenseVector< Number > * >	_re_blocks

std::vector< DenseVector< Number > * >	_absre_blocks

std::vector< DenseMatrix< Number > * >	_ke_blocks

std::vector< Real >	_absolute_residuals

unsigned int	_coupleable_max_qps

std::unordered_map< std::string, std::vector< unsigned int > >	_optional_var_index

std::unordered_map< std::string, std::vector< MooseVariableScalar * > >	_c_coupled_scalar_vars

std::set< TagID >	_fe_coupleable_vector_tags

std::set< TagID >	_fe_coupleable_matrix_tags

const bool	_is_fv

const MooseObject *const	_obj

const std::set< std::string >	_older_state_tags

std::vector< std::set< MooseWritableVariable * > >	_writable_coupled_variables

const Real	_kokkos_default_value_zero

const InputParameters &	_sc_parameters

const std::string &	_sc_name

const bool	_sc_is_implicit

std::unordered_map< std::string, std::vector< MooseVariableScalar * > >	_coupled_scalar_vars

std::unordered_map< std::string, std::unique_ptr< ADVariableValue > >	_dual_default_value

std::vector< MooseVariableScalar * >	_coupled_moose_scalar_vars

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

std::set< TagID >	_sc_coupleable_vector_tags

std::set< TagID >	_sc_coupleable_matrix_tags

std::set< MooseVariableFieldBase * >	_moose_variable_dependencies

std::vector< libMesh::dof_id_type >	_dof_indices

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; }

◆ 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.

{
  // 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();
    }
  }
}

Referenced by shouldApply().

◆ 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.

{
  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;
}

Referenced by computeJacobian().

◆ 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.

{
  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;
}

Referenced by computeOffDiagJacobian().

◆ 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.

{
  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;
}

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

◆ 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.

{
  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;
  }
}

Referenced by computeJacobian(), and computeOffDiagJacobian().

◆ 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.

{
  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;
}

Referenced by computeQpOffDiagJacobian(), and getConnectedDofIndices().

◆ getPenalty()

Real MechanicalContactConstraint::getPenalty ( const Node & node )

protected

Definition at line 1718 of file MechanicalContactConstraint.C.

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

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

◆ getTangentialPenalty()

Real MechanicalContactConstraint::getTangentialPenalty ( const Node & node )

protected

Definition at line 1727 of file MechanicalContactConstraint.C.

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

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

◆ 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.

{
  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;
}

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

◆ 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.

{
  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;
          }
        }
      }
    }
  }
}

Referenced by timestepSetup().

◆ updateContactStatefulData()

void MechanicalContactConstraint::updateContactStatefulData ( bool beginning_of_step )

virtual

Definition at line 428 of file MechanicalContactConstraint.C.

{
  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;
  }
}

Referenced by jacobianSetup(), and timestepSetup().

◆ 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;
}

Member Data Documentation

◆ _al_frictional_force_tolerance

Real MechanicalContactConstraint::_al_frictional_force_tolerance

protected

The tolerance of the frictional force for augmented Lagrangian method.

Definition at line 141 of file MechanicalContactConstraint.h.

Referenced by AugmentedLagrangianContactConverged(), MechanicalContactConstraint(), and updateAugmentedLagrangianMultiplier().

◆ _al_incremental_slip_tolerance

Real MechanicalContactConstraint::_al_incremental_slip_tolerance

protected

The tolerance of the incremental slip for augmented Lagrangian method.

Definition at line 139 of file MechanicalContactConstraint.h.

Referenced by AugmentedLagrangianContactConverged(), and MechanicalContactConstraint().

◆ _al_penetration_tolerance

Real MechanicalContactConstraint::_al_penetration_tolerance

protected

The tolerance of the penetration for augmented Lagrangian method.

Definition at line 137 of file MechanicalContactConstraint.h.

Referenced by AugmentedLagrangianContactConverged(), and MechanicalContactConstraint().

◆ _augmented_lagrange_problem

AugmentedLagrangianContactProblemInterface* const MechanicalContactConstraint::_augmented_lagrange_problem

protected

Definition at line 150 of file MechanicalContactConstraint.h.

Referenced by MechanicalContactConstraint().

◆ _aux_solution

const NumericVector<Number>* const MechanicalContactConstraint::_aux_solution

protected

Definition at line 127 of file MechanicalContactConstraint.h.

◆ _aux_system

SystemBase& MechanicalContactConstraint::_aux_system

protected

Definition at line 126 of file MechanicalContactConstraint.h.

Referenced by nodalArea().

◆ _capture_tolerance

const Real MechanicalContactConstraint::_capture_tolerance

protected

Definition at line 106 of file MechanicalContactConstraint.h.

Referenced by computeContactForce().

◆ _component

const unsigned int MechanicalContactConstraint::_component

protected

Definition at line 96 of file MechanicalContactConstraint.h.

Referenced by AugmentedLagrangianContactConverged(), computeQpJacobian(), computeQpOffDiagJacobian(), computeQpResidual(), jacobianSetup(), residualEnd(), shouldApply(), timestepSetup(), updateAugmentedLagrangianMultiplier(), and updateContactStatefulData().

◆ _connected_secondary_nodes_jacobian

const bool MechanicalContactConstraint::_connected_secondary_nodes_jacobian

protected

Whether to include coupling terms with the nodes connected to the secondary nodes in the Jacobian.

Definition at line 132 of file MechanicalContactConstraint.h.

Referenced by getConnectedDofIndices().

◆ _contact_linesearch

ContactLineSearchBase* MechanicalContactConstraint::_contact_linesearch

protected

Definition at line 143 of file MechanicalContactConstraint.h.

Referenced by computeContactForce(), residualEnd(), and timestepSetup().

◆ _contact_set_mutex

Threads::spin_mutex MechanicalContactConstraint::_contact_set_mutex

staticprotected

Definition at line 148 of file MechanicalContactConstraint.h.

Referenced by shouldApply().

◆ _current_contact_state

std::set<dof_id_type> MechanicalContactConstraint::_current_contact_state

protected

Definition at line 144 of file MechanicalContactConstraint.h.

Referenced by residualEnd(), and shouldApply().

◆ _displaced_problem

MooseSharedPointer<DisplacedProblem> MechanicalContactConstraint::_displaced_problem

protected

Definition at line 90 of file MechanicalContactConstraint.h.

◆ _formulation

const ContactFormulation MechanicalContactConstraint::_formulation

protected

Definition at line 98 of file MechanicalContactConstraint.h.

Referenced by computeContactForce(), computeQpJacobian(), computeQpOffDiagJacobian(), computeQpResidual(), MechanicalContactConstraint(), and timestepSetup().

◆ _friction_coefficient

const Real MechanicalContactConstraint::_friction_coefficient

protected

Definition at line 104 of file MechanicalContactConstraint.h.

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

◆ _has_mapped_primary_gap_offset

const bool MechanicalContactConstraint::_has_mapped_primary_gap_offset

protected

Definition at line 122 of file MechanicalContactConstraint.h.

Referenced by gapOffset().

◆ _has_secondary_gap_offset

const bool MechanicalContactConstraint::_has_secondary_gap_offset

protected

gap offset from either secondary, primary or both

Definition at line 120 of file MechanicalContactConstraint.h.

Referenced by gapOffset().

◆ _Ken

DenseMatrix<Number> MechanicalContactConstraint::_Ken

protected

Definition at line 155 of file MechanicalContactConstraint.h.

Referenced by computeJacobian(), and computeOffDiagJacobian().

◆ _Knn

DenseMatrix<Number> MechanicalContactConstraint::_Knn

protected

Definition at line 154 of file MechanicalContactConstraint.h.

Referenced by computeJacobian(), and computeOffDiagJacobian().

◆ _lagrangian_iteration_number

const unsigned int& MechanicalContactConstraint::_lagrangian_iteration_number

protected

Definition at line 152 of file MechanicalContactConstraint.h.

Referenced by getPenalty(), and getTangentialPenalty().

◆ _mapped_primary_gap_offset_var

const MooseVariable* const MechanicalContactConstraint::_mapped_primary_gap_offset_var

protected

Definition at line 123 of file MechanicalContactConstraint.h.

Referenced by gapOffset().

◆ _mesh_dimension

const unsigned int MechanicalContactConstraint::_mesh_dimension

protected

Definition at line 114 of file MechanicalContactConstraint.h.

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

◆ _model

const ContactModel MechanicalContactConstraint::_model

protected

Definition at line 97 of file MechanicalContactConstraint.h.

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

◆ _no_iterations

const unsigned int MechanicalContactConstraint::_no_iterations = 0

staticprotected

Definition at line 151 of file MechanicalContactConstraint.h.

◆ _nodal_area_var

MooseVariable* MechanicalContactConstraint::_nodal_area_var

protected

Definition at line 125 of file MechanicalContactConstraint.h.

Referenced by nodalArea().

◆ _non_displacement_vars_jacobian

const bool MechanicalContactConstraint::_non_displacement_vars_jacobian

protected

Whether to include coupling terms with non-displacement variables in the Jacobian.

Definition at line 134 of file MechanicalContactConstraint.h.

Referenced by getConnectedDofIndices().

◆ _normalize_penalty

const bool MechanicalContactConstraint::_normalize_penalty

protected

Definition at line 99 of file MechanicalContactConstraint.h.

Referenced by getPenalty(), and getTangentialPenalty().

◆ _old_contact_state

std::set<dof_id_type> MechanicalContactConstraint::_old_contact_state

protected

Definition at line 145 of file MechanicalContactConstraint.h.

Referenced by residualEnd().

◆ _penalty

const Real MechanicalContactConstraint::_penalty

protected

Definition at line 101 of file MechanicalContactConstraint.h.

Referenced by getPenalty(), and MechanicalContactConstraint().

◆ _penalty_multiplier

const Real MechanicalContactConstraint::_penalty_multiplier

protected

Definition at line 102 of file MechanicalContactConstraint.h.

Referenced by getPenalty(), and getTangentialPenalty().

◆ _penalty_tangential

Real MechanicalContactConstraint::_penalty_tangential

protected

Definition at line 103 of file MechanicalContactConstraint.h.

Referenced by getTangentialPenalty(), and MechanicalContactConstraint().

◆ _primary_secondary_jacobian

const bool MechanicalContactConstraint::_primary_secondary_jacobian

protected

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

Definition at line 130 of file MechanicalContactConstraint.h.

Referenced by addCouplingEntriesToJacobian(), computeJacobian(), computeOffDiagJacobian(), and getConnectedDofIndices().

◆ _print_contact_nodes

const bool MechanicalContactConstraint::_print_contact_nodes

protected

Definition at line 147 of file MechanicalContactConstraint.h.

Referenced by residualEnd().

◆ _residual_copy

NumericVector<Number>& MechanicalContactConstraint::_residual_copy

protected

Definition at line 111 of file MechanicalContactConstraint.h.

Referenced by computeContactForce().

◆ _secondary_gap_offset_var

const MooseVariable* const MechanicalContactConstraint::_secondary_gap_offset_var

protected

Definition at line 121 of file MechanicalContactConstraint.h.

Referenced by gapOffset().

◆ _stick_lock_iterations

const unsigned int MechanicalContactConstraint::_stick_lock_iterations

protected

Definition at line 107 of file MechanicalContactConstraint.h.

Referenced by computeContactForce().

◆ _stick_unlock_factor

const Real MechanicalContactConstraint::_stick_unlock_factor

protected

Definition at line 108 of file MechanicalContactConstraint.h.

Referenced by computeContactForce().

◆ _tension_release

const Real MechanicalContactConstraint::_tension_release

protected

Definition at line 105 of file MechanicalContactConstraint.h.

Referenced by computeContactForce().

◆ _update_stateful_data

bool MechanicalContactConstraint::_update_stateful_data

protected

Definition at line 109 of file MechanicalContactConstraint.h.

Referenced by jacobianSetup(), and timestepSetup().

◆ _var_objects

std::vector<MooseVariable *> MechanicalContactConstraint::_var_objects

protected

Definition at line 117 of file MechanicalContactConstraint.h.

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

◆ _vars

std::vector<unsigned int> MechanicalContactConstraint::_vars

protected

Definition at line 116 of file MechanicalContactConstraint.h.

Referenced by AugmentedLagrangianContactConverged(), computeContactForce(), computeQpJacobian(), computeQpOffDiagJacobian(), getCoupledVarComponent(), MechanicalContactConstraint(), updateAugmentedLagrangianMultiplier(), and updateContactStatefulData().

The documentation for this class was generated from the following files:

contact/include/constraints/MechanicalContactConstraint.h
contact/src/constraints/MechanicalContactConstraint.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ MechanicalContactConstraint()

Member Function Documentation

◆ addCouplingEntriesToJacobian()

◆ AugmentedLagrangianContactConverged()

◆ computeContactForce()

◆ computeJacobian()

◆ computeOffDiagJacobian()

◆ computeQpJacobian()

◆ computeQpOffDiagJacobian()

◆ computeQpResidual()

◆ computeQpSecondaryValue()

◆ gapOffset()

◆ getConnectedDofIndices()

◆ getCoupledVarComponent()

◆ getPenalty()

◆ getTangentialPenalty()

◆ jacobianSetup()

◆ nodalArea()

◆ residualEnd()

◆ shouldApply()

◆ timestepSetup()

◆ updateAugmentedLagrangianMultiplier()

◆ updateContactStatefulData()

◆ validParams()

Member Data Documentation

◆ _al_frictional_force_tolerance

◆ _al_incremental_slip_tolerance

◆ _al_penetration_tolerance

◆ _augmented_lagrange_problem

◆ _aux_solution

◆ _aux_system

◆ _capture_tolerance

◆ _component

◆ _connected_secondary_nodes_jacobian

◆ _contact_linesearch

◆ _contact_set_mutex

◆ _current_contact_state

◆ _displaced_problem

◆ _formulation

◆ _friction_coefficient

◆ _has_mapped_primary_gap_offset

◆ _has_secondary_gap_offset

◆ _Ken

◆ _Knn

◆ _lagrangian_iteration_number

◆ _mapped_primary_gap_offset_var

◆ _mesh_dimension

◆ _model

◆ _no_iterations

◆ _nodal_area_var

◆ _non_displacement_vars_jacobian

◆ _normalize_penalty

◆ _old_contact_state

◆ _penalty

◆ _penalty_multiplier

◆ _penalty_tangential

◆ _primary_secondary_jacobian

◆ _print_contact_nodes

◆ _residual_copy

◆ _secondary_gap_offset_var

◆ _stick_lock_iterations

◆ _stick_unlock_factor

◆ _tension_release

◆ _update_stateful_data

◆ _var_objects

◆ _vars