#include <RANFSNormalMechanicalContact.h>

Inheritance diagram for RANFSNormalMechanicalContact:

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

typedef DataFileName	DataFileParameterType

Public Member Functions
	RANFSNormalMechanicalContact (const InputParameters &parameters)

bool	shouldApply () override

void	residualSetup () override

void	timestepSetup () override

void	initialSetup () override

bool	overwriteSecondaryResidual () override

void	computeSecondaryValue (NumericVector< Number > &solution) override

virtual void	computeResidual () override

virtual void	computeJacobian () override

virtual void	computeOffDiagJacobian (unsigned int jvar) override

virtual void	getConnectedDofIndices (unsigned int var_num)

virtual bool	overwriteSecondaryJacobian ()

virtual MooseVariable &	primaryVariable ()

BoundaryID	primaryBoundary () const

BoundaryID	secondaryBoundary () const

const MooseVariable &	variable () const override

Real	secondaryResidual () const

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 bool	addCouplingEntriesToJacobian ()

virtual void	subdomainSetup () override final

virtual void	residualEnd ()

void	prepareNeighborShapes (unsigned int var_num)

virtual void	computeResidualAndJacobian ()

virtual void	computeOffDiagJacobianScalar (unsigned int)

virtual void	computeNonlocalJacobian ()

virtual void	computeNonlocalOffDiagJacobian (unsigned int)

const SubProblem &	subProblem () const

virtual void	prepareShapes (unsigned int var_num)

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

virtual bool	enabled () const

std::shared_ptr< MooseObject >	getSharedPtr ()

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

MooseApp &	getMooseApp () const

const std::string &	type () const

virtual const std::string &	name () const

std::string	typeAndName () const

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

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

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

const InputParameters &	parameters () const

MooseObjectName	uniqueName () const

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

virtual void	jacobianSetup ()

virtual void	customSetup (const ExecFlagType &)

const ExecFlagEnum &	getExecuteOnEnum () const

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

const Function &	getFunctionByName (const FunctionName &name) const

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

bool	hasFunctionByName (const FunctionName &name) const

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

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

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

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

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

bool	isImplicit ()

Moose::StateArg	determineState () const

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

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

bool	hasPostprocessorByName (const PostprocessorName &name) const

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

bool	hasVectorPostprocessorByName (const VectorPostprocessorName &name) const

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

void	setRandomResetFrequency (ExecFlagType exec_flag)

unsigned long	getRandomLong () const

Real	getRandomReal () const

unsigned int	getSeed (std::size_t id)

unsigned int	getMasterSeed () const

bool	isNodal () const

ExecFlagType	getResetOnTime () const

void	setRandomDataPointer (RandomData *random_data)

virtual void	meshChanged ()

void	useVectorTag (const TagName &tag_name, VectorTagsKey)

void	useVectorTag (TagID tag_id, VectorTagsKey)

void	useMatrixTag (const TagName &tag_name, MatrixTagsKey)

void	useMatrixTag (TagID tag_id, MatrixTagsKey)

bool	isVectorTagged ()

bool	isMatrixTagged ()

bool	hasVectorTags () const

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void	addFEVariableCoupleableVectorTag (TagID tag)

void	addFEVariableCoupleableMatrixTag (TagID tag)

std::set< TagID > &	getFEVariableCoupleableVectorTags ()

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

std::set< TagID > &	getFEVariableCoupleableMatrixTags ()

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

auto &	getWritableCoupledVariables () const

bool	hasWritableCoupledVariables () const

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

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

const ADVariableGradient &	getADDefaultGradient () const

const ADVectorVariableGradient &	getADDefaultVectorGradient () const

const ADVariableSecond &	getADDefaultSecond () const

const ADVectorVariableCurl &	getADDefaultCurl () const

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

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

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

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

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

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

void	addMooseVariableDependency (MooseVariableFieldBase *var)

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

MooseVariableBase *	mooseVariableBase () const

MooseVariableField< Real > &	mooseVariableField ()

MooseVariableFE< Real > *	mooseVariable () const

MooseVariableFV< Real > *	mooseVariableFV () const

MooseLinearVariableFV< Real > *	mooseLinearVariableFV () const

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

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

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

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

bool	hasUserObjectByName (const UserObjectName &object_name) const

bool	hasUserObjectByName (const UserObjectName &object_name) const

bool	hasUserObjectByName (const UserObjectName &object_name) const

