Computes Rhie-Chow face mass fluxes for porous flow with optional internal pressure jumps. More...

#include <PorousRhieChowMassFlux.h>

Inheritance diagram for PorousRhieChowMassFlux:

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	PorousRhieChowMassFlux (const InputParameters &params)
	Construct the porous Rhie-Chow mass flux object.

void	linkMomentumPressureSystems (const std::vector< LinearSystem * > &momentum_systems, LinearSystem &pressure_system, const std::vector< unsigned int > &momentum_system_numbers) override
	Update the momentum system-related information.

void	computeHbyA (bool verbose) override
	Computes the inverse of the diagonal (1/A) of the system matrix plus the H/A components for the pressure equation plus Rhie-Chow interpolation.

Real	getFaceSidePorosity (const FaceInfo &fi, bool elem_side, const Moose::StateArg &time) const
	Return the porosity on one side of a face.

Real	getSignedBaffleJump (const FaceInfo &fi, bool elem_side) const
	Return the pressure jump seen from one side of a baffle face.

bool	faceIsBaffle (const FaceInfo &fi) const
	Whether a face is governed by a pressure-jump model.

bool	hasPressureBaffles () const
	Whether at least one pressure-jump model is configured.

RealVectorValue	baffleFaceVelocity (const FaceInfo &fi, bool elem_side) const
	Return the superficial velocity at a baffle face as seen from one side.

Real	baffleNormalVelocity (const FaceInfo &fi) const
	Return the normal superficial velocity at a baffle face, recovered from the shared face mass flux and the face-interpolated density.

Real	cellPressureDiffusionCoefficient (const ElemInfo &elem_info, unsigned int component) const
	Cell coefficient whose face interpolation forms the pressure-diffusion tensor.

bool	pressureDiffusionDataReady () const
	Whether the pressure-diffusion kernel and cell coefficients are ready for interface use.

bool	pressureDiffusionUsesNonorthogonalCorrection () const
	Whether the linked pressure-diffusion kernel applies a nonorthogonal correction.

NS::FV::PressureJumpInterfaceData	pressureJumpInterfaceData (const FaceInfo &fi, const RealVectorValue &elem_gradient, const RealVectorValue &neighbor_gradient, Real face_area) const
	Construct the complete pressure-jump operator for a face.

void	initCouplingField () override
	Populate baffle-jump storage after initializing the pressure coupling field.

void	meshChanged () override
	Clear face-indexed baffle-jump data after a mesh change.

Real	getMassFlux (const FaceInfo &fi) const
	Get the face velocity times density (used in advection terms)

Real	getVolumetricFaceFlux (const FaceInfo &fi) const
	Get the volumetric face flux (used in advection terms)

virtual Real	getVolumetricFaceFlux (const Moose::FV::InterpMethod m, const FaceInfo &fi, const Moose::StateArg &time, const THREAD_ID tid, bool subtract_mesh_velocity) const override
	Retrieve the volumetric face flux, will not include derivatives.

template<typename VarType >
void	checkBlocks (const VarType &var) const
	Check the block consistency between the passed in `var` and us.

const LinearFVGradientReader &	pressureGradientField () const
	Get the registered pressure gradient field used by compatible momentum pressure kernels.

const LinearFVGradientReader &	basePressureGradientField () const
	Get the base pressure gradient field used to seed reconstructed gradient updates.

const std::vector< NumericVector< Number > * > &	basePressureGradientComponents () const
	Get the base-pressure gradient component vectors used to seed reconstructed updates.

const std::vector< std::unique_ptr< NumericVector< Number > > > &	HbyAComponents () const
	Get the momentum-layout H/A component vectors.

const std::vector< std::unique_ptr< NumericVector< Number > > > &	AinvComponents () const
	Get the momentum-layout 1/A component vectors.

unsigned int	pressureVariableNumber () const
	Variable number of the pressure variable reconstructed by this object.

unsigned int	dimension () const
	Number of spatial dimensions of the coupled momentum/pressure systems.

MooseLinearVariableFVReal &	velocityVariable (unsigned int component)
	Velocity variable for one spatial component.

const MooseLinearVariableFVReal &	velocityVariable (unsigned int component) const
	Velocity variable for one spatial component.

LinearSystem &	momentumSystem (unsigned int component)
	Momentum linear system for one spatial component.

const LinearSystem &	momentumSystem (unsigned int component) const
	Momentum linear system for one spatial component.

const LinearSystem &	pressureSystem () const
	Pressure linear system.

dof_id_type	faceMassFluxGeneration () const
	Producer counter for the conservative face mass flux: incremented every time computeFaceMassFlux() runs.

virtual void	initFaceMassFlux ()
	Initialize the container for face velocities.

virtual void	computeFaceMassFlux ()
	Update the values of the face velocities in the containers.

bool	usingReconstructedPressureGradientMethod () const
	Whether the registered pressure gradient field is produced by the reconstructed method.

void	prepareMomentumPredictor ()
	Snapshot the fields read by the next momentum predictor.

void	finalizeMomentumPredictor ()
	Capture the lagged velocity gradients computed while assembling the momentum predictor.

void	preparePISOCorrector ()
	Capture the lagged velocity gradient for another corrector using the current predictor.

void	preparePressureRelaxation ()
	Before pressure relaxation, form the conservative reconstructed candidate from the corrected face flux and update the cell velocity from that unrelaxed candidate.

void	finalizePressureCorrector ()
	After pressure relaxation, refresh every registered pressure gradient and publish relaxed reconstructed feedback for the next momentum predictor.

void	initPressureGradient ()
	Compute every registered pressure gradient once, before the first momentum predictor of a SIMPLE iteration sequence has anything to read.

virtual void	initialize () override

virtual void	execute () override

virtual void	finalize () override

virtual void	initialSetup () override

virtual void	timestepSetup () override
	Prepare reconstructed-gradient state once per attempted time step.

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

virtual Real	spatialValue (const Point &) const

virtual const std::vector< Point >	spatialPoints () const

void	setPrimaryThreadCopy (UserObject *primary)

UserObject *	primaryThreadCopy ()

SubProblem &	getSubProblem () const

bool	shouldDuplicateInitialExecution () const

void	gatherSum (T &value)

void	gatherMax (T &value)

void	gatherMin (T &value)

void	gatherProxyValueMax (T1 &proxy, T2 &value)

void	gatherProxyValueMin (T1 &proxy, T2 &value)

std::set< UserObjectName >	getDependObjects () const

const std::set< std::string > &	getRequestedItems () override

const std::set< std::string > &	getSuppliedItems () override

unsigned int	systemNumber () const

virtual bool	needThreadedCopy () const

virtual bool	enabled () const

std::shared_ptr< MooseObject >	getSharedPtr ()

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

bool	isKokkosObject () const

MooseApp &	getMooseApp () const

const std::string &	type () const

const std::string &	name () const

std::string	typeAndName () const

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

MooseObjectName	uniqueName () const

const InputParameters &	parameters () const

const hit::Node *	getHitNode () const

bool	hasBase () const

const std::string &	getBase () const

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

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

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

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

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

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

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

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

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

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

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

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

std::string	messagePrefix (const bool hit_prefix=true) const

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

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

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

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

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

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

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

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

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

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

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

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

void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) const

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

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

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

virtual void	jacobianSetup ()

virtual void	residualSetup ()

virtual void	customSetup (const ExecFlagType &)

const ExecFlagEnum &	getExecuteOnEnum () const

UserObjectName	getUserObjectName (const std::string &param_name) const

const T &	getUserObject (const std::string &param_name, bool is_dependency=true) const

const T &	getUserObjectByName (const UserObjectName &object_name, bool is_dependency=true) const

const UserObjectBase &	getUserObjectBase (const std::string &param_name, bool is_dependency=true) const

const UserObjectBase &	getUserObjectBaseByName (const UserObjectName &object_name, bool is_dependency=true) const

const std::vector< MooseVariableScalar * > &	getCoupledMooseScalarVars ()

const std::set< TagID > &	getScalarVariableCoupleableVectorTags () const

const std::set< TagID > &	getScalarVariableCoupleableMatrixTags () const

const GenericMaterialProperty< T, is_ad > &	getGenericMaterialProperty (const std::string &name, MaterialData &material_data, const unsigned int state=0)

const GenericMaterialProperty< T, is_ad > &	getGenericMaterialProperty (const std::string &name, const unsigned int state=0)

const GenericMaterialProperty< T, is_ad > &	getGenericMaterialProperty (const std::string &name, const unsigned int state=0)

const MaterialProperty< T > &	getMaterialProperty (const std::string &name, MaterialData &material_data, const unsigned int state=0)

const MaterialProperty< T > &	getMaterialProperty (const std::string &name, const unsigned int state=0)

const MaterialProperty< T > &	getMaterialProperty (const std::string &name, const unsigned int state=0)

const ADMaterialProperty< T > &	getADMaterialProperty (const std::string &name, MaterialData &material_data)

const ADMaterialProperty< T > &	getADMaterialProperty (const std::string &name)

const ADMaterialProperty< T > &	getADMaterialProperty (const std::string &name)

const MaterialProperty< T > &	getMaterialPropertyOld (const std::string &name, MaterialData &material_data)

const MaterialProperty< T > &	getMaterialPropertyOld (const std::string &name)

const MaterialProperty< T > &	getMaterialPropertyOld (const std::string &name)

const MaterialProperty< T > &	getMaterialPropertyOlder (const std::string &name, MaterialData &material_data)

const MaterialProperty< T > &	getMaterialPropertyOlder (const std::string &name)

const MaterialProperty< T > &	getMaterialPropertyOlder (const std::string &name)

const GenericMaterialProperty< T, is_ad > &	getGenericMaterialPropertyByName (const MaterialPropertyName &name, MaterialData &material_data, const unsigned int state)

const GenericMaterialProperty< T, is_ad > &	getGenericMaterialPropertyByName (const MaterialPropertyName &name, const unsigned int state=0)

const GenericMaterialProperty< T, is_ad > &	getGenericMaterialPropertyByName (const MaterialPropertyName &name, const unsigned int state=0)

const MaterialProperty< T > &	getMaterialPropertyByName (const MaterialPropertyName &name, MaterialData &material_data, const unsigned int state=0)

const MaterialProperty< T > &	getMaterialPropertyByName (const MaterialPropertyName &name, const unsigned int state=0)

const MaterialProperty< T > &	getMaterialPropertyByName (const MaterialPropertyName &name, const unsigned int state=0)

const ADMaterialProperty< T > &	getADMaterialPropertyByName (const MaterialPropertyName &name, MaterialData &material_data)

const ADMaterialProperty< T > &	getADMaterialPropertyByName (const MaterialPropertyName &name)

const ADMaterialProperty< T > &	getADMaterialPropertyByName (const MaterialPropertyName &name)

const MaterialProperty< T > &	getMaterialPropertyOldByName (const MaterialPropertyName &name, MaterialData &material_data)

const MaterialProperty< T > &	getMaterialPropertyOldByName (const MaterialPropertyName &name)

const MaterialProperty< T > &	getMaterialPropertyOldByName (const MaterialPropertyName &name)

const MaterialProperty< T > &	getMaterialPropertyOlderByName (const MaterialPropertyName &name, MaterialData &material_data)

const MaterialProperty< T > &	getMaterialPropertyOlderByName (const MaterialPropertyName &name)

const MaterialProperty< T > &	getMaterialPropertyOlderByName (const MaterialPropertyName &name)

Moose::Kokkos::MaterialProperty< T, dimension >	getKokkosMaterialPropertyByName (const std::string &prop_name_in)

Moose::Kokkos::MaterialProperty< T, dimension >	getKokkosMaterialPropertyOldByName (const std::string &prop_name)

Moose::Kokkos::MaterialProperty< T, dimension >	getKokkosMaterialPropertyOlderByName (const std::string &prop_name)

Moose::Kokkos::MaterialProperty< T, dimension >	getKokkosMaterialProperty (const std::string &name)

Moose::Kokkos::MaterialProperty< T, dimension >	getKokkosMaterialPropertyOld (const std::string &name)

Moose::Kokkos::MaterialProperty< T, dimension >	getKokkosMaterialPropertyOlder (const std::string &name)

std::pair< const MaterialProperty< T > *, std::set< SubdomainID > >	getBlockMaterialProperty (const MaterialPropertyName &name)

std::pair< Moose::Kokkos::MaterialProperty< T, dimension >, std::set< SubdomainID > >	getKokkosBlockMaterialProperty (const MaterialPropertyName &name)

const GenericMaterialProperty< T, is_ad > &	getGenericZeroMaterialProperty (const std::string &name)

const GenericMaterialProperty< T, is_ad > &	getGenericZeroMaterialProperty ()

const GenericMaterialProperty< T, is_ad > &	getGenericZeroMaterialPropertyByName (const std::string &prop_name)

const MaterialProperty< T > &	getZeroMaterialProperty (Ts... args)

std::set< SubdomainID >	getMaterialPropertyBlocks (const std::string &name)

std::vector< SubdomainName >	getMaterialPropertyBlockNames (const std::string &name)

std::set< BoundaryID >	getMaterialPropertyBoundaryIDs (const std::string &name)

std::vector< BoundaryName >	getMaterialPropertyBoundaryNames (const std::string &name)

void	checkBlockAndBoundaryCompatibility (std::shared_ptr< MaterialBase > discrete)

std::unordered_map< SubdomainID, std::vector< MaterialBase * > >	buildRequiredMaterials (bool allow_stateful=true)

void	statefulPropertiesAllowed (bool)

virtual bool	getMaterialPropertyCalled () const

virtual const std::unordered_set< unsigned int > &	getMatPropDependencies () const

virtual void	resolveOptionalProperties ()

const GenericMaterialProperty< T, is_ad > &	getPossiblyConstantGenericMaterialPropertyByName (const MaterialPropertyName &prop_name, MaterialData &material_data, const unsigned int state)

bool	isImplicit ()

Moose::StateArg	determineState () const

virtual void	threadJoin (const UserObject &) override

virtual void	threadJoin (const UserObject &) override

virtual void	subdomainSetup () override

virtual void	subdomainSetup () override

bool	hasUserObject (const std::string &param_name) const

bool	hasUserObject (const std::string &param_name) const

bool	hasUserObject (const std::string &param_name) const

bool	hasUserObject (const std::string &param_name) const

bool	hasUserObjectByName (const UserObjectName &object_name) const

bool	hasUserObjectByName (const UserObjectName &object_name) const

bool	hasUserObjectByName (const UserObjectName &object_name) const

bool	hasUserObjectByName (const UserObjectName &object_name) const

const GenericOptionalMaterialProperty< T, is_ad > &	getGenericOptionalMaterialProperty (const std::string &name, const unsigned int state=0)

const GenericOptionalMaterialProperty< T, is_ad > &	getGenericOptionalMaterialProperty (const std::string &name, const unsigned int state=0)

const OptionalMaterialProperty< T > &	getOptionalMaterialProperty (const std::string &name, const unsigned int state=0)

const OptionalMaterialProperty< T > &	getOptionalMaterialProperty (const std::string &name, const unsigned int state=0)

const OptionalADMaterialProperty< T > &	getOptionalADMaterialProperty (const std::string &name)

const OptionalADMaterialProperty< T > &	getOptionalADMaterialProperty (const std::string &name)

const OptionalMaterialProperty< T > &	getOptionalMaterialPropertyOld (const std::string &name)

const OptionalMaterialProperty< T > &	getOptionalMaterialPropertyOld (const std::string &name)

const OptionalMaterialProperty< T > &	getOptionalMaterialPropertyOlder (const std::string &name)

const OptionalMaterialProperty< T > &	getOptionalMaterialPropertyOlder (const std::string &name)

MaterialBase &	getMaterial (const std::string &name)

MaterialBase &	getMaterial (const std::string &name)

MaterialBase &	getMaterialByName (const std::string &name, bool no_warn=false)

MaterialBase &	getMaterialByName (const std::string &name, bool no_warn=false)

bool	hasMaterialProperty (const std::string &name)

