#include <INSFVVelocityVariable.h>

Inheritance diagram for INSFVVelocityVariable:

Public Types
typedef typename MooseVariableField< Real >::OutputGradient	OutputGradient

typedef typename MooseVariableField< Real >::OutputSecond	OutputSecond

typedef typename MooseVariableField< Real >::OutputDivergence	OutputDivergence

typedef typename MooseVariableField< Real >::FieldVariableValue	FieldVariableValue

typedef typename MooseVariableField< Real >::FieldVariableGradient	FieldVariableGradient

typedef typename MooseVariableField< Real >::FieldVariableSecond	FieldVariableSecond

typedef typename MooseVariableField< Real >::FieldVariableCurl	FieldVariableCurl

typedef typename MooseVariableField< Real >::FieldVariableDivergence	FieldVariableDivergence

typedef typename MooseVariableField< Real >::OutputShape	OutputShape

typedef typename MooseVariableField< Real >::OutputShapeGradient	OutputShapeGradient

typedef typename MooseVariableField< Real >::OutputShapeSecond	OutputShapeSecond

typedef typename MooseVariableField< Real >::OutputShapeDivergence	OutputShapeDivergence

typedef typename MooseVariableField< Real >::OutputData	OutputData

typedef typename MooseVariableField< Real >::DoFValue	DoFValue

typedef typename MooseVariableField< Real >::FieldVariablePhiValue	FieldVariablePhiValue

typedef typename MooseVariableField< Real >::FieldVariablePhiDivergence	FieldVariablePhiDivergence

typedef typename MooseVariableField< Real >::FieldVariablePhiGradient	FieldVariablePhiGradient

typedef typename MooseVariableField< Real >::FieldVariablePhiSecond	FieldVariablePhiSecond

typedef Moose::ElemQpArg	ElemQpArg

typedef Moose::ElemSideQpArg	ElemSideQpArg

typedef Moose::ElemArg	ElemArg

typedef Moose::FaceArg	FaceArg

typedef Moose::StateArg	StateArg

typedef Moose::NodeArg	NodeArg

typedef Moose::ElemPointArg	ElemPointArg

typedef MooseArray< std::vector< OutputShape > >	FieldVariablePhiCurl

typedef MooseArray< std::vector< OutputShape > >	FieldVariableTestValue

typedef MooseArray< std::vector< OutputShapeGradient > >	FieldVariableTestGradient

typedef MooseArray< std::vector< OutputShapeSecond > >	FieldVariableTestSecond

typedef MooseArray< std::vector< OutputShape > >	FieldVariableTestCurl

typedef MooseArray< std::vector< OutputShapeDivergence > >	FieldVariableTestDivergence

typedef DataFileName	DataFileParameterType

typedef FunctorBase< T >	FunctorType

typedef T	ValueType

typedef typename FunctorReturnType< T, FunctorEvaluationKind::Gradient >::type	GradientType

typedef ValueType	DotType

Public Member Functions
	INSFVVelocityVariable (const InputParameters &params)

const VectorValue< ADReal > &	adGradSln (const Elem *const elem, const StateArg &time, bool correct_skewness=false) const override

VectorValue< ADReal >	uncorrectedAdGradSln (const FaceInfo &fi, const StateArg &time, const bool correct_skewness=false) const override

void	computeFaceValues (const FaceInfo &) override

void	computeElemValues () override

void	computeElemValuesFace () override

void	computeNeighborValuesFace () override

void	computeNeighborValues () override

void	requireQpComputations () const override

virtual void	initialSetup () override

virtual void	timestepSetup () override

virtual void	meshChanged () override

bool	isSeparatorBoundary (const FaceInfo &fi) const

bool	isExtrapolatedBoundaryFace (const FaceInfo &fi, const Elem *elem, const Moose::StateArg &time) const override

virtual bool	isExtrapolatedBoundaryFace (const FaceInfo &, const Elem *, const StateArg &) const

virtual bool	isFV () const override

virtual void	prepare () override final

virtual void	prepareNeighbor () override final

virtual void	prepareAux () override final

virtual void	reinitNode () override final

virtual void	reinitNodes (const std::vector< dof_id_type > &) override final

virtual void	reinitNodesNeighbor (const std::vector< dof_id_type > &) override final

virtual void	reinitAux () override final

virtual void	reinitAuxNeighbor () override final

virtual void	prepareLowerD () override final

virtual const dof_id_type &	nodalDofIndex () const override final

virtual const dof_id_type &	nodalDofIndexNeighbor () const override final

virtual std::size_t	phiSize () const override final

virtual std::size_t	phiFaceSize () const override final

virtual std::size_t	phiNeighborSize () const override final

virtual std::size_t	phiFaceNeighborSize () const override final

virtual std::size_t	phiLowerSize () const override final

virtual void	computeLowerDValues () override final

virtual void	computeNodalNeighborValues () override final

virtual void	computeNodalValues () override final

virtual const std::vector< dof_id_type > &	dofIndicesLower () const override final

unsigned int	numberOfDofs () const override final

virtual unsigned int	numberOfDofsNeighbor () override final

virtual bool	isNodal () const override final

bool	hasDoFsOnNodes () const override final

libMesh::FEContinuity	getContinuity () const override final

virtual bool	isNodalDefined () const override final

virtual void	setNodalValue (const Real &value, unsigned int idx=0) override

virtual void	setDofValue (const OutputData &value, unsigned int index) override

virtual void	setDofValue (const OutputData &value, unsigned int index)=0

void	clearDofIndices () override

virtual void	prepareIC () override

virtual const Elem *const &	currentElem () const override

virtual void	getDofIndices (const Elem *elem, std::vector< dof_id_type > &dof_indices) const override

virtual const std::vector< dof_id_type > &	dofIndices () const final

virtual const std::vector< dof_id_type > &	dofIndicesNeighbor () const final

Moose::FV::InterpMethod	faceInterpolationMethod () const

void	clearAllDofIndices () final

const DoFValue &	nodalVectorTagValue (TagID) const override

const DoFValue &	nodalMatrixTagValue (TagID) const override

const FieldVariableValue &	vectorTagValue (TagID tag) const override

const DoFValue &	vectorTagDofValue (TagID tag) const override

const FieldVariableValue &	matrixTagValue (TagID tag) const override

const FieldVariableValue &	vectorTagValueNeighbor (TagID tag)

const FieldVariableValue &	matrixTagValueNeighbor (TagID tag)

const FieldVariableValue &	uDot () const

const FieldVariableValue &	sln () const override

const FieldVariableValue &	slnOld () const override

