#include <INSFVVelocityVariable.h>

Inheritance diagram for INSFVVelocityVariable:

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

typedef typename MooseVariableField< OutputType >::OutputSecond	OutputSecond

typedef typename MooseVariableField< OutputType >::OutputDivergence	OutputDivergence

typedef typename MooseVariableField< OutputType >::FieldVariableValue	FieldVariableValue

typedef typename MooseVariableField< OutputType >::FieldVariableGradient	FieldVariableGradient

typedef typename MooseVariableField< OutputType >::FieldVariableSecond	FieldVariableSecond

typedef typename MooseVariableField< OutputType >::FieldVariableCurl	FieldVariableCurl

typedef typename MooseVariableField< OutputType >::FieldVariableDivergence	FieldVariableDivergence

typedef typename MooseVariableField< OutputType >::OutputShape	OutputShape

typedef typename MooseVariableField< OutputType >::OutputShapeGradient	OutputShapeGradient

typedef typename MooseVariableField< OutputType >::OutputShapeSecond	OutputShapeSecond

typedef typename MooseVariableField< OutputType >::OutputShapeDivergence	OutputShapeDivergence

typedef typename MooseVariableField< OutputType >::FieldVariablePhiValue	FieldVariablePhiValue

typedef typename MooseVariableField< OutputType >::FieldVariablePhiDivergence	FieldVariablePhiDivergence

typedef typename MooseVariableField< OutputType >::FieldVariablePhiGradient	FieldVariablePhiGradient

typedef typename MooseVariableField< OutputType >::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 typename MooseVariableDataBase< OutputType >::DofValue	DofValue

typedef typename MooseVariableDataBase< OutputType >::DofValues	DofValues

typedef typename MooseVariableDataBase< OutputType >::ADDofValue	ADDofValue

typedef typename MooseVariableDataBase< OutputType >::ADDofValues	ADDofValues

typedef DataFileName	DataFileParameterType

typedef FunctorBase< Moose::ADType< OutputType >::type >	FunctorType

typedef Moose::ADType< OutputType >::type	ValueType

typedef typename FunctorReturnType< Moose::ADType< OutputType >::type, 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

bool	supportsQpBasedLoops () const override

bool	supportsGeometricInfoBasedLoops () 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 OutputType &value, unsigned int idx=0) override

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

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 DofValues &	nodalVectorTagValue (TagID) const override

const DofValues &	nodalMatrixTagValue (TagID) const override

const FieldVariableValue &	vectorTagValue (TagID tag) const override

const DofValues &	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< OutputType > &	adSln () const override

const ADTemplateVariableGradient< OutputType > &	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< OutputType > &	adSecondSln () const override

const ADTemplateVariableValue< OutputType > &	adUDot () const override

const ADTemplateVariableValue< OutputType > &	adUDotDot () const override

const ADTemplateVariableGradient< OutputType > &	adGradSlnDot () const override

const ADTemplateVariableCurl< OutputType > &	adCurlSln () const override

const ADTemplateVariableValue< OutputType > &	adSlnNeighbor () const override

const ADTemplateVariableGradient< OutputType > &	adGradSlnNeighbor () const override

const ADTemplateVariableSecond< OutputType > &	adSecondSlnNeighbor () const override

const ADTemplateVariableValue< OutputType > &	adUDotNeighbor () const override

const ADTemplateVariableValue< OutputType > &	adUDotDotNeighbor () const override

const ADTemplateVariableGradient< OutputType > &	adGradSlnNeighborDot () const override

const ADTemplateVariableCurl< OutputType > &	adCurlSlnNeighbor () const override

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

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

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

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

DofValue	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 DofValues &	dofValues () const override

const DofValues &	dofValuesOld () const override

const DofValues &	dofValuesOlder () const override

const DofValues &	dofValuesPreviousNL () const override

const DofValues &	dofValuesNeighbor () const override

const DofValues &	dofValuesOldNeighbor () const override

const DofValues &	dofValuesOlderNeighbor () const override

const DofValues &	dofValuesPreviousNLNeighbor () const override

const DofValues &	dofValuesDot () const override

const DofValues &	dofValuesDotNeighbor () const override

const DofValues &	dofValuesDotOld () const override

const DofValues &	dofValuesDotOldNeighbor () const override

const DofValues &	dofValuesDotDot () const override

const DofValues &	dofValuesDotDotNeighbor () const override

const DofValues &	dofValuesDotDotOld () const override

const DofValues &	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 ADDofValues &	adDofValues () const override

const ADDofValues &	adDofValuesNeighbor () const override

const ADDofValues &	adDofValuesDot () const override

OutputType	getValue (const Elem *elem) const

OutputTools< OutputType >::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