bool	hasMaterialProperty (const std::string &name)

bool	hasMaterialPropertyByName (const std::string &name)

bool	hasMaterialPropertyByName (const std::string &name)

bool	hasADMaterialProperty (const std::string &name)

bool	hasADMaterialProperty (const std::string &name)

bool	hasADMaterialPropertyByName (const std::string &name)

bool	hasADMaterialPropertyByName (const std::string &name)

bool	hasKokkosMaterialProperty (const std::string &name)

bool	hasKokkosMaterialProperty (const std::string &name)

bool	hasKokkosMaterialPropertyByName (const std::string &name)

bool	hasKokkosMaterialPropertyByName (const std::string &name)

bool	hasGenericMaterialProperty (const std::string &name)

bool	hasGenericMaterialProperty (const std::string &name)

bool	hasGenericMaterialPropertyByName (const std::string &name)

bool	hasGenericMaterialPropertyByName (const std::string &name)

const Function &	getFunction (const std::string &name) const

const Function &	getFunctionByName (const FunctionName &name) const

bool	hasFunction (const std::string &param_name) const

bool	hasFunctionByName (const FunctionName &name) const

Moose::Kokkos::Function	getKokkosFunction (const std::string &name) const

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

Moose::Kokkos::Function	getKokkosFunctionByName (const FunctionName &name) const

const T &	getKokkosFunctionByName (const FunctionName &name) const

bool	hasKokkosFunction (const std::string &param_name) const

bool	hasKokkosFunctionByName (const FunctionName &name) const

bool	isDefaultPostprocessorValue (const std::string &param_name, const unsigned int index=0) const

bool	hasPostprocessor (const std::string &param_name, const unsigned int index=0) const

bool	hasPostprocessorByName (const PostprocessorName &name) const

std::size_t	coupledPostprocessors (const std::string &param_name) const

const PostprocessorName &	getPostprocessorName (const std::string &param_name, const unsigned int index=0) const

const VectorPostprocessorValue &	getVectorPostprocessorValue (const std::string &param_name, const std::string &vector_name) const

const VectorPostprocessorValue &	getVectorPostprocessorValue (const std::string &param_name, const std::string &vector_name, bool needs_broadcast) const

const VectorPostprocessorValue &	getVectorPostprocessorValueByName (const VectorPostprocessorName &name, const std::string &vector_name) const

const VectorPostprocessorValue &	getVectorPostprocessorValueByName (const VectorPostprocessorName &name, const std::string &vector_name, bool needs_broadcast) const

const VectorPostprocessorValue &	getVectorPostprocessorValueOld (const std::string &param_name, const std::string &vector_name) const

const VectorPostprocessorValue &	getVectorPostprocessorValueOld (const std::string &param_name, const std::string &vector_name, bool needs_broadcast) const

const VectorPostprocessorValue &	getVectorPostprocessorValueOldByName (const VectorPostprocessorName &name, const std::string &vector_name) const

const VectorPostprocessorValue &	getVectorPostprocessorValueOldByName (const VectorPostprocessorName &name, const std::string &vector_name, bool needs_broadcast) const

const ScatterVectorPostprocessorValue &	getScatterVectorPostprocessorValue (const std::string &param_name, const std::string &vector_name) const

const ScatterVectorPostprocessorValue &	getScatterVectorPostprocessorValueByName (const VectorPostprocessorName &name, const std::string &vector_name) const

const ScatterVectorPostprocessorValue &	getScatterVectorPostprocessorValueOld (const std::string &param_name, const std::string &vector_name) const

const ScatterVectorPostprocessorValue &	getScatterVectorPostprocessorValueOldByName (const VectorPostprocessorName &name, const std::string &vector_name) const

bool	hasVectorPostprocessor (const std::string &param_name, const std::string &vector_name) const

bool	hasVectorPostprocessor (const std::string &param_name) const

bool	hasVectorPostprocessorByName (const VectorPostprocessorName &name, const std::string &vector_name) const

bool	hasVectorPostprocessorByName (const VectorPostprocessorName &name) const

const VectorPostprocessorName &	getVectorPostprocessorName (const std::string &param_name) const

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

Sampler &	getSampler (const std::string &name)

T &	getSamplerByName (const SamplerName &name)

Sampler &	getSamplerByName (const SamplerName &name)

virtual void	meshDisplaced ()

PerfGraph &	perfGraph ()