bool	hasUserObjectByName (const UserObjectName &object_name) const

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

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

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

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

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

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

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

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

const PostprocessorValue &	getPostprocessorValueOldByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOldByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOlderByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOlderByName (const PostprocessorName &name) const

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

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

bool	isVectorPostprocessorDistributedByName (const VectorPostprocessorName &name) const

bool	isVectorPostprocessorDistributedByName (const VectorPostprocessorName &name) const

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

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

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

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

bool	requiresGeometricSearch () const

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Static Public Member Functions
static InputParameters	validParams ()

Public Attributes
const ConsoleStream	_console

Protected Member Functions
virtual Real	computeQpSecondaryValue () override

virtual Real	computeQpResidual (Moose::ConstraintType type) override

virtual Real	computeQpJacobian (Moose::ConstraintJacobianType type) override

virtual Real	computeQpOffDiagJacobian (Moose::ConstraintJacobianType, unsigned int)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

virtual void	precalculateResidual ()

virtual void	precalculateJacobian ()

virtual void	precalculateOffDiagJacobian (unsigned int)

const MooseVariableFieldBase &	getVariable (unsigned int jvar_num) const

virtual void	addUserObjectDependencyHelper (const UserObject &) const

virtual void	addPostprocessorDependencyHelper (const PostprocessorName &) const

virtual void	addVectorPostprocessorDependencyHelper (const VectorPostprocessorName &) const

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

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

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

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

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

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

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

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

void	prepareVectorTag (Assembly &assembly, unsigned int ivar)

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

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

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

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

void	prepareVectorTagNeighbor (Assembly &assembly, unsigned int ivar)

void	prepareVectorTagLower (Assembly &assembly, unsigned int ivar)

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

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

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

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

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

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

void	accumulateTaggedLocalResidual ()

void	assignTaggedLocalResidual ()

void	accumulateTaggedLocalMatrix ()

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

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

void	accumulateTaggedNonlocalMatrix ()

void	assignTaggedLocalMatrix ()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void	setResidual (SystemBase &sys, SetResidualFunctor set_residual_functor)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void	checkWritableVar (MooseWritableVariable *var)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

const ADVariableValue &	adZeroValue () const

const ADVariableGradient &	adZeroGradient () const

const ADVariableSecond &	adZeroSecond () const

const GenericVariableValue< is_ad > &	genericZeroValue ()

const GenericVariableValue< false > &	genericZeroValue ()

const GenericVariableValue< true > &	genericZeroValue ()

const GenericVariableGradient< is_ad > &	genericZeroGradient ()

const GenericVariableGradient< false > &	genericZeroGradient ()

const GenericVariableGradient< true > &	genericZeroGradient ()

const GenericVariableSecond< is_ad > &	genericZeroSecond ()

const GenericVariableSecond< false > &	genericZeroSecond ()

const GenericVariableSecond< true > &	genericZeroSecond ()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

const VectorVariableValue &	neighborValue ()

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

const VectorVariableValue &	neighborValueOld ()

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

const VectorVariableValue &	neighborValueOlder ()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

virtual const VariableValue &	dotDu ()

virtual const VariableValue &	dotDotDu ()

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

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

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

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

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

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

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

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

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

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

Protected Attributes
const MooseEnum	_component

const unsigned int	_mesh_dimension

NumericVector< Number > &	_residual_copy

unsigned int	_largest_component

std::vector< unsigned int >	_vars

std::vector< MooseVariable * >	_var_objects

std::unordered_map< dof_id_type, Real >	_node_to_contact_lm

std::unordered_map< dof_id_type, Real >	_node_to_tied_lm

std::unordered_map< dof_id_type, std::vector< const Elem * > >	_node_to_primary_elem_sequence

Real	_contact_lm

Real	_tied_lm

PenetrationInfo *	_pinfo

std::unordered_map< dof_id_type, const Node * >	_ping_pong_secondary_node_to_primary_node

Real	_distance

bool	_tie_nodes

unsigned int	_primary_index

RealVectorValue	_res_vec

const Node *	_nearest_node

std::vector< std::unordered_map< dof_id_type, Number > >	_dof_number_to_value

CouplingMatrix	_disp_coupling

const bool	_ping_pong_protection

const SparseMatrix< Number > *	_jacobian

BoundaryID	_secondary

BoundaryID	_primary

MooseVariable &	_var