const FieldVariableValue &	slnOlder () const override

const FieldVariableGradient &	gradSln () const override

const FieldVariableGradient &	gradSlnOld () const override

const FieldVariableValue &	uDotNeighbor () const

const FieldVariableValue &	slnNeighbor () const override

const FieldVariableValue &	slnOldNeighbor () const override

const FieldVariableGradient &	gradSlnNeighbor () const override

const FieldVariableGradient &	gradSlnOldNeighbor () const override

const VariableValue &	duDotDu () const

const VariableValue &	duDotDotDu () const

const VariableValue &	duDotDuNeighbor () const

const VariableValue &	duDotDotDuNeighbor () const

const ADTemplateVariableValue< Real > &	adSln () const override

const ADTemplateVariableGradient< Real > &	adGradSln () const override

virtual VectorValue< ADReal >	adGradSln (const FaceInfo &fi, const StateArg &state, const bool correct_skewness=false) const

ADReal	getBoundaryFaceValue (const FaceInfo &fi, const StateArg &state, bool correct_skewness=false) const

const ADTemplateVariableSecond< Real > &	adSecondSln () const override

const ADTemplateVariableValue< Real > &	adUDot () const override

const ADTemplateVariableValue< Real > &	adUDotDot () const override

const ADTemplateVariableGradient< Real > &	adGradSlnDot () const override

const ADTemplateVariableCurl< Real > &	adCurlSln () const override

const ADTemplateVariableValue< Real > &	adSlnNeighbor () const override

const ADTemplateVariableGradient< Real > &	adGradSlnNeighbor () const override

const ADTemplateVariableSecond< Real > &	adSecondSlnNeighbor () const override

const ADTemplateVariableValue< Real > &	adUDotNeighbor () const override

const ADTemplateVariableValue< Real > &	adUDotDotNeighbor () const override

const ADTemplateVariableGradient< Real > &	adGradSlnNeighborDot () const override

const ADTemplateVariableCurl< Real > &	adCurlSlnNeighbor () const override

virtual void	setDofValues (const DenseVector< OutputData > &values) override

virtual void	setDofValues (const DenseVector< OutputData > &values)=0

virtual void	setLowerDofValues (const DenseVector< OutputData > &values) override

virtual void	setLowerDofValues (const DenseVector< OutputData > &values)=0

OutputData	getElementalValue (const Elem *elem, unsigned int idx=0) const

OutputData	getElementalValueOld (const Elem *elem, unsigned int idx=0) const

OutputData	getElementalValueOlder (const Elem *elem, unsigned int idx=0) const

virtual void	insert (libMesh::NumericVector< libMesh::Number > &vector) override

virtual void	insertLower (libMesh::NumericVector< libMesh::Number > &vector) override

virtual void	add (libMesh::NumericVector< libMesh::Number > &vector) override

const DoFValue &	dofValues () const override

const DoFValue &	dofValuesOld () const override

const DoFValue &	dofValuesOlder () const override

const DoFValue &	dofValuesPreviousNL () const override

const DoFValue &	dofValuesNeighbor () const override

const DoFValue &	dofValuesOldNeighbor () const override

const DoFValue &	dofValuesOlderNeighbor () const override

const DoFValue &	dofValuesPreviousNLNeighbor () const override

const DoFValue &	dofValuesDot () const override

const DoFValue &	dofValuesDotNeighbor () const override

const DoFValue &	dofValuesDotOld () const override

const DoFValue &	dofValuesDotOldNeighbor () const override

const DoFValue &	dofValuesDotDot () const override

const DoFValue &	dofValuesDotDotNeighbor () const override

const DoFValue &	dofValuesDotDotOld () const override

const DoFValue &	dofValuesDotDotOldNeighbor () const override

const MooseArray< libMesh::Number > &	dofValuesDuDotDu () const override

const MooseArray< libMesh::Number > &	dofValuesDuDotDuNeighbor () const override

const MooseArray< libMesh::Number > &	dofValuesDuDotDotDu () const override

const MooseArray< libMesh::Number > &	dofValuesDuDotDotDuNeighbor () const override

const MooseArray< ADReal > &	adDofValues () const override

const MooseArray< ADReal > &	adDofValuesNeighbor () const override

const MooseArray< ADReal > &	adDofValuesDot () const override

Real	getValue (const Elem *elem) const

OutputTools< Real >::OutputGradient	getGradient (const Elem *elem) const

bool	hasDirichletBC () const

std::pair< bool, const FVDirichletBCBase * >	getDirichletBC (const FaceInfo &fi) const

std::pair< bool, std::vector< const FVFluxBC * > >	getFluxBCs (const FaceInfo &fi) const

virtual void	residualSetup () override

virtual void	jacobianSetup () override

ADReal	getElemValue (const Elem *elem, const StateArg &state) const

void	setActiveTags (const std::set< TagID > &vtags) override

virtual bool	isDirichletBoundaryFace (const FaceInfo &fi, const Elem *elem, const Moose::StateArg &state) const

bool	supportsFaceArg () const override final

bool	supportsElemSideQpArg () const override final

const MooseArray< Real > &	nodalValueArray () const override

const MooseArray< Real > &	nodalValueOldArray () const override

const MooseArray< Real > &	nodalValueOlderArray () const override

bool	computingSecond () const override final

bool	computingCurl () const override final

bool	computingDiv () const override final

bool	usesSecondPhiNeighbor () const override final

const FieldVariablePhiValue &	phi () const override final

const FieldVariablePhiGradient &	gradPhi () const override final

const FieldVariablePhiSecond &	secondPhi () const override final

const FieldVariablePhiValue &	curlPhi () const override final

const FieldVariablePhiDivergence &	divPhi () const override final

const FieldVariablePhiValue &	phiFace () const override final

const FieldVariablePhiGradient &	gradPhiFace () const override final

const FieldVariablePhiSecond &	secondPhiFace () const override final

const FieldVariablePhiValue &	phiFaceNeighbor () const override final

const FieldVariablePhiGradient &	gradPhiFaceNeighbor () const override final

const FieldVariablePhiSecond &	secondPhiFaceNeighbor () const override final

const FieldVariablePhiValue &	phiNeighbor () const override final

const FieldVariablePhiGradient &	gradPhiNeighbor () const override final

const FieldVariablePhiSecond &	secondPhiNeighbor () const override final

virtual const FieldVariablePhiValue &	phiLower () const override

unsigned int	oldestSolutionStateRequested () const override final

const bool &	getTwoTermBoundaryExpansion () const

virtual Moose::VarFieldType	fieldType () const override

virtual bool	isArray () const override