const PostprocessorValue &	getPostprocessorValue (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValue (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValueOld (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValueOld (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValueOlder (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValueOlder (const std::string &param_name, const unsigned int index=0) const

virtual const PostprocessorValue &	getPostprocessorValueByName (const PostprocessorName &name) const

virtual const PostprocessorValue &	getPostprocessorValueByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOldByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOldByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOlderByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOlderByName (const PostprocessorName &name) const

bool	isVectorPostprocessorDistributed (const std::string &param_name) const

bool	isVectorPostprocessorDistributed (const std::string &param_name) const

bool	isVectorPostprocessorDistributedByName (const VectorPostprocessorName &name) const

bool	isVectorPostprocessorDistributedByName (const VectorPostprocessorName &name) const

const Distribution &	getDistribution (const std::string &name) const

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

const Distribution &	getDistribution (const std::string &name) const

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

const Distribution &	getDistributionByName (const DistributionName &name) const

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

const Distribution &	getDistributionByName (const DistributionName &name) const

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

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

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

unsigned int	numBlocks () const

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

unsigned int	blocksMaxDimension () const

bool	hasBlocks (const SubdomainName &name) const

bool	hasBlocks (const std::vector< SubdomainName > &names) const

bool	hasBlocks (const std::set< SubdomainName > &names) const

bool	hasBlocks (SubdomainID id) const

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

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

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

bool	isBlockSubset (const std::vector< SubdomainID > &ids) const

bool	hasBlockMaterialProperty (const std::string &prop_name)

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

virtual bool	blockRestricted () const

virtual void	checkVariable (const MooseVariableBase &variable) const

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

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

Static Public Member Functions
static InputParameters	validParams ()

static void	callMooseError (MooseApp const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node node, const bool show_trace=true)

static void	sort (typename std::vector< T > &vector)

static void	sortDFS (typename std::vector< T > &vector)

static void	cyclicDependencyError (CyclicDependencyException< T2 > &e, const std::string &header, NameFunc &&name_func)

static void	cyclicDependencyError (CyclicDependencyException< T2 > &e, const std::string &header)

static std::string	deduceFunctorName (const std::string &name, const InputParameters &params)

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

static constexpr PropertyValue::id_type	default_property_id

static constexpr PropertyValue::id_type	zero_property_id

static constexpr auto	SYSTEM

static constexpr auto	NAME

Protected Member Functions
template<typename GradientComponent >
void	updateCellVelocity (const std::vector< GradientComponent > &pressure_gradient)
	Update cell velocity from the supplied momentum-coupling pressure gradient.

const std::vector< NumericVector< Number > * > &	pressureGradientComponents () const
	Get the registered pressure gradient component vectors.

FVReconstructedPressureGradient &	reconstructedGradientMethod ()
	Access the reconstructed gradient method when it is selected.

const FVReconstructedPressureGradient &	reconstructedGradientMethod () const
	Access the reconstructed gradient method when it is selected.

void	checkReconstructedPressureGradientCompatibility () const
	Check the single-variable system layout assumed by reconstructed pressure-gradient vector ops.

Real	computeFacePressureGradientFlux (const FaceInfo &fi, PetscVectorReader &p_reader)
	Compute the pressure-gradient flux contribution for a single face.

void	setupMeshInformation ()
	Compute the cell volumes on the mesh.

void	populateCouplingFunctors (const std::vector< std::unique_ptr< NumericVector< Number > > > &raw_hbya, const std::vector< std::unique_ptr< NumericVector< Number > > > &raw_Ainv)
	Populate the face values of the H/A and 1/A fields.

Real	velocityBoundaryValue (unsigned int component, const FaceInfo &fi, const Moose::FaceArg &boundary_face) const
	Get the prescribed velocity value on a Dirichlet boundary face.

virtual bool	supportMeshVelocity () const override
	Returns whether the UO can support mesh velocity advection.

virtual void	addPostprocessorDependencyHelper (const PostprocessorName &name) const override

virtual void	addVectorPostprocessorDependencyHelper (const VectorPostprocessorName &name) const override

virtual void	addUserObjectDependencyHelper (const UserObjectBase &uo) const override

void	addReporterDependencyHelper (const ReporterName &reporter_name) override

void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const

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

const ReporterContextBase &	getReporterContextBaseByName (const ReporterName &reporter_name) const

const ReporterName &	getReporterName (const std::string &param_name) const

T &	declareRestartableData (const std::string &data_name, Args &&... args)

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

const T &	getRestartableData (const std::string &data_name) const

T &	declareRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)

T &	declareRecoverableData (const std::string &data_name, Args &&... args)

T &	declareRestartableDataWithObjectName (const std::string &data_name, const std::string &object_name, Args &&... args)

T &	declareRestartableDataWithObjectNameWithContext (const std::string &data_name, const std::string &object_name, void *context, Args &&... args)

std::string	restartableName (const std::string &data_name) const

const T &	getMeshProperty (const std::string &data_name, const std::string &prefix)

const T &	getMeshProperty (const std::string &data_name)

bool	hasMeshProperty (const std::string &data_name, const std::string &prefix) const

bool	hasMeshProperty (const std::string &data_name, const std::string &prefix) const

bool	hasMeshProperty (const std::string &data_name) const

bool	hasMeshProperty (const std::string &data_name) const

std::string	meshPropertyName (const std::string &data_name) const

PerfID	registerTimedSection (const std::string &section_name, const unsigned int level) const

PerfID	registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const

std::string	timedSectionName (const std::string &section_name) const

bool	isCoupledScalar (const std::string &var_name, unsigned int i=0) const

unsigned int	coupledScalarComponents (const std::string &var_name) const

unsigned int	coupledScalar (const std::string &var_name, unsigned int comp=0) const

libMesh::Order	coupledScalarOrder (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarValue (const std::string &var_name, unsigned int comp=0) const

const ADVariableValue &	adCoupledScalarValue (const std::string &var_name, unsigned int comp=0) const

const GenericVariableValue< is_ad > &	coupledGenericScalarValue (const std::string &var_name, unsigned int comp=0) const

const GenericVariableValue< false > &	coupledGenericScalarValue (const std::string &var_name, const unsigned int comp) const

const GenericVariableValue< true > &	coupledGenericScalarValue (const std::string &var_name, const unsigned int comp) const

const VariableValue &	coupledVectorTagScalarValue (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const

const VariableValue &	coupledMatrixTagScalarValue (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const

const VariableValue &	coupledScalarValueOld (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarValueOlder (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarDot (const std::string &var_name, unsigned int comp=0) const

const ADVariableValue &	adCoupledScalarDot (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarDotDot (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarDotOld (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarDotDotOld (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarDotDu (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarDotDotDu (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledVectorTagScalarValueByName (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledVectorTagScalarValue (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledScalarValue (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledScalarValueOld (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledScalarValueOlder (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledScalarDot (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::Scalar< const Real >	kokkosCoupledScalarDotDu (const std::string &var_name, unsigned int comp=0) const

const MooseVariableScalar *	getScalarVar (const std::string &var_name, unsigned int comp) const

virtual void	checkMaterialProperty (const std::string &name, const unsigned int state)

virtual void	getKokkosMaterialPropertyHook (const std::string &, const unsigned int)

void	markMatPropRequested (const std::string &)

MaterialPropertyName	getMaterialPropertyName (const std::string &name) const

void	checkExecutionStage ()

const T &	getReporterValue (const std::string &param_name, const std::size_t time_index=0)

const T &	getReporterValue (const std::string &param_name, ReporterMode mode, const std::size_t time_index=0)

const T &	getReporterValue (const std::string &param_name, const std::size_t time_index=0)

const T &	getReporterValue (const std::string &param_name, ReporterMode mode, const std::size_t time_index=0)

const T &	getReporterValueByName (const ReporterName &reporter_name, const std::size_t time_index=0)

const T &	getReporterValueByName (const ReporterName &reporter_name, ReporterMode mode, const std::size_t time_index=0)

const T &	getReporterValueByName (const ReporterName &reporter_name, const std::size_t time_index=0)

const T &	getReporterValueByName (const ReporterName &reporter_name, ReporterMode mode, const std::size_t time_index=0)

bool	hasReporterValue (const std::string &param_name) const

bool	hasReporterValue (const std::string &param_name) const

bool	hasReporterValue (const std::string &param_name) const

bool	hasReporterValue (const std::string &param_name) const

bool	hasReporterValueByName (const ReporterName &reporter_name) const

bool	hasReporterValueByName (const ReporterName &reporter_name) const

bool	hasReporterValueByName (const ReporterName &reporter_name) const

bool	hasReporterValueByName (const ReporterName &reporter_name) const

const GenericMaterialProperty< T, is_ad > *	defaultGenericMaterialProperty (const std::string &name)

const GenericMaterialProperty< T, is_ad > *	defaultGenericMaterialProperty (const std::string &name)

const MaterialProperty< T > *	defaultMaterialProperty (const std::string &name)

const MaterialProperty< T > *	defaultMaterialProperty (const std::string &name)

const ADMaterialProperty< T > *	defaultADMaterialProperty (const std::string &name)

const ADMaterialProperty< T > *	defaultADMaterialProperty (const std::string &name)

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

std::string	deduceFunctorName (const std::string &name) const

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

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

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

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

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

bool	isFunctor (const std::string &name, const SubProblem &subproblem) const

Moose::ElemArg	makeElemArg (const Elem *elem, bool correct_skewnewss=false) const

void	checkFunctorSupportsSideIntegration (const std::string &name, bool qp_integration)

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

Static Protected Member Functions
static std::string	meshPropertyName (const std::string &data_name, const std::string &prefix)

Protected Attributes
const MooseMesh &	_moose_mesh
	The `MooseMesh` that this user object operates on.

const libMesh::MeshBase &	_mesh
	The `libMesh` mesh that this object acts on.

const unsigned int	_dim
	The dimension of the mesh, e.g. 3 for hexes and tets, 2 for quads and tris.

const MooseLinearVariableFVReal *const	_p
	The thread 0 copy of the pressure variable.

std::vector< MooseLinearVariableFVReal * >	_vel
	Thread 0 copies of the velocity variables; non-const to allow writing cell velocities in updateCellVelocity().

LinearFVPressureCorrectionDiffusion *	_p_diffusion_kernel
	Pointer to the pressure diffusion term in the pressure Poisson equation.

FaceCenteredMapFunctor< Real, std::unordered_map< dof_id_type, Real > >	_HbyA_flux
	A map functor from faces to $HbyA_{ij} = (A_{offdiag}*\mathrm{(predicted~velocity)} - \mathrm{Source})_{ij}/A_{ij}$.

std::vector< std::unique_ptr< NumericVector< Number > > >	_HbyA_raw
	We hold on to the cell-based HbyA vectors so that we can easily reconstruct the cell velocities as well.

FaceCenteredMapFunctor< RealVectorValue, std::unordered_map< dof_id_type, RealVectorValue > >	_Ainv
	A map functor from faces to $(1/A)_f$.

std::vector< std::unique_ptr< NumericVector< Number > > >	_Ainv_raw
	We hold on to the cell-based 1/A vectors so that we can easily reconstruct the cell velocities as well.

std::unique_ptr< NumericVector< Number > >	_A_avg

FaceCenteredMapFunctor< Real, std::unordered_map< dof_id_type, Real > > &	_face_mass_flux
	A map functor from faces to mass fluxes which are used in the advection terms.

std::vector< std::unique_ptr< NumericVector< Number > > >	_grad_p_current
	Coupling pressure gradient captured before the current momentum predictor is assembled.

dof_id_type	_face_mass_flux_generation = 0
	Producer counter for the conservative face mass flux: incremented every time computeFaceMassFlux() runs.

const Moose::Functor< Real > &	_rho
	Functor describing the density of the fluid.

std::vector< LinearSystem * >	_momentum_systems
	Pointers to the linear system(s) in moose corresponding to the momentum equation(s)

std::vector< unsigned int >	_momentum_system_numbers
	Numbers of the momentum system(s)

std::vector< unsigned int >	_global_momentum_system_numbers
	Global numbers of the momentum system(s)

std::vector< libMesh::LinearImplicitSystem * >	_momentum_implicit_systems
	Pointers to the momentum equation implicit system(s) from libmesh.

LinearSystem *	_pressure_system
	Pointer to the pressure system.

const LinearFVGradientReader *	_pressure_gradient_field
	Registered pressure gradient field used by Rhie-Chow and compatible momentum pressure kernels.

const LinearFVGradientReader *	_base_pressure_gradient_field
	Base pressure gradient field used to seed reconstructed gradient updates.

unsigned int	_global_pressure_system_number
	Global number of the pressure system.

std::unique_ptr< NumericVector< Number > >	_cell_fluid_volumes
	Fluid volume of each cell, used to rapidly scale the pressure-gradient force in H/A and 1/A.

const MooseEnum	_pressure_projection_method
	Enumerator for the method used for pressure projection.

const Moose::FV::InterpMethod	_pressure_diffusion_interp_method
	Interpolation method used for the pressure diffusion coefficient on faces.

std::vector< const FaceInfo * >	_flow_face_info
	The subset of the FaceInfo objects that actually cover the subdomains which the flow field is defined on.

const Moose::CoordinateSystemType &	_coord_sys

const THREAD_ID	_tid

SubProblem &	_subproblem

FEProblemBase &	_fe_problem

SystemBase &	_sys

Assembly &	_assembly

const bool	_duplicate_initial_execution

std::set< std::string >	_depend_uo

const bool &	_enabled

MooseApp &	_app

Factory &	_factory

ActionFactory &	_action_factory

const std::string &	_type

const std::string &	_name

const InputParameters &	_pars

const ExecFlagEnum &	_execute_enum

const ExecFlagType &	_current_execute_flag

MooseApp &	_restartable_app

const std::string	_restartable_system_name

const THREAD_ID	_restartable_tid

const bool	_restartable_read_only

FEProblemBase &	_mci_feproblem

FEProblemBase &	_mdi_feproblem

MooseApp &	_pg_moose_app

const std::string	_prefix

FEProblemBase &	_sc_fe_problem

const THREAD_ID	_sc_tid

const Real &	_real_zero

const VariableValue &	_scalar_zero

const Point &	_point_zero

const InputParameters &	_mi_params

const std::string	_mi_name

const MooseObjectName	_mi_moose_object_name

FEProblemBase &	_mi_feproblem

SubProblem &	_mi_subproblem

const THREAD_ID	_mi_tid

const bool	_is_kokkos_object

const Moose::MaterialDataType	_material_data_type

MaterialData &	_material_data

bool	_stateful_allowed

bool	_get_material_property_called

std::vector< std::unique_ptr< PropertyValue > >	_default_properties

std::unordered_set< unsigned int >	_material_property_dependencies

const MaterialPropertyName	_get_suffix

const bool	_use_interpolated_state

const InputParameters &	_ti_params

FEProblemBase &	_ti_feproblem

bool	_is_implicit

Real &	_t

const Real &	_t_old

int &	_t_step

Real &	_dt

Real &	_dt_old

bool	_is_transient

const Parallel::Communicator &	_communicator

const MaterialData *	_blk_material_data

Static Protected Attributes
static const std::string	_interpolated_old

static const std::string	_interpolated_older

Private Member Functions
void	setupPorousMeshInformation ()
	Overwrite the cached cell fluid volumes with cell volume times porosity.

void	updateBaffleJumps ()
	Recompute and relax the pressure jumps using the current face mass fluxes.

const PressureJumpModel *	getPressureJumpModel (const FaceInfo &fi) const
	Return the pressure-jump model that applies to the face, or null if there is none.

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

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

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

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

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

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

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

bool	isDefaultPostprocessorValueByName (const PostprocessorName &name) const

PostprocessorValue	getDefaultPostprocessorValueByName (const PostprocessorName &name) const

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

bool	postprocessorsAdded () const

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

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

bool	vectorPostprocessorsAdded () const

bool	reportersAdded () const

void	possiblyCheckHasReporter (const ReporterName &reporter_name, const std::string &param_name="") const

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

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

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

virtual std::string	meshPropertyPrefix (const std::string &data_name) const

const RestartableDataValue &	getMeshPropertyInternal (const std::string &data_name, const std::string &prefix) const

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

const VariableValue *	getDefaultValue (const std::string &var_name) const

const ADVariableValue *	getADDefaultValue (const std::string &var_name) const

void	checkVar (const std::string &var_name) const

void	validateExecutionerType (const std::string &name, const std::string &fn_name) const

Moose::Kokkos::Variable	kokkosCoupledVectorTagScalarVariable (const std::string &var_name, const std::string &tag_name, unsigned int comp) const

Moose::MaterialDataType	getMaterialDataType (const std::set< BoundaryID > &boundary_ids) const

unsigned int	getMaxQps () const

void	addConsumedPropertyName (const MooseObjectName &obj_name, const std::string &prop_name)

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

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

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

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

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

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

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

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

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

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

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

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

virtual bool	isADObject () const override

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
const Moose::Functor< Real > &	_eps
	Porosity functor.

std::vector< const PressureJumpModel * >	_pressure_jump_models
	Pressure-jump models with mutually disjoint boundary sets.

const Real	_pressure_jump_relaxation
	Under-relaxation factor applied when updating pressure jumps.

std::vector< const LinearFVGradientReader * >	_velocity_gradients
	Published velocity gradients, one per component, read by the baffle face states.

FaceCenteredMapFunctor< Real, std::unordered_map< dof_id_type, Real > > &	_baffle_jump
	Restartable face field storing pressure as non-owner minus owner.

UserObject *	_primary_thread_copy

std::set< std::string >	_supplied_uo

const ParallelParamObject &	_parent

const MooseBase &	_si_moose_base

const FEProblemBase *	_si_problem

ExecFlagEnum	_empty_execute_enum

const MooseObject &	_fni_object

const InputParameters &	_fni_params

FEProblemBase &	_fni_feproblem

const THREAD_ID	_fni_tid

const MooseObject &	_uoi_moose_object

const FEProblemBase &	_uoi_feproblem

const THREAD_ID	_uoi_tid

const MooseObject &	_ppi_moose_object

const InputParameters &	_ppi_params

const FEProblemBase &	_ppi_feproblem

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

const bool	_broadcast_by_default

const MooseObject &	_vpi_moose_object

const FEProblemBase &	_vpi_feproblem

const THREAD_ID	_vpi_tid

const InputParameters &	_ri_params

FEProblemBase &	_ri_fe_problem_base

const ReporterData &	_ri_reporter_data

const MooseObject &	_ri_moose_object

const InputParameters &	_dni_params

FEProblemBase &	_dni_feproblem

const MooseObject *const	_dni_moose_object_ptr

const InputParameters &	_si_params

FEProblemBase &	_si_feproblem

THREAD_ID	_si_tid

const RestartableDataMapName	_metaname

std::string	_restartable_name

MooseApp &	_meta_data_app

const MooseObject *const	_meta_data_object

const InputParameters &	_sc_parameters

const std::string &	_sc_name

const bool	_sc_is_implicit

std::unordered_map< std::string, std::vector< MooseVariableScalar * > >	_coupled_scalar_vars

std::unordered_map< std::string, std::unique_ptr< VariableValue > >	_default_value

std::unordered_map< std::string, std::unique_ptr< ADVariableValue > >	_dual_default_value

std::vector< MooseVariableScalar * >	_coupled_moose_scalar_vars

std::unordered_map< std::string, std::vector< MooseVariableFieldBase * > >	_sc_coupled_vars

std::set< TagID >	_sc_coupleable_vector_tags

std::set< TagID >	_sc_coupleable_matrix_tags

const MooseObject &	_mi_moose_object

const bool	_mi_boundary_restricted

const std::set< SubdomainID > &	_mi_block_ids

const std::set< BoundaryID > &	_mi_boundary_ids

std::vector< std::unique_ptr< OptionalMaterialPropertyProxyBase< MaterialPropertyInterface > > >	_optional_property_proxies

const std::string	_ti_name

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

const InputParameters &	_fi_params

const std::string	_fi_name

SubProblem *const	_fi_subproblem

const THREAD_ID	_fi_tid

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

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

Detailed Description

Computes Rhie-Chow face mass fluxes for porous flow with optional internal pressure jumps.

This object supplies side-specific porosity values to porous momentum kernels, maintains the relaxed pressure jump on each modeled baffle face, and applies the jump consistently to pressure reconstruction and face fluxes.

Definition at line 29 of file PorousRhieChowMassFlux.h.

Constructor & Destructor Documentation

◆ PorousRhieChowMassFlux()

PorousRhieChowMassFlux::PorousRhieChowMassFlux ( const InputParameters & params )

Construct the porous Rhie-Chow mass flux object.

Parameters

params The input parameters for the object

Definition at line 49 of file PorousRhieChowMassFlux.C.

  : RhieChowMassFlux(params),
    _eps(getFunctor<Real>(NS::porosity)),
    _pressure_jump_relaxation(getParam<Real>("pressure_jump_relaxation")),
    _baffle_jump(
        declareRestartableData<FaceCenteredMapFunctor<Real, std::unordered_map<dof_id_type, Real>>>(
            "baffle_jump", _moose_mesh, blockIDs(), "baffle_jump"))
{
  // A face on this object's blocks must be either fully internal or fully external to the
  // pressure and velocity variables too; a face that is one-sided for a momentum variable but
  // two-sided for this object has no baffle treatment.
  if (_p->blockIDs() != blockIDs())
    paramError(NS::pressure,
               "Pressure variable '",
               _p->name(),
               "' must have the same block restriction as this object. Variable blocks: ",
               Moose::stringify(_p->blockIDs()),
               "; this object's blocks: ",
               Moose::stringify(blockIDs()),
               ".");
  for (const auto * const velocity : _vel)
    if (velocity->blockIDs() != blockIDs())
      paramError("u",
                 "Velocity variable '",
                 velocity->name(),
                 "' must have the same block restriction as this object. Variable blocks: ",
                 Moose::stringify(velocity->blockIDs()),
                 "; this object's blocks: ",
                 Moose::stringify(blockIDs()),
                 ".");
 
  std::unordered_set<BoundaryID> pressure_jump_boundary_ids;
  for (const auto & model_name : getParam<std::vector<UserObjectName>>("pressure_jump_models"))
  {
    const auto & model = getUserObjectByName<PressureJumpModel>(model_name);
    for (const auto boundary_id : model.boundaryIDs())
      if (!pressure_jump_boundary_ids.insert(boundary_id).second)
        paramError("pressure_jump_models",
                   "Pressure jump models must not act on overlapping boundaries.");
    _pressure_jump_models.push_back(&model);
 
    // A jump model evaluating different porosity or density than this object would act on a
    // flow that is not the one being solved.
    for (const auto & [model_param, rc_param] :
         {std::make_pair("porosity", NS::porosity), std::make_pair("density", NS::density)})
      if (model.parameters().have_parameter<MooseFunctorName>(model_param) &&
          model.getParam<MooseFunctorName>(model_param) != getParam<MooseFunctorName>(rc_param))
        paramError("pressure_jump_models",
                   "Pressure jump model '",
                   model.name(),
                   "' uses ",
                   model_param,
                   " '",
                   model.getParam<MooseFunctorName>(model_param),
                   "' but this object uses '",
                   getParam<MooseFunctorName>(rc_param),
                   "'.");
  }
}

Member Function Documentation

◆ AinvComponents()

const std::vector< std::unique_ptr< NumericVector< Number > > > & RhieChowMassFlux::AinvComponents ( ) const

inherited

Get the momentum-layout 1/A component vectors.

Definition at line 724 of file RhieChowMassFlux.C.

{
  mooseAssert(!_Ainv_raw.empty(), "Ainv data is not ready.");
 
  return _Ainv_raw;
}

Referenced by TestRhieChowMassFluxSequence::execute(), and FVReconstructedPressureGradient::reconstructPressureGradient().

◆ baffleFaceVelocity()

RealVectorValue PorousRhieChowMassFlux::baffleFaceVelocity	(	const FaceInfo &	fi,
		bool	elem_side
	)		const

Return the superficial velocity at a baffle face as seen from one side.

The velocity is extrapolated from the side's cell center with that side's velocity gradient, which is exact for a velocity that is linear on each side and needs no data from across the baffle. Before linkMomentumPressureSystems() collects the FVVelocityJumpGreenGaussGradient velocity gradients, no gradient is available and the cell velocity is returned.

Parameters

fi	The baffle face
elem_side	Whether to return the element-side state

Definition at line 332 of file PorousRhieChowMassFlux.C.

{
  mooseAssert(fi.neighborPtr() && faceIsBaffle(fi), "Baffle face states require a baffle face.");
 
  const auto & cell_info = elem_side ? *fi.elemInfo() : *fi.neighborInfo();
  const auto state = Moose::currentState();
  RealVectorValue velocity;
  for (const auto component : index_range(_vel))
    velocity(component) = _vel[component]->getElemValue(cell_info, state);
 
  // Gradient history is initialized before the velocity gradients are linked.
  if (_velocity_gradients.empty())
    return velocity;
 
  const auto cell_to_face = fi.faceCentroid() - cell_info.centroid();
  for (const auto component : index_range(_vel))
    velocity(component) += _velocity_gradients[component]->gradient(cell_info) * cell_to_face;
 
  return velocity;
}

Referenced by LinearPWCNSFVMomentumFlux::baffleStressData(), LinearPWCNSFVMomentumFlux::computeBaffleAdvectionExplicitCorrection(), and FVVelocityJumpGreenGaussGradient::internalFaceValues().

◆ baffleNormalVelocity()

Real PorousRhieChowMassFlux::baffleNormalVelocity ( const FaceInfo & fi ) const

Return the normal superficial velocity at a baffle face, recovered from the shared face mass flux and the face-interpolated density.

Density is assumed to vary smoothly across the baffle, so both sides share this value.

Parameters

fi	The baffle face

Definition at line 354 of file PorousRhieChowMassFlux.C.

{
  mooseAssert(fi.neighborPtr() && faceIsBaffle(fi), "Baffle face states require a baffle face.");
 
  const auto state = Moose::currentState();
  const Real elem_rho = _rho(makeElemArg(fi.elemPtr()), state);
  const Real neighbor_rho = _rho(makeElemArg(fi.neighborPtr()), state);
  if (elem_rho <= 0.0 || neighbor_rho <= 0.0)
    mooseError("density must be positive on pressure-jump face ", fi.id(), ".");
 
  // Mass conservation makes rho U.n continuous. Density is assumed to vary smoothly across the
  // baffle, as in BernoulliFormLossPressureJump, so the same face-interpolated density recovers
  // one normal velocity for both sides. Dividing by the cell-center density instead would make
  // the normal velocity first-order accurate wherever density varies within the cell.
  Real face_rho = 0.0;
  Moose::FV::interpolate(
      Moose::FV::InterpMethod::Average, face_rho, elem_rho, neighbor_rho, fi, true);
  return _face_mass_flux.evaluate(&fi) / face_rho;
}

Referenced by LinearPWCNSFVMomentumFlux::computeBaffleAdvectionExplicitCorrection().

◆ basePressureGradientComponents()

const std::vector< NumericVector< Number > * > & RhieChowMassFlux::basePressureGradientComponents ( ) const

inherited

Get the base-pressure gradient component vectors used to seed reconstructed updates.

Definition at line 732 of file RhieChowMassFlux.C.

{
  return basePressureGradientField().components();
}

Referenced by FVReconstructedPressureGradient::computeCandidateFromCorrectedFlux(), and RhieChowMassFlux::finalizePressureCorrector().

◆ basePressureGradientField()

const LinearFVGradientReader & RhieChowMassFlux::basePressureGradientField ( ) const

inherited

Get the base pressure gradient field used to seed reconstructed gradient updates.

Definition at line 705 of file RhieChowMassFlux.C.

{
  if (!_base_pressure_gradient_field)
    mooseError("The base pressure gradient field has not been registered for RhieChowMassFlux '",
               name(),
               "'.");
 
  return *_base_pressure_gradient_field;
}

Referenced by RhieChowMassFlux::basePressureGradientComponents(), computeHbyA(), and linkMomentumPressureSystems().

◆ cellPressureDiffusionCoefficient()

Real PorousRhieChowMassFlux::cellPressureDiffusionCoefficient	(	const ElemInfo &	elem_info,
		unsigned int	component
	)		const

Cell coefficient whose face interpolation forms the pressure-diffusion tensor.

Definition at line 375 of file PorousRhieChowMassFlux.C.

{
  mooseAssert(component < _Ainv_raw.size(), "Invalid pressure-diffusion component.");
 
  const auto momentum_dof = elem_info.dofIndices()[_global_momentum_system_numbers[component]][0];
  const Real density = _rho(makeElemArg(elem_info.elem()), Moose::currentState());
  return density * (*_Ainv_raw[component])(momentum_dof);
}

Referenced by pressureJumpInterfaceData().

◆ checkBlocks()

template<typename VarType >

void RhieChowMassFlux::checkBlocks ( const VarType & var ) const

inherited

Check the block consistency between the passed in var and us.

Definition at line 325 of file RhieChowMassFlux.h.

{
  const auto & var_blocks = var.blockIDs();
  const auto & uo_blocks = blockIDs();
 
  // Error if this UO has any blocks that the variable does not
  std::set<SubdomainID> uo_blocks_minus_var_blocks;
  std::set_difference(uo_blocks.begin(),
                      uo_blocks.end(),
                      var_blocks.begin(),
                      var_blocks.end(),
                      std::inserter(uo_blocks_minus_var_blocks, uo_blocks_minus_var_blocks.end()));
  if (uo_blocks_minus_var_blocks.size() > 0)
    mooseError("Block restriction of interpolator user object '",
               this->name(),
               "' (",
               Moose::stringify(blocks()),
               ") includes blocks not in the block restriction of variable '",
               var.name(),
               "' (",
               Moose::stringify(var.blocks()),
               ")");
 
  // Get the blocks in the variable but not this UO
  std::set<SubdomainID> var_blocks_minus_uo_blocks;
  std::set_difference(var_blocks.begin(),
                      var_blocks.end(),
                      uo_blocks.begin(),
                      uo_blocks.end(),
                      std::inserter(var_blocks_minus_uo_blocks, var_blocks_minus_uo_blocks.end()));
 
  // For each block in the variable but not this UO, error if there is connection
  // to any blocks on the UO.
  for (auto & block_id : var_blocks_minus_uo_blocks)
  {
    const auto connected_blocks = _moose_mesh.getBlockConnectedBlocks(block_id);
    std::set<SubdomainID> connected_blocks_on_uo;
    std::set_intersection(connected_blocks.begin(),
                          connected_blocks.end(),
                          uo_blocks.begin(),
                          uo_blocks.end(),
                          std::inserter(connected_blocks_on_uo, connected_blocks_on_uo.end()));
    if (connected_blocks_on_uo.size() > 0)
      mooseError("Block restriction of interpolator user object '",
                 this->name(),
                 "' (",
                 Moose::stringify(uo_blocks),
                 ") doesn't match the block restriction of variable '",
                 var.name(),
                 "' (",
                 Moose::stringify(var_blocks),
                 ")");
  }
}

Referenced by LinearFVEnergyAdvection::LinearFVEnergyAdvection(), LinearFVScalarAdvection::LinearFVScalarAdvection(), LinearFVTurbulentAdvection::LinearFVTurbulentAdvection(), and RhieChowMassFlux::RhieChowMassFlux().

◆ checkReconstructedPressureGradientCompatibility()

void RhieChowMassFlux::checkReconstructedPressureGradientCompatibility ( ) const

protectedinherited

Check the single-variable system layout assumed by reconstructed pressure-gradient vector ops.

Definition at line 1226 of file RhieChowMassFlux.C.

{
  if (!_pressure_system || !_pressure_gradient_field || !_base_pressure_gradient_field ||
      !_p_diffusion_kernel)
    mooseError("RhieChowMassFlux '",
               name(),
               "' is missing a required pressure system, pressure-gradient field, base-gradient "
               "field, or pressure-correction diffusion kernel for reconstructed pressure "
               "gradients.");
 
  reconstructedGradientMethod().validateSetup(*this);
 
  if (_momentum_systems.size() != _dim || _momentum_implicit_systems.size() != _dim ||
      _global_momentum_system_numbers.size() != _dim)
    mooseError("RhieChowMassFlux '",
               name(),
               "' requires one linked momentum system per spatial component for reconstructed "
               "pressure gradients.");
 
  if (_pressure_system->nVariables() != 1)
    mooseError(
        "FVReconstructedPressureGradient assumes the pressure and momentum systems each have "
        "exactly one variable so their DOF indices can be used in vector operations. Pressure "
        "system '",
        _pressure_system->name(),
        "' has variables: ",
        Moose::stringify(_pressure_system->getVariableNames()));
 
  for (const auto system_i : index_range(_momentum_systems))
  {
    const auto * const momentum_system = _momentum_systems[system_i];
    if (!momentum_system || !_momentum_implicit_systems[system_i])
      mooseError("RhieChowMassFlux '",
                 name(),
                 "' has an invalid momentum-system layout for component ",
                 system_i,
                 ".");
 
    if (momentum_system->nVariables() != 1)
      mooseError("FVReconstructedPressureGradient assumes the pressure and momentum systems each "
                 "have exactly one variable so their DOF indices can be used in vector operations. "
                 "Momentum system '",
                 momentum_system->name(),
                 "' has variables: ",
                 Moose::stringify(momentum_system->getVariableNames()));
  }
}

Referenced by RhieChowMassFlux::linkMomentumPressureSystems().

◆ computeFaceMassFlux()

void RhieChowMassFlux::computeFaceMassFlux ( )

virtualinherited

Update the values of the face velocities in the containers.

Definition at line 761 of file RhieChowMassFlux.C.

{
  using namespace Moose::FV;
 
  // Petsc vector reader to make the repeated reading from the vector faster
  PetscVectorReader p_reader(*_pressure_system->system().current_local_solution);
 
  // We loop through the faces and compute the face fluxes using the pressure gradient
  // and the momentum matrix/right hand side
  for (auto & fi : _flow_face_info)
  {
    const Real p_grad_flux = computeFacePressureGradientFlux(*fi, p_reader);
    // Compute the new face flux
    const Real face_flux = -_HbyA_flux[fi->id()] + p_grad_flux;
    _face_mass_flux[fi->id()] = face_flux;
  }
 
  ++_face_mass_flux_generation;
}

Referenced by LinearAssemblySegregatedSolve::correctVelocity(), and TestRhieChowMassFluxSequence::execute().

◆ computeFacePressureGradientFlux()

Real RhieChowMassFlux::computeFacePressureGradientFlux	(	const FaceInfo &	fi,
		PetscVectorReader &	p_reader
	)

protectedinherited

Compute the pressure-gradient flux contribution for a single face.

Definition at line 811 of file RhieChowMassFlux.C.

{
  // Making sure the kernel knows which face we are on
  _p_diffusion_kernel->setupFaceData(&fi);
 
  // We are setting this to 1.0 because we don't want to multiply the kernel contributions
  // with the surface area yet. The surface area will be factored in in the advection kernels.
  _p_diffusion_kernel->setCurrentFaceArea(1.0);
 
  Real p_grad_flux = 0.0;
  if (_p->isInternalFace(fi))
  {
    const auto & elem_info = *fi.elemInfo();
    const auto & neighbor_info = *fi.neighborInfo();
 
    // Fetching the dof indices for the pressure variable
    const auto elem_dof = elem_info.dofIndices()[_global_pressure_system_number][0];
    const auto neighbor_dof = neighbor_info.dofIndices()[_global_pressure_system_number][0];
 
    // Fetching the values of the pressure for the element and the neighbor
    const auto p_elem_value = p_reader(elem_dof);
    const auto p_neighbor_value = p_reader(neighbor_dof);
 
    // Compute the elem matrix contributions for the face
    const auto elem_matrix_contribution = _p_diffusion_kernel->computeElemMatrixContribution();
    const auto neighbor_matrix_contribution =
        _p_diffusion_kernel->computeNeighborMatrixContribution();
    const auto elem_rhs_contribution = _p_diffusion_kernel->computeElemRightHandSideContribution();
 
    // Compute the face flux from the matrix and right hand side contributions
    p_grad_flux = (p_neighbor_value * neighbor_matrix_contribution +
                   p_elem_value * elem_matrix_contribution) -
                  elem_rhs_contribution;
  }
  else if (auto * bc_pointer = _p->getBoundaryCondition(*fi.boundaryIDs().begin()))
  {
    mooseAssert(fi.boundaryIDs().size() == 1, "We should only have one boundary on every face.");
    bc_pointer->setupFaceData(
        &fi, fi.faceType(std::make_pair(_p->number(), _global_pressure_system_number)));
 
    const auto time_arg = Moose::currentState();
    const ElemInfo & elem_info =
        hasBlocks(fi.elemPtr()->subdomain_id()) ? *fi.elemInfo() : *fi.neighborInfo();
    const auto p_elem_value = _p->getElemValue(elem_info, time_arg);
    const auto matrix_contribution =
        _p_diffusion_kernel->computeBoundaryMatrixContribution(*bc_pointer);
    const auto rhs_contribution = _p_diffusion_kernel->computeBoundaryRHSContribution(*bc_pointer);
 
    // On the boundary, only the element side has a contribution
    p_grad_flux = p_elem_value * matrix_contribution - rhs_contribution;
  }
 
  return p_grad_flux;
}

Referenced by RhieChowMassFlux::computeFaceMassFlux().

◆ computeHbyA()

void PorousRhieChowMassFlux::computeHbyA ( bool verbose )

overridevirtual

Computes the inverse of the diagonal (1/A) of the system matrix plus the H/A components for the pressure equation plus Rhie-Chow interpolation.

Reimplemented from RhieChowMassFlux.

Definition at line 219 of file PorousRhieChowMassFlux.C.

{
  // This runs before every pressure corrector, so PIMPLE relaxes the jump once per PISO corrector
  // and the effective relaxation per outer iteration grows with num_piso_iterations. Without a
  // reconstructed pressure gradient, all those updates use the same face flux.
  updateBaffleJumps();
 
  // Pressure jumps are external data for the variable's gradient method. Refresh that field
  // before pressure assembly even though the pressure solution itself has not changed yet.
  if (hasPressureBaffles())
    _pressure_system->updateFVGradient(basePressureGradientField());
 
  RhieChowMassFlux::computeHbyA(verbose);
 
  // Each side of a baffle carries its own momentum relation rho_s U_s.n = -h_s + (pressure flux),
  // with h_s = rho_s (H/A)_s.n. Continuity of the mass flux weights the side H/A fluxes with the
  // same half-cell conductances as the pressure, so a body force balanced by the pressure on each
  // side (a fluid at rest across a porosity or density jump) gives zero face flux. The face area
  // is 1 to match computeFacePressureGradientFlux, and the pressure gradients only enter the
  // nonorthogonal correction, which the H/A flux does not use.
  if (hasPressureBaffles())
    for (const auto * const fi : _flow_face_info)
      if (_vel[0]->isInternalFace(*fi) && faceIsBaffle(*fi))
        _HbyA_flux[fi->id()] = NS::FV::pressureJumpHbyAFlux(
            pressureJumpInterfaceData(*fi, RealVectorValue(), RealVectorValue(), 1.0));
}

◆ dimension()

unsigned int RhieChowMassFlux::dimension ( ) const

inlineinherited

Number of spatial dimensions of the coupled momentum/pressure systems.

Definition at line 75 of file RhieChowMassFlux.h.

75{ return _dim; }

Referenced by FVReconstructedPressureGradient::assembleFaceProjection(), FVReconstructedPressureGradient::computeCandidateFromCorrectedFlux(), FVVelocityJumpGreenGaussGradient::internalFaceValues(), FVReconstructedPressureGradient::linkFlowSystem(), RhieChowMassFlux::preparePISOCorrector(), pressureDiffusionDataReady(), pressureJumpInterfaceData(), FVReconstructedPressureGradient::reconstructionVelocityGradient(), FVReconstructedPressureGradient::saveLaggedVelocityGradient(), and FVReconstructedPressureGradient::validateSetup().

◆ execute()

virtual void RhieChowMassFlux::execute ( )

inlineoverridevirtualinherited

Implements GeneralUserObject.

Definition at line 150 of file RhieChowMassFlux.h.

150{}

◆ faceIsBaffle()

bool PorousRhieChowMassFlux::faceIsBaffle ( const FaceInfo & fi ) const

Whether a face is governed by a pressure-jump model.

Definition at line 326 of file PorousRhieChowMassFlux.C.

{
  return getPressureJumpModel(fi) != nullptr;
}

Referenced by LinearPWCNSFVMomentumFlux::addMatrixContribution(), baffleFaceVelocity(), baffleNormalVelocity(), LinearPWCNSFVMomentumFlux::computeBaffleAdvectionExplicitCorrection(), LinearPWCNSFVMomentumFlux::computeElemRightHandSideContribution(), computeHbyA(), LinearPWCNSFVMomentumFlux::computeNeighborRightHandSideContribution(), FVPressureJumpGreenGaussGradient::internalFaceValues(), FVVelocityJumpGreenGaussGradient::internalFaceValues(), pressureJumpInterfaceData(), and FVReconstructedPressureGradient::reconstructionVelocityGradient().

◆ faceMassFluxGeneration()

dof_id_type RhieChowMassFlux::faceMassFluxGeneration ( ) const

inlineinherited

Producer counter for the conservative face mass flux: incremented every time computeFaceMassFlux() runs.

Used to verify reconstruction consumes the face flux produced by the current pressure corrector, not one left over from a preceding corrector.

Definition at line 103 of file RhieChowMassFlux.h.

103{ return _face_mass_flux_generation; }

Referenced by FVReconstructedPressureGradient::computeCandidateFromCorrectedFlux().

◆ finalize()

virtual void RhieChowMassFlux::finalize ( )

inlineoverridevirtualinherited

Implements GeneralUserObject.

Definition at line 151 of file RhieChowMassFlux.h.

151{}

◆ finalizeMomentumPredictor()

void RhieChowMassFlux::finalizeMomentumPredictor ( )

inherited

Capture the lagged velocity gradients computed while assembling the momentum predictor.

Definition at line 413 of file RhieChowMassFlux.C.

{
  if (usingReconstructedPressureGradientMethod())
    reconstructedGradientMethod().saveLaggedVelocityGradient(*this);
}

Referenced by LinearAssemblySegregatedSolve::solveMomentumPredictor().

◆ finalizePressureCorrector()

void RhieChowMassFlux::finalizePressureCorrector ( )

inherited

After pressure relaxation, refresh every registered pressure gradient and publish relaxed reconstructed feedback for the next momentum predictor.

Ordinary methods also update the cell velocity here, preserving their existing relaxed-pressure behavior.

Definition at line 446 of file RhieChowMassFlux.C.

{
  if (usingReconstructedPressureGradientMethod())
  {
    // Refresh every ordinary pressure gradient while leaving the old coupling field untouched
    // until the current reconstructed candidate has been relaxed into it.
    _pressure_system->computeGradientsExcept(pressureGradientField());
    reconstructedGradientMethod().finalizeCouplingPressureGradient(
        *this, basePressureGradientComponents());
    _pressure_system->updateFVGradient(pressureGradientField());
  }
  else
  {
    _pressure_system->computeGradients();
    updateCellVelocity(pressureGradientComponents());
  }
}

Referenced by LinearAssemblySegregatedSolve::correctVelocity().

◆ getFaceSidePorosity()

Real PorousRhieChowMassFlux::getFaceSidePorosity	(	const FaceInfo &	fi,
		bool	elem_side,
		const Moose::StateArg &	time
	)		const

Return the porosity on one side of a face.

Parameters

fi	The face on which to evaluate porosity
elem_side	Whether to use the element side instead of the neighbor side
time	The solution state at which to evaluate porosity

Definition at line 280 of file PorousRhieChowMassFlux.C.

{
  const Elem * const elem = elem_side ? fi.elemPtr() : fi.neighborPtr();
  if (!elem)
    return 1.0;
 
  return _eps(makeElemArg(elem), time);
}

Referenced by LinearPWCNSFVMomentumFlux::inversePorosity(), and LinearPWCNSFVMomentumFlux::isClearFluidSide().

◆ getMassFlux()

Real RhieChowMassFlux::getMassFlux ( const FaceInfo & fi ) const

inherited

Get the face velocity times density (used in advection terms)

Definition at line 615 of file RhieChowMassFlux.C.

{
  return _face_mass_flux.evaluate(&fi);
}

Referenced by LinearFVEnergyAdvection::setupFaceData(), LinearFVTurbulentAdvection::setupFaceData(), LinearWCNSFV2PMomentumDriftFlux::setupFaceData(), and LinearWCNSFVMomentumFlux::setupFaceData().

◆ getPressureJumpModel()

const PressureJumpModel * PorousRhieChowMassFlux::getPressureJumpModel ( const FaceInfo & fi ) const

private

Return the pressure-jump model that applies to the face, or null if there is none.

Definition at line 455 of file PorousRhieChowMassFlux.C.

{
  const PressureJumpModel * face_model = nullptr;
  for (const auto * const model : _pressure_jump_models)
    if (model->appliesTo(fi))
    {
      // The models act on disjoint boundaries, but a face can still carry boundaries of two
      // models, which would make its jump ambiguous.
      mooseAssert(!face_model,
                  "Pressure-jump face " + std::to_string(fi.id()) +
                      " lies on boundaries of more than one pressure jump model.");
      face_model = model;
    }
 
  return face_model;
}

Referenced by faceIsBaffle(), getSignedBaffleJump(), and updateBaffleJumps().

◆ getSignedBaffleJump()

Real PorousRhieChowMassFlux::getSignedBaffleJump	(	const FaceInfo &	fi,
		bool	elem_side
	)		const

Return the pressure jump seen from one side of a baffle face.

Parameters

fi	The face on which to query the jump
elem_side	Whether to return the jump seen from the element side

Definition at line 292 of file PorousRhieChowMassFlux.C.

{
  const auto * const pressure_jump_model = getPressureJumpModel(fi);
  if (!pressure_jump_model)
    return 0.0;
 
  const Real J = _baffle_jump.evaluate(&fi);
  const bool elem_is_owner = pressure_jump_model->elemIsOwner(fi);
  // J is stored as (p_non_owner - p_owner), so the owner side sees -J.
  return (elem_side == elem_is_owner) ? -J : J;
}

Referenced by FVPressureJumpGreenGaussGradient::internalFaceValues(), and pressureJumpInterfaceData().

◆ getVolumetricFaceFlux() [1/2]

Real RhieChowMassFlux::getVolumetricFaceFlux ( const FaceInfo & fi ) const

inherited

Get the volumetric face flux (used in advection terms)

Definition at line 621 of file RhieChowMassFlux.C.

{
  const std::string neighbor_cell_id =
      fi.neighborPtr() ? std::to_string(fi.neighborPtr()->id()) : "none";
  const auto face_flux = _face_mass_flux.find(fi.id());
  if (face_flux == _face_mass_flux.end())
    mooseError("RhieChowMassFlux '",
               name(),
               "' has no corrected mass flux for face ID ",
               fi.id(),
               " adjacent to cell ID ",
               fi.elem().id(),
               " and neighbor cell ID ",
               neighbor_cell_id,
               ".");
 
  if (!std::isfinite(face_flux->second))
    mooseError("RhieChowMassFlux '",
               name(),
               "' has non-finite corrected mass flux ",
               face_flux->second,
               " on face ID ",
               fi.id(),
               " adjacent to cell ID ",
               fi.elem().id(),
               " and neighbor cell ID ",
               neighbor_cell_id,
               ".");
 
  // On a face shared with a non-flow block, the FaceInfo element may be the non-flow cell, so
  // the density must be evaluated on the flow side.
  const Elem * face_side = fi.elemPtr();
  if (!_vel[0]->isInternalFace(fi) && !hasBlocks(fi.elemPtr()->subdomain_id()))
    face_side = fi.neighborPtr();
 
  const Moose::FaceArg face_arg{&fi,
                                /*limiter_type=*/Moose::FV::LimiterType::CentralDifference,
                                /*elem_is_upwind=*/true,
                                /*correct_skewness=*/false,
                                face_side,
                                /*state_limiter*/ nullptr};
  const Real face_rho = _rho(face_arg, Moose::currentState());
  if (!std::isfinite(face_rho) || face_rho <= 0.0)
    mooseError("RhieChowMassFlux '",
               name(),
               "' requires finite, positive density for corrected face flux reconstruction, but "
               "density is ",
               face_rho,
               " on face ID ",
               fi.id(),
               " adjacent to cell ID ",
               fi.elem().id(),
               " and neighbor cell ID ",
               neighbor_cell_id,
               ".");
 
  const Real volumetric_flux = face_flux->second / face_rho;
  if (!std::isfinite(volumetric_flux))
    mooseError("RhieChowMassFlux '",
               name(),
               "' computed non-finite volumetric flux ",
               volumetric_flux,
               " on face ID ",
               fi.id(),
               " adjacent to cell ID ",
               fi.elem().id(),
               " and neighbor cell ID ",
               neighbor_cell_id,
               ".");
 
  return volumetric_flux;
}

Referenced by FVReconstructedPressureGradient::assembleFaceProjection(), and LinearFVScalarAdvection::setupFaceData().

◆ getVolumetricFaceFlux() [2/2]

virtual Real RhieChowMassFlux::getVolumetricFaceFlux	(	const Moose::FV::InterpMethod	m,
		const FaceInfo &	fi,
		const Moose::StateArg &	time,
		const THREAD_ID	tid,
		bool	subtract_mesh_velocity
	)		const

overridevirtualinherited

Retrieve the volumetric face flux, will not include derivatives.

Parameters

m	The velocity interpolation method. This is either Rhie-Chow or Average. Rhie-Chow is recommended as it avoids checkerboards in the pressure field
fi	The face that we wish to retrieve the velocity for
tid	The thread ID

Returns: The face velocity

Implements RhieChowFaceFluxProvider.

◆ hasFaceSide()

bool RhieChowFaceFluxProvider::hasFaceSide	(	const FaceInfo &	fi,
		const bool	fi_elem_side
	)		const

overridevirtualinherited

Implements FaceArgInterface.

Definition at line 27 of file RhieChowFaceFluxProvider.C.

{
  if (fi_elem_side)
    return hasBlocks(fi.elem().subdomain_id());
  else
    return fi.neighborPtr() && hasBlocks(fi.neighbor().subdomain_id());
}

◆ hasPressureBaffles()

bool PorousRhieChowMassFlux::hasPressureBaffles ( ) const

inline

Whether at least one pressure-jump model is configured.

Definition at line 66 of file PorousRhieChowMassFlux.h.

66{ return !_pressure_jump_models.empty(); }

Referenced by computeHbyA(), and linkMomentumPressureSystems().

◆ HbyAComponents()

const std::vector< std::unique_ptr< NumericVector< Number > > > & RhieChowMassFlux::HbyAComponents ( ) const

inherited

Get the momentum-layout H/A component vectors.

Definition at line 716 of file RhieChowMassFlux.C.

{
  mooseAssert(!_HbyA_raw.empty(), "HbyA data is not ready.");
 
  return _HbyA_raw;
}

Referenced by FVReconstructedPressureGradient::reconstructPressureGradient().

◆ initCouplingField()

void PorousRhieChowMassFlux::initCouplingField ( )

overridevirtual

Populate baffle-jump storage after initializing the pressure coupling field.

Reimplemented from RhieChowMassFlux.

Definition at line 271 of file PorousRhieChowMassFlux.C.

{
  RhieChowMassFlux::initCouplingField();
 
  for (const auto & fi : _fe_problem.mesh().faceInfo())
    _baffle_jump[fi->id()];
}

◆ initFaceMassFlux()

void RhieChowMassFlux::initFaceMassFlux ( )

virtualinherited

Initialize the container for face velocities.

Definition at line 565 of file RhieChowMassFlux.C.

{
  using namespace Moose::FV;
 
  const auto time_arg = Moose::currentState();
 
  // We loop through the faces and compute the resulting face fluxes from the
  // initial conditions for velocity
  for (auto & fi : _flow_face_info)
  {
    RealVectorValue density_times_velocity;
    // On internal face we do a regular interpolation with geometric weights
    if (_vel[0]->isInternalFace(*fi))
    {
      const auto & elem_info = *fi->elemInfo();
      const auto & neighbor_info = *fi->neighborInfo();
 
      Real elem_rho = _rho(makeElemArg(fi->elemPtr()), time_arg);
      Real neighbor_rho = _rho(makeElemArg(fi->neighborPtr()), time_arg);
 
      for (const auto dim_i : index_range(_vel))
        interpolate(InterpMethod::Average,
                    density_times_velocity(dim_i),
                    _vel[dim_i]->getElemValue(elem_info, time_arg) * elem_rho,
                    _vel[dim_i]->getElemValue(neighbor_info, time_arg) * neighbor_rho,
                    *fi,
                    true);
    }
    // On the boundary, we just take the boundary values
    else
    {
      const bool elem_is_fluid = hasBlocks(fi->elemPtr()->subdomain_id());
      const Elem * const boundary_elem = elem_is_fluid ? fi->elemPtr() : fi->neighborPtr();
 
      // We need this multiplier in case the face is an internal face and
      const Real boundary_normal_multiplier = elem_is_fluid ? 1.0 : -1.0;
      const Moose::FaceArg boundary_face{
          fi, Moose::FV::LimiterType::CentralDifference, true, false, boundary_elem, nullptr};
 
      const Real face_rho = _rho(boundary_face, time_arg);
      for (const auto dim_i : index_range(_vel))
        density_times_velocity(dim_i) = boundary_normal_multiplier * face_rho *
                                        velocityBoundaryValue(dim_i, *fi, boundary_face);
    }
 
    _face_mass_flux[fi->id()] = density_times_velocity * fi->normal();
  }
}

Referenced by LinearAssemblySegregatedSolve::linkRhieChowUserObject().

◆ initialize()

void RhieChowMassFlux::initialize ( )

overridevirtualinherited

Implements GeneralUserObject.

Definition at line 555 of file RhieChowMassFlux.C.

{
  for (const auto & pair : _HbyA_flux)
    _HbyA_flux[pair.first] = 0;
 
  for (const auto & pair : _Ainv)
    _Ainv[pair.first] = 0;
}

◆ initialSetup()

void RhieChowMassFlux::initialSetup ( )

overridevirtualinherited

Reimplemented from GeneralUserObject.

Definition at line 471 of file RhieChowMassFlux.C.

{
  // We fetch the pressure diffusion kernel to ensure that the face flux correction
  // is consistent with the pressure discretization in the Poisson equation.
  std::vector<LinearFVFluxKernel *> flux_kernel;
  auto base_query = _fe_problem.theWarehouse()
                        .query()
                        .template condition<AttribThread>(_tid)
                        .template condition<AttribSysNum>(_p->sys().number())
                        .template condition<AttribSystem>("LinearFVFluxKernel")
                        .template condition<AttribName>(getParam<std::string>("p_diffusion_kernel"))
                        .queryInto(flux_kernel);
  if (flux_kernel.size() != 1)
    paramError(
        "p_diffusion_kernel",
        "The kernel with the given name could not be found or multiple instances were identified.");
  _p_diffusion_kernel = dynamic_cast<LinearFVPressureCorrectionDiffusion *>(flux_kernel[0]);
  if (!_p_diffusion_kernel)
    paramError("p_diffusion_kernel",
               "The provided diffusion kernel must be of type "
               "LinearFVPressureCorrectionDiffusion.");
}

◆ initPressureGradient()

void RhieChowMassFlux::initPressureGradient ( )

inherited

Compute every registered pressure gradient once, before the first momentum predictor of a SIMPLE iteration sequence has anything to read.

Definition at line 465 of file RhieChowMassFlux.C.

{
  _pressure_system->computeGradients();
}

Referenced by TestRhieChowMassFluxSequence::execute(), and LinearAssemblySegregatedSolve::solve().

◆ linkMomentumPressureSystems()

void PorousRhieChowMassFlux::linkMomentumPressureSystems	(	const std::vector< LinearSystem * > &	momentum_systems,
		LinearSystem &	pressure_system,
		const std::vector< unsigned int > &	momentum_system_numbers
	)

overridevirtual

Update the momentum system-related information.

Parameters

momentum_systems	Pointers to the momentum systems which are solved for the momentum vector components
pressure_system	Reference to the pressure system
momentum_system_numbers	The numbers of these systems

Reimplemented from RhieChowMassFlux.

Definition at line 110 of file PorousRhieChowMassFlux.C.

{
  RhieChowMassFlux::linkMomentumPressureSystems(
      momentum_systems, pressure_system, momentum_system_numbers);
 
  // A pressure jump represents a baffle interior to the flow domain. A boundary with no
  // flow-block element on one side is a domain boundary, not a baffle. The boundary element
  // range this check needs is not yet built when this object is constructed.
  for (const auto * const model : _pressure_jump_models)
    for (const auto boundary_id : model->boundaryIDs())
      if (_moose_mesh.isBoundaryFullyExternalToSubdomains(boundary_id, blockIDs()))
        paramError("pressure_jump_models",
                   "Pressure jump model '",
                   model->name(),
                   "' boundary '",
                   _moose_mesh.getBoundaryName(boundary_id),
                   "' is not internal to this object's blocks. Pressure-jump baffles must lie "
                   "strictly inside the flow domain.");
 
  // The porous momentum pressure kernels must weight the pressure gradient with the porosity
  // this object uses to form the face fluxes.
  for (const auto system_number : momentum_system_numbers)
  {
    std::vector<LinearFVElementalKernel *> kernels;
    _fe_problem.theWarehouse()
        .query()
        .template condition<AttribThread>(_tid)
        .template condition<AttribSystem>("LinearFVElementalKernel")
        .template condition<AttribSysNum>(system_number)
        .queryInto(kernels);
 
    for (const auto * const kernel : kernels)
      if (const auto * const pressure_kernel =
              dynamic_cast<const LinearPWCNSFVMomentumPressure *>(kernel);
          pressure_kernel && MooseUtils::setsIntersect(pressure_kernel->blockIDs(), blockIDs()) &&
          pressure_kernel->getParam<MooseFunctorName>(NS::porosity) !=
              getParam<MooseFunctorName>(NS::porosity))
        paramError(NS::porosity,
                   "Momentum pressure kernel '",
                   pressure_kernel->name(),
                   "' uses porosity '",
                   pressure_kernel->getParam<MooseFunctorName>(NS::porosity),
                   "' but this object uses '",
                   getParam<MooseFunctorName>(NS::porosity),
                   "'.");
  }
 
  if (hasPressureBaffles() &&
      !dynamic_cast<const LinearFVPressureCorrectionDiffusionJump *>(_p_diffusion_kernel))
    paramError("p_diffusion_kernel",
               "Pressure jump models require LinearFVPressureCorrectionDiffusionJump.");
 
  auto * const pressure_var =
      dynamic_cast<MooseLinearVariableFVReal *>(&_pressure_system->getVariable(0, _p->number()));
  mooseAssert(pressure_var, "The pressure variable type was checked by RhieChowMassFlux.");
  const auto & solution_gradient_reader = pressure_var->requestCellGradients();
 
  if (hasPressureBaffles())
  {
    auto * const jump_gradient_method = dynamic_cast<FVPressureJumpGreenGaussGradient *>(
        &_fe_problem.getFVGradientMethod(solution_gradient_reader.method().name(), _tid));
    if (!jump_gradient_method)
      mooseError("Pressure variable '",
                 pressure_var->name(),
                 "' must use FVPressureJumpGreenGaussGradient as its default gradient method "
                 "when this object has pressure baffles.");
 
    jump_gradient_method->linkFlowSystem(*this, solution_gradient_reader);
 
    if (usingReconstructedPressureGradientMethod())
    {
      if (&basePressureGradientField().method() != &solution_gradient_reader.method())
        mooseError("FVReconstructedPressureGradient '",
                   reconstructedGradientMethod().name(),
                   "' must use the pressure variable's FVPressureJumpGreenGaussGradient as its "
                   "base_gradient_method when this object has pressure baffles.");
    }
    else if (&pressureGradientField().method() != &solution_gradient_reader.method())
      mooseError(
          "Momentum pressure kernels coupled to this object must use the pressure "
          "variable's FVPressureJumpGreenGaussGradient or an FVReconstructedPressureGradient "
          "based on it when pressure baffles are present.");
 
    // Velocity gradients that interpolate across a baffle turn the physical velocity jump into
    // a slope. Every consumer of the default velocity gradient must see the one-sided states.
    _velocity_gradients.clear();
    for (auto * const velocity : _vel)
    {
      const auto & velocity_gradient = velocity->requestCellGradients();
      auto * const velocity_gradient_method = dynamic_cast<FVVelocityJumpGreenGaussGradient *>(
          &_fe_problem.getFVGradientMethod(velocity_gradient.method().name(), _tid));
      if (!velocity_gradient_method)
        mooseError("Velocity variable '",
                   velocity->name(),
                   "' must use FVVelocityJumpGreenGaussGradient as its default gradient method "
                   "when this object has pressure baffles.");
 
      velocity_gradient_method->linkFlowSystem(*this);
      _velocity_gradients.push_back(&velocity_gradient);
    }
  }
 
  setupPorousMeshInformation();
}

◆ meshChanged()

void PorousRhieChowMassFlux::meshChanged ( )

overridevirtual

Clear face-indexed baffle-jump data after a mesh change.

Reimplemented from RhieChowMassFlux.

Definition at line 247 of file PorousRhieChowMassFlux.C.

{
  RhieChowMassFlux::meshChanged();
  _baffle_jump.clear();
  setupPorousMeshInformation();
}

◆ momentumSystem() [1/2]

LinearSystem & RhieChowMassFlux::momentumSystem ( unsigned int component )

inlineinherited

Momentum linear system for one spatial component.

Definition at line 87 of file RhieChowMassFlux.h.

87{ return *_momentum_systems[component]; }

Referenced by FVReconstructedPressureGradient::computeCandidateFromCorrectedFlux(), FVVelocityJumpGreenGaussGradient::internalFaceValues(), FVReconstructedPressureGradient::linkFlowSystem(), RhieChowMassFlux::preparePISOCorrector(), FVReconstructedPressureGradient::reconstructionVelocityGradient(), FVReconstructedPressureGradient::reconstructPressureGradient(), and FVReconstructedPressureGradient::validateSetup().

◆ momentumSystem() [2/2]

const LinearSystem & RhieChowMassFlux::momentumSystem ( unsigned int component ) const

inlineinherited

Momentum linear system for one spatial component.

Definition at line 90 of file RhieChowMassFlux.h.

  {
    return *_momentum_systems[component];
  }

◆ populateCouplingFunctors()

void RhieChowMassFlux::populateCouplingFunctors	(	const std::vector< std::unique_ptr< NumericVector< Number > > > &	raw_hbya,
		const std::vector< std::unique_ptr< NumericVector< Number > > > &	raw_Ainv
	)

protectedinherited

Populate the face values of the H/A and 1/A fields.

Definition at line 880 of file RhieChowMassFlux.C.

{
  // We have the raw H/A and 1/A vectors in a petsc format. This function
  // will create face functors from them
  using namespace Moose::FV;
  const auto time_arg = Moose::currentState();
 
  // Create the petsc vector readers for faster repeated access
  std::vector<PetscVectorReader> hbya_reader;
  for (const auto dim_i : index_range(raw_hbya))
    hbya_reader.emplace_back(*raw_hbya[dim_i]);
 
  std::vector<PetscVectorReader> ainv_reader;
  for (const auto dim_i : index_range(raw_Ainv))
    ainv_reader.emplace_back(*raw_Ainv[dim_i]);
 
  // We loop through the faces and populate the coupling fields (face H/A and 1/A)
  for (auto & fi : _flow_face_info)
  {
    Real face_rho = 0;
    RealVectorValue face_hbya;
 
    // We do the lookup in advance
    auto & Ainv = _Ainv[fi->id()];
 
    // If it is internal, we just interpolate (using geometric weights) to the face
    if (_vel[0]->isInternalFace(*fi))
    {
      // Get the dof indices for the element and the neighbor
      const auto & elem_info = *fi->elemInfo();
      const auto & neighbor_info = *fi->neighborInfo();
      const auto elem_dof = elem_info.dofIndices()[_global_momentum_system_numbers[0]][0];
      const auto neighbor_dof = neighbor_info.dofIndices()[_global_momentum_system_numbers[0]][0];
 
      // Get the density values for the element and neighbor. We need this multiplication to make
      // the coupling fields mass fluxes.
      const Real elem_rho = _rho(makeElemArg(fi->elemPtr()), time_arg);
      const Real neighbor_rho = _rho(makeElemArg(fi->neighborPtr()), time_arg);
 
      // Now we do the interpolation to the face
      interpolate(Moose::FV::InterpMethod::Average, face_rho, elem_rho, neighbor_rho, *fi, true);
      for (const auto dim_i : index_range(raw_hbya))
      {
        interpolate(Moose::FV::InterpMethod::Average,
                    face_hbya(dim_i),
                    hbya_reader[dim_i](elem_dof),
                    hbya_reader[dim_i](neighbor_dof),
                    *fi,
                    true);
        interpolate(_pressure_diffusion_interp_method,
                    Ainv(dim_i),
                    elem_rho * ainv_reader[dim_i](elem_dof),
                    neighbor_rho * ainv_reader[dim_i](neighbor_dof),
                    *fi,
                    true);
      }
    }
    else
    {
      const bool elem_is_fluid = hasBlocks(fi->elemPtr()->subdomain_id());
 
      // We need this multiplier in case the face is an internal face and
      const Real boundary_normal_multiplier = elem_is_fluid ? 1.0 : -1.0;
 
      const ElemInfo & elem_info = elem_is_fluid ? *fi->elemInfo() : *fi->neighborInfo();
      const auto elem_dof = elem_info.dofIndices()[_global_momentum_system_numbers[0]][0];
 
      mooseAssert(fi->boundaryIDs().size() == 1, "We should only have one boundary on every face.");
      const auto * pressure_bc = _p->getBoundaryCondition(*fi->boundaryIDs().begin());
 
      // For the legacy Dirichlet-velocity plus extrapolated-pressure path, we still need a
      // special boundary HbyA reconstruction to keep the face flux consistent. When the pressure
      // BC itself is a LinearFVPressureFluxBC, that object already enforces the prescribed
      // boundary mass flux, so we use the standard one-term boundary expansion instead.
      if (_vel[0]->isDirichletBoundaryFace(*fi) &&
          !dynamic_cast<const LinearFVPressureFluxBC *>(pressure_bc))
      {
        const Moose::FaceArg boundary_face{
            fi, Moose::FV::LimiterType::CentralDifference, true, false, elem_info.elem(), nullptr};
        face_rho = _rho(boundary_face, Moose::currentState());
 
        for (const auto dim_i : make_range(_dim))
        {
 
          face_hbya(dim_i) =
              -MetaPhysicL::raw_value((*_vel[dim_i])(boundary_face, Moose::currentState()));
          face_hbya(dim_i) *= boundary_normal_multiplier;
        }
      }
      // Otherwise we just do a one-term expansion (so we just use the element value)
      else
      {
        const auto elem_dof = elem_info.dofIndices()[_global_momentum_system_numbers[0]][0];
 
        face_rho = _rho(makeElemArg(elem_info.elem()), time_arg);
        for (const auto dim_i : make_range(_dim))
          face_hbya(dim_i) = boundary_normal_multiplier * hbya_reader[dim_i](elem_dof);
      }
 
      // We just do a one-term expansion for 1/A no matter what
      const Real elem_rho = _rho(makeElemArg(elem_info.elem()), time_arg);
      for (const auto dim_i : index_range(raw_Ainv))
        Ainv(dim_i) = elem_rho * ainv_reader[dim_i](elem_dof);
    }
    // Lastly, we populate the face flux resulted by H/A
    _HbyA_flux[fi->id()] = face_hbya * fi->normal() * face_rho;
  }
}

Referenced by RhieChowMassFlux::computeHbyA().

◆ prepareMomentumPredictor()

void RhieChowMassFlux::prepareMomentumPredictor ( )

inherited

Snapshot the fields read by the next momentum predictor.

Definition at line 402 of file RhieChowMassFlux.C.

{
  mooseAssert(_pressure_gradient_field,
              "The pressure gradient field must be linked before preparing momentum.");
 
  _grad_p_current.clear();
  for (const auto & component : pressureGradientComponents())
    _grad_p_current.push_back(component->clone());
}

Referenced by LinearAssemblySegregatedSolve::solve().

◆ preparePISOCorrector()

void RhieChowMassFlux::preparePISOCorrector ( )

inherited

Capture the lagged velocity gradient for another corrector using the current predictor.

Definition at line 420 of file RhieChowMassFlux.C.

{
  if (!usingReconstructedPressureGradientMethod())
    return;
 
  mooseAssert(!_grad_p_current.empty(),
              "A momentum predictor must be prepared before another PISO corrector.");
 
  for (const auto component : make_range(dimension()))
    momentumSystem(component).updateFVGradient(velocityVariable(component).requestCellGradients());
  reconstructedGradientMethod().saveLaggedVelocityGradient(*this);
}

Referenced by PIMPLESolve::correctVelocity(), and TestRhieChowMassFluxSequence::execute().

◆ preparePressureRelaxation()

void RhieChowMassFlux::preparePressureRelaxation ( )

inherited

Before pressure relaxation, form the conservative reconstructed candidate from the corrected face flux and update the cell velocity from that unrelaxed candidate.

No-op for ordinary pressure-gradient methods.

Definition at line 434 of file RhieChowMassFlux.C.

{
  if (!usingReconstructedPressureGradientMethod())
    return;
 
  // The current pressure solution and corrected face flux are both unrelaxed here. Form the
  // conservative candidate before pressure relaxation replaces that solution.
  reconstructedGradientMethod().computeCandidateFromCorrectedFlux(*this);
  updateCellVelocity(reconstructedGradientMethod().reconstructedCandidate(*this));
}

Referenced by LinearAssemblySegregatedSolve::correctVelocity(), and TestRhieChowMassFluxSequence::execute().

◆ pressureDiffusionDataReady()

bool PorousRhieChowMassFlux::pressureDiffusionDataReady ( ) const

Whether the pressure-diffusion kernel and cell coefficients are ready for interface use.

Definition at line 386 of file PorousRhieChowMassFlux.C.

{
  return _p_diffusion_kernel && _Ainv_raw.size() == dimension() && _HbyA_raw.size() == dimension();
}

Referenced by FVPressureJumpGreenGaussGradient::internalFaceValues(), pressureDiffusionUsesNonorthogonalCorrection(), and pressureJumpInterfaceData().

◆ pressureDiffusionUsesNonorthogonalCorrection()

bool PorousRhieChowMassFlux::pressureDiffusionUsesNonorthogonalCorrection ( ) const

Whether the linked pressure-diffusion kernel applies a nonorthogonal correction.

Definition at line 392 of file PorousRhieChowMassFlux.C.

{
  mooseAssert(pressureDiffusionDataReady(), "Pressure-diffusion data must be ready first.");
  return _p_diffusion_kernel->useNonorthogonalCorrection();
}

Referenced by pressureJumpInterfaceData().

◆ pressureGradientComponents()

const std::vector< NumericVector< Number > * > & RhieChowMassFlux::pressureGradientComponents ( ) const

protectedinherited

Get the registered pressure gradient component vectors.

Definition at line 1195 of file RhieChowMassFlux.C.

{
  return pressureGradientField().components();
}

Referenced by RhieChowMassFlux::finalizePressureCorrector(), and RhieChowMassFlux::prepareMomentumPredictor().

◆ pressureGradientField()

const LinearFVGradientReader & RhieChowMassFlux::pressureGradientField ( ) const

inherited

Get the registered pressure gradient field used by compatible momentum pressure kernels.

Definition at line 695 of file RhieChowMassFlux.C.

{
  if (!_pressure_gradient_field)
    mooseError(
        "The pressure gradient field has not been registered for RhieChowMassFlux '", name(), "'.");
 
  return *_pressure_gradient_field;
}

Referenced by RhieChowMassFlux::finalizePressureCorrector(), linkMomentumPressureSystems(), RhieChowMassFlux::pressureGradientComponents(), RhieChowMassFlux::reconstructedGradientMethod(), RhieChowMassFlux::reconstructedGradientMethod(), FVReconstructedPressureGradient::resetForTimeStep(), and RhieChowMassFlux::usingReconstructedPressureGradientMethod().

◆ pressureJumpInterfaceData()

NS::FV::PressureJumpInterfaceData PorousRhieChowMassFlux::pressureJumpInterfaceData	(	const FaceInfo &	fi,
		const RealVectorValue &	elem_gradient,
		const RealVectorValue &	neighbor_gradient,
		Real	face_area
	)		const

Construct the complete pressure-jump operator for a face.

Parameters

fi	The face on which to construct the operator
elem_gradient	The lagged pressure gradient in the element
neighbor_gradient	The lagged pressure gradient in the neighbor
face_area	The area multiplier used by the caller's flux convention

Definition at line 399 of file PorousRhieChowMassFlux.C.

{
  NS::FV::PressureJumpInterfaceData data;
  if (!fi.neighborPtr() || !faceIsBaffle(fi))
    return data;
 
  mooseAssert(pressureDiffusionDataReady(),
              "Pressure-diffusion data must be ready before constructing a baffle face operator.");
 
  const auto & elem_info = *fi.elemInfo();
  const auto & neighbor_info = *fi.neighborInfo();
  const auto time_arg = Moose::currentState();
  const Real elem_rho = _rho(makeElemArg(fi.elemPtr()), time_arg);
  const Real neighbor_rho = _rho(makeElemArg(fi.neighborPtr()), time_arg);
  RealVectorValue elem_diffusion;
  RealVectorValue neighbor_diffusion;
  RealVectorValue elem_rho_hbya;
  RealVectorValue neighbor_rho_hbya;
  for (const auto component : make_range(dimension()))
  {
    elem_diffusion(component) = cellPressureDiffusionCoefficient(elem_info, component);
    neighbor_diffusion(component) = cellPressureDiffusionCoefficient(neighbor_info, component);
    const auto system_number = _global_momentum_system_numbers[component];
    elem_rho_hbya(component) =
        elem_rho * (*_HbyA_raw[component])(elem_info.dofIndices()[system_number][0]);
    neighbor_rho_hbya(component) =
        neighbor_rho * (*_HbyA_raw[component])(neighbor_info.dofIndices()[system_number][0]);
  }
 
  data = NS::FV::pressureJumpInterfaceData(fi.normal(),
                                           fi.faceCentroid() - elem_info.centroid(),
                                           neighbor_info.centroid() - fi.faceCentroid(),
                                           elem_diffusion,
                                           neighbor_diffusion,
                                           elem_gradient,
                                           neighbor_gradient,
                                           elem_rho_hbya,
                                           neighbor_rho_hbya,
                                           face_area,
                                           pressureDiffusionUsesNonorthogonalCorrection(),
                                           getSignedBaffleJump(fi, /*elem_side=*/true));
 
  // A valid mesh gives positive projected half-cell distances, and a positive momentum diagonal
  // and density give positive conductances.
  mooseAssert(data.valid,
              "Cannot construct the pressure-jump operator on face " + std::to_string(fi.id()) +
                  ": the half-cell distances, normal pressure diffusion coefficients, face area, "
                  "and conductances must be finite and positive, and the corrections finite.");
 
  return data;
}

Referenced by computeHbyA(), FVPressureJumpGreenGaussGradient::internalFaceValues(), and LinearFVPressureCorrectionDiffusionJump::jumpInterfaceData().

◆ pressureSystem()

const LinearSystem & RhieChowMassFlux::pressureSystem ( ) const

inlineinherited

Pressure linear system.

Definition at line 96 of file RhieChowMassFlux.h.

96{ return *_pressure_system; }

Referenced by FVReconstructedPressureGradient::computeCandidateFromCorrectedFlux(), FVPressureJumpGreenGaussGradient::linkFlowSystem(), FVReconstructedPressureGradient::linkFlowSystem(), FVReconstructedPressureGradient::updateCouplingPressureGradient(), and FVReconstructedPressureGradient::validateSetup().

◆ pressureVariableNumber()

unsigned int RhieChowMassFlux::pressureVariableNumber ( ) const

inherited

Variable number of the pressure variable reconstructed by this object.

Definition at line 738 of file RhieChowMassFlux.C.

{
  return _p->number();
}

Referenced by FVPressureJumpGreenGaussGradient::linkFlowSystem(), FVReconstructedPressureGradient::linkFlowSystem(), and FVReconstructedPressureGradient::validateSetup().

◆ reconstructedGradientMethod() [1/2]

FVReconstructedPressureGradient & RhieChowMassFlux::reconstructedGradientMethod ( )

protectedinherited

Access the reconstructed gradient method when it is selected.

Definition at line 1217 of file RhieChowMassFlux.C.

{
  auto & method = _fe_problem.getFVGradientMethod(pressureGradientField().method().name(), _tid);
  mooseAssert(&method == &pressureGradientField().method(),
              "The registered writable gradient method must match the pressure-gradient reader.");
  return dynamic_cast<FVReconstructedPressureGradient &>(method);
}

Referenced by RhieChowMassFlux::checkReconstructedPressureGradientCompatibility(), RhieChowMassFlux::finalizeMomentumPredictor(), RhieChowMassFlux::finalizePressureCorrector(), RhieChowMassFlux::linkMomentumPressureSystems(), linkMomentumPressureSystems(), RhieChowMassFlux::preparePISOCorrector(), RhieChowMassFlux::preparePressureRelaxation(), and RhieChowMassFlux::timestepSetup().

◆ reconstructedGradientMethod() [2/2]

const FVReconstructedPressureGradient & RhieChowMassFlux::reconstructedGradientMethod ( ) const

protectedinherited

Access the reconstructed gradient method when it is selected.

Definition at line 1207 of file RhieChowMassFlux.C.

{
  mooseAssert(usingReconstructedPressureGradientMethod(),
              "reconstructedGradientMethod() should only be called when reconstructed "
              "pressure gradients are active.");
 
  return dynamic_cast<const FVReconstructedPressureGradient &>(pressureGradientField().method());
}

◆ setupMeshInformation()

void RhieChowMassFlux::setupMeshInformation ( )

protectedinherited

Compute the cell volumes on the mesh.

Definition at line 495 of file RhieChowMassFlux.C.

{
  // We cache the cell volumes into a petsc vector for corrections here so we can use
  // the optimized petsc operations for the normalization
  _cell_fluid_volumes = _pressure_system->currentSolution()->zero_clone();
  for (const auto & elem_info : _fe_problem.mesh().elemInfoVector())
    // We have to check this because the variable might not be defined on the given
    // block
    if (hasBlocks(elem_info->subdomain_id()))
    {
      const auto elem_dof = elem_info->dofIndices()[_global_pressure_system_number][0];
      _cell_fluid_volumes->set(elem_dof, elem_info->volume() * elem_info->coordFactor());
    }
 
  _cell_fluid_volumes->close();
 
  _flow_face_info.clear();
  for (auto & fi : _fe_problem.mesh().faceInfo())
    if (hasBlocks(fi->elemPtr()->subdomain_id()) ||
        (fi->neighborPtr() && hasBlocks(fi->neighborPtr()->subdomain_id())))
      _flow_face_info.push_back(fi);
}

Referenced by RhieChowMassFlux::linkMomentumPressureSystems(), and RhieChowMassFlux::meshChanged().

◆ setupPorousMeshInformation()

void PorousRhieChowMassFlux::setupPorousMeshInformation ( )

private

Overwrite the cached cell fluid volumes with cell volume times porosity.

Definition at line 255 of file PorousRhieChowMassFlux.C.

{
  const auto time_arg = Moose::currentState();
  for (const auto & elem_info : _fe_problem.mesh().elemInfoVector())
    if (hasBlocks(elem_info->subdomain_id()))
    {
      const auto elem_dof = elem_info->dofIndices()[_global_pressure_system_number][0];
      const Real cell_volume = elem_info->volume() * elem_info->coordFactor();
      _cell_fluid_volumes->set(elem_dof,
                               cell_volume * _eps(makeElemArg(elem_info->elem()), time_arg));
    }
 
  _cell_fluid_volumes->close();
}

Referenced by linkMomentumPressureSystems(), and meshChanged().

◆ supportMeshVelocity()

virtual bool RhieChowMassFlux::supportMeshVelocity ( ) const

inlineoverrideprotectedvirtualinherited

Returns whether the UO can support mesh velocity advection.

Reimplemented from RhieChowFaceFluxProvider.

Definition at line 212 of file RhieChowMassFlux.h.

212{ return false; }

◆ timestepSetup()

void RhieChowMassFlux::timestepSetup ( )

overridevirtualinherited

Prepare reconstructed-gradient state once per attempted time step.

Accepted coupling feedback is retained for the next time step and restored when an attempt is retried, while candidate fields and sequencing counters are reset for every attempt.

Reimplemented from GeneralUserObject.

Definition at line 384 of file RhieChowMassFlux.C.

{
  // Nothing to reset when momentum hasn't been linked (e.g. should_solve_momentum = false, used
  // by the restart-freeze pattern).
  if (!_pressure_gradient_field)
    return;
 
  _grad_p_current.clear();
 
  if (!usingReconstructedPressureGradientMethod())
    return;
 
  // Seed the next attempt from the most recently accepted coupling gradient. The linear FV
  // gradient manager restores that state after rejection and checkpoints it for restart/recovery.
  reconstructedGradientMethod().resetForTimeStep(*this);
}

◆ updateBaffleJumps()

void PorousRhieChowMassFlux::updateBaffleJumps ( )

private

Recompute and relax the pressure jumps using the current face mass fluxes.

Definition at line 305 of file PorousRhieChowMassFlux.C.

{
  if (_pressure_jump_models.empty())
    return;
 
  for (auto & fi : _flow_face_info)
  {
    const auto * const pressure_jump_model = getPressureJumpModel(*fi);
    if (!pressure_jump_model || !fi->neighborPtr())
      continue;
    if (!hasBlocks(fi->elemPtr()->subdomain_id()) || !hasBlocks(fi->neighborPtr()->subdomain_id()))
      continue;
 
    const Real new_jump =
        pressure_jump_model->computePressureJump(*fi, _face_mass_flux.evaluate(fi));
    _baffle_jump[fi->id()] = _pressure_jump_relaxation * new_jump +
                             (1.0 - _pressure_jump_relaxation) * _baffle_jump[fi->id()];
  }
}

Referenced by computeHbyA().

◆ updateCellVelocity()

template<typename GradientComponent >

void RhieChowMassFlux::updateCellVelocity ( const std::vector< GradientComponent > & pressure_gradient )

protectedinherited

Update cell velocity from the supplied momentum-coupling pressure gradient.

Definition at line 520 of file RhieChowMassFlux.C.

{
  // u_C = -(H/A)_C - (1/A)_C * grad(p)_C.
  for (const auto system_i : index_range(_momentum_implicit_systems))
  {
    auto working_vector = _Ainv_raw[system_i]->clone();
    working_vector->pointwise_mult(*working_vector, *pressure_gradient[system_i]);
    working_vector->add(*_HbyA_raw[system_i]);
    working_vector->scale(-1.0);
    (*_momentum_implicit_systems[system_i]->solution) = *working_vector;
 
#ifndef NDEBUG
    {
      // Proof that the assignment above satisfies the momentum-coupling identity
      // u_C + (H/A)_C + Ainv_C * grad(p)_C = 0. The solution was just assigned directly from
      // this formula, so the residual is pure floating-point round-off from the
      // clone/scale/add sequence, not solver error; 1e-10 is a loose absolute bound with
      // headroom over that round-off.
      auto defect = _Ainv_raw[system_i]->clone();
      defect->pointwise_mult(*defect, *pressure_gradient[system_i]);
      defect->add(*_HbyA_raw[system_i]);
      defect->add(*_momentum_implicit_systems[system_i]->solution);
      mooseAssert(MooseUtils::absoluteFuzzyEqual(defect->linfty_norm(), 0.0, 1e-10),
                  "RhieChowMassFlux: cell-velocity update violates the momentum-coupling "
                  "identity u + H/A + Ainv*grad(p) = 0.");
    }
#endif
 
    _momentum_implicit_systems[system_i]->update();
    _momentum_systems[system_i]->setSolution(
        *_momentum_implicit_systems[system_i]->current_local_solution);
  }
}

Referenced by RhieChowMassFlux::finalizePressureCorrector(), and RhieChowMassFlux::preparePressureRelaxation().

◆ usingReconstructedPressureGradientMethod()

bool RhieChowMassFlux::usingReconstructedPressureGradientMethod ( ) const

inherited

Whether the registered pressure gradient field is produced by the reconstructed method.

Definition at line 1201 of file RhieChowMassFlux.C.

{
  return dynamic_cast<const FVReconstructedPressureGradient *>(&pressureGradientField().method());
}

Referenced by PIMPLESolve::correctVelocity(), RhieChowMassFlux::finalizeMomentumPredictor(), RhieChowMassFlux::finalizePressureCorrector(), RhieChowMassFlux::linkMomentumPressureSystems(), linkMomentumPressureSystems(), RhieChowMassFlux::preparePISOCorrector(), RhieChowMassFlux::preparePressureRelaxation(), RhieChowMassFlux::reconstructedGradientMethod(), and RhieChowMassFlux::timestepSetup().

◆ validParams()

InputParameters PorousRhieChowMassFlux::validParams ( )

static

Definition at line 32 of file PorousRhieChowMassFlux.C.

{
  InputParameters params = RhieChowMassFlux::validParams();
  params.addClassDescription(
      "Rhie-Chow mass flux object specialized for porous flow/baffle cases.");
 
  params.addParam<MooseFunctorName>(
      NS::porosity, "1", "Porosity functor (defaults to 1 for non-porous calculations).");
  params.addParam<std::vector<UserObjectName>>(
      "pressure_jump_models", {}, "Pressure jump models applied by this object.");
  params.addRangeCheckedParam<Real>("pressure_jump_relaxation",
                                    1.0,
                                    "0.0<pressure_jump_relaxation<=1.0",
                                    "Under-relaxation factor for pressure jump updates.");
  return params;
}

◆ velocityBoundaryValue()

Real RhieChowMassFlux::velocityBoundaryValue	(	unsigned int	component,
		const FaceInfo &	fi,
		const Moose::FaceArg &	boundary_face
	)		const

protectedinherited

Get the prescribed velocity value on a Dirichlet boundary face.

Definition at line 782 of file RhieChowMassFlux.C.

{
  const auto face_type = fi.faceType(
      std::make_pair(_vel[component]->number(), _global_momentum_system_numbers[component]));
 
  LinearFVBoundaryCondition * dirichlet_bc = nullptr;
  for (const auto bnd_id : fi.boundaryIDs())
    if (auto * const bc_pointer = _vel[component]->getBoundaryCondition(bnd_id))
      if (dynamic_cast<LinearFVAdvectionDiffusionFunctorDirichletBC *>(bc_pointer))
      {
        // Two Dirichlet conditions on one face would prescribe conflicting velocities.
        mooseAssert(!dirichlet_bc,
                    "Face " + std::to_string(fi.id()) +
                        " carries more than one Dirichlet velocity boundary condition.");
        dirichlet_bc = bc_pointer;
      }
 
  if (dirichlet_bc)
  {
    dirichlet_bc->setupFaceData(&fi, face_type);
    return dirichlet_bc->computeBoundaryValue();
  }
 
  return MetaPhysicL::raw_value((*_vel[component])(boundary_face, Moose::currentState()));
}

Referenced by RhieChowMassFlux::initFaceMassFlux().

◆ velocityVariable() [1/2]

MooseLinearVariableFVReal & RhieChowMassFlux::velocityVariable ( unsigned int component )

inlineinherited

Velocity variable for one spatial component.

Definition at line 78 of file RhieChowMassFlux.h.

78{ return *_vel[component]; }

Referenced by FVReconstructedPressureGradient::computeCandidateFromCorrectedFlux(), FVVelocityJumpGreenGaussGradient::internalFaceValues(), FVReconstructedPressureGradient::linkFlowSystem(), RhieChowMassFlux::preparePISOCorrector(), FVReconstructedPressureGradient::reconstructionVelocityGradient(), and FVReconstructedPressureGradient::validateSetup().

◆ velocityVariable() [2/2]

const MooseLinearVariableFVReal & RhieChowMassFlux::velocityVariable ( unsigned int component ) const

inlineinherited

Velocity variable for one spatial component.

Definition at line 81 of file RhieChowMassFlux.h.

  {
    return *_vel[component];
  }

Member Data Documentation

◆ _A_avg

std::unique_ptr<NumericVector<Number> > RhieChowMassFlux::_A_avg

protectedinherited

Definition at line 259 of file RhieChowMassFlux.h.

◆ _Ainv

FaceCenteredMapFunctor<RealVectorValue, std::unordered_map<dof_id_type, RealVectorValue> > RhieChowMassFlux::_Ainv

protectedinherited

A map functor from faces to $(1/A)_f$.

Where $A_i$ is the diagonal of the system matrix for the momentum equation.

Definition at line 251 of file RhieChowMassFlux.h.

Referenced by RhieChowMassFlux::initCouplingField(), RhieChowMassFlux::initialize(), RhieChowMassFlux::meshChanged(), RhieChowMassFlux::populateCouplingFunctors(), and RhieChowMassFlux::RhieChowMassFlux().

◆ _Ainv_raw

std::vector<std::unique_ptr<NumericVector<Number> > > RhieChowMassFlux::_Ainv_raw

protectedinherited

We hold on to the cell-based 1/A vectors so that we can easily reconstruct the cell velocities as well.

Definition at line 257 of file RhieChowMassFlux.h.

Referenced by RhieChowMassFlux::AinvComponents(), cellPressureDiffusionCoefficient(), RhieChowMassFlux::computeHbyA(), pressureDiffusionDataReady(), and RhieChowMassFlux::updateCellVelocity().

◆ _baffle_jump

FaceCenteredMapFunctor<Real, std::unordered_map<dof_id_type, Real> >& PorousRhieChowMassFlux::_baffle_jump

private

Restartable face field storing pressure as non-owner minus owner.

Definition at line 139 of file PorousRhieChowMassFlux.h.

Referenced by getSignedBaffleJump(), initCouplingField(), meshChanged(), and updateBaffleJumps().

◆ _base_pressure_gradient_field

const LinearFVGradientReader* RhieChowMassFlux::_base_pressure_gradient_field

protectedinherited

Base pressure gradient field used to seed reconstructed gradient updates.

Definition at line 301 of file RhieChowMassFlux.h.

Referenced by RhieChowMassFlux::basePressureGradientField(), RhieChowMassFlux::checkReconstructedPressureGradientCompatibility(), and RhieChowMassFlux::linkMomentumPressureSystems().

◆ _cell_fluid_volumes

std::unique_ptr<NumericVector<Number> > RhieChowMassFlux::_cell_fluid_volumes

protectedinherited

Fluid volume of each cell, used to rapidly scale the pressure-gradient force in H/A and 1/A.

This is the cell volume, or the cell volume times porosity for porous flow.

Definition at line 310 of file RhieChowMassFlux.h.

Referenced by RhieChowMassFlux::computeHbyA(), RhieChowMassFlux::setupMeshInformation(), and setupPorousMeshInformation().

◆ _dim

const unsigned int RhieChowMassFlux::_dim

protectedinherited

The dimension of the mesh, e.g. 3 for hexes and tets, 2 for quads and tris.

Definition at line 221 of file RhieChowMassFlux.h.

Referenced by RhieChowMassFlux::checkReconstructedPressureGradientCompatibility(), RhieChowMassFlux::dimension(), RhieChowMassFlux::linkMomentumPressureSystems(), and RhieChowMassFlux::populateCouplingFunctors().

◆ _eps

const Moose::Functor<Real>& PorousRhieChowMassFlux::_eps

private

Porosity functor.

Definition at line 127 of file PorousRhieChowMassFlux.h.

Referenced by getFaceSidePorosity(), and setupPorousMeshInformation().

◆ _face_mass_flux

FaceCenteredMapFunctor<Real, std::unordered_map<dof_id_type, Real> >& RhieChowMassFlux::_face_mass_flux

protectedinherited

A map functor from faces to mass fluxes which are used in the advection terms.

Definition at line 264 of file RhieChowMassFlux.h.

Referenced by baffleNormalVelocity(), RhieChowMassFlux::computeFaceMassFlux(), RhieChowMassFlux::getMassFlux(), RhieChowMassFlux::getVolumetricFaceFlux(), RhieChowMassFlux::initFaceMassFlux(), RhieChowMassFlux::meshChanged(), and updateBaffleJumps().

◆ _face_mass_flux_generation

dof_id_type RhieChowMassFlux::_face_mass_flux_generation = 0

protectedinherited

Producer counter for the conservative face mass flux: incremented every time computeFaceMassFlux() runs.

Exposed read-only through faceMassFluxGeneration() so the reconstructed gradient can verify it is reconstructing from the face flux produced by the current pressure corrector, not one left over from a preceding corrector.

Definition at line 275 of file RhieChowMassFlux.h.

Referenced by RhieChowMassFlux::computeFaceMassFlux(), and RhieChowMassFlux::faceMassFluxGeneration().

◆ _flow_face_info

std::vector<const FaceInfo *> RhieChowMassFlux::_flow_face_info

protectedinherited

The subset of the FaceInfo objects that actually cover the subdomains which the flow field is defined on.

Cached for performance optimization.

Definition at line 320 of file RhieChowMassFlux.h.

Referenced by RhieChowMassFlux::computeFaceMassFlux(), computeHbyA(), RhieChowMassFlux::initFaceMassFlux(), RhieChowMassFlux::populateCouplingFunctors(), RhieChowMassFlux::setupMeshInformation(), and updateBaffleJumps().

◆ _global_momentum_system_numbers

std::vector<unsigned int> RhieChowMassFlux::_global_momentum_system_numbers

protectedinherited

Global numbers of the momentum system(s)

Definition at line 289 of file RhieChowMassFlux.h.

Referenced by cellPressureDiffusionCoefficient(), RhieChowMassFlux::checkReconstructedPressureGradientCompatibility(), RhieChowMassFlux::linkMomentumPressureSystems(), RhieChowMassFlux::populateCouplingFunctors(), pressureJumpInterfaceData(), and RhieChowMassFlux::velocityBoundaryValue().

◆ _global_pressure_system_number

unsigned int RhieChowMassFlux::_global_pressure_system_number

protectedinherited

Global number of the pressure system.

Definition at line 304 of file RhieChowMassFlux.h.

Referenced by RhieChowMassFlux::computeFacePressureGradientFlux(), RhieChowMassFlux::linkMomentumPressureSystems(), RhieChowMassFlux::setupMeshInformation(), and setupPorousMeshInformation().

◆ _grad_p_current

std::vector<std::unique_ptr<NumericVector<Number> > > RhieChowMassFlux::_grad_p_current

protectedinherited

Coupling pressure gradient captured before the current momentum predictor is assembled.

Definition at line 267 of file RhieChowMassFlux.h.

Referenced by RhieChowMassFlux::computeHbyA(), RhieChowMassFlux::meshChanged(), RhieChowMassFlux::prepareMomentumPredictor(), RhieChowMassFlux::preparePISOCorrector(), and RhieChowMassFlux::timestepSetup().

◆ _HbyA_flux

FaceCenteredMapFunctor<Real, std::unordered_map<dof_id_type, Real> > RhieChowMassFlux::_HbyA_flux

protectedinherited

A map functor from faces to $HbyA_{ij} = (A_{offdiag}*\mathrm{(predicted~velocity)} - \mathrm{Source})_{ij}/A_{ij}$.

So this contains the off-diagonal part of the system matrix multiplied by the predicted velocity minus the source terms from the right hand side of the linearized momentum predictor step.

Definition at line 239 of file RhieChowMassFlux.h.

Referenced by RhieChowMassFlux::computeFaceMassFlux(), computeHbyA(), RhieChowMassFlux::initCouplingField(), RhieChowMassFlux::initialize(), RhieChowMassFlux::meshChanged(), RhieChowMassFlux::populateCouplingFunctors(), and RhieChowMassFlux::RhieChowMassFlux().

◆ _HbyA_raw

std::vector<std::unique_ptr<NumericVector<Number> > > RhieChowMassFlux::_HbyA_raw

protectedinherited

We hold on to the cell-based HbyA vectors so that we can easily reconstruct the cell velocities as well.

Definition at line 245 of file RhieChowMassFlux.h.

Referenced by RhieChowMassFlux::computeHbyA(), RhieChowMassFlux::HbyAComponents(), pressureDiffusionDataReady(), pressureJumpInterfaceData(), and RhieChowMassFlux::updateCellVelocity().

◆ _mesh

const libMesh::MeshBase& RhieChowMassFlux::_mesh

protectedinherited

The libMesh mesh that this object acts on.

Definition at line 218 of file RhieChowMassFlux.h.

◆ _momentum_implicit_systems

std::vector<libMesh::LinearImplicitSystem *> RhieChowMassFlux::_momentum_implicit_systems

protectedinherited

Pointers to the momentum equation implicit system(s) from libmesh.

Definition at line 292 of file RhieChowMassFlux.h.

Referenced by RhieChowMassFlux::checkReconstructedPressureGradientCompatibility(), RhieChowMassFlux::computeHbyA(), RhieChowMassFlux::linkMomentumPressureSystems(), and RhieChowMassFlux::updateCellVelocity().

◆ _momentum_system_numbers

std::vector<unsigned int> RhieChowMassFlux::_momentum_system_numbers

protectedinherited

Numbers of the momentum system(s)

Definition at line 286 of file RhieChowMassFlux.h.

Referenced by RhieChowMassFlux::linkMomentumPressureSystems().

◆ _momentum_systems

std::vector<LinearSystem *> RhieChowMassFlux::_momentum_systems

protectedinherited

Pointers to the linear system(s) in moose corresponding to the momentum equation(s)

Definition at line 283 of file RhieChowMassFlux.h.

Referenced by RhieChowMassFlux::checkReconstructedPressureGradientCompatibility(), RhieChowMassFlux::computeHbyA(), RhieChowMassFlux::linkMomentumPressureSystems(), RhieChowMassFlux::momentumSystem(), RhieChowMassFlux::momentumSystem(), and RhieChowMassFlux::updateCellVelocity().

◆ _moose_mesh

const MooseMesh& RhieChowMassFlux::_moose_mesh

protectedinherited

The MooseMesh that this user object operates on.

Definition at line 215 of file RhieChowMassFlux.h.

Referenced by RhieChowMassFlux::checkBlocks(), RhieChowMassFlux::linkMomentumPressureSystems(), and linkMomentumPressureSystems().

◆ _p

const MooseLinearVariableFVReal* const RhieChowMassFlux::_p

protectedinherited

The thread 0 copy of the pressure variable.

Definition at line 224 of file RhieChowMassFlux.h.

Referenced by RhieChowMassFlux::computeFacePressureGradientFlux(), RhieChowMassFlux::initialSetup(), RhieChowMassFlux::linkMomentumPressureSystems(), linkMomentumPressureSystems(), RhieChowMassFlux::populateCouplingFunctors(), PorousRhieChowMassFlux(), RhieChowMassFlux::pressureVariableNumber(), and RhieChowMassFlux::RhieChowMassFlux().

◆ _p_diffusion_kernel

LinearFVPressureCorrectionDiffusion* RhieChowMassFlux::_p_diffusion_kernel

protectedinherited

Pointer to the pressure diffusion term in the pressure Poisson equation.

Definition at line 231 of file RhieChowMassFlux.h.

Referenced by RhieChowMassFlux::checkReconstructedPressureGradientCompatibility(), RhieChowMassFlux::computeFacePressureGradientFlux(), RhieChowMassFlux::initialSetup(), RhieChowMassFlux::linkMomentumPressureSystems(), linkMomentumPressureSystems(), pressureDiffusionDataReady(), and pressureDiffusionUsesNonorthogonalCorrection().

◆ _pressure_diffusion_interp_method

const Moose::FV::InterpMethod RhieChowMassFlux::_pressure_diffusion_interp_method

protectedinherited

Interpolation method used for the pressure diffusion coefficient on faces.

Definition at line 316 of file RhieChowMassFlux.h.

Referenced by RhieChowMassFlux::populateCouplingFunctors().

◆ _pressure_gradient_field

const LinearFVGradientReader* RhieChowMassFlux::_pressure_gradient_field

protectedinherited

Registered pressure gradient field used by Rhie-Chow and compatible momentum pressure kernels.

Definition at line 298 of file RhieChowMassFlux.h.

Referenced by RhieChowMassFlux::checkReconstructedPressureGradientCompatibility(), RhieChowMassFlux::linkMomentumPressureSystems(), RhieChowMassFlux::prepareMomentumPredictor(), RhieChowMassFlux::pressureGradientField(), and RhieChowMassFlux::timestepSetup().

◆ _pressure_jump_models

std::vector<const PressureJumpModel *> PorousRhieChowMassFlux::_pressure_jump_models

private

Pressure-jump models with mutually disjoint boundary sets.

Definition at line 130 of file PorousRhieChowMassFlux.h.

Referenced by getPressureJumpModel(), hasPressureBaffles(), linkMomentumPressureSystems(), PorousRhieChowMassFlux(), and updateBaffleJumps().

◆ _pressure_jump_relaxation

const Real PorousRhieChowMassFlux::_pressure_jump_relaxation

private

Under-relaxation factor applied when updating pressure jumps.

Definition at line 133 of file PorousRhieChowMassFlux.h.

Referenced by updateBaffleJumps().

◆ _pressure_projection_method

const MooseEnum RhieChowMassFlux::_pressure_projection_method

protectedinherited

Enumerator for the method used for pressure projection.

Definition at line 313 of file RhieChowMassFlux.h.

Referenced by RhieChowMassFlux::computeHbyA(), and RhieChowMassFlux::linkMomentumPressureSystems().

◆ _pressure_system

LinearSystem* RhieChowMassFlux::_pressure_system

protectedinherited

Pointer to the pressure system.

Definition at line 295 of file RhieChowMassFlux.h.

Referenced by RhieChowMassFlux::checkReconstructedPressureGradientCompatibility(), RhieChowMassFlux::computeFaceMassFlux(), computeHbyA(), RhieChowMassFlux::finalizePressureCorrector(), RhieChowMassFlux::initPressureGradient(), RhieChowMassFlux::linkMomentumPressureSystems(), linkMomentumPressureSystems(), RhieChowMassFlux::pressureSystem(), and RhieChowMassFlux::setupMeshInformation().

◆ _rho

const Moose::Functor<Real>& RhieChowMassFlux::_rho

protectedinherited

Functor describing the density of the fluid.

Definition at line 280 of file RhieChowMassFlux.h.

Referenced by baffleNormalVelocity(), cellPressureDiffusionCoefficient(), RhieChowMassFlux::getVolumetricFaceFlux(), RhieChowMassFlux::initFaceMassFlux(), RhieChowMassFlux::populateCouplingFunctors(), and pressureJumpInterfaceData().

◆ _vel

std::vector<MooseLinearVariableFVReal *> RhieChowMassFlux::_vel

protectedinherited

Thread 0 copies of the velocity variables; non-const to allow writing cell velocities in updateCellVelocity().

Definition at line 228 of file RhieChowMassFlux.h.

Referenced by baffleFaceVelocity(), computeHbyA(), RhieChowMassFlux::getVolumetricFaceFlux(), RhieChowMassFlux::initFaceMassFlux(), RhieChowMassFlux::linkMomentumPressureSystems(), linkMomentumPressureSystems(), RhieChowMassFlux::populateCouplingFunctors(), PorousRhieChowMassFlux(), RhieChowMassFlux::RhieChowMassFlux(), RhieChowMassFlux::velocityBoundaryValue(), RhieChowMassFlux::velocityVariable(), and RhieChowMassFlux::velocityVariable().

◆ _velocity_gradients

std::vector<const LinearFVGradientReader *> PorousRhieChowMassFlux::_velocity_gradients

private

Published velocity gradients, one per component, read by the baffle face states.

Definition at line 136 of file PorousRhieChowMassFlux.h.

Referenced by baffleFaceVelocity(), and linkMomentumPressureSystems().

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

navier_stokes/include/userobjects/PorousRhieChowMassFlux.h
navier_stokes/src/userobjects/PorousRhieChowMassFlux.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ PorousRhieChowMassFlux()

Member Function Documentation

◆ AinvComponents()

◆ baffleFaceVelocity()

◆ baffleNormalVelocity()

◆ basePressureGradientComponents()

◆ basePressureGradientField()

◆ cellPressureDiffusionCoefficient()

◆ checkBlocks()

◆ checkReconstructedPressureGradientCompatibility()

◆ computeFaceMassFlux()

◆ computeFacePressureGradientFlux()

◆ computeHbyA()

◆ dimension()

◆ execute()

◆ faceIsBaffle()

◆ faceMassFluxGeneration()

◆ finalize()

◆ finalizeMomentumPredictor()

◆ finalizePressureCorrector()

◆ getFaceSidePorosity()

◆ getMassFlux()

◆ getPressureJumpModel()

◆ getSignedBaffleJump()

◆ getVolumetricFaceFlux() [1/2]

◆ getVolumetricFaceFlux() [2/2]

◆ hasFaceSide()

◆ hasPressureBaffles()

◆ HbyAComponents()

◆ initCouplingField()

◆ initFaceMassFlux()

◆ initialize()

◆ initialSetup()

◆ initPressureGradient()

◆ linkMomentumPressureSystems()

◆ meshChanged()

◆ momentumSystem() [1/2]

◆ momentumSystem() [2/2]

◆ populateCouplingFunctors()

◆ prepareMomentumPredictor()

◆ preparePISOCorrector()

◆ preparePressureRelaxation()

◆ pressureDiffusionDataReady()

◆ pressureDiffusionUsesNonorthogonalCorrection()

◆ pressureGradientComponents()

◆ pressureGradientField()

◆ pressureJumpInterfaceData()

◆ pressureSystem()

◆ pressureVariableNumber()

◆ reconstructedGradientMethod() [1/2]

◆ reconstructedGradientMethod() [2/2]

◆ setupMeshInformation()

◆ setupPorousMeshInformation()

◆ supportMeshVelocity()

◆ timestepSetup()

◆ updateBaffleJumps()

◆ updateCellVelocity()

◆ usingReconstructedPressureGradientMethod()

◆ validParams()

◆ velocityBoundaryValue()

◆ velocityVariable() [1/2]

◆ velocityVariable() [2/2]

Member Data Documentation

◆ _A_avg

◆ _Ainv

◆ _Ainv_raw