#include <INSFVVelocityNoQpComputation.h>

Inheritance diagram for INSFVVelocityNoQpComputation:

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 >::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 typename MooseVariableDataBase< Real >::DofValue	DofValue

typedef typename MooseVariableDataBase< Real >::DofValues	DofValues

typedef typename MooseVariableDataBase< Real >::ADDofValue	ADDofValue

typedef typename MooseVariableDataBase< Real >::ADDofValues	ADDofValues

typedef DataFileName	DataFileParameterType

typedef FunctorBase< T >	FunctorType

typedef T	ValueType

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

typedef ValueType	DotType

Public Member Functions
	INSFVVelocityNoQpComputation (const InputParameters &params)

virtual void	requireQpComputations () const override
	Set a selection of routines that are use Qp values to error to make sure Qp values are not being computed. More...

const MooseArray< ADReal > &	adDofValues () const override

virtual const DofValues &	dofValues () const override

virtual const DofValues &	dofValuesOld () const override

virtual const DofValues &	dofValuesDot () const override

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

const ADTemplateVariableGradient< Real > &	adGradSln () const override

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

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

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

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< 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 &	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 &	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 &	adDofValuesNeighbor () const override

const ADDofValues &	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

virtual void	sizeMatrixTagData () override

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

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

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

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

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

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

Detailed Description

Definition at line 16 of file INSFVVelocityNoQpComputation.h.

Constructor & Destructor Documentation

◆ INSFVVelocityNoQpComputation()

INSFVVelocityNoQpComputation::INSFVVelocityNoQpComputation ( const InputParameters & params )

Definition at line 14 of file INSFVVelocityNoQpComputation.C.

   : INSFVVelocityVariable(params)
 {
 }

Member Function Documentation

◆ adDofValues()

const MooseArray<ADReal>& INSFVVelocityNoQpComputation::adDofValues ( ) const

inlineoverridevirtual

Reimplemented from MooseVariableFV< Real >.

Definition at line 28 of file INSFVVelocityNoQpComputation.h.

   {
     mooseError("Qp-calculations should not be requested");
   }

◆ adGradSln()

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

overridevirtualinherited

Reimplemented from MooseVariableFV< Real >.

Definition at line 128 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 (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;
   }
 }

◆ 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);
     }
   }
 }