virtual bool	isVector () const override

bool	usesPhiNeighbor () const

bool	usesGradPhiNeighbor () 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 (const std::vector< SubdomainID > &ids) const

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

bool	hasBlocks (const SubdomainID id) const override

const std::string &	componentName (const unsigned int comp) const

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

bool	activeOnSubdomain (SubdomainID subdomain) const

bool	activeOnSubdomains (const std::set< SubdomainID > &subdomains) const

virtual bool	needsGradientVectorStorage () const

const std::string &	arrayVariableComponent (const unsigned int i) const

unsigned int	number () const

const libMesh::FEType &	feType () const

SystemBase &	sys ()

const SystemBase &	sys () const

const std::string &	name () const override

bool	useDual () const

const std::vector< dof_id_type > &	allDofIndices () const

unsigned int	totalVarDofs ()

Moose::VarKindType	kind () const

void	scalingFactor (const std::vector< Real > &factor)

Real	scalingFactor () const

const std::vector< Real > &	arrayScalingFactor () const

libMesh::Order	order () const

unsigned int	count () const

const libMesh::DofMap &	dofMap () const

std::vector< dof_id_type >	componentDofIndices (const std::vector< dof_id_type > &dof_indices, unsigned int component) const

bool	eigen () const

void	eigen (bool eigen)

bool	isLowerD () const

virtual bool	enabled () const

std::shared_ptr< MooseObject >	getSharedPtr ()

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

MooseApp &	getMooseApp () const

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

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

unsigned int	numBlocks () const

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

unsigned int	blocksMaxDimension () 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

void	buildOutputHideVariableList (std::set< std::string > variable_names)

const std::set< OutputName > &	getOutputs ()

virtual void	subdomainSetup ()

virtual void	customSetup (const ExecFlagType &)

virtual void	customSetup (const ExecFlagType &exec_type) override

const ExecFlagEnum &	getExecuteOnEnum () const

FunctorReturnType< T, FET >::type	genericEvaluate (const Space &r, const State &state) const

const MooseFunctorName &	functorName () const

void	setCacheClearanceSchedule (const std::set< ExecFlagType > &clearance_schedule)

bool	isInternalFace (const FaceInfo &) const

virtual bool	isConstant () const

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

void	checkFace (const Moose::FaceArg &face) const

ValueType	operator() (const ElemArg &elem, const StateArg &state) const

ValueType	operator() (const FaceArg &face, const StateArg &state) const

ValueType	operator() (const ElemQpArg &qp, const StateArg &state) const

ValueType	operator() (const ElemSideQpArg &qp, const StateArg &state) const

ValueType	operator() (const ElemPointArg &elem_point, const StateArg &state) const

ValueType	operator() (const NodeArg &node, const StateArg &state) const

ValueType	operator() (const ElemArg &elem, const StateArg &state) const

ValueType	operator() (const FaceArg &face, const StateArg &state) const

ValueType	operator() (const ElemQpArg &qp, const StateArg &state) const

ValueType	operator() (const ElemSideQpArg &qp, const StateArg &state) const

ValueType	operator() (const ElemPointArg &elem_point, const StateArg &state) const

ValueType	operator() (const NodeArg &node, const StateArg &state) const

ValueType	operator() (const ElemArg &elem, const StateArg &state) const

ValueType	operator() (const FaceArg &face, const StateArg &state) const

ValueType	operator() (const ElemQpArg &qp, const StateArg &state) const

ValueType	operator() (const ElemSideQpArg &qp, const StateArg &state) const

ValueType	operator() (const ElemPointArg &elem_point, const StateArg &state) const

ValueType	operator() (const NodeArg &node, const StateArg &state) const

GradientType	gradient (const ElemArg &elem, const StateArg &state) const

GradientType	gradient (const FaceArg &face, const StateArg &state) const

GradientType	gradient (const ElemQpArg &qp, const StateArg &state) const

GradientType	gradient (const ElemSideQpArg &qp, const StateArg &state) const

GradientType	gradient (const ElemPointArg &elem_point, const StateArg &state) const

GradientType	gradient (const NodeArg &node, const StateArg &state) const

GradientType	gradient (const ElemArg &elem, const StateArg &state) const

GradientType	gradient (const FaceArg &face, const StateArg &state) const

GradientType	gradient (const ElemQpArg &qp, const StateArg &state) const

GradientType	gradient (const ElemSideQpArg &qp, const StateArg &state) const

GradientType	gradient (const ElemPointArg &elem_point, const StateArg &state) const

GradientType	gradient (const NodeArg &node, const StateArg &state) const

GradientType	gradient (const ElemArg &elem, const StateArg &state) const

GradientType	gradient (const FaceArg &face, const StateArg &state) const

GradientType	gradient (const ElemQpArg &qp, const StateArg &state) const

GradientType	gradient (const ElemSideQpArg &qp, const StateArg &state) const

GradientType	gradient (const ElemPointArg &elem_point, const StateArg &state) const

GradientType	gradient (const NodeArg &node, const StateArg &state) const

DotType	dot (const ElemArg &elem, const StateArg &state) const

DotType	dot (const FaceArg &face, const StateArg &state) const

DotType	dot (const ElemQpArg &qp, const StateArg &state) const

DotType	dot (const ElemSideQpArg &qp, const StateArg &state) const

DotType	dot (const ElemPointArg &elem_point, const StateArg &state) const

DotType	dot (const NodeArg &node, const StateArg &state) const

DotType	dot (const ElemArg &elem, const StateArg &state) const

DotType	dot (const FaceArg &face, const StateArg &state) const

DotType	dot (const ElemQpArg &qp, const StateArg &state) const

DotType	dot (const ElemSideQpArg &qp, const StateArg &state) const

DotType	dot (const ElemPointArg &elem_point, const StateArg &state) const

DotType	dot (const NodeArg &node, const StateArg &state) const

DotType	dot (const ElemArg &elem, const StateArg &state) const

DotType	dot (const FaceArg &face, const StateArg &state) const

DotType	dot (const ElemQpArg &qp, const StateArg &state) const

DotType	dot (const ElemSideQpArg &qp, const StateArg &state) const

DotType	dot (const ElemPointArg &elem_point, const StateArg &state) const

DotType	dot (const NodeArg &node, const StateArg &state) const

GradientType	gradDot (const ElemArg &elem, const StateArg &state) const

GradientType	gradDot (const FaceArg &face, const StateArg &state) const

GradientType	gradDot (const ElemQpArg &qp, const StateArg &state) const

GradientType	gradDot (const ElemSideQpArg &qp, const StateArg &state) const