const MooseArray< Point > &	_primary_q_point

const QBase *const &	_primary_qrule

std::set< BoundaryID >	_boundary_ids

PenetrationLocator &	_penetration_locator

const Node *const &	_current_node

const Elem *const &	_current_primary

const VariableValue &	_u_secondary

VariablePhiValue	_phi_secondary

VariableTestValue	_test_secondary

MooseVariable &	_primary_var

unsigned int	_primary_var_num

const VariablePhiValue &	_phi_primary

const VariablePhiGradient &	_grad_phi_primary

const VariableTestValue &	_test_primary

const VariableTestGradient &	_grad_test_primary

const VariableValue &	_u_primary

const VariableGradient &	_grad_u_primary

const DofMap &	_dof_map

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

bool	_overwrite_secondary_residual

const MooseArray< Real > &	_primary_JxW

bool	_secondary_residual_computed

Real	_secondary_residual

const std::unordered_set< unsigned int >	_empty_mat_prop_deps

std::vector< dof_id_type >	_connected_dof_indices

DenseMatrix< Number >	_Kne

DenseMatrix< Number >	_Kee

DenseMatrix< Number >	_Ken

unsigned int	_i

unsigned int	_j

unsigned int	_qp

SubProblem &	_subproblem

FEProblemBase &	_fe_problem

SystemBase &	_sys

THREAD_ID	_tid

Assembly &	_assembly

MooseMesh &	_mesh

const bool &	_enabled

MooseApp &	_app

const std::string	_type

const std::string	_name

const InputParameters &	_pars

Factory &	_factory

ActionFactory &	_action_factory

const ExecFlagEnum &	_execute_enum

const ExecFlagType &	_current_execute_flag

const InputParameters &	_ti_params

FEProblemBase &	_ti_feproblem

bool	_is_implicit

Real &	_t

const Real &	_t_old

int &	_t_step

Real &	_dt

Real &	_dt_old

bool	_is_transient

MooseApp &	_restartable_app

const std::string	_restartable_system_name

const THREAD_ID	_restartable_tid

const bool	_restartable_read_only

FEProblemBase &	_mci_feproblem

DenseVector< Number >	_local_re

DenseMatrix< Number >	_local_ke

DenseMatrix< Number >	_nonlocal_ke

GeometricSearchData &	_geometric_search_data

bool	_requires_geometric_search

bool	_neighbor_nodal

const InputParameters &	_c_parameters

const std::string &	_c_name

const std::string &	_c_type

FEProblemBase &	_c_fe_problem

const SystemBase *const	_c_sys

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

std::vector< MooseVariableFieldBase *>	_coupled_moose_vars

std::vector< MooseVariable *>	_coupled_standard_moose_vars

std::vector< VectorMooseVariable *>	_coupled_vector_moose_vars

std::vector< ArrayMooseVariable *>	_coupled_array_moose_vars

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

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

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

bool	_c_nodal

bool	_c_is_implicit

const bool	_c_allow_element_to_nodal_coupling

THREAD_ID	_c_tid

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

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

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

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

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

VariableValue	_default_value_zero

VariableGradient	_default_gradient

MooseArray< ADRealVectorValue >	_ad_default_gradient

MooseArray< ADRealTensorValue >	_ad_default_vector_gradient

VariableSecond	_default_second

MooseArray< ADRealTensorValue >	_ad_default_second

MooseArray< ADRealVectorValue >	_ad_default_curl

const VariableValue &	_zero

const VariablePhiValue &	_phi_zero

const MooseArray< ADReal > &	_ad_zero

const VariableGradient &	_grad_zero

const MooseArray< ADRealVectorValue > &	_ad_grad_zero

const VariablePhiGradient &	_grad_phi_zero

const VariableSecond &	_second_zero

const MooseArray< ADRealTensorValue > &	_ad_second_zero

const VariablePhiSecond &	_second_phi_zero

const VectorVariableValue &	_vector_zero

const VectorVariableCurl &	_vector_curl_zero

VectorVariableValue	_default_vector_value_zero

VectorVariableGradient	_default_vector_gradient

VectorVariableCurl	_default_vector_curl

VectorVariableDivergence	_default_div

ArrayVariableValue	_default_array_value_zero

ArrayVariableGradient	_default_array_gradient

bool	_coupleable_neighbor

FEProblemBase &	_sc_fe_problem

