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

MooseApp &	getMooseApp () const

const std::string &	type () const

virtual const std::string &	name () const

std::string	typeAndName () const

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

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

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

const InputParameters &	parameters () const

MooseObjectName	uniqueName () const

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

virtual void	initialSetup ()

virtual void	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

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

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={})

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)

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

Static Public Member Functions
static InputParameters	validParams ()

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
const ConsoleStream	_console

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

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)

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

void	initializeBlockRestrictable (const MooseObject *moose_object)

Moose::CoordinateSystemType	getBlockCoordSystem ()

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)

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

std::pair< Real, Real >	_advected_interp_coeffs
	Container for the current advected interpolation coefficients on the face to make sure we don't compute it multiple times for different terms. More...

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

Moose::FV::InterpMethod	_advected_interp_method
	The interpolation method to use for the advected quantity. More...

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

const MooseLinearVariableFVReal *const	_u_var
	Velocity in direction x. More...

const MooseLinearVariableFVReal *const	_v_var
	Velocity in direction y. More...

const MooseLinearVariableFVReal *const	_w_var
	Velocity in direction z. 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

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

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

Detailed Description

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

Definition at line 22 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 49 of file LinearWCNSFVMomentumFlux.C.

   : LinearFVFluxKernel(params),
     _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")),
     _advected_interp_coeffs(std::make_pair<Real, Real>(0, 0)),
     _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")),
     _u_var(dynamic_cast<const MooseLinearVariableFVReal *>(
         &_fe_problem.getVariable(_tid, getParam<SolverVariableName>("u")))),
     _v_var(params.isParamValid("v")
                ? dynamic_cast<const MooseLinearVariableFVReal *>(
                      &_fe_problem.getVariable(_tid, getParam<SolverVariableName>("v")))
                : nullptr),
     _w_var(params.isParamValid("w")
                ? dynamic_cast<const MooseLinearVariableFVReal *>(
                      &_fe_problem.getVariable(_tid, getParam<SolverVariableName>("w")))
                : nullptr)
 {
   // 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();
 
   Moose::FV::setInterpolationMethod(*this, _advected_interp_method, "advected_interp_method");
 
   if (!_u_var)
     paramError("u", "the u velocity must be a MooseLinearVariableFVReal.");
 
   if (_dim >= 2 && !_v_var)
     paramError("v",
                "In two or more dimensions, the v velocity must be supplied and it must be a "
                "MooseLinearVariableFVReal.");
 
   if (_dim >= 3 && !_w_var)
     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 360 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 368 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 123 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 133 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 95 of file LinearWCNSFVMomentumFlux.C.

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

◆ computeElemRightHandSideContribution()

Real LinearWCNSFVMomentumFlux::computeElemRightHandSideContribution ( )

overridevirtual

Implements LinearFVFluxKernel.

Definition at line 111 of file LinearWCNSFVMomentumFlux.C.

 {
   return computeInternalStressRHSContribution() * _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 144 of file LinearWCNSFVMomentumFlux.C.

Referenced by computeElemMatrixContribution().

 {
   return _advected_interp_coeffs.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 150 of file LinearWCNSFVMomentumFlux.C.

Referenced by computeNeighborMatrixContribution().

 {
   return _advected_interp_coeffs.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 156 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 178 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());
       const auto & grad_neighbor = _var.gradSln(*_current_face_info->neighborInfo());
 
       // 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)
     {
       // Interpolate the two gradients to the face
       const auto interp_coeffs =
           interpCoeffs(Moose::FV::InterpMethod::Average, *_current_face_info, true);
 
       const auto u_grad_elem = _u_var->gradSln(*_current_face_info->elemInfo());
       const auto u_grad_neighbor = _u_var->gradSln(*_current_face_info->neighborInfo());
 
       Real trace_elem = 0;
       Real trace_neighbor = 0;
       RealVectorValue deviatoric_vector_elem;
       RealVectorValue deviatoric_vector_neighbor;
 
       deviatoric_vector_elem(0) = u_grad_elem(_index);
       deviatoric_vector_neighbor(0) = u_grad_neighbor(_index);
       trace_elem += u_grad_elem(0);
       trace_neighbor += u_grad_neighbor(0);
 
       const auto face_arg = makeCDFace(*_current_face_info);
       const auto state_arg = determineState();
 
       if (_dim > 1)
       {
         const auto v_grad_elem = _v_var->gradSln(*_current_face_info->elemInfo());
         const auto v_grad_neighbor = _v_var->gradSln(*_current_face_info->neighborInfo());
 
         deviatoric_vector_elem(1) = v_grad_elem(_index);
         deviatoric_vector_neighbor(1) = v_grad_neighbor(_index);
         trace_elem += v_grad_elem(1);
         trace_neighbor += v_grad_neighbor(1);
         if (_dim > 2)
         {
           const auto w_grad_elem = _w_var->gradSln(*_current_face_info->elemInfo());
           const auto w_grad_neighbor = _w_var->gradSln(*_current_face_info->neighborInfo());
 
           deviatoric_vector_elem(2) = w_grad_elem(_index);
           deviatoric_vector_neighbor(2) = w_grad_neighbor(_index);
           trace_elem += w_grad_elem(2);
           trace_neighbor += w_grad_neighbor(2);
         }
       }
       deviatoric_vector_elem(_index) -= 2 / 3 * trace_elem;
       deviatoric_vector_neighbor(_index) -= 2 / 3 * trace_neighbor;
 
       _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 103 of file LinearWCNSFVMomentumFlux.C.

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

◆ computeNeighborRightHandSideContribution()

Real LinearWCNSFVMomentumFlux::computeNeighborRightHandSideContribution ( )

overridevirtual

Implements LinearFVFluxKernel.

Definition at line 117 of file LinearWCNSFVMomentumFlux.C.

 {
   return -computeInternalStressRHSContribution() * _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 270 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 286 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)
   {
     // 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;
 
     grad_contrib += _mu(face_arg, determineState()) * _var.gradSln(*elem_info) *
                     _boundary_normal_factor * correction_vector;
   }
 
   if (_use_deviatoric_terms)
   {
     // 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 u_grad_elem = _u_var->gradSln(*elem_info);
 
     Real trace_elem = 0;
     RealVectorValue frace_grad_approx;
 
     trace_elem += u_grad_elem(0);
     frace_grad_approx(0) = u_grad_elem(_index);
 
     const auto state_arg = determineState();
 
     if (_dim > 1)
     {
       const auto v_grad_elem = _v_var->gradSln(*elem_info);
       trace_elem += v_grad_elem(1);
       frace_grad_approx(1) = v_grad_elem(_index);
 
       if (_dim > 2)
       {
         const auto w_grad_elem = _w_var->gradSln(*elem_info);
         trace_elem += w_grad_elem(2);
         frace_grad_approx(2) = w_grad_elem(_index);
       }
     }
 
     frace_grad_approx(_index) -= 2 / 3 * trace_elem;
 
     // We support internal boundaries too so we have to make sure the normal points always outward
     grad_contrib += _mu(face_arg, state_arg) * frace_grad_approx * _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 376 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);
 
   // Caching the interpolation coefficients so they will be reused for the matrix and right hand
   // side terms
   _advected_interp_coeffs =
       interpCoeffs(_advected_interp_method, *_current_face_info, true, _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 21 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 += Moose::FV::advectedInterpolationParameter();
   return params;
 }