GradientType	gradDot (const ElemPointArg &elem_point, const StateArg &state) const

GradientType	gradDot (const NodeArg &node, const StateArg &state) const

GradientType	gradDot (const ElemArg &elem, const StateArg &state) const

GradientType	gradDot (const FaceArg &face, const StateArg &state) const

GradientType	gradDot (const ElemQpArg &qp, const StateArg &state) const

GradientType	gradDot (const ElemSideQpArg &qp, const StateArg &state) const

GradientType	gradDot (const ElemPointArg &elem_point, const StateArg &state) const

GradientType	gradDot (const NodeArg &node, const StateArg &state) const

GradientType	gradDot (const ElemArg &elem, const StateArg &state) const

GradientType	gradDot (const FaceArg &face, const StateArg &state) const

GradientType	gradDot (const ElemQpArg &qp, const StateArg &state) const

GradientType	gradDot (const ElemSideQpArg &qp, const StateArg &state) const

GradientType	gradDot (const ElemPointArg &elem_point, const StateArg &state) const

GradientType	gradDot (const NodeArg &node, const StateArg &state) const

const MooseArray< GenericReal< is_ad > > &	genericDofValues () const

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Static Public Member Functions
static InputParameters	validParams ()

Public Attributes
const ConsoleStream	_console

Protected Member Functions
ADReal	getExtrapolatedBoundaryFaceValue (const FaceInfo &fi, bool two_term_expansion, bool correct_skewness, const Elem *elem_side_to_extrapolate_from, const StateArg &time) const override

bool	isFullyDevelopedFlowFace (const FaceInfo &fi) const
	Returns whether the passed-in `FaceInfo` corresponds to a fully-developed flow face. More...

void	cacheSeparatorBoundaries ()
	Caches the separator boundaries. More...

virtual ADReal	getDirichletBoundaryFaceValue (const FaceInfo &fi, const Elem *elem, const Moose::StateArg &state) const

void	clearCaches ()

bool	doDerivatives () const

virtual bool	hasBlockMaterialPropertyHelper (const std::string &prop_name)

void	initializeBlockRestrictable (const MooseObject *moose_object)

Moose::CoordinateSystemType	getBlockCoordSystem ()

virtual GradientType	evaluateGradient (const ElemSideQpArg &, const StateArg &) const

virtual GradientType	evaluateGradient (const ElemPointArg &, const StateArg &) const

virtual GradientType	evaluateGradient (const NodeArg &, const StateArg &) const

virtual GradientType	evaluateGradient (const ElemSideQpArg &, const StateArg &) const

virtual GradientType	evaluateGradient (const ElemPointArg &, const StateArg &) const

virtual GradientType	evaluateGradient (const NodeArg &, const StateArg &) const

virtual GradientType	evaluateGradient (const ElemArg &, const StateArg &) const

virtual GradientType	evaluateGradient (const FaceArg &, const StateArg &) const

virtual GradientType	evaluateGradient (const ElemQpArg &, const StateArg &) const

virtual GradientType	evaluateGradient (const ElemSideQpArg &, const StateArg &) const

virtual GradientType	evaluateGradient (const ElemPointArg &, const StateArg &) const

virtual GradientType	evaluateGradient (const NodeArg &, const StateArg &) const

virtual DotType	evaluateDot (const ElemSideQpArg &, const StateArg &) const

virtual DotType	evaluateDot (const ElemPointArg &, const StateArg &) const

virtual DotType	evaluateDot (const NodeArg &, const StateArg &) const

virtual DotType	evaluateDot (const ElemSideQpArg &, const StateArg &) const

virtual DotType	evaluateDot (const ElemPointArg &, const StateArg &) const

virtual DotType	evaluateDot (const NodeArg &, const StateArg &) const

virtual DotType	evaluateDot (const ElemArg &, const StateArg &) const

virtual DotType	evaluateDot (const FaceArg &, const StateArg &) const

virtual DotType	evaluateDot (const ElemQpArg &, const StateArg &) const

virtual DotType	evaluateDot (const ElemSideQpArg &, const StateArg &) const

virtual DotType	evaluateDot (const ElemPointArg &, const StateArg &) const

virtual DotType	evaluateDot (const NodeArg &, const StateArg &) const

virtual GradientType	evaluateGradDot (const ElemArg &, const StateArg &) const

virtual GradientType	evaluateGradDot (const FaceArg &, const StateArg &) const

virtual GradientType	evaluateGradDot (const ElemQpArg &, const StateArg &) const

virtual GradientType	evaluateGradDot (const ElemSideQpArg &, const StateArg &) const

virtual GradientType	evaluateGradDot (const ElemPointArg &, const StateArg &) const

virtual GradientType	evaluateGradDot (const NodeArg &, const StateArg &) const

virtual GradientType	evaluateGradDot (const ElemArg &, const StateArg &) const

virtual GradientType	evaluateGradDot (const FaceArg &, const StateArg &) const

virtual GradientType	evaluateGradDot (const ElemQpArg &, const StateArg &) const

virtual GradientType	evaluateGradDot (const ElemSideQpArg &, const StateArg &) const

virtual GradientType	evaluateGradDot (const ElemPointArg &, const StateArg &) const

virtual GradientType	evaluateGradDot (const NodeArg &, const StateArg &) const

virtual GradientType	evaluateGradDot (const ElemArg &, const StateArg &) const

virtual GradientType	evaluateGradDot (const FaceArg &, const StateArg &) const

virtual GradientType	evaluateGradDot (const ElemQpArg &, const StateArg &) const

virtual GradientType	evaluateGradDot (const ElemSideQpArg &, const StateArg &) const

virtual GradientType	evaluateGradDot (const ElemPointArg &, const StateArg &) const

virtual GradientType	evaluateGradDot (const NodeArg &, const StateArg &) const

virtual ValueType	evaluate (const ElemArg &elem, const StateArg &state) const=0

virtual ValueType	evaluate (const FaceArg &face, const StateArg &state) const=0

virtual ValueType	evaluate (const ElemQpArg &qp, const StateArg &state) const=0

virtual ValueType	evaluate (const ElemSideQpArg &side_qp, const StateArg &state) const=0

virtual ValueType	evaluate (const ElemPointArg &elem_point, const StateArg &state) const=0

virtual ValueType	evaluate (const NodeArg &node, const StateArg &state) const=0

const libMesh::NumericVector< libMesh::Number > &	getSolution (const Moose::StateArg &state) const

