Kernel that implements the stress tensor and advection terms for the momentum equation. More...

#include <LinearWCNSFVMomentumFlux.h>

Inheritance diagram for LinearWCNSFVMomentumFlux:

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

typedef DataFileName	DataFileParameterType

Public Member Functions
	LinearWCNSFVMomentumFlux (const InputParameters &params)
	Class constructor. More...

virtual Real	computeElemMatrixContribution () override

virtual Real	computeNeighborMatrixContribution () override

virtual Real	computeElemRightHandSideContribution () override

virtual Real	computeNeighborRightHandSideContribution () override

virtual Real	computeBoundaryMatrixContribution (const LinearFVBoundaryCondition &bc) override

virtual Real	computeBoundaryRHSContribution (const LinearFVBoundaryCondition &bc) override

virtual void	setupFaceData (const FaceInfo *face_info) override
	Set the current FaceInfo object. More...

virtual void	addMatrixContribution () override

virtual void	addRightHandSideContribution () override

virtual bool	hasFaceSide (const FaceInfo &fi, bool fi_elem_side) const override

void	setCurrentFaceArea (const Real area)

virtual Real	computeBoundaryFlux (const LinearFVBoundaryCondition &bc)

virtual const MooseLinearVariableFV< Real > &	variable () const override

void	linkTaggedVectorsAndMatrices (const std::set< TagID > &vector_tags, const std::set< TagID > &matrix_tags)

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	timestepSetup ()

virtual void	jacobianSetup ()

virtual void	residualSetup ()

virtual void	subdomainSetup ()

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

const std::vector< SubdomainName > &	blocks () const

unsigned int	numBlocks () const

virtual const std::set< SubdomainID > &	blockIDs () const

unsigned int	blocksMaxDimension () const

bool	hasBlocks (const SubdomainName &name) const

bool	hasBlocks (const std::vector< SubdomainName > &names) const

bool	hasBlocks (const std::set< SubdomainName > &names) const

bool	hasBlocks (SubdomainID id) const

bool	hasBlocks (const std::vector< SubdomainID > &ids) const

bool	hasBlocks (const std::set< SubdomainID > &ids) const

bool	isBlockSubset (const std::set< SubdomainID > &ids) const

bool	isBlockSubset (const std::vector< SubdomainID > &ids) const

bool	hasBlockMaterialProperty (const std::string &prop_name)

const std::set< SubdomainID > &	meshBlockIDs () const

virtual bool	blockRestricted () const

virtual void	checkVariable (const MooseVariableFieldBase &variable) const

MooseVariableBase *	mooseVariableBase () const

MooseVariableField< Real > &	mooseVariableField ()

MooseVariableFE< Real > *	mooseVariable () const

MooseVariableFV< Real > *	mooseVariableFV () const

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

Moose::FaceArg	makeFace (const FaceInfo &fi, const Moose::FV::LimiterType limiter_type, const bool elem_is_upwind, const bool correct_skewness=false, const Moose::StateArg *state_limiter=nullptr) const

Moose::FaceArg	makeCDFace (const FaceInfo &fi, const bool correct_skewness=false) 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

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

const FVFaceInterpolationMethod &	getFVFaceInterpolationMethod (const InterpolationMethodName &name) const

const FVAdvectedInterpolationMethod &	getFVAdvectedInterpolationMethod (const InterpolationMethodName &name) const

bool	hasFVInterpolationMethod (const InterpolationMethodName &name) 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)

static std::string	deduceFunctorName (const std::string &name, const InputParameters &params)

static void	setRMParamsAdvection (const InputParameters &obj_params, InputParameters &rm_params, const unsigned short conditional_extended_layers)