virtual void	sizeMatrixTagData () override

const MooseArray< OutputType > &	nodalValueArray () const override

const MooseArray< OutputType > &	nodalValueOldArray () const override

const MooseArray< OutputType > &	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

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)

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

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< Moose::ADType< OutputType >::type, 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 ()

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)

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

void	cacheSeparatorBoundaries ()
	Caches the separator boundaries.

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

void	clearCaches ()

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

bool	doDerivatives () const

void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const

InvalidSolutionID	registerInvalidSolutionInternal (const std::string &message, const bool warning) const

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

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

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.

	usingMooseVariableFieldMembers

std::unique_ptr< MooseVariableDataFV< OutputType > >	_element_data

std::unique_ptr< MooseVariableDataFV< OutputType > >	_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

bool	_use_dual

bool	_is_lower_d

std::vector< std::string >	_array_var_component_names

const bool &	_enabled

MooseApp &	_app

Factory &	_factory

ActionFactory &	_action_factory

const std::string &	_type

const std::string &	_name

const InputParameters &	_pars

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

Private Member Functions
GradientType	evaluateGradient (const ElemQpArg &qp_arg, const StateArg &) const override final

GradientType	evaluateGradient (const ElemArg &elem_arg, const StateArg &) const override final

GradientType	evaluateGradient (const FaceArg &face, const StateArg &) const override final

DotType	evaluateDot (const ElemArg &elem, const StateArg &) const override final

DotType	evaluateDot (const FaceArg &face, const StateArg &) const override final

DotType	evaluateDot (const ElemQpArg &elem_qp, const StateArg &) const override final

ValueType	evaluate (const ElemArg &elem, const StateArg &) const override final

ValueType	evaluate (const FaceArg &face, const StateArg &) const override final

ValueType	evaluate (const NodeArg &node, const StateArg &) const override final

ValueType	evaluate (const ElemPointArg &elem_point, const StateArg &state) const override final

ValueType	evaluate (const ElemQpArg &elem_qp, const StateArg &state) const override final

ValueType	evaluate (const ElemSideQpArg &elem_side_qp, const StateArg &state) const override final

void	determineBoundaryToDirichletBCMap ()

void	determineBoundaryToFluxBCMap ()

void	lowerDError () const

void	clearCacheData ()

ValueType	queryQpCache (unsigned int qp, const libMesh::QBase &qrule, std::vector< std::pair< bool, Moose::ADType< OutputType >::type > > &qp_cache_data, const SpaceArg &space, const StateArg &state) const

ValueType	queryFVArgCache (std::map< SpaceArg, ValueType > &cache_data, const SpaceArg &space) const

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

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

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

bool	_dirichlet_map_setup

bool	_flux_map_setup

const libMesh::NumericVector< libMesh::Number > *const &	_solution

const FieldVariablePhiValue &	_phi

const FieldVariablePhiGradient &	_grad_phi

const FieldVariablePhiValue &	_phi_face

const FieldVariablePhiGradient &	_grad_phi_face

const FieldVariablePhiValue &	_phi_face_neighbor

const FieldVariablePhiGradient &	_grad_phi_face_neighbor

const FieldVariablePhiValue &	_phi_neighbor

const FieldVariablePhiGradient &	_grad_phi_neighbor

const Elem *	_prev_elem

std::unordered_map< BoundaryID, const FVDirichletBCBase * >	_boundary_id_to_dirichlet_bc

std::unordered_map< BoundaryID, std::vector< const FVFluxBC * > >	_boundary_id_to_flux_bc

const ParallelParamObject &	_parent

const MooseBase &	_si_moose_base

const FEProblemBase *	_si_problem

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

const MooseObject *	_moose_object

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

MooseApp &	_oi_moose_app

OutputWarehouse &	_oi_output_warehouse

std::set< OutputName >	_oi_outputs

ExecFlagEnum	_empty_execute_enum

std::set< ExecFlagType >	_clearance_schedule

bool	_always_evaluate

dof_id_type	_current_qp_map_key

std::vector< std::pair< bool, ValueType > > *	_current_qp_map_value

std::unordered_map< dof_id_type, std::vector< std::pair< bool, ValueType > > >	_qp_to_value

dof_id_type	_current_side_qp_map_key

std::vector< std::vector< std::pair< bool, ValueType > > > *	_current_side_qp_map_value

std::unordered_map< dof_id_type, std::vector< std::vector< std::pair< bool, ValueType > > > >	_side_qp_to_value

std::map< ElemArg, ValueType >	_elem_arg_to_value

std::map< FaceArg, ValueType >	_face_arg_to_value

std::map< NodeArg, ValueType >	_node_arg_to_value