Protected Attributes
std::unordered_map< BoundaryID, const INSFVHydraulicSeparatorInterface * >	_boundary_id_to_separator
	A container for quick access of hydraulic separator BCs associated with this variable. More...

	usingMooseVariableFieldMembers

std::unique_ptr< MooseVariableDataFV< Real > >	_element_data

std::unique_ptr< MooseVariableDataFV< Real > >	_neighbor_data

std::unordered_map< const Elem *, VectorValue< ADReal > >	_elem_to_grad

bool	_two_term_boundary_expansion

VectorValue< ADReal >	_temp_cell_gradient

const bool	_cache_cell_gradients

Moose::FV::InterpMethod	_face_interp_method

SystemBase &	_sys

libMesh::FEType	_fe_type

unsigned int	_var_num

unsigned int	_index

bool	_is_eigen

Moose::VarKindType	_var_kind

SubProblem &	_subproblem

const libMesh::Variable &	_variable

Assembly &	_assembly

const libMesh::DofMap &	_dof_map

std::vector< dof_id_type >	_dof_indices

MooseMesh &	_mesh

THREAD_ID	_tid

const unsigned int	_count

std::vector< Real >	_scaling_factor

std::string	_var_name

bool	_use_dual

bool	_is_lower_d

std::vector< std::string >	_array_var_component_names

const bool &	_enabled

MooseApp &	_app

const std::string	_type

const std::string	_name

const InputParameters &	_pars

Factory &	_factory

ActionFactory &	_action_factory

const MaterialData *	_blk_material_data

const ExecFlagEnum &	_execute_enum

const ExecFlagType &	_current_execute_flag

FEProblemBase &	_mci_feproblem

const TimeIntegrator *const	_time_integrator

ADReal	_ad_real_dummy

const Parallel::Communicator &	_communicator

Detailed Description

Definition at line 17 of file INSFVVelocityVariable.h.

Constructor & Destructor Documentation

◆ INSFVVelocityVariable()

INSFVVelocityVariable::INSFVVelocityVariable ( const InputParameters & params )

Definition at line 63 of file INSFVVelocityVariable.C.

                                                                            : INSFVVariable(params)
 {
 }

Member Function Documentation

◆ adGradSln()

const VectorValue< ADReal > & INSFVVelocityVariable::adGradSln	(	const Elem *const	elem,
		const StateArg &	time,
		bool	correct_skewness = `false`
	)		const

overridevirtual

Reimplemented from MooseVariableFV< Real >.

Definition at line 126 of file INSFVVelocityVariable.C.