const THREAD_ID	_sc_tid

const Real &	_real_zero

const VariableValue &	_scalar_zero

const Point &	_point_zero

bool	_nodal

MooseVariableFE< Real > *	_variable

MooseVariableFV< Real > *	_fv_variable

MooseLinearVariableFV< Real > *	_linear_fv_variable

MooseVariableField< Real > *	_field_variable

Assembly *	_mvi_assembly

const Parallel::Communicator &	_communicator

Detailed Description

Definition at line 29 of file RANFSNormalMechanicalContact.h.

Constructor & Destructor Documentation

◆ RANFSNormalMechanicalContact()

RANFSNormalMechanicalContact::RANFSNormalMechanicalContact ( const InputParameters & parameters )

Definition at line 50 of file RANFSNormalMechanicalContact.C.

   : NodeFaceConstraint(parameters),
     _component(getParam<MooseEnum>("component")),
     _mesh_dimension(_mesh.dimension()),
     _residual_copy(_sys.residualGhosted()),
     _dof_number_to_value(coupledComponents("displacements")),
     _disp_coupling(coupledComponents("displacements")),
     _ping_pong_protection(getParam<bool>("ping_pong_protection"))
 {
   // modern parameter scheme for displacements
   for (unsigned int i = 0; i < coupledComponents("displacements"); ++i)
   {
     _vars.push_back(coupled("displacements", i));
     _var_objects.push_back(getVar("displacements", i));
   }
 
   for (auto & var : _var_objects)
     if (var->feType().family != LAGRANGE)
       mooseError("This object only works when the displacement variables use a Lagrange basis");
 
   if (_vars.size() != _mesh_dimension)
     mooseError("The number of displacement variables does not match the mesh dimension!");
 
   if (parameters.isParamValid("normal_smoothing_distance"))
     _penetration_locator.setNormalSmoothingDistance(getParam<Real>("normal_smoothing_distance"));
 }

Member Function Documentation

◆ computeQpJacobian()

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

overrideprotectedvirtual

Implements NodeFaceConstraint.

Definition at line 315 of file RANFSNormalMechanicalContact.C.

 {
   switch (type)
   {
     case Moose::ConstraintJacobianType::SecondarySecondary:
     {
       if (_tie_nodes)
         return _phi_secondary[_j][_qp];
 
       // doing contact
       else
       {
         // corresponds to gap equation
         if (_largest_component == static_cast<unsigned int>(_component))
           // _phi_secondary has been set such that it is 1 when _j corresponds to the degree of
           // freedom associated with the _current node and 0 otherwise
           return std::abs(_pinfo->_normal(_component)) * _phi_secondary[_j][_qp];
 
         // corresponds to regular residual with Lagrange Multiplier applied
         else
         {
           Real ret_val = 0;
           for (MooseIndex(_disp_coupling) i = 0; i < _disp_coupling.size(); ++i)
             if (_disp_coupling(_component, i))
             {
               mooseAssert(
                   _dof_number_to_value[i].find(_connected_dof_indices[_j]) !=
                       _dof_number_to_value[i].end(),
                   "The connected dof index is not found in the _dof_number_to_value container. "
                   "This must mean that insufficient sparsity was allocated");
               ret_val += -_pinfo->_normal(_component) * _pinfo->_normal(i) *
                          _dof_number_to_value[i][_connected_dof_indices[_j]];
             }
           return ret_val;
         }
       }
     }
 
     case Moose::ConstraintJacobianType::SecondaryPrimary:
     {
       if (_tie_nodes)
       {
         if (_primary_index == _j)
           return -1;
 
         // We're tying the secondary node to only one node on the primary side (specified by
         // _primary_index). If the current _j doesn't correspond to that tied primary node, then the
         // secondary residual doesn't depend on it
         else
           return 0;
       }
       else
       {
         if (_largest_component == static_cast<unsigned int>(_component))
           return -std::abs(_pinfo->_normal(_component)) * _phi_primary[_j][_qp];
 
         // If we're not applying the gap constraint equation on this _component, then we're
         // applying a Lagrange multiplier, and consequently there is no dependence of the secondary
         // residual on the primary dofs because the Lagrange multiplier is only a functon of the
         // secondary residuals
         else
           return 0;
       }
     }
 
     case Moose::ConstraintJacobianType::PrimarySecondary:
     {
       if (_tie_nodes)
       {
         if (_i == _primary_index)
         {
           mooseAssert(_dof_number_to_value[_component].find(_connected_dof_indices[_j]) !=
                           _dof_number_to_value[_component].end(),
                       "The connected dof index is not found in the _dof_number_to_value container. "
                       "This must mean that insufficient sparsity was allocated");
           return _dof_number_to_value[_component][_connected_dof_indices[_j]];
         }
 
         // We only apply the tied node Lagrange multiplier to the closest primary node
         else
           return 0;
       }
       else
       {
         Real ret_val = 0;
         for (MooseIndex(_disp_coupling) i = 0; i < _disp_coupling.size(); ++i)
           if (_disp_coupling(_component, i))
           {
             mooseAssert(
                 _dof_number_to_value[i].find(_connected_dof_indices[_j]) !=
                     _dof_number_to_value[i].end(),
                 "The connected dof index is not found in the _dof_number_to_value container. "
                 "This must mean that insufficient sparsity was allocated");
             ret_val += _test_primary[_i][_qp] * _pinfo->_normal(_component) * _pinfo->_normal(i) *
                        _dof_number_to_value[i][_connected_dof_indices[_j]];
           }
         return ret_val;
       }
     }
 
       // The only primary-primary dependence would come from the dependence of the normal and also
       // the location of the integration (quadrature) points. We assume (valid or not) that this
       // dependence is weak
       // case MooseConstraintJacobianType::PrimaryPrimary
 
     default:
       return 0;
   }
 }