static void	setRMParamsDiffusion (const InputParameters &obj_params, InputParameters &rm_params, const unsigned short conditional_extended_layers)

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	computeInternalAdvectionElemMatrixContribution ()
	Computes the matrix contribution of the advective flux on the element side of current face when the face is an internal face (doesn't have associated boundary conditions). More...

Real	computeInternalAdvectionNeighborMatrixContribution ()
	Computes the matrix contribution of the advective flux on the neighbor side of current face when the face is an internal face (doesn't have associated boundary conditions). More...

Real	computeInternalStressMatrixContribution ()
	Computes the matrix contribution of the stress term on the current face when the face is an internal face (doesn't have associated boundary conditions). More...

Real	computeInternalStressRHSContribution ()
	Computes the right hand side contribution of the stress term on the current face when the face is an internal face (doesn't have associated boundary conditions). More...

Real	computeStressBoundaryMatrixContribution (const LinearFVAdvectionDiffusionBC *bc)
	Computes the matrix contributions of the boundary conditions resulting from the stress tensor. More...

Real	computeStressBoundaryRHSContribution (const LinearFVAdvectionDiffusionBC *bc)
	Computes the right hand side contributions of the boundary conditions resulting from the stress tensor. More...

Real	computeAdvectionBoundaryMatrixContribution (const LinearFVAdvectionDiffusionBC *bc)
	Computes the matrix contributions of the boundary conditions resulting from the advection term. More...

Real	computeAdvectionBoundaryRHSContribution (const LinearFVAdvectionDiffusionBC *bc)
	Computes the right hand side contributions of the boundary conditions resulting from the advection term. More...

const MooseLinearVariableFVReal &	velocityVar (unsigned int dir) const
	Helper to access the velocity variable for a given direction. More...

std::string	deduceFunctorName (const std::string &name) const

Moose::FaceArg	singleSidedFaceArg (const FaceInfo *fi, Moose::FV::LimiterType limiter_type=Moose::FV::LimiterType::CentralDifference, bool correct_skewness=false) const

void	requestVariableCellGradient (const std::string &variable_name)

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	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 bool	hasBlockMaterialPropertyHelper (const std::string &prop_name)

void	initializeBlockRestrictable (const MooseObject *moose_object)

void	initializeKokkosBlockRestrictable ()

Moose::CoordinateSystemType	getBlockCoordSystem ()

KOKKOS_FUNCTION dof_id_type	numKokkosBlockElements () const

KOKKOS_FUNCTION dof_id_type	numKokkosBlockNodes () const

KOKKOS_FUNCTION dof_id_type	numKokkosBlockSides () const

KOKKOS_FUNCTION ContiguousElementID	kokkosBlockElementID (Moose::Kokkos::ThreadID tid) const

KOKKOS_FUNCTION ContiguousElementID	kokkosBlockNodeID (Moose::Kokkos::ThreadID tid) const

KOKKOS_FUNCTION auto	kokkosBlockElementSideID (Moose::Kokkos::ThreadID tid) const

const Moose::Functor< T > &	getFunctor (const std::string &name)

const Moose::Functor< T > &	getFunctor (const std::string &name, THREAD_ID tid)

const Moose::Functor< T > &	getFunctor (const std::string &name, SubProblem &subproblem)

const Moose::Functor< T > &	getFunctor (const std::string &name, SubProblem &subproblem, THREAD_ID tid)

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

bool	isFunctor (const std::string &name, const SubProblem &subproblem) const

Moose::ElemArg	makeElemArg (const Elem *elem, bool correct_skewnewss=false) const

void	checkFunctorSupportsSideIntegration (const std::string &name, bool qp_integration)

const Moose::Functor< T > &	getFunctorByName (const std::string &name)

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 unsigned int	_dim
	The dimension of the mesh. More...

const RhieChowMassFlux &	_mass_flux_provider
	The Rhie-Chow user object that provides us with the face velocity. More...

const Moose::Functor< Real > &	_mu
	The functor for the dynamic viscosity. More...

const bool	_use_nonorthogonal_correction
	Switch to enable/disable nonorthogonal correction in the stress term. More...

const bool	_use_deviatoric_terms
	Switch to enable/disable deviatoric parts in the stress term. More...

const FVAdvectedInterpolationMethod &	_adv_interp_method
	The interpolation method to use for the advected quantity. More...

FVAdvectedInterpolationMethod::AdvectedSystemContribution	_adv_interp_result
	Current advected interpolation contribution on the face. More...

VectorValue< Real >	_elem_grad_storage
	Reusable gradient storage used when advected interpolation requires gradients. More...

VectorValue< Real >	_neighbor_grad_storage

Real	_face_mass_flux
	Container for the mass flux on the face which will be reused in the advection term's matrix and right hand side contribution. More...

Real	_boundary_normal_factor
	Multiplier that ensures the normal of the boundary always points outwards, even in cases when the boundary is within the mesh. More...

Real	_stress_matrix_contribution
	The cached matrix contribution. More...

Real	_stress_rhs_contribution
	The cached right hand side contribution. More...

const unsigned int	_index
	Index x\|y\|z, this is mainly to handle the deviatoric parts correctly in in the stress term. More...

std::array< const MooseLinearVariableFVReal *, 3 >	_velocity_vars
	Velocity variables for each coordinate direction. More...

const Moose::CoordinateSystemType	_coord_type
	Coordinate system of the blocks this kernel operates on. More...

const unsigned int	_rz_radial_coord
	Axisymmetric radial coordinate index (only used when in RZ) More...

const FaceInfo *	_current_face_info

Real	_current_face_area

FaceInfo::VarFaceNeighbors	_current_face_type

bool	_cached_matrix_contribution

bool	_cached_rhs_contribution

const bool	_force_boundary_execution

DenseVector< dof_id_type >	_dof_indices

DenseMatrix< Real >	_matrix_contribution

DenseVector< Real >	_rhs_contribution

MooseLinearVariableFV< Real > &	_var

const unsigned int	_var_num

const unsigned int	_sys_num

FEProblemBase &	_fe_problem

SystemBase &	_sys

libMesh::LinearImplicitSystem &	_linear_system

const THREAD_ID	_tid

MooseMesh &	_mesh

std::vector< NumericVector< Number > *>	_vectors

std::vector< SparseMatrix< Number > *>	_matrices

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

SubProblem &	_subproblem

DenseVector< Number >	_local_re

DenseMatrix< Number >	_local_ke

DenseMatrix< Number >	_nonlocal_ke

const MaterialData *	_blk_material_data

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

const InputParameters &	_fvim_params

FEProblemBase &	_fvim_feproblem

const THREAD_ID	_fvim_tid

Detailed Description

Kernel that implements the stress tensor and advection terms for the momentum equation.

Definition at line 26 of file LinearWCNSFVMomentumFlux.h.

Constructor & Destructor Documentation

◆ LinearWCNSFVMomentumFlux()

LinearWCNSFVMomentumFlux::LinearWCNSFVMomentumFlux ( const InputParameters & params )

Class constructor.

Parameters

params The InputParameters for the kernel.

Definition at line 50 of file LinearWCNSFVMomentumFlux.C.

   : LinearFVFluxKernel(params),
     FVInterpolationMethodInterface(this),
     _dim(_subproblem.mesh().dimension()),
     _mass_flux_provider(getUserObject<RhieChowMassFlux>("rhie_chow_user_object")),
     _mu(getFunctor<Real>(getParam<MooseFunctorName>(NS::mu))),
     _use_nonorthogonal_correction(getParam<bool>("use_nonorthogonal_correction")),
     _use_deviatoric_terms(getParam<bool>("use_deviatoric_terms")),
     _adv_interp_method(getFVAdvectedInterpolationMethod(
         getParam<InterpolationMethodName>("advected_interp_method_name"))),
     _face_mass_flux(0.0),
     _boundary_normal_factor(1.0),
     _stress_matrix_contribution(0.0),
     _stress_rhs_contribution(0.0),
     _index(getParam<MooseEnum>("momentum_component")),
     _velocity_vars{nullptr, nullptr, nullptr},
     _coord_type(getBlockCoordSystem()),
     _rz_radial_coord(_fe_problem.mesh().getAxisymmetricRadialCoord())
 {
   // We only need gradients if the nonorthogonal correction is enabled or when we request the
   // computation of the deviatoric parts of the stress tensor.
   if (_use_nonorthogonal_correction || _use_deviatoric_terms)
     _var.computeCellGradients();
 
   if (_adv_interp_method.needsGradients())
     _var.computeCellGradients(_adv_interp_method.gradientLimiter());
 
   auto get_velocity_var = [&](const std::string & param_name)
   {
     return dynamic_cast<const MooseLinearVariableFVReal *>(
         &_fe_problem.getVariable(_tid, getParam<SolverVariableName>(param_name)));
   };
 
   _velocity_vars[0] = get_velocity_var("u");
   if (!_velocity_vars[0])
     paramError("u", "the u velocity must be a MooseLinearVariableFVReal.");
 
   if (_dim >= 2)
   {
     if (!params.isParamValid("v"))
       paramError("v", "In two or more dimensions, the v velocity must be supplied.");
     _velocity_vars[1] = get_velocity_var("v");
     if (!_velocity_vars[1])
       paramError("v",
                  "In two or more dimensions, the v velocity must be supplied and it must be a "
                  "MooseLinearVariableFVReal.");
   }
 
   if (_dim >= 3)
   {
     if (!params.isParamValid("w"))
       paramError("w", "In three-dimensions, the w velocity must be supplied.");
     _velocity_vars[2] = get_velocity_var("w");
     if (!_velocity_vars[2])
       paramError("w",
                  "In three-dimensions, the w velocity must be supplied and it must be a "
                  "MooseLinearVariableFVReal.");
   }
 }

Member Function Documentation

◆ computeAdvectionBoundaryMatrixContribution()

Real LinearWCNSFVMomentumFlux::computeAdvectionBoundaryMatrixContribution ( const LinearFVAdvectionDiffusionBC * bc )

protected

Computes the matrix contributions of the boundary conditions resulting from the advection term.

Parameters

bc	The boundary condition whose contributions should be used

Definition at line 386 of file LinearWCNSFVMomentumFlux.C.

Referenced by computeBoundaryMatrixContribution().

 {
   const auto boundary_value_matrix_contrib = bc->computeBoundaryValueMatrixContribution();
   return boundary_value_matrix_contrib * _face_mass_flux;
 }

◆ computeAdvectionBoundaryRHSContribution()

Real LinearWCNSFVMomentumFlux::computeAdvectionBoundaryRHSContribution ( const LinearFVAdvectionDiffusionBC * bc )

protected

Computes the right hand side contributions of the boundary conditions resulting from the advection term.

Parameters

bc	The boundary condition whose contributions should be used

Definition at line 394 of file LinearWCNSFVMomentumFlux.C.

Referenced by computeBoundaryRHSContribution().

 {
   const auto boundary_value_rhs_contrib = bc->computeBoundaryValueRHSContribution();
   return -boundary_value_rhs_contrib * _face_mass_flux;
 }

◆ computeBoundaryMatrixContribution()

Real LinearWCNSFVMomentumFlux::computeBoundaryMatrixContribution ( const LinearFVBoundaryCondition & bc )

overridevirtual

Implements LinearFVFluxKernel.

Definition at line 143 of file LinearWCNSFVMomentumFlux.C.

 {
   const auto * const adv_diff_bc = static_cast<const LinearFVAdvectionDiffusionBC *>(&bc);
 
   mooseAssert(adv_diff_bc, "This should be a valid BC!");
   return (computeStressBoundaryMatrixContribution(adv_diff_bc) +
           computeAdvectionBoundaryMatrixContribution(adv_diff_bc)) *
          _current_face_area;
 }

◆ computeBoundaryRHSContribution()

Real LinearWCNSFVMomentumFlux::computeBoundaryRHSContribution ( const LinearFVBoundaryCondition & bc )

overridevirtual

Implements LinearFVFluxKernel.

Definition at line 154 of file LinearWCNSFVMomentumFlux.C.

 {
   const auto * const adv_diff_bc = static_cast<const LinearFVAdvectionDiffusionBC *>(&bc);
   mooseAssert(adv_diff_bc, "This should be a valid BC!");
   return (computeStressBoundaryRHSContribution(adv_diff_bc) +
           computeAdvectionBoundaryRHSContribution(adv_diff_bc)) *
          _current_face_area;
 }

◆ computeElemMatrixContribution()

Real LinearWCNSFVMomentumFlux::computeElemMatrixContribution ( )

overridevirtual

Implements LinearFVFluxKernel.

Definition at line 111 of file LinearWCNSFVMomentumFlux.C.

 {
   return (computeInternalAdvectionElemMatrixContribution() +
           computeInternalStressMatrixContribution()) *
          _current_face_area;
 }

◆ computeElemRightHandSideContribution()

Real LinearWCNSFVMomentumFlux::computeElemRightHandSideContribution ( )

overridevirtual

Implements LinearFVFluxKernel.

Definition at line 127 of file LinearWCNSFVMomentumFlux.C.

 {
   return (computeInternalStressRHSContribution() +
           _adv_interp_result.rhs_face_value * _face_mass_flux) *
          _current_face_area;
 }

◆ computeInternalAdvectionElemMatrixContribution()

Real LinearWCNSFVMomentumFlux::computeInternalAdvectionElemMatrixContribution ( )

protected

Computes the matrix contribution of the advective flux on the element side of current face when the face is an internal face (doesn't have associated boundary conditions).

Definition at line 164 of file LinearWCNSFVMomentumFlux.C.

Referenced by computeElemMatrixContribution().

 {
   return _adv_interp_result.weights_matrix.first * _face_mass_flux;
 }

◆ computeInternalAdvectionNeighborMatrixContribution()

Real LinearWCNSFVMomentumFlux::computeInternalAdvectionNeighborMatrixContribution ( )

protected

Computes the matrix contribution of the advective flux on the neighbor side of current face when the face is an internal face (doesn't have associated boundary conditions).

Definition at line 170 of file LinearWCNSFVMomentumFlux.C.

Referenced by computeNeighborMatrixContribution().

 {
   return _adv_interp_result.weights_matrix.second * _face_mass_flux;
 }

◆ computeInternalStressMatrixContribution()

Real LinearWCNSFVMomentumFlux::computeInternalStressMatrixContribution ( )

protected

Computes the matrix contribution of the stress term on the current face when the face is an internal face (doesn't have associated boundary conditions).

Definition at line 176 of file LinearWCNSFVMomentumFlux.C.

Referenced by computeElemMatrixContribution(), and computeNeighborMatrixContribution().

 {
   // If we don't have the value yet, we compute it
   if (!_cached_matrix_contribution)
   {
     const auto face_arg = makeCDFace(*_current_face_info);
 
     // If we requested nonorthogonal correction, we use the normal component of the
     // cell to face vector.
     const auto d = _use_nonorthogonal_correction
                        ? std::abs(_current_face_info->dCN() * _current_face_info->normal())
                        : _current_face_info->dCNMag();
 
     // Cache the matrix contribution
     _stress_matrix_contribution = _mu(face_arg, determineState()) / d;
     _cached_matrix_contribution = true;
   }
 
   return _stress_matrix_contribution;
 }

◆ computeInternalStressRHSContribution()

Real LinearWCNSFVMomentumFlux::computeInternalStressRHSContribution ( )

protected

Computes the right hand side contribution of the stress term on the current face when the face is an internal face (doesn't have associated boundary conditions).

Definition at line 198 of file LinearWCNSFVMomentumFlux.C.

Referenced by computeElemRightHandSideContribution(), and computeNeighborRightHandSideContribution().

 {
   // We can have contributions to the right hand side in two occasions:
   // (1) when we use nonorthogonal correction for the normal gradients
   // (2) when we request the deviatoric parts of the stress tensor. (needed for space-dependent
   // viscosities for example)
   if (!_cached_rhs_contribution)
   {
     // scenario (1), we need to add the nonorthogonal correction. In 1D, we don't have
     // any correction so we just skip this part
     if (_dim > 1 && _use_nonorthogonal_correction)
     {
       const auto face_arg = makeCDFace(*_current_face_info);
       const auto state_arg = determineState();
 
       // Get the gradients from the adjacent cells
       const auto grad_elem = _var.gradSln(*_current_face_info->elemInfo(), state_arg);
       const auto & grad_neighbor = _var.gradSln(*_current_face_info->neighborInfo(), state_arg);
 
       // Interpolate the two gradients to the face
       const auto interp_coeffs =
           interpCoeffs(Moose::FV::InterpMethod::Average, *_current_face_info, true);
 
       const auto correction_vector =
           _current_face_info->normal() -
           1 / (_current_face_info->normal() * _current_face_info->eCN()) *
               _current_face_info->eCN();
 
       // Cache the matrix contribution
       _stress_rhs_contribution +=
           _mu(face_arg, state_arg) *
           (interp_coeffs.first * grad_elem + interp_coeffs.second * grad_neighbor) *
           correction_vector;
     }
     // scenario (2), we will have to account for the deviatoric parts of the stress tensor.
     if (_use_deviatoric_terms)
     {
       const auto state_arg = determineState();
 
       // Interpolate the two gradients to the face
       const auto interp_coeffs =
           interpCoeffs(Moose::FV::InterpMethod::Average, *_current_face_info, true);
 
       RealGradient grad_elem[3];
       RealGradient grad_neighbor[3];
       Real trace_elem = 0;
       Real trace_neighbor = 0;
       RealVectorValue deviatoric_vector_elem;
       RealVectorValue deviatoric_vector_neighbor;
 
       // Loop over every velocity component so we can form the symmetric gradient pieces
       for (const auto dir : make_range(_dim))
       {
         grad_elem[dir] = velocityVar(dir).gradSln(*_current_face_info->elemInfo(), state_arg);
         grad_neighbor[dir] =
             velocityVar(dir).gradSln(*_current_face_info->neighborInfo(), state_arg);
         trace_elem += grad_elem[dir](dir);
         trace_neighbor += grad_neighbor[dir](dir);
       }
 
       const auto face_arg = makeCDFace(*_current_face_info);
 
       if (_coord_type == Moose::CoordinateSystemType::COORD_RZ)
       {
         Real elem_value = 0.0;
         Real neighbor_value = 0.0;
         const auto & radial_var = velocityVar(_rz_radial_coord);
         elem_value = radial_var.getElemValue(*_current_face_info->elemInfo(), state_arg) /
                      _current_face_info->elemInfo()->centroid()(_rz_radial_coord);
         neighbor_value = radial_var.getElemValue(*_current_face_info->neighborInfo(), state_arg) /
                          _current_face_info->neighborInfo()->centroid()(_rz_radial_coord);
 
         trace_elem += elem_value;
         trace_neighbor += neighbor_value;
       }
 
       // Assemble the explicit transpose/trace contribution component by component
       for (const auto dir : make_range(_dim))
       {
         grad_elem[dir](dir) -= 2. / 3 * trace_elem;
         grad_neighbor[dir](dir) -= 2. / 3 * trace_neighbor;
 
         deviatoric_vector_elem(dir) = grad_elem[dir](_index);
         deviatoric_vector_neighbor(dir) = grad_neighbor[dir](_index);
       }
 
       _stress_rhs_contribution += _mu(face_arg, state_arg) *
                                   (interp_coeffs.first * deviatoric_vector_elem +
                                    interp_coeffs.second * deviatoric_vector_neighbor) *
                                   _current_face_info->normal();
     }
     _cached_rhs_contribution = true;
   }
 
   return _stress_rhs_contribution;
 }

◆ computeNeighborMatrixContribution()

Real LinearWCNSFVMomentumFlux::computeNeighborMatrixContribution ( )

overridevirtual

Implements LinearFVFluxKernel.

Definition at line 119 of file LinearWCNSFVMomentumFlux.C.

 {
   return (computeInternalAdvectionNeighborMatrixContribution() -
           computeInternalStressMatrixContribution()) *
          _current_face_area;
 }

◆ computeNeighborRightHandSideContribution()

Real LinearWCNSFVMomentumFlux::computeNeighborRightHandSideContribution ( )

overridevirtual

Implements LinearFVFluxKernel.

Definition at line 135 of file LinearWCNSFVMomentumFlux.C.

 {
   return -(computeInternalStressRHSContribution() +
            _adv_interp_result.rhs_face_value * _face_mass_flux) *
          _current_face_area;
 }

◆ computeStressBoundaryMatrixContribution()

Real LinearWCNSFVMomentumFlux::computeStressBoundaryMatrixContribution ( const LinearFVAdvectionDiffusionBC * bc )

protected

Computes the matrix contributions of the boundary conditions resulting from the stress tensor.

Parameters

bc	The boundary condition whose contributions should be used

Definition at line 296 of file LinearWCNSFVMomentumFlux.C.

Referenced by computeBoundaryMatrixContribution().

 {
   auto grad_contrib = bc->computeBoundaryGradientMatrixContribution();
   // If the boundary condition does not include the diffusivity contribution then
   // add it here.
   if (!bc->includesMaterialPropertyMultiplier())
   {
     const auto face_arg = singleSidedFaceArg(_current_face_info);
     grad_contrib *= _mu(face_arg, determineState());
   }
 
   return grad_contrib;
 }

◆ computeStressBoundaryRHSContribution()

Real LinearWCNSFVMomentumFlux::computeStressBoundaryRHSContribution ( const LinearFVAdvectionDiffusionBC * bc )

protected

Computes the right hand side contributions of the boundary conditions resulting from the stress tensor.

Parameters

bc	The boundary condition whose contributions should be used

Definition at line 312 of file LinearWCNSFVMomentumFlux.C.

Referenced by computeBoundaryRHSContribution().

 {
   const auto face_arg = singleSidedFaceArg(_current_face_info);
   auto grad_contrib = bc->computeBoundaryGradientRHSContribution();
   // If the boundary condition does not include the diffusivity contribution then
   // add it here.
   if (!bc->includesMaterialPropertyMultiplier())
     grad_contrib *= _mu(face_arg, determineState());
 
   // We add the nonorthogonal corrector for the face here. Potential idea: we could do
   // this in the boundary condition too. For now, however, we keep it like this.
   if (_use_nonorthogonal_correction && bc->useBoundaryGradientExtrapolation())
   {
     // We support internal boundaries as well. In that case we have to decide on which side
     // of the boundary we are on.
     const auto elem_info = (_current_face_type == FaceInfo::VarFaceNeighbors::ELEM)
                                ? _current_face_info->elemInfo()
                                : _current_face_info->neighborInfo();
 
     // Unit vector to the boundary. Unfortunately, we have to recompute it because the value
     // stored in the face info is only correct for external boundaries
     const auto e_Cf = _current_face_info->faceCentroid() - elem_info->centroid();
     const auto correction_vector =
         _current_face_info->normal() - 1 / (_current_face_info->normal() * e_Cf) * e_Cf;
 
     const auto state_arg = determineState();
     grad_contrib += _mu(face_arg, state_arg) * _var.gradSln(*elem_info, state_arg) *
                     _boundary_normal_factor * correction_vector;
   }
 
   if (_use_deviatoric_terms && bc->useBoundaryGradientExtrapolation())
   {
     // We might be on a face which is an internal boundary so we want to make sure we
     // get the gradient from the right side.
     const auto elem_info = (_current_face_type == FaceInfo::VarFaceNeighbors::ELEM)
                                ? _current_face_info->elemInfo()
                                : _current_face_info->neighborInfo();
 
     const auto state_arg = determineState();
 
     RealGradient grad_elem[3];
     Real trace_elem = 0;
     RealVectorValue deviatoric_vector_elem;
 
     for (const auto dir : make_range(_dim))
     {
       grad_elem[dir] = velocityVar(dir).gradSln(*elem_info, state_arg);
       trace_elem += grad_elem[dir](dir);
     }
 
     if (_coord_type == Moose::CoordinateSystemType::COORD_RZ)
     {
       const auto & radial_var = velocityVar(_rz_radial_coord);
       const Real elem_value =
           radial_var.getElemValue(*elem_info, state_arg) / elem_info->centroid()(_rz_radial_coord);
       trace_elem += elem_value;
     }
 
     for (const auto dir : make_range(_dim))
     {
       grad_elem[dir](dir) -= 2. / 3 * trace_elem;
       deviatoric_vector_elem(dir) = grad_elem[dir](_index);
     }
 
     // We support internal boundaries too so we have to make sure the normal points always outward
     grad_contrib += _mu(face_arg, state_arg) * deviatoric_vector_elem * _boundary_normal_factor *
                     _current_face_info->normal();
   }
 
   return grad_contrib;
 }

◆ setupFaceData()

void LinearWCNSFVMomentumFlux::setupFaceData ( const FaceInfo * face_info )

overridevirtual

Set the current FaceInfo object.

We override this here to make sure the face velocity evaluation happens only once and that it can be reused for the matrix and right hand side contributions.

Parameters

face_info The face info which will be used as current face info

Reimplemented from LinearFVFluxKernel.

Definition at line 402 of file LinearWCNSFVMomentumFlux.C.

 {
   LinearFVFluxKernel::setupFaceData(face_info);
 
   // Multiplier that ensures the normal of the boundary always points outwards, even in cases
   // when the boundary is within the mesh.
   _boundary_normal_factor = (_current_face_type == FaceInfo::VarFaceNeighbors::ELEM) ? 1.0 : -1.0;
 
   // Caching the mass flux on the face which will be reused in the advection term's matrix and
   // right hand side contributions
   _face_mass_flux = _mass_flux_provider.getMassFlux(*face_info);
 
   if (_current_face_type == FaceInfo::VarFaceNeighbors::BOTH)
   {
     const auto state = determineState();
     const auto & elem_info = *_current_face_info->elemInfo();
     const auto & neighbor_info = *_current_face_info->neighborInfo();
 
     const Real elem_value = _var.getElemValue(elem_info, state);
     const Real neighbor_value = _var.getElemValue(neighbor_info, state);
 
     if (_adv_interp_method.needsGradients())
     {
       const auto limiter_type = _adv_interp_method.gradientLimiter();
       _elem_grad_storage = _var.gradSln(elem_info, state, limiter_type);
       _neighbor_grad_storage = _var.gradSln(neighbor_info, state, limiter_type);
     }
 
     _adv_interp_result = _adv_interp_method.advectedInterpolate(*_current_face_info,
                                                                 elem_value,
                                                                 neighbor_value,
                                                                 &_elem_grad_storage,
                                                                 &_neighbor_grad_storage,
                                                                 _face_mass_flux);
   }
 
   // We'll have to set this to zero to make sure that we don't accumulate values over multiple
   // faces. The matrix contribution should be fine.
   _stress_rhs_contribution = 0;
 }

◆ validParams()

InputParameters LinearWCNSFVMomentumFlux::validParams ( )

static

Definition at line 20 of file LinearWCNSFVMomentumFlux.C.

 {
   InputParameters params = LinearFVFluxKernel::validParams();
   params.addClassDescription("Represents the matrix and right hand side contributions of the "
                              "stress and advection terms of the momentum equation.");
   params.addRequiredParam<SolverVariableName>("u", "The velocity in the x direction.");
   params.addParam<SolverVariableName>("v", "The velocity in the y direction.");
   params.addParam<SolverVariableName>("w", "The velocity in the z direction.");
   params.addRequiredParam<UserObjectName>(
       "rhie_chow_user_object",
       "The rhie-chow user-object which is used to determine the face velocity.");
   params.addRequiredParam<MooseFunctorName>(NS::mu, "The diffusion coefficient.");
   MooseEnum momentum_component("x=0 y=1 z=2");
   params.addRequiredParam<MooseEnum>(
       "momentum_component",
       momentum_component,
       "The component of the momentum equation that this kernel applies to.");
   params.addParam<bool>(
       "use_nonorthogonal_correction",
       true,
       "If the nonorthogonal correction should be used when computing the normal gradient.");
   params.addParam<bool>(
       "use_deviatoric_terms", false, "If deviatoric terms in the stress terms need to be used.");
 
   params.addRequiredParam<InterpolationMethodName>(
       "advected_interp_method_name",
       "Name of the FVInterpolationMethod to use for the advected velocity.");
   return params;
 }

◆ velocityVar()

const MooseLinearVariableFVReal & LinearWCNSFVMomentumFlux::velocityVar ( unsigned int dir ) const

protected

Helper to access the velocity variable for a given direction.

Definition at line 444 of file LinearWCNSFVMomentumFlux.C.

Referenced by computeInternalStressRHSContribution(), and computeStressBoundaryRHSContribution().

 {
   mooseAssert(dir < _velocity_vars.size() && _velocity_vars[dir],
               "Velocity variable for requested direction is not available.");
   return *_velocity_vars[dir];
 }