Referenced by INSFVMixingLengthTurbulentViscosityAux::computeValue().

 {
   VectorValue<ADReal> * value_pointer = &_temp_cell_gradient;
 
   // We ensure that no caching takes place when we compute skewness-corrected
   // quantities.
   if (_cache_cell_gradients && !correct_skewness && time.state == 0)
   {
     auto it = _elem_to_grad.find(elem);
 
     if (it != _elem_to_grad.end())
       return it->second;
   }
 
   ADReal elem_value = getElemValue(elem, time);
 
   // We'll save off the extrapolated boundary faces (ebf) for later assignment to the cache (these
   // are the keys). The boolean in the pair will denote whether the ebf face is a fully developed
   // flow (e.g. fdf) face
   std::vector<std::pair<const FaceInfo *, bool>> ebf_faces;
 
   try
   {
     VectorValue<ADReal> & grad = *value_pointer;
 
     bool volume_set = false;
     Real volume = 0;
 
     // If we are performing a two term Taylor expansion for extrapolated boundary faces (faces on
     // boundaries that do not have associated Dirichlet conditions), then the element gradient
     // depends on the boundary face value and the boundary face value depends on the element
     // gradient, so we have a system of equations to solve. Here is the system:
     //
     // \nabla \phi_C - \frac{1}{V} \sum_{ebf} \phi_{ebf} \vec{S_f} =
     //   \frac{1}{V} \sum_{of} \phi_{of} \vec{S_f}                                            eqn.
     //   1
     //
     // \phi_{ebf} - \vec{d_{Cf}} \cdot \nabla \phi_C = \phi_C                                 eqn.
     // 2
     //
     // where $C$ refers to the cell centroid, $ebf$ refers to an extrapolated boundary face, $of$
     // refers to "other faces", e.g. non-ebf faces, and $f$ is a general face. $d_{Cf}$ is the
     // vector drawn from the element centroid to the face centroid, and $\vec{S_f}$ is the surface
     // vector, e.g. the face area times the outward facing normal
     //
     // NOTE: On fully developed flow boundaries, we modify our equation set slightly. In equation
     // 2,
     // $\nabla \phi_C$ is replaced with $\nabla \phi_{ebf,fdf}$ where $fdf$ denotes fully
     // developed flow. Moreover, we introduce a third equation:
     //
     // \nabla \phi_{ebf,fdf} - \nabla \phi_C + (\nabla \phi_C \cdot \hat{n}) \hat{n} = 0      eqn.
     // 3
     //
     // These modifications correspond to Moukalled's equations 15.140 and 15.141, but with
     // $\hat{e_b}$ replaced with $\hat{n}$ because we believe the equation as written doesn't
     // reflect the intent of the text, which is to guarantee a zero normal gradient in the
     // direction of the surface normal
 
     // ebf eqns: element gradient coefficients, e.g. eqn. 2, LHS term 2 coefficient. *Note* that
     // each element of the std::vector could correspond to a cell centroid gradient or to a face
     // gradient computed on a fully developed flow face
     std::vector<VectorValue<Real>> ebf_grad_coeffs;
     // ebf eqns: rhs b values. These will actually correspond to the elem_value so we can use a
     // pointer and avoid copying. This is the RHS of eqn. 2
     std::vector<const ADReal *> ebf_b;
 
     // elem grad eqns: ebf coefficients, e.g. eqn. 1, LHS term 2 coefficients
     std::vector<VectorValue<Real>> grad_ebf_coeffs;
     // elem grad eqns: rhs b value, e.g. eqn. 1 RHS
     VectorValue<ADReal> grad_b = 0;
 
     // eqn. 3 coefficients for cell centroid gradient, e.g. the coefficients that fall out of term
     // 2 on the LHS of eqn. 3
     std::vector<TensorValue<Real>> fdf_grad_centroid_coeffs;
 
     const unsigned int lm_dim = LIBMESH_DIM;
 
     auto action_functor = [&volume_set,
                            &volume,
                            &elem_value,
 #ifndef NDEBUG
                            &elem,
 #endif
                            &ebf_faces,
                            &ebf_grad_coeffs,
                            &ebf_b,
                            &grad_ebf_coeffs,
                            &grad_b,
                            &fdf_grad_centroid_coeffs,
                            correct_skewness,
                            &time,
                            this](const Elem & functor_elem,
                                  const Elem * const neighbor,
                                  const FaceInfo * const fi,
                                  const Point & surface_vector,
                                  Real coord,
                                  const bool elem_has_info)
     {
       mooseAssert(fi, "We need a FaceInfo for this action_functor");
       mooseAssert(elem == &functor_elem,
                   "Just a sanity check that the element being passed in is the one we passed out.");
 
       if (isExtrapolatedBoundaryFace(*fi, &functor_elem, time))
       {
         if (_two_term_boundary_expansion)
         {
           const bool fdf_face = isFullyDevelopedFlowFace(*fi);
           ebf_faces.push_back(std::make_pair(fi, fdf_face));
 
           // eqn. 2
           ebf_grad_coeffs.push_back(-1. * (elem_has_info
                                                ? (fi->faceCentroid() - fi->elemCentroid())
                                                : (fi->faceCentroid() - fi->neighborCentroid())));
           ebf_b.push_back(&elem_value);
 
           // eqn. 1
           grad_ebf_coeffs.push_back(-surface_vector);
 
           // eqn. 3
           if (fdf_face)
           {
             // Will be nice in C++17 we'll get a returned reference from this method
             fdf_grad_centroid_coeffs.emplace_back();
             auto & current_coeffs = fdf_grad_centroid_coeffs.back();
             const auto normal = fi->normal();
             for (const auto i : make_range(lm_dim))
               for (const auto j : make_range(lm_dim))
               {
                 auto & current_coeff = current_coeffs(i, j);
                 current_coeff = normal(i) * normal(j);
                 if (i == j)
                   current_coeff -= 1.;
               }
           }
         }
         else
           // We are doing a one-term expansion for the extrapolated boundary faces, in which case
           // we have no eqn. 2 and we have no second term in the LHS of eqn. 1. Instead we apply
           // the element centroid value as the face value (one-term expansion) in the RHS of eqn.
           // 1
           grad_b += surface_vector * elem_value;
       }
       else if (isInternalFace(*fi))
         grad_b +=
             surface_vector * (*this)(Moose::FaceArg({fi,
                                                      Moose::FV::LimiterType::CentralDifference,
                                                      true,
                                                      correct_skewness,
                                                      nullptr,
                                                      nullptr}),
                                      time);
       else
       {
         mooseAssert(isDirichletBoundaryFace(*fi, &functor_elem, time),
                     "We've run out of face types");
         grad_b += surface_vector * getDirichletBoundaryFaceValue(*fi, &functor_elem, time);
       }
 
       if (!volume_set)
       {
         // We use the FaceInfo volumes because those values have been pre-computed and cached.
         // An explicit call to elem->volume() here would incur unnecessary expense
         if (elem_has_info)
         {
           coordTransformFactor(
               this->_subproblem, functor_elem.subdomain_id(), fi->elemCentroid(), coord);
           volume = fi->elemVolume() * coord;
         }
         else
         {
           coordTransformFactor(
               this->_subproblem, neighbor->subdomain_id(), fi->neighborCentroid(), coord);
           volume = fi->neighborVolume() * coord;
         }
 
         volume_set = true;
       }
     };
 
     Moose::FV::loopOverElemFaceInfo(*elem, this->_mesh, this->_subproblem, action_functor);
 
     mooseAssert(volume_set && volume > 0, "We should have set the volume");
     grad_b /= volume;
 
     const auto coord_system = this->_subproblem.getCoordSystem(elem->subdomain_id());
     if (coord_system == Moose::CoordinateSystemType::COORD_RZ)
     {
       const auto r_coord = this->_subproblem.getAxisymmetricRadialCoord();
       grad_b(r_coord) -= elem_value / elem->vertex_average()(r_coord);
     }
 
     mooseAssert(
         coord_system != Moose::CoordinateSystemType::COORD_RSPHERICAL,
         "We have not yet implemented the correct translation from gradient to divergence for "
         "spherical coordinates yet.");
 
     mooseAssert(
         ebf_faces.size() < UINT_MAX,
         "You've created a mystical element that has more faces than can be held by unsigned "
         "int. I applaud you.");
     const auto num_ebfs = static_cast<unsigned int>(ebf_faces.size());
 
     // test for simple case
     if (num_ebfs == 0)
       grad = grad_b;
     else
     {
       // We have to solve a system
       const unsigned int sys_dim =
           lm_dim + num_ebfs + lm_dim * static_cast<unsigned int>(fdf_grad_centroid_coeffs.size());
       DenseVector<ADReal> x(sys_dim), b(sys_dim);
       DenseMatrix<ADReal> A(sys_dim, sys_dim);
 
       // eqn. 1
       for (const auto lm_dim_index : make_range(lm_dim))
       {
         // LHS term 1 coeffs
         A(lm_dim_index, lm_dim_index) = 1;
 
         // LHS term 2 coeffs
         for (const auto ebf_index : make_range(num_ebfs))
           A(lm_dim_index, lm_dim + ebf_index) = grad_ebf_coeffs[ebf_index](lm_dim_index) / volume;
 
         // RHS
         b(lm_dim_index) = grad_b(lm_dim_index);
       }
 
       unsigned int num_fdf_faces = 0;
 
       // eqn. 2
       for (const auto ebf_index : make_range(num_ebfs))
       {
         // LHS term 1 coeffs
         A(lm_dim + ebf_index, lm_dim + ebf_index) = 1;
 
         const bool fdf_face = ebf_faces[ebf_index].second;
         const unsigned int starting_j_index =
             fdf_face ? lm_dim + num_ebfs + num_fdf_faces * lm_dim : 0;
 
         num_fdf_faces += fdf_face;
 
         // LHS term 2 coeffs
         for (const auto lm_dim_index : make_range(lm_dim))
           A(lm_dim + ebf_index, starting_j_index + lm_dim_index) =
               ebf_grad_coeffs[ebf_index](lm_dim_index);
 
         // RHS
         b(lm_dim + ebf_index) = *ebf_b[ebf_index];
       }
 
       mooseAssert(num_fdf_faces == fdf_grad_centroid_coeffs.size(),
                   "Bad math in INSFVVelocityVariable::adGradlnSln(const Elem *). Please contact a "
                   "MOOSE developer");
 
       // eqn. 3
       for (const auto fdf_face_index : make_range(num_fdf_faces))
       {
         const auto starting_i_index = lm_dim + num_ebfs + fdf_face_index * lm_dim;
 
         for (const auto lm_dim_i_index : make_range(lm_dim))
         {
           auto i_index = starting_i_index + lm_dim_i_index;
           A(i_index, i_index) = 1;
 
           for (const auto lm_dim_j_index : make_range(lm_dim))
             // j_index = lm_dim_j_index
             A(i_index, lm_dim_j_index) =
                 fdf_grad_centroid_coeffs[fdf_face_index](lm_dim_i_index, lm_dim_j_index);
         }
       }
 
       A.lu_solve(b, x);
       for (const auto lm_dim_index : make_range(lm_dim))
         grad(lm_dim_index) = x(lm_dim_index);
     }
 
     if (_cache_cell_gradients && !correct_skewness)
     {
       auto pr = _elem_to_grad.emplace(elem, std::move(grad));
       mooseAssert(pr.second, "Insertion should have just happened.");
       return pr.first->second;
     }
     else
       return grad;
   }
   catch (libMesh::LogicError &)
   {
     // Retry without two-term
     mooseAssert(_two_term_boundary_expansion,
                 "I believe we should only get singular systems when two-term boundary expansion is "
                 "being used");
     const_cast<INSFVVelocityVariable *>(this)->_two_term_boundary_expansion = false;
     const auto & grad = adGradSln(elem, time, correct_skewness);
 
     // Two term boundary expansion should only fail at domain corners. We want to keep trying it
     // at other boundary locations
     const_cast<INSFVVelocityVariable *>(this)->_two_term_boundary_expansion = true;
 
     return grad;
   }
 }