◆ computeQpResidual()

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

overrideprotectedvirtual

Implements NodeFaceConstraint.

Definition at line 271 of file RANFSNormalMechanicalContact.C.

 {
   switch (type)
   {
     case Moose::ConstraintType::Secondary:
     {
       if (_tie_nodes)
         return (*_current_node - *_nearest_node)(_component);
       else
       {
         if (_largest_component == static_cast<unsigned int>(_component))
         {
           mooseAssert(_pinfo->_normal(_component) != 0,
                       "We should be selecting the largest normal component, hence it should be "
                       "impossible for this normal component to be zero");
 
           return _distance;
         }
 
         else
           // The normal points out of the primary face
           return _contact_lm * -_pinfo->_normal(_component);
       }
     }
 
     case Moose::ConstraintType::Primary:
     {
       if (_tie_nodes)
       {
         if (_i == _primary_index)
           return _tied_lm;
         else
           return 0;
       }
       else
         return _test_primary[_i][_qp] * _contact_lm * _pinfo->_normal(_component);
     }
 
     default:
       return 0;
   }
 }

◆ computeQpSecondaryValue()

Real RANFSNormalMechanicalContact::computeQpSecondaryValue ( )

overrideprotectedvirtual

Implements NodeFaceConstraint.

Definition at line 431 of file RANFSNormalMechanicalContact.C.

 {
   mooseError(
       "We overrode commputeSecondaryValue so computeQpSecondaryValue should never get called");
 }

◆ computeSecondaryValue()

void RANFSNormalMechanicalContact::computeSecondaryValue ( NumericVector< Number > & solution )

overridevirtual

Reimplemented from NodeFaceConstraint.

Definition at line 426 of file RANFSNormalMechanicalContact.C.

427 {

428 }

◆ initialSetup()

void RANFSNormalMechanicalContact::initialSetup ( )

overridevirtual

Reimplemented from NodeFaceConstraint.

Definition at line 78 of file RANFSNormalMechanicalContact.C.

 {
   auto system_coupling_matrix = _subproblem.couplingMatrix(_sys.number());
 
   for (MooseIndex(_vars) i = 0; i < _vars.size(); ++i)
     for (MooseIndex(_vars) j = 0; j < _vars.size(); ++j)
       _disp_coupling(i, j) = (*system_coupling_matrix)(_vars[i], _vars[j]);
 }

◆ overwriteSecondaryResidual()

bool RANFSNormalMechanicalContact::overwriteSecondaryResidual ( )

overridevirtual

Reimplemented from NodeFaceConstraint.

Definition at line 103 of file RANFSNormalMechanicalContact.C.

 {
   if (_tie_nodes)
     return true;
   else
     return _largest_component == static_cast<unsigned int>(_component);
 }

◆ residualSetup()

void RANFSNormalMechanicalContact::residualSetup ( )

overridevirtual

Reimplemented from NodeFaceConstraint.