MooseFunctorName	_functor_name

Detailed Description

Definition at line 17 of file INSFVVelocityVariable.h.

Constructor & Destructor Documentation

◆ INSFVVelocityVariable()

INSFVVelocityVariable::INSFVVelocityVariable ( const InputParameters & params )

Definition at line 65 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 128 of file INSFVVelocityVariable.C.

{
  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 (std::exception & e)
  {
    // Don't ignore any *real* errors; we only handle matrix
    // singularity here
    if (!strstr(e.what(), "singular"))
      throw;
 
    // 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;
  }
}

Referenced by INSFVMixingLengthTurbulentViscosityAux::computeValue().

◆ cacheSeparatorBoundaries()

void INSFVVariable::cacheSeparatorBoundaries ( )

protectedinherited

Caches the separator boundaries.

Definition at line 35 of file INSFVVariable.C.

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

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

◆ computeElemValues()

void INSFVVariable::computeElemValues ( )

inlineoverridevirtualinherited

Reimplemented from MooseVariableFV< Real >.

Definition at line 75 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 84 of file INSFVVariable.h.

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

◆ computeFaceValues()

void INSFVVariable::computeFaceValues ( const FaceInfo & fi )

inlineoverridevirtualinherited

Reimplemented from MooseVariableFV< Real >.

Definition at line 68 of file INSFVVariable.h.

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

◆ computeNeighborValues()

void INSFVVariable::computeNeighborValues ( )

inlineoverridevirtualinherited

Reimplemented from MooseVariableFV< Real >.

Definition at line 98 of file INSFVVariable.h.

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

◆ computeNeighborValuesFace()

void INSFVVariable::computeNeighborValuesFace ( )

inlineoverridevirtualinherited

Reimplemented from MooseVariableFV< Real >.

Definition at line 91 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 70 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.

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

◆ isExtrapolatedBoundaryFace()

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

overrideinherited

Definition at line 92 of file INSFVVariable.C.

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

Referenced by adGradSln().

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

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

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

◆ isSeparatorBoundary()

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

inherited

Definition at line 82 of file INSFVVariable.C.

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

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

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

Definition at line 30 of file INSFVVariable.h.

30{ _qp_calculations = true; }

◆ supportsGeometricInfoBasedLoops()

bool INSFVVariable::supportsGeometricInfoBasedLoops ( ) const

inlineoverridevirtualinherited

Reimplemented from MooseVariableField< typename OutputType >.

Definition at line 32 of file INSFVVariable.h.

32{ return true; }

◆ supportsQpBasedLoops()

bool INSFVVariable::supportsQpBasedLoops ( ) const

inlineoverridevirtualinherited

Reimplemented from MooseVariableField< typename OutputType >.

Definition at line 31 of file INSFVVariable.h.

31{ return _qp_calculations; }

◆ 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 110 of file INSFVVelocityVariable.C.

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

Referenced by getExtrapolatedBoundaryFaceValue().

◆ validParams()

InputParameters INSFVVelocityVariable::validParams ( )

static

Definition at line 60 of file INSFVVelocityVariable.C.

{
  return INSFVVariable::validParams();
}

Referenced by PINSFVSuperficialVelocityVariable::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 58 of file INSFVVariable.h.

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

◆ _qp_calculations

bool INSFVVariable::_qp_calculations

mutableprivateinherited

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

This can be changed to true if objects request variable values in a way that is generated by quadrature point based calculations

Definition at line 64 of file INSFVVariable.h.

Referenced by INSFVVariable::computeElemValues(), INSFVVariable::computeElemValuesFace(), INSFVVariable::computeFaceValues(), INSFVVariable::computeNeighborValues(), INSFVVariable::computeNeighborValuesFace(), INSFVVariable::requireQpComputations(), and INSFVVariable::supportsQpBasedLoops().

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

Static Public Attributes

Protected Member Functions

Protected Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ INSFVVelocityVariable()

Member Function Documentation

◆ adGradSln()

◆ cacheSeparatorBoundaries()

◆ computeElemValues()

◆ computeElemValuesFace()

◆ computeFaceValues()

◆ computeNeighborValues()

◆ computeNeighborValuesFace()

◆ getExtrapolatedBoundaryFaceValue()

◆ initialSetup()

◆ isExtrapolatedBoundaryFace()

◆ isFullyDevelopedFlowFace()

◆ isSeparatorBoundary()

◆ meshChanged()

◆ requireQpComputations()

◆ supportsGeometricInfoBasedLoops()

◆ supportsQpBasedLoops()

◆ timestepSetup()

◆ uncorrectedAdGradSln()

◆ validParams()

Member Data Documentation

◆ _boundary_id_to_separator

◆ _qp_calculations