◆ cacheSeparatorBoundaries()

void INSFVVariable::cacheSeparatorBoundaries ( )

protectedinherited

Caches the separator boundaries.

Definition at line 35 of file INSFVVariable.C.

Referenced by INSFVVariable::initialSetup(), INSFVVariable::meshChanged(), and INSFVVariable::timestepSetup().

 {
   _boundary_id_to_separator.clear();
   std::vector<FVFluxBC *> bcs;
 
   const auto base_query = this->_subproblem.getMooseApp()
                               .theWarehouse()
                               .query()
                               .template condition<AttribSystem>("FVFluxBC")
                               .template condition<AttribThread>(_tid);
 
   for (const auto bnd_id : this->_mesh.getBoundaryIDs())
   {
     auto base_query_copy = base_query;
     base_query_copy.template condition<AttribBoundaries>(std::set<BoundaryID>({bnd_id}))
         .queryInto(bcs);
     for (const auto bc : bcs)
     {
       const auto separator = dynamic_cast<const INSFVHydraulicSeparatorInterface *>(bc);
       if (separator)
         _boundary_id_to_separator.emplace(bnd_id, separator);
     }
   }
 }

◆ computeElemValues()

void INSFVVariable::computeElemValues ( )

inlineoverridevirtualinherited

Reimplemented from MooseVariableFV< Real >.

Definition at line 73 of file INSFVVariable.h.

 {
   if (_qp_calculations)
     MooseVariableFVReal::computeElemValues();
   else
     _element_data->setGeometry(Moose::Volume);
 }

◆ computeElemValuesFace()

void INSFVVariable::computeElemValuesFace ( )

inlineoverridevirtualinherited

Reimplemented from MooseVariableFV< Real >.

Definition at line 82 of file INSFVVariable.h.

 {
   if (_qp_calculations)
     MooseVariableFVReal::computeElemValuesFace();
 }

◆ computeFaceValues()

void INSFVVariable::computeFaceValues ( const FaceInfo & fi )

inlineoverridevirtualinherited

Reimplemented from MooseVariableFV< Real >.

Definition at line 66 of file INSFVVariable.h.

 {
   if (_qp_calculations)
     MooseVariableFVReal::computeFaceValues(fi);
 }

◆ computeNeighborValues()

void INSFVVariable::computeNeighborValues ( )

inlineoverridevirtualinherited

Reimplemented from MooseVariableFV< Real >.

Definition at line 96 of file INSFVVariable.h.

 {
   if (_qp_calculations)
     MooseVariableFVReal::computeNeighborValues();
 }

◆ computeNeighborValuesFace()

void INSFVVariable::computeNeighborValuesFace ( )

inlineoverridevirtualinherited

Reimplemented from MooseVariableFV< Real >.

Definition at line 89 of file INSFVVariable.h.

 {
   if (_qp_calculations)
     MooseVariableFVReal::computeNeighborValuesFace();
 }

◆ getExtrapolatedBoundaryFaceValue()

ADReal INSFVVelocityVariable::getExtrapolatedBoundaryFaceValue	(	const FaceInfo &	fi,
		bool	two_term_expansion,
		bool	correct_skewness,
		const Elem *	elem_side_to_extrapolate_from,
		const StateArg &	time
	)		const

overrideprotectedvirtual

Reimplemented from MooseVariableFV< Real >.

Definition at line 68 of file INSFVVelocityVariable.C.

 {
   ADReal boundary_value;
   bool elem_to_extrapolate_from_is_fi_elem;
   std::tie(elem_to_extrapolate_from, elem_to_extrapolate_from_is_fi_elem) =
       [this, &fi, elem_to_extrapolate_from]() -> std::pair<const Elem *, bool>
   {
     if (elem_to_extrapolate_from)
       return {elem_to_extrapolate_from, elem_to_extrapolate_from == &fi.elem()};
     else
     {
       const auto [elem_guaranteed_to_have_dofs,
                   other_elem,
                   elem_guaranteed_to_have_dofs_is_fi_elem] =
           Moose::FV::determineElemOneAndTwo(fi, *this);
       libmesh_ignore(other_elem);
       return {elem_guaranteed_to_have_dofs, elem_guaranteed_to_have_dofs_is_fi_elem};
     }
   }();
 
   if (two_term_expansion && isFullyDevelopedFlowFace(fi))
   {
     const Point vector_to_face = elem_to_extrapolate_from_is_fi_elem
                                      ? (fi.faceCentroid() - fi.elemCentroid())
                                      : (fi.faceCentroid() - fi.neighborCentroid());
     boundary_value = uncorrectedAdGradSln(fi, time, correct_skewness) * vector_to_face +
                      getElemValue(elem_to_extrapolate_from, time);
   }
   else
     boundary_value = INSFVVariable::getExtrapolatedBoundaryFaceValue(
         fi, two_term_expansion, correct_skewness, elem_to_extrapolate_from, time);
 
   return boundary_value;
 }

◆ initialSetup()

void INSFVVariable::initialSetup ( )

overridevirtualinherited

Reimplemented from MooseVariableFV< Real >.