Definition at line 95 of file RANFSNormalMechanicalContact.C.

 {
   _node_to_contact_lm.clear();
   _node_to_tied_lm.clear();
   NodeFaceConstraint::residualSetup();
 }

◆ shouldApply()

bool RANFSNormalMechanicalContact::shouldApply ( )

overridevirtual

Reimplemented from NodeFaceConstraint.

Definition at line 112 of file RANFSNormalMechanicalContact.C.

 {
   std::map<dof_id_type, PenetrationInfo *>::iterator found =
       _penetration_locator._penetration_info.find(_current_node->id());
   if (found != _penetration_locator._penetration_info.end())
   {
     _pinfo = found->second;
     if (_pinfo)
     {
       // We overwrite the secondary residual when constraints are active so we cannot use the
       // residual copy for determining the Lagrange multiplier when computing the Jacobian
       if (!_subproblem.currentlyComputingJacobian())
       {
         // Build up residual vector corresponding to contact forces
         _res_vec.zero();
         for (unsigned int i = 0; i < _mesh_dimension; ++i)
         {
           dof_id_type dof_number = _current_node->dof_number(0, _vars[i], 0);
           _res_vec(i) = _residual_copy(dof_number) / _var_objects[i]->scalingFactor();
         }
 
         _node_to_contact_lm.insert(std::make_pair(_current_node->id(), _res_vec * _pinfo->_normal));
         _node_to_tied_lm.insert(std::make_pair(_current_node->id(), _res_vec(_component)));
       }
       else
       {
         std::vector<dof_id_type> cols;
         std::vector<Number> values;
 
         for (auto & d_to_v : _dof_number_to_value)
           d_to_v.clear();
 
         mooseAssert(_vars.size() == _dof_number_to_value.size() &&
                         _vars.size() == _var_objects.size(),
                     "Somehow the sizes of our variable containers got out of sync");
         for (MooseIndex(_var_objects) i = 0; i < _var_objects.size(); ++i)
         {
           auto secondary_dof_number = _current_node->dof_number(0, _vars[i], 0);
 
           _jacobian->get_row(secondary_dof_number, cols, values);
           mooseAssert(cols.size() == values.size(),
                       "The size of the dof container and value container are different");
 
           for (MooseIndex(cols) j = 0; j < cols.size(); ++j)
             _dof_number_to_value[i].insert(
                 std::make_pair(cols[j], values[j] / _var_objects[i]->scalingFactor()));
         }
       }
 
       mooseAssert(_node_to_contact_lm.find(_current_node->id()) != _node_to_contact_lm.end(),
                   "The node " << _current_node->id()
                               << " should map to a contact lagrange multiplier");
       mooseAssert(_node_to_tied_lm.find(_current_node->id()) != _node_to_tied_lm.end(),
                   "The node " << _current_node->id()
                               << " should map to a tied lagrange multiplier");
       _contact_lm = _node_to_contact_lm[_current_node->id()];
       _tied_lm = _node_to_tied_lm[_current_node->id()];
 
       // Check to see whether we've locked a ping-ponging node
       if (_ping_pong_secondary_node_to_primary_node.find(_current_node->id()) ==
           _ping_pong_secondary_node_to_primary_node.end())
       {
         if (_contact_lm > -_pinfo->_distance)
         {
           // Ok, our math is telling us we should apply the constraint, but what if we are
           // ping-ponging back and forth between different primary faces?
 
           // This only works for a basic line search! Write assertion here
           if (_subproblem.computingNonlinearResid())
           {
             auto & primary_elem_sequence = _node_to_primary_elem_sequence[_current_node->id()];
             mooseAssert(
                 _current_primary == _pinfo->_elem,
                 "The current primary element and the PenetrationInfo object's element should "
                 "be the same");
             primary_elem_sequence.push_back(_pinfo->_elem);
 
             // 5 here is a heuristic choice. In testing, generally speaking, if a node ping-pongs
             // back and forth 5 times then it will ping pong indefinitely. However, if it goes 3
             // times for example, it is not guaranteed to ping-pong indefinitely and the Newton
             // iteration may naturally resolve the correct face dofs that need to be involved in the
             // constraint.
             if (_ping_pong_protection && primary_elem_sequence.size() >= 5 &&
                 _pinfo->_elem == *(primary_elem_sequence.rbegin() + 2) &&
                 _pinfo->_elem == *(primary_elem_sequence.rbegin() + 4) &&
                 _pinfo->_elem != *(primary_elem_sequence.rbegin() + 1) &&
                 *(primary_elem_sequence.rbegin() + 1) == *(primary_elem_sequence.rbegin() + 3))
             {
               // Ok we are ping-ponging. Determine the primary node
               auto primary_node =
                   _penetration_locator._nearest_node.nearestNode(_current_node->id());
 
               // Sanity checks
               mooseAssert(_pinfo->_elem->get_node_index(primary_node) != libMesh::invalid_uint,
                           "The primary node is not on the current element");
               mooseAssert((*(primary_elem_sequence.rbegin() + 1))->get_node_index(primary_node) !=
                               libMesh::invalid_uint,
                           "The primary node is not on the other ping-ponging element");
 
               _ping_pong_secondary_node_to_primary_node.insert(
                   std::make_pair(_current_node->id(), primary_node));
             }
           }
         }
         else
           // We have not locked the node into contact nor is the gap smaller than the Lagrange
           // Multiplier so we should not apply
           return false;
       }
 
       // Determine whether we're going to apply the tied node equality constraint or the contact
       // inequality constraint
       auto it = _ping_pong_secondary_node_to_primary_node.find(_current_node->id());
       if (it != _ping_pong_secondary_node_to_primary_node.end())
       {
         _tie_nodes = true;
         _nearest_node = it->second;
         _primary_index = _current_primary->get_node_index(_nearest_node);
         mooseAssert(_primary_index != libMesh::invalid_uint,
                     "nearest node not a node on the current primary element");
       }
       else
       {
         _distance = _pinfo->_distance;
         // Do this to make sure constraint equation has a positive on the diagonal
         if (_pinfo->_normal(_component) > 0)
           _distance *= -1;
         _tie_nodes = false;
 
         // The contact constraint is active -> we're going to use our linear solve to ensure that
         // the gap is driven to zero. We only have one zero-penetration constraint per node, so we
         // choose to apply the zero penetration constraint only to the displacement component with
         // the largest magnitude normal
         auto largest_component_magnitude = std::abs(_pinfo->_normal(0));
         _largest_component = 0;
         for (MooseIndex(_mesh_dimension) i = 1; i < _mesh_dimension; ++i)
         {
           auto component_magnitude = std::abs(_pinfo->_normal(i));
           if (component_magnitude > largest_component_magnitude)
           {
             largest_component_magnitude = component_magnitude;
             _largest_component = i;
           }
         }
       }
 
       return true;
     }
   }
 
   // If we're not applying the constraint then we can clear the node to primary elem sequence for
   // this node
   if (_node_to_primary_elem_sequence.find(_current_node->id()) !=
       _node_to_primary_elem_sequence.end())
     _node_to_primary_elem_sequence[_current_node->id()].clear();
   return false;
 }

