Momentum flux kernel for porous equations written in superficial velocity. More...

#include <LinearPWCNSFVMomentumFlux.h>

Inheritance diagram for LinearPWCNSFVMomentumFlux:

Classes
struct	BaffleStressData
	Implicit coefficients and deferred right-hand sides of the stress on a baffle face. More...

Public Types
enum	ResidualTagType

typedef DataFileName	DataFileParameterType

Public Member Functions
	LinearPWCNSFVMomentumFlux (const InputParameters &params)
	Construct the porous momentum flux kernel.

void	addMatrixContribution () override
	Assemble the internal-face matrix with side-specific porosity scaling of advection.

Real	computeElemRightHandSideContribution () override
	Compute the element-row internal-face right-hand-side contribution.

Real	computeNeighborRightHandSideContribution () override
	Compute the neighbor-row internal-face right-hand-side contribution.

virtual Real	computeElemMatrixContribution () override

virtual Real	computeNeighborMatrixContribution () 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.

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 MooseVariableBase &variable) const

const Moose::Functor< Real > *	defaultFunctor (const std::string &name)

const Moose::Functor< ADReal > *	defaultFunctor (const std::string &name)

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	makeFace (const FunctorType &functor, 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	computeAdvectionBoundaryMatrixContribution (const LinearFVAdvectionDiffusionBC *bc) override
	Compute the boundary advection matrix contribution with local porosity scaling.

Real	computeAdvectionBoundaryRHSContribution (const LinearFVAdvectionDiffusionBC *bc) override
	Compute the boundary advection right-hand-side contribution with local porosity scaling.

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

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

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

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

Real	computeInternalStressTransmissibility () const
	Computes the implicit internal-face stress transmissibility.

Real	computeInternalStressExplicitCorrection () const
	Computes the explicit internal-face stress correction.

Real	computeCellStressExplicitCorrection (const ElemInfo &cell_info, const RealVectorValue &nonorthogonal_correction_vector) const
	Compute the explicit stress correction reconstructed from one adjacent cell.

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

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

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

const LinearFVGradientReader &	velocityGradientField (unsigned int dir) const
	Helper to access the velocity gradient field for a given direction.

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.

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

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

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

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

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

const LinearFVGradientReader *const	_advected_gradient_field
	Gradient field used by advected interpolations that require gradients.

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

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

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.

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.

Real	_stress_matrix_contribution
	The cached matrix contribution.

Real	_stress_rhs_contribution
	The cached right hand side contribution.

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

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

const LinearFVGradientReader *	_gradient_field
	Gradient field used for the kernel variable nonorthogonal correction.

std::array< const LinearFVGradientReader *, 3 >	_velocity_gradient_fields
	Gradient fields used for velocity variables in deviatoric stress terms.

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

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

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

Private Member Functions
Real	computeBaffleAdvectionExplicitCorrection (bool elem_side) const
	Compute the correction that replaces the shared advected state with the baffle face state: the upstream interstitial tangential velocity and this side's extrapolated normal velocity.

BaffleStressData	baffleStressData () const
	Compute the stress on the current baffle face, per unit face area.

bool	isClearFluidSide (bool elem_side) const
	Whether one side of the current face is clear fluid, i.e.

Real	inversePorosity (bool elem_side) const
	Return the inverse porosity on one side of the current face.

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

const Moose::Functor< Real > *	defaultFunctor (const std::string &name)

const Moose::Functor< ADReal > *	defaultFunctor (const std::string &name)

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

const Moose::FunctionBase *	getKokkosFunctionByNameHelper (const FunctionName &name) const

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

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

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

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

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

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

bool	isDefaultPostprocessorValueByName (const PostprocessorName &name) const

PostprocessorValue	getDefaultPostprocessorValueByName (const PostprocessorName &name) const

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

bool	postprocessorsAdded () const

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

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

bool	vectorPostprocessorsAdded () const

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

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

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

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

void	checkForNans () const

virtual bool	isADObject () const override

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

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

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

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

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

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

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

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

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

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

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

static void	setRMParams (const InputParameters &obj_params, InputParameters &rm_params, const unsigned short ghost_layers)

static void	parameterError (const InputParameters &obj_params, const std::string &parameter_name, const std::string &function_name, const std::string &description)

Private Attributes
const PorousRhieChowMassFlux &	_porous_mass_flux_provider
	Porous Rhie-Chow object supplying porosity and pressure-baffle data.

const ParallelParamObject &	_parent

const MooseBase &	_si_moose_base

const FEProblemBase *	_si_problem

ExecFlagEnum	_empty_execute_enum

const MooseObject &	_fni_object

const InputParameters &	_fni_params

FEProblemBase &	_fni_feproblem

const THREAD_ID	_fni_tid

const MooseObject &	_uoi_moose_object

const FEProblemBase &	_uoi_feproblem

const THREAD_ID	_uoi_tid

const std::string	_ti_name

const MooseObject &	_ppi_moose_object

const InputParameters &	_ppi_params

const FEProblemBase &	_ppi_feproblem

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

const bool	_broadcast_by_default

const MooseObject &	_vpi_moose_object

const FEProblemBase &	_vpi_feproblem

const THREAD_ID	_vpi_tid

RandomData *	_random_data

MooseRandom *	_generator

FEProblemBase &	_ri_problem

const std::string	_ri_name

unsigned int	_master_seed

bool	_is_nodal

ExecFlagType	_reset_on

const Node *const &	_curr_node

const Elem *const &	_curr_element

const RestartableDataMapName	_metaname

std::string	_restartable_name

std::set< TagID >	_vector_tags

std::set< TagID >	_abs_vector_tags

std::set< TagID >	_matrix_tags

std::set< TagID >	_non_ref_vector_tags

std::set< TagID >	_non_ref_abs_vector_tags

std::set< TagID >	_ref_vector_tags

std::set< TagID >	_ref_abs_vector_tags

const MooseObject &	_moose_object

const InputParameters &	_tag_params

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

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

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

std::vector< Real >	_absolute_residuals

std::set< SubdomainID >	_blk_ids

std::vector< SubdomainID >	_vec_ids

std::vector< SubdomainName >	_blocks

const bool	_blk_dual_restrictable

FEProblemBase *	_blk_feproblem

const MooseMesh *	_blk_mesh

const std::set< BoundaryID >	_empty_boundary_ids

const std::set< BoundaryID > &	_boundary_ids

THREAD_ID	_blk_tid

const std::string &	_blk_name

unsigned int	_blk_dim

Moose::Kokkos::Array< ContiguousElementID >	_kokkos_element_ids

Moose::Kokkos::Array< ContiguousNodeID >	_kokkos_node_ids

Moose::Kokkos::Array< Moose::Kokkos::Pair< ContiguousElementID, unsigned int > >	_kokkos_element_side_ids

const InputParameters &	_fi_params

const std::string	_fi_name

SubProblem *const	_fi_subproblem

const THREAD_ID	_fi_tid

std::vector< std::unique_ptr< Moose::Functor< Real > > >	_default_real_functors

std::vector< std::unique_ptr< Moose::Functor< ADReal > > >	_default_ad_real_functors

std::set< MooseVariableFieldBase * >	_moose_variable_dependencies

Detailed Description

Momentum flux kernel for porous equations written in superficial velocity.

The advective contribution is divided by the porosity on each side of a face. Internal baffle faces advect the upstream interstitial tangential velocity with each side's normal velocity and transmit only a shear traction that depends on which sides are clear fluid.

Definition at line 23 of file LinearPWCNSFVMomentumFlux.h.

Constructor & Destructor Documentation

◆ LinearPWCNSFVMomentumFlux()

LinearPWCNSFVMomentumFlux::LinearPWCNSFVMomentumFlux ( const InputParameters & params )

Construct the porous momentum flux kernel.

Parameters

params The input parameters for the kernel

Definition at line 27 of file LinearPWCNSFVMomentumFlux.C.

  : LinearWCNSFVMomentumFlux(params),
    _porous_mass_flux_provider(getUserObject<PorousRhieChowMassFlux>("rhie_chow_user_object"))
{
}

Member Function Documentation

◆ addMatrixContribution()

void LinearPWCNSFVMomentumFlux::addMatrixContribution ( )

overridevirtual

Assemble the internal-face matrix with side-specific porosity scaling of advection.

Reimplemented from LinearFVFluxKernel.

Definition at line 34 of file LinearPWCNSFVMomentumFlux.C.

{
  // porosity jumps are always internal to the domain
  if (_current_face_type != FaceInfo::VarFaceNeighbors::BOTH)
  {
    LinearFVFluxKernel::addMatrixContribution();
    return;
  }
 
  _dof_indices(0) = _current_face_info->elemInfo()->dofIndices()[_sys_num][_var_num];
  _dof_indices(1) = _current_face_info->neighborInfo()->dofIndices()[_sys_num][_var_num];
 
  const Real adv_elem = computeInternalAdvectionElemMatrixContribution();
  const Real adv_neighbor = computeInternalAdvectionNeighborMatrixContribution();
 
  BaffleStressData stress;
  if (_porous_mass_flux_provider.faceIsBaffle(*_current_face_info))
    stress = baffleStressData();
  else
  {
    const Real transmissibility = computeInternalStressMatrixContribution();
    stress = {transmissibility, -transmissibility, -transmissibility, transmissibility, 0.0, 0.0};
  }
 
  const Real scale_elem = inversePorosity(/*elem_side=*/true);
  const Real scale_neighbor = inversePorosity(/*elem_side=*/false);
 
  // No per-side block check is needed: the base class requires the kernel and the variable to
  // share a block restriction, so on a face with the variable on both sides both cells are in
  // this kernel's blocks.
  _matrix_contribution(0, 0) = (adv_elem * scale_elem + stress.elem_elem) * _current_face_area;
  _matrix_contribution(0, 1) =
      (adv_neighbor * scale_elem + stress.elem_neighbor) * _current_face_area;
  _matrix_contribution(1, 0) =
      (-adv_elem * scale_neighbor + stress.neighbor_elem) * _current_face_area;
  _matrix_contribution(1, 1) =
      (-adv_neighbor * scale_neighbor + stress.neighbor_neighbor) * _current_face_area;
 
  for (auto & matrix : _matrices)
    (*matrix).add_matrix(_matrix_contribution, _dof_indices.get_values());
}

◆ baffleStressData()

LinearPWCNSFVMomentumFlux::BaffleStressData LinearPWCNSFVMomentumFlux::baffleStressData ( ) const

private

Compute the stress on the current baffle face, per unit face area.

Only a shear traction is transmitted: between two clear sides with the two-point transmissibility, from a clear side against the superficial cell velocity of a porous side, and none between two porous sides.

Definition at line 166 of file LinearPWCNSFVMomentumFlux.C.

{
  const auto & fi = *_current_face_info;
  const auto & elem_info = *fi.elemInfo();
  const auto & neighbor_info = *fi.neighborInfo();
  const auto state = determineState();
  const auto & normal = fi.normal();
 
  // A side of unit porosity is clear fluid; any other side is a porous medium. The viscous
  // (Brinkman) layer on the porous side of an interface is of the order of the square root of the
  // permeability, much thinner than the cells next to a lumped interface. Clear fluid therefore
  // shears against the porous side as against a rough wall moving with the superficial velocity
  // of the porous medium at the interface, and two porous sides transmit no shear.
  const bool elem_clear = isClearFluidSide(/*elem_side=*/true);
  const bool neighbor_clear = isClearFluidSide(/*elem_side=*/false);
  if (!elem_clear && !neighbor_clear)
    return {0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
 
  // Viscosity varies continuously, so the face value serves both half-cells, as on ordinary faces.
  const Real face_viscosity = _mu(makeCDFace(fi), state);
  if (face_viscosity == 0.0)
    return {0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
 
  const auto elem_to_face = fi.faceCentroid() - elem_info.centroid();
  const auto face_to_neighbor = neighbor_info.centroid() - fi.faceCentroid();
  const Real elem_distance =
      _use_nonorthogonal_correction ? std::abs(elem_to_face * normal) : elem_to_face.norm();
  const Real neighbor_distance =
      _use_nonorthogonal_correction ? std::abs(face_to_neighbor * normal) : face_to_neighbor.norm();
 
  // The shear traction q_t = T (I - n n) (U_N,f - U_P,f) acts between the superficial face
  // velocities of the two sides. A clear side extrapolates its face velocity across its half-cell,
  // whose resistance is d_s / mu_f; a porous side adds no resistance. Hence
  //   1 / T = sum of d_s / mu_f over the clear sides,
  // which for two clear sides is the ordinary two-point transmissibility.
  Real distance = 0.0;
  if (elem_clear)
    distance += elem_distance;
  if (neighbor_clear)
    distance += neighbor_distance;
  const Real transmissibility = face_viscosity / distance;
 
  // The explicit nonorthogonal corrections c_s = grad(U)_s . (n - d_Pf,s / d_s) of each clear
  // half-cell enter the same balance as the face values.
  RealVectorValue elem_correction;
  RealVectorValue neighbor_correction;
  if (_dim > 1 && _use_nonorthogonal_correction)
  {
    const auto elem_correction_vector = normal - elem_to_face / elem_distance;
    const auto neighbor_correction_vector = normal - face_to_neighbor / neighbor_distance;
    for (const auto component : make_range(_dim))
    {
      const auto & gradient = velocityGradientField(component);
      if (elem_clear)
        elem_correction(component) = gradient.gradient(elem_info) * elem_correction_vector;
      if (neighbor_clear)
        neighbor_correction(component) =
            gradient.gradient(neighbor_info) * neighbor_correction_vector;
    }
  }
 
  RealVectorValue elem_velocity;
  RealVectorValue neighbor_velocity;
  for (const auto component : make_range(_dim))
  {
    const auto & velocity = velocityVar(component);
    elem_velocity(component) = velocity.getElemValue(elem_info, state);
    neighbor_velocity(component) = velocity.getElemValue(neighbor_info, state);
  }
 
  // A porous side's face velocity is the extrapolated face state that the baffle advection also
  // uses, so the clear fluid shears against the porous velocity at the interface rather than at
  // the cell center. It is exact for a linear velocity and so needs no nonorthogonal correction.
  const auto elem_face_velocity =
      elem_clear ? RealVectorValue(elem_velocity - elem_distance * elem_correction)
                 : _porous_mass_flux_provider.baffleFaceVelocity(fi, /*elem_side=*/true);
  const auto neighbor_face_velocity =
      neighbor_clear ? RealVectorValue(neighbor_velocity + neighbor_distance * neighbor_correction)
                     : _porous_mass_flux_provider.baffleFaceVelocity(fi, /*elem_side=*/false);
  const auto face_velocity_difference = neighbor_face_velocity - elem_face_velocity;
  const auto shear_traction =
      transmissibility * (face_velocity_difference - (face_velocity_difference * normal) * normal);
 
  // There is no normal viscous stress on a baffle face: the pressure jump carries the normal
  // momentum balance, and a normal stress of the interstitial velocity would read the jump of
  // mdot / (rho_f eps_s) as a gradient. The element row adds -q_t, the neighbor row +q_t. The part
  // proportional to the kernel variable is implicit; everything else, including the coupling to the
  // other velocity components, is lagged on the right-hand side.
  const Real n_i = normal(_index);
  const Real coefficient = transmissibility * (1.0 - n_i * n_i);
 
  BaffleStressData data;
  data.elem_elem = coefficient;
  data.elem_neighbor = -coefficient;
  data.neighbor_elem = -coefficient;
  data.neighbor_neighbor = coefficient;
  data.elem_rhs =
      shear_traction(_index) + coefficient * (elem_velocity(_index) - neighbor_velocity(_index));
  data.neighbor_rhs =
      -shear_traction(_index) + coefficient * (neighbor_velocity(_index) - elem_velocity(_index));
 
  // The deviatoric stress is lagged in each clear half-cell.
  if (_use_deviatoric_terms)
  {
    if (elem_clear)
      data.elem_rhs +=
          face_viscosity * computeCellStressExplicitCorrection(elem_info, RealVectorValue());
    if (neighbor_clear)
      data.neighbor_rhs -=
          face_viscosity * computeCellStressExplicitCorrection(neighbor_info, RealVectorValue());
  }
 
  return data;
}

Referenced by addMatrixContribution(), computeElemRightHandSideContribution(), and computeNeighborRightHandSideContribution().

◆ computeAdvectionBoundaryMatrixContribution()

Real LinearPWCNSFVMomentumFlux::computeAdvectionBoundaryMatrixContribution ( const LinearFVAdvectionDiffusionBC * bc )

overrideprotectedvirtual

Compute the boundary advection matrix contribution with local porosity scaling.

Reimplemented from LinearWCNSFVMomentumFlux.

Definition at line 105 of file LinearPWCNSFVMomentumFlux.C.

{
  const auto boundary_value_matrix_contrib = bc->computeBoundaryValueMatrixContribution();
  const bool elem_side = _current_face_type != FaceInfo::VarFaceNeighbors::NEIGHBOR;
  return boundary_value_matrix_contrib * _face_mass_flux * inversePorosity(elem_side);
}

◆ computeAdvectionBoundaryRHSContribution()

Real LinearPWCNSFVMomentumFlux::computeAdvectionBoundaryRHSContribution ( const LinearFVAdvectionDiffusionBC * bc )

overrideprotectedvirtual

Compute the boundary advection right-hand-side contribution with local porosity scaling.

Reimplemented from LinearWCNSFVMomentumFlux.

Definition at line 114 of file LinearPWCNSFVMomentumFlux.C.

{
  const auto boundary_value_rhs_contrib = bc->computeBoundaryValueRHSContribution();
  const bool elem_side = _current_face_type != FaceInfo::VarFaceNeighbors::NEIGHBOR;
  return -boundary_value_rhs_contrib * _face_mass_flux * inversePorosity(elem_side);
}

◆ computeBaffleAdvectionExplicitCorrection()

Real LinearPWCNSFVMomentumFlux::computeBaffleAdvectionExplicitCorrection ( bool elem_side ) const

private

Compute the correction that replaces the shared advected state with the baffle face state: the upstream interstitial tangential velocity and this side's extrapolated normal velocity.

Parameters

elem_side Whether to compute the correction for the element side

Definition at line 123 of file LinearPWCNSFVMomentumFlux.C.

{
  if (!_porous_mass_flux_provider.faceIsBaffle(*_current_face_info))
    return 0.0;
 
  const auto state_arg = determineState();
 
  const auto & fi = *_current_face_info;
  const Real u_elem = _var.getElemValue(*fi.elemInfo(), state_arg);
  const Real u_neighbor = _var.getElemValue(*fi.neighborInfo(), state_arg);
  // Keep the shared internal-face stencil, then explicitly replace the interpolated superficial
  // velocity on baffle faces. Interpolating across the baffle would mix the two sides of the
  // velocity jump, and the cell value alone would miss the variation between the cell center and
  // the face.
  const Real shared_advected_velocity = _adv_interp_result.weights_matrix.first * u_elem +
                                        _adv_interp_result.weights_matrix.second * u_neighbor;
 
  // With V_s the velocity of side s extrapolated to the face, both sides advect the interstitial
  // tangential velocity u_t,f = (I - n n) V_up / eps_up of the upstream side, so the tangential
  // momentum flux mdot u_t,f leaving one side enters the other and the face is no source of
  // tangential momentum. Mass conservation fixes the normal superficial velocity from the shared
  // face mass flux, U_n = mdot / rho_f, with the face-interpolated density rho_f standing in for
  // both sides because density is assumed to vary smoothly across the baffle. The pressure jump
  // balances the normal momentum difference. Side s therefore advects
  //   V*_s = eps_s u_t,f + U_n n.
  const auto & normal = fi.normal();
  const bool upstream_elem_side = _face_mass_flux >= 0.0;
  const auto upstream_velocity =
      _porous_mass_flux_provider.baffleFaceVelocity(fi, upstream_elem_side);
  const auto interstitial_tangential_velocity =
      (upstream_velocity - (upstream_velocity * normal) * normal) *
      inversePorosity(upstream_elem_side);
  const Real normal_velocity = _porous_mass_flux_provider.baffleNormalVelocity(fi);
  const Real baffle_advected_velocity =
      interstitial_tangential_velocity(_index) / inversePorosity(elem_side) +
      normal_velocity * normal(_index);
  const Real factor = elem_side ? 1.0 : -1.0;
 
  return factor * _face_mass_flux * inversePorosity(elem_side) *
         (shared_advected_velocity - baffle_advected_velocity) * _current_face_area;
}

Referenced by computeElemRightHandSideContribution(), and computeNeighborRightHandSideContribution().

◆ computeBoundaryMatrixContribution()

Real LinearWCNSFVMomentumFlux::computeBoundaryMatrixContribution ( const LinearFVBoundaryCondition & bc )

overridevirtualinherited

Implements LinearFVFluxKernel.

Definition at line 168 of file LinearWCNSFVMomentumFlux.C.

{
  const auto * const adv_diff_bc = cast_ptr<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 )

overridevirtualinherited

Implements LinearFVFluxKernel.

Definition at line 179 of file LinearWCNSFVMomentumFlux.C.

{
  const auto * const adv_diff_bc = cast_ptr<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;
}

◆ computeCellStressExplicitCorrection()

Real LinearWCNSFVMomentumFlux::computeCellStressExplicitCorrection	(	const ElemInfo &	cell_info,
		const RealVectorValue &	nonorthogonal_correction_vector
	)		const

protectedinherited

Compute the explicit stress correction reconstructed from one adjacent cell.

Parameters

cell_info	The cell where velocity gradients and values are evaluated
nonorthogonal_correction_vector	The geometric correction vector for this cell

Definition at line 269 of file LinearWCNSFVMomentumFlux.C.

{
  Real correction = 0.0;
 
  if (_dim > 1 && _use_nonorthogonal_correction)
  {
    mooseAssert(_gradient_field, "Gradient field should be registered when gradients are needed.");
    // Get the kernel variable gradient from this cell.
    correction += _gradient_field->gradient(cell_info) * nonorthogonal_correction_vector;
  }
 
  // Scenario (2), account for the deviatoric parts of the stress tensor.
  if (_use_deviatoric_terms)
  {
    std::array<RealGradient, 3> gradients;
    Real trace = 0.0;
    RealVectorValue deviatoric_vector;
 
    // Loop over every velocity component to form the symmetric gradient pieces.
    for (const auto dir : make_range(_dim))
    {
      gradients[dir] = velocityGradientField(dir).gradient(cell_info);
      trace += gradients[dir](dir);
    }
 
    if (_coord_type == Moose::CoordinateSystemType::COORD_RZ)
      trace += velocityVar(_rz_radial_coord).getElemValue(cell_info, determineState()) /
               cell_info.centroid()(_rz_radial_coord);
 
    // Assemble the explicit transpose/trace contribution component by component.
    for (const auto dir : make_range(_dim))
    {
      gradients[dir](dir) -= 2.0 / 3.0 * trace;
      deviatoric_vector(dir) = gradients[dir](_index);
    }
 
    correction += deviatoric_vector * _current_face_info->normal();
  }
 
  return correction;
}

Referenced by baffleStressData(), LinearWCNSFVMomentumFlux::computeInternalStressExplicitCorrection(), and LinearWCNSFVMomentumFlux::computeStressBoundaryRHSContribution().

◆ computeElemMatrixContribution()

Real LinearWCNSFVMomentumFlux::computeElemMatrixContribution ( )

overridevirtualinherited

Implements LinearFVFluxKernel.

Definition at line 136 of file LinearWCNSFVMomentumFlux.C.

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

◆ computeElemRightHandSideContribution()

Real LinearPWCNSFVMomentumFlux::computeElemRightHandSideContribution ( )

overridevirtual

Compute the element-row internal-face right-hand-side contribution.

Reimplemented from LinearWCNSFVMomentumFlux.

Definition at line 77 of file LinearPWCNSFVMomentumFlux.C.

{
  const bool correct_baffle = _porous_mass_flux_provider.faceIsBaffle(*_current_face_info);
  const Real stress_rhs =
      (correct_baffle ? baffleStressData().elem_rhs : computeInternalStressRHSContribution()) *
      _current_face_area;
  const Real advection_rhs = correct_baffle
                                 ? 0.0
                                 : _adv_interp_result.rhs_face_value * _face_mass_flux *
                                       inversePorosity(/*elem_side=*/true) * _current_face_area;
  return stress_rhs + advection_rhs + computeBaffleAdvectionExplicitCorrection(/*elem_side=*/true);
}

◆ computeInternalAdvectionElemMatrixContribution()

Real LinearWCNSFVMomentumFlux::computeInternalAdvectionElemMatrixContribution ( )

protectedinherited

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 189 of file LinearWCNSFVMomentumFlux.C.

{
  return _adv_interp_result.weights_matrix.first * _face_mass_flux;
}

Referenced by addMatrixContribution(), and LinearWCNSFVMomentumFlux::computeElemMatrixContribution().

◆ computeInternalAdvectionNeighborMatrixContribution()

Real LinearWCNSFVMomentumFlux::computeInternalAdvectionNeighborMatrixContribution ( )

protectedinherited

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 195 of file LinearWCNSFVMomentumFlux.C.

{
  return _adv_interp_result.weights_matrix.second * _face_mass_flux;
}

Referenced by addMatrixContribution(), and LinearWCNSFVMomentumFlux::computeNeighborMatrixContribution().

◆ computeInternalStressExplicitCorrection()

Real LinearWCNSFVMomentumFlux::computeInternalStressExplicitCorrection ( ) const

protectedinherited

Computes the explicit internal-face stress correction.

Definition at line 239 of file LinearWCNSFVMomentumFlux.C.

{
  // 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 ((!_use_nonorthogonal_correction || _dim == 1) && !_use_deviatoric_terms)
    return 0.0;
 
  // Scenario (1), add the nonorthogonal correction. In 1D, there is no correction.
  RealVectorValue correction_vector;
  if (_dim > 1 && _use_nonorthogonal_correction)
    correction_vector =
        _current_face_info->normal() -
        1 / (_current_face_info->normal() * _current_face_info->eCN()) * _current_face_info->eCN();
 
  // Interpolate the two cell corrections to the face.
  const auto interp_coeffs =
      interpCoeffs(Moose::FV::InterpMethod::Average, *_current_face_info, true);
  const Real elem_correction =
      computeCellStressExplicitCorrection(*_current_face_info->elemInfo(), correction_vector);
  const Real neighbor_correction =
      computeCellStressExplicitCorrection(*_current_face_info->neighborInfo(), correction_vector);
 
  const auto face_arg = makeCDFace(*_current_face_info);
  return _mu(face_arg, determineState()) *
         (interp_coeffs.first * elem_correction + interp_coeffs.second * neighbor_correction);
}

Referenced by LinearWCNSFVMomentumFlux::computeInternalStressRHSContribution().

◆ computeInternalStressMatrixContribution()

Real LinearWCNSFVMomentumFlux::computeInternalStressMatrixContribution ( )

protectedinherited

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 201 of file LinearWCNSFVMomentumFlux.C.

{
  // If we don't have the value yet, we compute it
  if (!_cached_matrix_contribution)
  {
    _stress_matrix_contribution = computeInternalStressTransmissibility();
    _cached_matrix_contribution = true;
  }
 
  return _stress_matrix_contribution;
}

Referenced by addMatrixContribution(), LinearWCNSFVMomentumFlux::computeElemMatrixContribution(), and LinearWCNSFVMomentumFlux::computeNeighborMatrixContribution().

◆ computeInternalStressRHSContribution()

Real LinearWCNSFVMomentumFlux::computeInternalStressRHSContribution ( )

protectedinherited

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 214 of file LinearWCNSFVMomentumFlux.C.

{
  if (!_cached_rhs_contribution)
  {
    _stress_rhs_contribution = computeInternalStressExplicitCorrection();
    _cached_rhs_contribution = true;
  }
 
  return _stress_rhs_contribution;
}

Referenced by computeElemRightHandSideContribution(), LinearWCNSFVMomentumFlux::computeElemRightHandSideContribution(), computeNeighborRightHandSideContribution(), and LinearWCNSFVMomentumFlux::computeNeighborRightHandSideContribution().

◆ computeInternalStressTransmissibility()

Real LinearWCNSFVMomentumFlux::computeInternalStressTransmissibility ( ) const

protectedinherited

Computes the implicit internal-face stress transmissibility.

Definition at line 226 of file LinearWCNSFVMomentumFlux.C.

{
  const auto face_arg = makeCDFace(*_current_face_info);
 
  // A nonorthogonal correction uses the normal component of the cell-to-cell vector.
  const auto d = _use_nonorthogonal_correction
                     ? std::abs(_current_face_info->dCN() * _current_face_info->normal())
                     : _current_face_info->dCNMag();
 
  return _mu(face_arg, determineState()) / d;
}

Referenced by LinearWCNSFVMomentumFlux::computeInternalStressMatrixContribution().

◆ computeNeighborMatrixContribution()

Real LinearWCNSFVMomentumFlux::computeNeighborMatrixContribution ( )

overridevirtualinherited

Implements LinearFVFluxKernel.

Definition at line 144 of file LinearWCNSFVMomentumFlux.C.

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

◆ computeNeighborRightHandSideContribution()

Real LinearPWCNSFVMomentumFlux::computeNeighborRightHandSideContribution ( )

overridevirtual

Compute the neighbor-row internal-face right-hand-side contribution.

Reimplemented from LinearWCNSFVMomentumFlux.

Definition at line 91 of file LinearPWCNSFVMomentumFlux.C.

{
  const bool correct_baffle = _porous_mass_flux_provider.faceIsBaffle(*_current_face_info);
  const Real stress_rhs =
      (correct_baffle ? baffleStressData().neighbor_rhs : -computeInternalStressRHSContribution()) *
      _current_face_area;
  const Real advection_rhs = correct_baffle
                                 ? 0.0
                                 : -_adv_interp_result.rhs_face_value * _face_mass_flux *
                                       inversePorosity(/*elem_side=*/false) * _current_face_area;
  return stress_rhs + advection_rhs + computeBaffleAdvectionExplicitCorrection(/*elem_side=*/false);
}

◆ computeStressBoundaryMatrixContribution()

Real LinearWCNSFVMomentumFlux::computeStressBoundaryMatrixContribution ( const LinearFVAdvectionDiffusionBC * bc )

protectedinherited

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 313 of file LinearWCNSFVMomentumFlux.C.

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

Referenced by LinearWCNSFVMomentumFlux::computeBoundaryMatrixContribution().

◆ computeStressBoundaryRHSContribution()

Real LinearWCNSFVMomentumFlux::computeStressBoundaryRHSContribution ( const LinearFVAdvectionDiffusionBC * bc )

protectedinherited

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 329 of file LinearWCNSFVMomentumFlux.C.

{
  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->needsBoundaryNonorthogonalCorrection())
  {
    // 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();
    mooseAssert(_gradient_field, "Gradient field should be registered when gradients are needed.");
    grad_contrib += _mu(face_arg, state_arg) * _gradient_field->gradient(*elem_info) *
                    _boundary_normal_factor * correction_vector;
  }
 
  // Complete prescribed fluxes already include all applicable stress contributions.
  if (_use_deviatoric_terms && !bc->providesCompleteBoundaryFlux())
  {
    // 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();
 
    // A zero correction vector restricts the cell correction to its deviatoric part; the
    // boundary nonorthogonal correction is added above. We support internal boundaries too so
    // we have to make sure the normal points always outward.
    grad_contrib += _mu(face_arg, determineState()) * _boundary_normal_factor *
                    computeCellStressExplicitCorrection(*elem_info, RealVectorValue());
  }
 
  return grad_contrib;
}

Referenced by LinearWCNSFVMomentumFlux::computeBoundaryRHSContribution().

◆ inversePorosity()

Real LinearPWCNSFVMomentumFlux::inversePorosity ( bool elem_side ) const

private

Return the inverse porosity on one side of the current face.

Parameters

elem_side Whether to evaluate porosity on the element side

Definition at line 290 of file LinearPWCNSFVMomentumFlux.C.

{
  const Real porosity = _porous_mass_flux_provider.getFaceSidePorosity(
      *_current_face_info, elem_side, determineState());
  if (porosity <= 0.0)
    mooseError("porosity must be positive on face ", _current_face_info->id(), ".");
 
  return 1.0 / porosity;
}

Referenced by addMatrixContribution(), computeAdvectionBoundaryMatrixContribution(), computeAdvectionBoundaryRHSContribution(), computeBaffleAdvectionExplicitCorrection(), computeElemRightHandSideContribution(), and computeNeighborRightHandSideContribution().

◆ isClearFluidSide()

bool LinearPWCNSFVMomentumFlux::isClearFluidSide ( bool elem_side ) const

private

Whether one side of the current face is clear fluid, i.e.

has unit porosity.

Parameters

elem_side Whether to check the element side

Definition at line 282 of file LinearPWCNSFVMomentumFlux.C.

{
  return MooseUtils::absoluteFuzzyEqual(_porous_mass_flux_provider.getFaceSidePorosity(
                                            *_current_face_info, elem_side, determineState()),
                                        1.0);
}

Referenced by baffleStressData().

◆ setupFaceData()

void LinearWCNSFVMomentumFlux::setupFaceData ( const FaceInfo * face_info )

overridevirtualinherited

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 397 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())
    {
      mooseAssert(_advected_gradient_field,
                  "Gradient field should be registered when gradients are needed.");
      _elem_grad_storage = _advected_gradient_field->gradient(elem_info);
      _neighbor_grad_storage = _advected_gradient_field->gradient(neighbor_info);
    }
 
    _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 LinearPWCNSFVMomentumFlux::validParams ( )

static

Definition at line 20 of file LinearPWCNSFVMomentumFlux.C.

{
  InputParameters params = LinearWCNSFVMomentumFlux::validParams();
  params.addClassDescription("Momentum flux kernel with porous-specific advection handling.");
  return params;
}

◆ velocityGradientField()

const LinearFVGradientReader & LinearWCNSFVMomentumFlux::velocityGradientField ( unsigned int dir ) const

protectedinherited

Helper to access the velocity gradient field for a given direction.

Definition at line 448 of file LinearWCNSFVMomentumFlux.C.

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

Referenced by baffleStressData(), and LinearWCNSFVMomentumFlux::computeCellStressExplicitCorrection().

◆ velocityVar()

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

protectedinherited

Helper to access the velocity variable for a given direction.

Definition at line 440 of file LinearWCNSFVMomentumFlux.C.

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

Referenced by baffleStressData(), and LinearWCNSFVMomentumFlux::computeCellStressExplicitCorrection().

Member Data Documentation

◆ _adv_interp_method

const FVAdvectedInterpolationMethod& LinearWCNSFVMomentumFlux::_adv_interp_method

protectedinherited

The interpolation method to use for the advected quantity.

Definition at line 124 of file LinearWCNSFVMomentumFlux.h.

Referenced by LinearWCNSFVMomentumFlux::setupFaceData().

◆ _adv_interp_result

FVAdvectedInterpolationMethod::AdvectedSystemContribution LinearWCNSFVMomentumFlux::_adv_interp_result

protectedinherited

Current advected interpolation contribution on the face.

Definition at line 130 of file LinearWCNSFVMomentumFlux.h.

Referenced by computeBaffleAdvectionExplicitCorrection(), computeElemRightHandSideContribution(), LinearWCNSFVMomentumFlux::computeElemRightHandSideContribution(), LinearWCNSFVMomentumFlux::computeInternalAdvectionElemMatrixContribution(), LinearWCNSFVMomentumFlux::computeInternalAdvectionNeighborMatrixContribution(), computeNeighborRightHandSideContribution(), LinearWCNSFVMomentumFlux::computeNeighborRightHandSideContribution(), and LinearWCNSFVMomentumFlux::setupFaceData().

◆ _advected_gradient_field

const LinearFVGradientReader* const LinearWCNSFVMomentumFlux::_advected_gradient_field

protectedinherited

Gradient field used by advected interpolations that require gradients.

Definition at line 127 of file LinearWCNSFVMomentumFlux.h.

Referenced by LinearWCNSFVMomentumFlux::setupFaceData().

◆ _boundary_normal_factor

Real LinearWCNSFVMomentumFlux::_boundary_normal_factor

protectedinherited

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

Definition at line 142 of file LinearWCNSFVMomentumFlux.h.

Referenced by LinearWCNSFVMomentumFlux::computeStressBoundaryRHSContribution(), and LinearWCNSFVMomentumFlux::setupFaceData().

◆ _coord_type

const Moose::CoordinateSystemType LinearWCNSFVMomentumFlux::_coord_type

protectedinherited

Coordinate system of the blocks this kernel operates on.

Definition at line 164 of file LinearWCNSFVMomentumFlux.h.

Referenced by LinearWCNSFVMomentumFlux::computeCellStressExplicitCorrection().

◆ _dim

const unsigned int LinearWCNSFVMomentumFlux::_dim

protectedinherited

The dimension of the mesh.

Definition at line 109 of file LinearWCNSFVMomentumFlux.h.

Referenced by baffleStressData(), LinearWCNSFVMomentumFlux::computeCellStressExplicitCorrection(), LinearWCNSFVMomentumFlux::computeInternalStressExplicitCorrection(), and LinearWCNSFVMomentumFlux::LinearWCNSFVMomentumFlux().

◆ _elem_grad_storage

VectorValue<Real> LinearWCNSFVMomentumFlux::_elem_grad_storage

protectedinherited

Reusable gradient storage used when advected interpolation requires gradients.

Definition at line 133 of file LinearWCNSFVMomentumFlux.h.

Referenced by LinearWCNSFVMomentumFlux::setupFaceData().

◆ _face_mass_flux

Real LinearWCNSFVMomentumFlux::_face_mass_flux

protectedinherited

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

Definition at line 138 of file LinearWCNSFVMomentumFlux.h.

Referenced by LinearWCNSFVMomentumFlux::computeAdvectionBoundaryMatrixContribution(), computeAdvectionBoundaryMatrixContribution(), LinearWCNSFVMomentumFlux::computeAdvectionBoundaryRHSContribution(), computeAdvectionBoundaryRHSContribution(), computeBaffleAdvectionExplicitCorrection(), computeElemRightHandSideContribution(), LinearWCNSFVMomentumFlux::computeElemRightHandSideContribution(), LinearWCNSFVMomentumFlux::computeInternalAdvectionElemMatrixContribution(), LinearWCNSFVMomentumFlux::computeInternalAdvectionNeighborMatrixContribution(), computeNeighborRightHandSideContribution(), LinearWCNSFVMomentumFlux::computeNeighborRightHandSideContribution(), and LinearWCNSFVMomentumFlux::setupFaceData().

◆ _gradient_field

const LinearFVGradientReader* LinearWCNSFVMomentumFlux::_gradient_field

protectedinherited

Gradient field used for the kernel variable nonorthogonal correction.

Definition at line 158 of file LinearWCNSFVMomentumFlux.h.

Referenced by LinearWCNSFVMomentumFlux::computeCellStressExplicitCorrection(), and LinearWCNSFVMomentumFlux::computeStressBoundaryRHSContribution().

◆ _index

const unsigned int LinearWCNSFVMomentumFlux::_index

protectedinherited

Index x|y|z, this is mainly to handle the deviatoric parts correctly in in the stress term.

Definition at line 152 of file LinearWCNSFVMomentumFlux.h.

Referenced by baffleStressData(), computeBaffleAdvectionExplicitCorrection(), and LinearWCNSFVMomentumFlux::computeCellStressExplicitCorrection().

◆ _mass_flux_provider

const RhieChowMassFlux& LinearWCNSFVMomentumFlux::_mass_flux_provider

protectedinherited

The Rhie-Chow user object that provides us with the face velocity.

Definition at line 112 of file LinearWCNSFVMomentumFlux.h.

Referenced by LinearWCNSFVMomentumFlux::setupFaceData().

◆ _mu

const Moose::Functor<Real>& LinearWCNSFVMomentumFlux::_mu

protectedinherited

The functor for the dynamic viscosity.

Definition at line 115 of file LinearWCNSFVMomentumFlux.h.

Referenced by baffleStressData(), LinearWCNSFVMomentumFlux::computeInternalStressExplicitCorrection(), LinearWCNSFVMomentumFlux::computeInternalStressTransmissibility(), LinearWCNSFVMomentumFlux::computeStressBoundaryMatrixContribution(), and LinearWCNSFVMomentumFlux::computeStressBoundaryRHSContribution().

◆ _neighbor_grad_storage

VectorValue<Real> LinearWCNSFVMomentumFlux::_neighbor_grad_storage

protectedinherited

Definition at line 134 of file LinearWCNSFVMomentumFlux.h.

Referenced by LinearWCNSFVMomentumFlux::setupFaceData().

◆ _porous_mass_flux_provider

const PorousRhieChowMassFlux& LinearPWCNSFVMomentumFlux::_porous_mass_flux_provider

private

Porous Rhie-Chow object supplying porosity and pressure-baffle data.

Definition at line 52 of file LinearPWCNSFVMomentumFlux.h.

Referenced by addMatrixContribution(), baffleStressData(), computeBaffleAdvectionExplicitCorrection(), computeElemRightHandSideContribution(), computeNeighborRightHandSideContribution(), inversePorosity(), and isClearFluidSide().

◆ _rz_radial_coord

const unsigned int LinearWCNSFVMomentumFlux::_rz_radial_coord

protectedinherited

Axisymmetric radial coordinate index (only used when in RZ)

Definition at line 167 of file LinearWCNSFVMomentumFlux.h.

Referenced by LinearWCNSFVMomentumFlux::computeCellStressExplicitCorrection().

◆ _stress_matrix_contribution

Real LinearWCNSFVMomentumFlux::_stress_matrix_contribution

protectedinherited

The cached matrix contribution.

Definition at line 145 of file LinearWCNSFVMomentumFlux.h.

Referenced by LinearWCNSFVMomentumFlux::computeInternalStressMatrixContribution().

◆ _stress_rhs_contribution

Real LinearWCNSFVMomentumFlux::_stress_rhs_contribution

protectedinherited

The cached right hand side contribution.

Definition at line 148 of file LinearWCNSFVMomentumFlux.h.

Referenced by LinearWCNSFVMomentumFlux::computeInternalStressRHSContribution(), and LinearWCNSFVMomentumFlux::setupFaceData().

◆ _use_deviatoric_terms

const bool LinearWCNSFVMomentumFlux::_use_deviatoric_terms

protectedinherited

Switch to enable/disable deviatoric parts in the stress term.

Definition at line 121 of file LinearWCNSFVMomentumFlux.h.

Referenced by baffleStressData(), LinearWCNSFVMomentumFlux::computeCellStressExplicitCorrection(), LinearWCNSFVMomentumFlux::computeInternalStressExplicitCorrection(), LinearWCNSFVMomentumFlux::computeStressBoundaryRHSContribution(), and LinearWCNSFVMomentumFlux::LinearWCNSFVMomentumFlux().

◆ _use_nonorthogonal_correction

const bool LinearWCNSFVMomentumFlux::_use_nonorthogonal_correction

protectedinherited

Switch to enable/disable nonorthogonal correction in the stress term.

Definition at line 118 of file LinearWCNSFVMomentumFlux.h.

Referenced by baffleStressData(), LinearWCNSFVMomentumFlux::computeCellStressExplicitCorrection(), LinearWCNSFVMomentumFlux::computeInternalStressExplicitCorrection(), LinearWCNSFVMomentumFlux::computeInternalStressTransmissibility(), LinearWCNSFVMomentumFlux::computeStressBoundaryRHSContribution(), and LinearWCNSFVMomentumFlux::LinearWCNSFVMomentumFlux().

◆ _velocity_gradient_fields

std::array<const LinearFVGradientReader *, 3> LinearWCNSFVMomentumFlux::_velocity_gradient_fields

protectedinherited

Gradient fields used for velocity variables in deviatoric stress terms.

Definition at line 161 of file LinearWCNSFVMomentumFlux.h.

Referenced by LinearWCNSFVMomentumFlux::LinearWCNSFVMomentumFlux(), and LinearWCNSFVMomentumFlux::velocityGradientField().

◆ _velocity_vars

std::array<const MooseLinearVariableFVReal *, 3> LinearWCNSFVMomentumFlux::_velocity_vars

protectedinherited

Velocity variables for each coordinate direction.

Definition at line 155 of file LinearWCNSFVMomentumFlux.h.

Referenced by LinearWCNSFVMomentumFlux::LinearWCNSFVMomentumFlux(), and LinearWCNSFVMomentumFlux::velocityVar().

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

navier_stokes/include/linearfvkernels/LinearPWCNSFVMomentumFlux.h
navier_stokes/src/linearfvkernels/LinearPWCNSFVMomentumFlux.C

Classes

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Protected Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ LinearPWCNSFVMomentumFlux()

Member Function Documentation

◆ addMatrixContribution()

◆ baffleStressData()

◆ computeAdvectionBoundaryMatrixContribution()

◆ computeAdvectionBoundaryRHSContribution()

◆ computeBaffleAdvectionExplicitCorrection()

◆ computeBoundaryMatrixContribution()

◆ computeBoundaryRHSContribution()

◆ computeCellStressExplicitCorrection()

◆ computeElemMatrixContribution()

◆ computeElemRightHandSideContribution()

◆ computeInternalAdvectionElemMatrixContribution()

◆ computeInternalAdvectionNeighborMatrixContribution()

◆ computeInternalStressExplicitCorrection()

◆ computeInternalStressMatrixContribution()

◆ computeInternalStressRHSContribution()

◆ computeInternalStressTransmissibility()

◆ computeNeighborMatrixContribution()

◆ computeNeighborRightHandSideContribution()

◆ computeStressBoundaryMatrixContribution()

◆ computeStressBoundaryRHSContribution()

◆ inversePorosity()

◆ isClearFluidSide()

◆ setupFaceData()

◆ validParams()

◆ velocityGradientField()

◆ velocityVar()

Member Data Documentation

◆ _adv_interp_method

◆ _adv_interp_result

◆ _advected_gradient_field

◆ _boundary_normal_factor

◆ _coord_type

◆ _dim

◆ _elem_grad_storage

◆ _face_mass_flux

◆ _gradient_field

◆ _index

◆ _mass_flux_provider

◆ _mu

◆ _neighbor_grad_storage

◆ _porous_mass_flux_provider

◆ _rz_radial_coord

◆ _stress_matrix_contribution

◆ _stress_rhs_contribution

◆ _use_deviatoric_terms

◆ _use_nonorthogonal_correction

◆ _velocity_gradient_fields

◆ _velocity_vars