Reimplemented in BernoulliPressureVariable.

Definition at line 75 of file INSFVVariable.C.

Referenced by BernoulliPressureVariable::initialSetup().

 {
   MooseVariableFVReal::initialSetup();
   cacheSeparatorBoundaries();
 }

◆ isExtrapolatedBoundaryFace()

bool INSFVVariable::isExtrapolatedBoundaryFace	(	const FaceInfo &	fi,
		const Elem *	elem,
		const Moose::StateArg &	time
	)		const

overridevirtualinherited

Reimplemented from MooseVariableFV< Real >.

Reimplemented in PiecewiseConstantVariable.

Definition at line 92 of file INSFVVariable.C.

Referenced by adGradSln().

 {
   if (isDirichletBoundaryFace(fi, elem, time))
     return false;
   if (!isInternalFace(fi))
     // We are neither a Dirichlet nor an internal face
     return true;
 
   // If we got here, then we're definitely on an internal face
   if (isSeparatorBoundary(fi))
     return true;
 
   return false;
 }

◆ isFullyDevelopedFlowFace()

bool INSFVVariable::isFullyDevelopedFlowFace ( const FaceInfo & fi ) const

protectedinherited

Returns whether the passed-in FaceInfo corresponds to a fully-developed flow face.

Definition at line 110 of file INSFVVariable.C.

Referenced by adGradSln(), getExtrapolatedBoundaryFaceValue(), and uncorrectedAdGradSln().

 {
   const auto & face_type = fi.faceType(std::make_pair(this->number(), this->sys().number()));
 
   mooseAssert(face_type != FaceInfo::VarFaceNeighbors::NEITHER,
               "I'm concerned that if you're calling this method with a FaceInfo that doesn't have "
               "this variable defined on either side, that you are doing something dangerous.");
 
   // If we're defined on both sides of the face, then we're not a boundary face
   if (face_type == FaceInfo::VarFaceNeighbors::BOTH)
     return false;
 
   std::vector<INSFVFullyDevelopedFlowBC *> bcs;
 
   this->_subproblem.getMooseApp()
       .theWarehouse()
       .query()
       .template condition<AttribINSFVBCs>(INSFVBCs::INSFVFullyDevelopedFlowBC)
       .template condition<AttribBoundaries>(fi.boundaryIDs())
       .queryInto(bcs);
 
   return !bcs.empty();
 }

◆ isSeparatorBoundary()

bool INSFVVariable::isSeparatorBoundary ( const FaceInfo & fi ) const

inherited

Definition at line 82 of file INSFVVariable.C.

Referenced by BernoulliPressureVariable::isDirichletBoundaryFace(), BernoulliPressureVariable::isExtrapolatedBoundaryFace(), and INSFVVariable::isExtrapolatedBoundaryFace().

 {
   for (const auto bid : fi.boundaryIDs())
     if (_boundary_id_to_separator.count(bid))
       return true;
 
   return false;
 }

◆ meshChanged()

void INSFVVariable::meshChanged ( )

overridevirtualinherited

Reimplemented from MooseVariableFV< Real >.

Definition at line 68 of file INSFVVariable.C.

 {
   MooseVariableFVReal::meshChanged();
   cacheSeparatorBoundaries();
 }

◆ requireQpComputations()

void INSFVVariable::requireQpComputations ( ) const

inlineoverridevirtualinherited

Reimplemented from MooseVariableFV< Real >.

Reimplemented in INSFVPressureNoQpComputation, and INSFVVelocityNoQpComputation.

Definition at line 30 of file INSFVVariable.h.

30 { _qp_calculations = true; }

INSFVVariable::_qp_calculations

bool _qp_calculations

Whether to pre-initialize variable data for use in traditional MOOSE quadrature point based objects...

Definition: INSFVVariable.h:62

◆ timestepSetup()

void INSFVVariable::timestepSetup ( )

overridevirtualinherited

Reimplemented from MooseVariableFV< Real >.

Definition at line 61 of file INSFVVariable.C.

 {
   MooseVariableFVReal::timestepSetup();
   cacheSeparatorBoundaries();
 }

◆ uncorrectedAdGradSln()

VectorValue< ADReal > INSFVVelocityVariable::uncorrectedAdGradSln	(	const FaceInfo &	fi,
		const StateArg &	time,
		const bool	correct_skewness = `false`
	)		const

overridevirtual

Reimplemented from MooseVariableFV< Real >.

Definition at line 108 of file INSFVVelocityVariable.C.

Referenced by getExtrapolatedBoundaryFaceValue().

 {
   VectorValue<ADReal> unc_grad;
   if (_two_term_boundary_expansion && isFullyDevelopedFlowFace(fi))
   {
     const auto & cell_gradient = adGradSln(&fi.elem(), time, correct_skewness);
     const auto & normal = fi.normal();
     unc_grad = cell_gradient - (cell_gradient * normal) * normal;
   }
   else
     unc_grad = INSFVVariable::uncorrectedAdGradSln(fi, time, correct_skewness);
 
   return unc_grad;
 }

◆ validParams()

InputParameters INSFVVelocityVariable::validParams ( )

static

Definition at line 58 of file INSFVVelocityVariable.C.

Referenced by PINSFVSuperficialVelocityVariable::validParams().

 {
   return INSFVVariable::validParams();
 }

Member Data Documentation

◆ _boundary_id_to_separator

std::unordered_map<BoundaryID, const INSFVHydraulicSeparatorInterface *> INSFVVariable::_boundary_id_to_separator

protectedinherited

A container for quick access of hydraulic separator BCs associated with this variable.

Definition at line 56 of file INSFVVariable.h.

Referenced by INSFVVariable::cacheSeparatorBoundaries(), and INSFVVariable::isSeparatorBoundary().

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

navier_stokes/include/variables/INSFVVelocityVariable.h
navier_stokes/src/variables/INSFVVelocityVariable.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ INSFVVelocityVariable()

Member Function Documentation

◆ adGradSln()

◆ cacheSeparatorBoundaries()

◆ computeElemValues()

◆ computeElemValuesFace()

◆ computeFaceValues()

◆ computeNeighborValues()

◆ computeNeighborValuesFace()

◆ getExtrapolatedBoundaryFaceValue()

◆ initialSetup()

◆ isExtrapolatedBoundaryFace()

◆ isFullyDevelopedFlowFace()

◆ isSeparatorBoundary()

◆ meshChanged()

◆ requireQpComputations()

◆ timestepSetup()

◆ uncorrectedAdGradSln()

◆ validParams()

Member Data Documentation

◆ _boundary_id_to_separator