◆ timestepSetup()

void RANFSNormalMechanicalContact::timestepSetup ( )

overridevirtual

Reimplemented from NodeFaceConstraint.

Definition at line 88 of file RANFSNormalMechanicalContact.C.

 {
   _node_to_primary_elem_sequence.clear();
   _ping_pong_secondary_node_to_primary_node.clear();
 }

◆ validParams()

InputParameters RANFSNormalMechanicalContact::validParams ( )

static

Definition at line 24 of file RANFSNormalMechanicalContact.C.

 {
   InputParameters params = NodeFaceConstraint::validParams();
   params.set<bool>("use_displaced_mesh") = true;
 
   MooseEnum component("x=0 y=1 z=2");
   params.addRequiredParam<MooseEnum>(
       "component", component, "The force component constraint that this object is supplying");
   params.addRequiredCoupledVar(
       "displacements",
       "The displacements appropriate for the simulation geometry and coordinate system");
   params.addParam<bool>("ping_pong_protection",
                         false,
                         "Whether to protect against ping-ponging, e.g. the oscillation of the "
                         "secondary node between two "
                         "different primary faces, by tying the secondary node to the "
                         "edge between the involved primary faces");
   params.addParam<Real>(
       "normal_smoothing_distance",
       "Distance from edge in parametric coordinates over which to smooth contact normal");
   params.addClassDescription("Applies the Reduced Active Nonlinear Function Set scheme in which "
                              "the secondary node's non-linear residual function is replaced by the "
                              "zero penetration constraint equation when the constraint is active");
   return params;
 }