User object responsible for determining the face fluxes using the Rhie-Chow interpolation in a segregated solver that uses the linear FV formulation. More...

#include <RhieChowMassFlux.h>

Inheritance diagram for RhieChowMassFlux:

[legend]

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	RhieChowMassFlux (const InputParameters &params)

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

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

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

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

void	initCouplingField ()
	Initialize the coupling fields (HbyA and Ainv) More...

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

void	computeCellVelocity ()
	Update the cell values of the velocity variables. More...

virtual void	meshChanged () override

virtual void	initialize () override

virtual void	execute () override

virtual void	finalize () override

virtual void	initialSetup () override

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

void	computeHbyA (const bool with_updated_pressure, const bool verbose)
	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. More...

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

SubProblem &	getSubProblem () const

bool	shouldDuplicateInitialExecution () const

virtual Real	spatialValue (const Point &) const

virtual const std::vector< Point >	spatialPoints () 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)

void	setPrimaryThreadCopy (UserObject *primary)

UserObject *	primaryThreadCopy ()

std::set< UserObjectName >	getDependObjects () const

virtual bool	needThreadedCopy () const

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

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

unsigned int	systemNumber () const

virtual bool	enabled () const

std::shared_ptr< MooseObject >	getSharedPtr ()

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

MooseApp &	getMooseApp () const

const std::string &	type () const

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	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	mooseWarningNonPrefixed (Args &&... args) const

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

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

void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr) 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	timestepSetup ()

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 UserObject &	getUserObjectBase (const std::string &param_name, bool is_dependency=true) const

const UserObject &	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)

std::pair< const MaterialProperty< T > *, std::set< SubdomainID > >	getBlockMaterialProperty (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)

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

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

Static Public Member Functions
static InputParameters	validParams ()

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

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)

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

Public Attributes
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 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
std::vector< std::unique_ptr< NumericVector< Number > > > &	selectPressureGradient (const bool updated_pressure)
	Select the right pressure gradient field and return a reference to the container. More...

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

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

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

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

virtual void	addPostprocessorDependencyHelper (const PostprocessorName &name) const override

virtual void	addVectorPostprocessorDependencyHelper (const VectorPostprocessorName &name) const override

virtual void	addUserObjectDependencyHelper (const UserObject &uo) const override

void	addReporterDependencyHelper (const ReporterName &reporter_name) override

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, TagID tag, unsigned int comp=0) const

const VariableValue &	coupledMatrixTagScalarValue (const std::string &var_name, TagID tag, 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

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

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

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)

Moose::CoordinateSystemType	getBlockCoordSystem ()

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)

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

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

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

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

std::vector< const MooseLinearVariableFVReal * >	_vel
	The thread 0 copy of the x-velocity variable. More...

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

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

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

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

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

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

std::vector< std::unique_ptr< NumericVector< Number > > >	_grad_p_current
	for a PISO iteration we need to hold on to the original pressure gradient field. More...

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

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

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

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

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

const LinearSystem *	_pressure_system
	Pointer to the pressure system. More...

unsigned int	_global_pressure_system_number
	Global number of the pressure system. More...

std::unique_ptr< NumericVector< Number > >	_cell_volumes
	We will hold a vector of cell volumes to make sure we can do volume corrections rapidly. More...

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

SubProblem &	_subproblem

FEProblemBase &	_fe_problem

SystemBase &	_sys

const THREAD_ID	_tid

Assembly &	_assembly

const Moose::CoordinateSystemType &	_coord_sys

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

Detailed Description

User object responsible for determining the face fluxes using the Rhie-Chow interpolation in a segregated solver that uses the linear FV formulation.

Definition at line 36 of file RhieChowMassFlux.h.

Constructor & Destructor Documentation

◆ RhieChowMassFlux()

RhieChowMassFlux::RhieChowMassFlux ( const InputParameters & params )

Definition at line 65 of file RhieChowMassFlux.C.

   : RhieChowFaceFluxProvider(params),
     NonADFunctorInterface(this),
     _moose_mesh(UserObject::_subproblem.mesh()),
     _mesh(_moose_mesh.getMesh()),
     _dim(blocksMaxDimension()),
     _p(dynamic_cast<MooseLinearVariableFVReal *>(
         &UserObject::_subproblem.getVariable(0, getParam<VariableName>(NS::pressure)))),
     _vel(_dim, nullptr),
     _HbyA_flux(_moose_mesh, blockIDs(), "HbyA_flux"),
     _Ainv(_moose_mesh, blockIDs(), "Ainv"),
     _face_mass_flux(
         declareRestartableData<FaceCenteredMapFunctor<Real, std::unordered_map<dof_id_type, Real>>>(
             "face_flux", _moose_mesh, blockIDs(), "face_values")),
     _rho(getFunctor<Real>(NS::density)),
     _pressure_projection_method(getParam<MooseEnum>("pressure_projection_method"))
 {
   if (!_p)
     paramError(NS::pressure, "the pressure must be a MooseLinearVariableFVReal.");
   checkBlocks(*_p);
 
   std::vector<std::string> vel_names = {"u", "v", "w"};
   for (const auto i : index_range(_vel))
   {
     _vel[i] = dynamic_cast<MooseLinearVariableFVReal *>(
         &UserObject::_subproblem.getVariable(0, getParam<VariableName>(vel_names[i])));
 
     if (!_vel[i])
       paramError(vel_names[i], "the velocity must be a MOOSELinearVariableFVReal.");
     checkBlocks(*_vel[i]);
   }
 
   // Register the elemental/face functors which will be queried in the pressure equation
   for (const auto tid : make_range(libMesh::n_threads()))
   {
     UserObject::_subproblem.addFunctor("Ainv", _Ainv, tid);
     UserObject::_subproblem.addFunctor("HbyA", _HbyA_flux, tid);
   }
 
   if (!dynamic_cast<SIMPLE *>(getMooseApp().getExecutioner()) &&
       !dynamic_cast<PIMPLE *>(getMooseApp().getExecutioner()))
     mooseError(this->name(),
                " should only be used with a linear segregated thermal-hydraulics solver!");
 }

Member Function Documentation

◆ checkBlocks()

template<typename VarType >

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

protected

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

Definition at line 199 of file RhieChowMassFlux.h.

Referenced by RhieChowMassFlux().

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

◆ computeCellVelocity()

void RhieChowMassFlux::computeCellVelocity ( )

Update the cell values of the velocity variables.

Definition at line 355 of file RhieChowMassFlux.C.

Referenced by LinearAssemblySegregatedSolve::correctVelocity().

 {
   auto & pressure_gradient = _pressure_system->gradientContainer();
 
   // We set the dof value in the solution vector the same logic applies:
   // u_C = -(H/A)_C - (1/A)_C*grad(p)_C where C is the cell index
   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;
     _momentum_implicit_systems[system_i]->update();
     _momentum_systems[system_i]->setSolution(
         *_momentum_implicit_systems[system_i]->current_local_solution);
   }
 }

◆ computeFaceMassFlux()

void RhieChowMassFlux::computeFaceMassFlux ( )

Update the values of the face velocities in the containers.

Definition at line 285 of file RhieChowMassFlux.C.

Referenced by LinearAssemblySegregatedSolve::correctVelocity().

 {
   using namespace Moose::FV;
 
   const auto time_arg = Moose::currentState();
 
   // 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)
   {
     // 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 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);
     }
     // Compute the new face flux
     _face_mass_flux[fi->id()] = -_HbyA_flux[fi->id()] + p_grad_flux;
   }
 }

◆ computeHbyA()

void RhieChowMassFlux::computeHbyA	(	const bool	with_updated_pressure,
		const bool	verbose
	)

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.

Definition at line 491 of file RhieChowMassFlux.C.

Referenced by LinearAssemblySegregatedSolve::correctVelocity().

 {
   if (verbose)
   {
     _console << "************************************" << std::endl;
     _console << "Computing HbyA" << std::endl;
     _console << "************************************" << std::endl;
   }
   mooseAssert(_momentum_implicit_systems.size() && _momentum_implicit_systems[0],
               "The momentum system shall be linked before calling this function!");
 
   auto & pressure_gradient = selectPressureGradient(with_updated_pressure);
 
   _HbyA_raw.clear();
   _Ainv_raw.clear();
   for (auto system_i : index_range(_momentum_systems))
   {
     LinearImplicitSystem * momentum_system = _momentum_implicit_systems[system_i];
 
     NumericVector<Number> & rhs = *(momentum_system->rhs);
     NumericVector<Number> & current_local_solution = *(momentum_system->current_local_solution);
     NumericVector<Number> & solution = *(momentum_system->solution);
     PetscMatrix<Number> * mmat = dynamic_cast<PetscMatrix<Number> *>(momentum_system->matrix);
     mooseAssert(mmat,
                 "The matrices used in the segregated INSFVRhieChow objects need to be convertable "
                 "to PetscMatrix!");
 
     if (verbose)
     {
       _console << "Matrix in rc object" << std::endl;
       mmat->print();
     }
 
     // First, we extract the diagonal and we will hold on to it for a little while
     _Ainv_raw.push_back(current_local_solution.zero_clone());
     NumericVector<Number> & Ainv = *(_Ainv_raw.back());
 
     mmat->get_diagonal(Ainv);
 
     if (verbose)
     {
       _console << "Velocity solution in H(u)" << std::endl;
       solution.print();
     }
 
     // Time to create H(u) = M_{offdiag} * u - b_{nonpressure}
     _HbyA_raw.push_back(current_local_solution.zero_clone());
     NumericVector<Number> & HbyA = *(_HbyA_raw.back());
 
     // We start with the matrix product part, we will do
     // M*u - A*u for 2 reasons:
     // 1, We assume A*u petsc operation is faster than setting the matrix diagonal to 0
     // 2, In PISO loops we need to reuse the matrix so we can't just set the diagonals to 0
 
     // We create a working vector to ease some of the operations, we initialize its values
     // with the current solution values to have something for the A*u term
     auto working_vector = momentum_system->current_local_solution->zero_clone();
     PetscVector<Number> * working_vector_petsc =
         dynamic_cast<PetscVector<Number> *>(working_vector.get());
     mooseAssert(working_vector_petsc,
                 "The vectors used in the RhieChowMassFlux objects need to be convertable "
                 "to PetscVectors!");
 
     mmat->vector_mult(HbyA, solution);
     working_vector_petsc->pointwise_mult(Ainv, solution);
     HbyA.add(-1.0, *working_vector_petsc);
 
     if (verbose)
     {
       _console << " H(u)" << std::endl;
       HbyA.print();
     }
 
     // We continue by adding the momentum right hand side contributions
     HbyA.add(-1.0, rhs);
 
     // Unfortunately, the pressure forces are included in the momentum RHS
     // so we have to correct them back
     working_vector_petsc->pointwise_mult(*pressure_gradient[system_i], *_cell_volumes);
     HbyA.add(-1.0, *working_vector_petsc);
 
     if (verbose)
     {
       _console << "total RHS" << std::endl;
       rhs.print();
       _console << "pressure RHS" << std::endl;
       pressure_gradient[system_i]->print();
       _console << " H(u)-rhs-relaxation_source" << std::endl;
       HbyA.print();
     }
 
     // It is time to create element-wise 1/A-s based on the the diagonal of the momentum matrix
     *working_vector_petsc = 1.0;
     Ainv.pointwise_divide(*working_vector_petsc, Ainv);
 
     // Create 1/A*(H(u)-RHS)
     HbyA.pointwise_mult(HbyA, Ainv);
 
     if (verbose)
     {
       _console << " (H(u)-rhs)/A" << std::endl;
       HbyA.print();
     }
 
     if (_pressure_projection_method == "consistent")
     {
 
       // Consistent Corrections to SIMPLE
       // 1. Ainv_old = 1/a_p <- Ainv = 1/(a_p + \sum_n a_n)
       // 2. H(u) <- H(u*) + H(u') = H(u*) - (Ainv - Ainv_old) * grad(p) * Vc
 
       if (verbose)
         _console << "Performing SIMPLEC projection." << std::endl;
 
       // Lambda function to calculate the sum of diagonal and neighbor coefficients
       auto get_row_sum = [mmat](NumericVector<Number> & sum_vector)
       {
         // Ensure the sum_vector is zeroed out
         sum_vector.zero();
 
         // Local row size
         const auto local_size = mmat->local_m();
 
         for (const auto row_i : make_range(local_size))
         {
           // Get all non-zero components of the row of the matrix
           const auto global_index = mmat->row_start() + row_i;
           std::vector<numeric_index_type> indices;
           std::vector<Real> values;
           mmat->get_row(global_index, indices, values);
 
           // Sum row elements (no absolute values)
           const Real row_sum = std::accumulate(values.cbegin(), values.cend(), 0.0);
 
           // Add the sum of diagonal and elements to the sum_vector
           sum_vector.add(global_index, row_sum);
         }
         sum_vector.close();
       };
 
       // Create a temporary vector to store the sum of diagonal and neighbor coefficients
       auto row_sum = current_local_solution.zero_clone();
       get_row_sum(*row_sum);
 
       // Create vector with new inverse projection matrix
       auto Ainv_full = current_local_solution.zero_clone();
       *working_vector_petsc = 1.0;
       Ainv_full->pointwise_divide(*working_vector_petsc, *row_sum);
       const auto Ainv_full_old = Ainv_full->clone();
 
       // Correct HbyA
       Ainv_full->add(-1.0, Ainv);
       working_vector_petsc->pointwise_mult(*Ainv_full, *pressure_gradient[system_i]);
       working_vector_petsc->pointwise_mult(*working_vector_petsc, *_cell_volumes);
       HbyA.add(-1.0, *working_vector_petsc);
 
       // Correct Ainv
       Ainv = *Ainv_full_old;
     }
 
     Ainv.pointwise_mult(Ainv, *_cell_volumes);
   }
 
   // We fill the 1/A and H/A functors
   populateCouplingFunctors(_HbyA_raw, _Ainv_raw);
 
   if (verbose)
   {
     _console << "************************************" << std::endl;
     _console << "DONE Computing HbyA " << std::endl;
     _console << "************************************" << std::endl;
   }
 }

◆ execute()

virtual void RhieChowMassFlux::execute ( )

inlineoverridevirtual

Implements GeneralUserObject.

Definition at line 65 of file RhieChowMassFlux.h.

65 {}

◆ finalize()

virtual void RhieChowMassFlux::finalize ( )

inlineoverridevirtual

Implements GeneralUserObject.

Definition at line 66 of file RhieChowMassFlux.h.

66 {}

◆ getMassFlux()

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

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

Definition at line 249 of file RhieChowMassFlux.C.

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

 {
   return _face_mass_flux.evaluate(&fi);
 }

◆ getVolumetricFaceFlux() [1/2]

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

Get the volumetric face flux (used in advection terms)

Definition at line 255 of file RhieChowMassFlux.C.

Referenced by LinearFVScalarAdvection::setupFaceData().

 {
   const Moose::FaceArg face_arg{&fi,
                                 /*limiter_type=*/Moose::FV::LimiterType::CentralDifference,
                                 /*elem_is_upwind=*/true,
                                 /*correct_skewness=*/false,
                                 &fi.elem(),
                                 /*state_limiter*/ nullptr};
   const Real face_rho = _rho(face_arg, Moose::currentState());
   return libmesh_map_find(_face_mass_flux, fi.id()) / face_rho;
 }

◆ 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

overridevirtual

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 29 of file RhieChowFaceFluxProvider.C.

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

◆ initCouplingField()

void RhieChowMassFlux::initCouplingField ( )

Initialize the coupling fields (HbyA and Ainv)

Definition at line 375 of file RhieChowMassFlux.C.

Referenced by LinearAssemblySegregatedSolve::linkRhieChowUserObject().

 {
   // We loop through the faces and populate the coupling fields (face H/A and 1/H)
   // with 0s for now. Pressure corrector solves will always come after the
   // momentum source so we expect these fields to change before the actual solve.
   for (auto & fi : _fe_problem.mesh().faceInfo())
   {
     _Ainv[fi->id()];
     _HbyA_flux[fi->id()];
   }
 }

◆ initFaceMassFlux()

void RhieChowMassFlux::initFaceMassFlux ( )

Initialize the container for face velocities.

Definition at line 198 of file RhieChowMassFlux.C.

Referenced by LinearAssemblySegregatedSolve::linkRhieChowUserObject().

 {
   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 *
                                         raw_value((*_vel[dim_i])(boundary_face, time_arg));
     }
 
     _face_mass_flux[fi->id()] = density_times_velocity * fi->normal();
   }
 }

◆ initialize()

void RhieChowMassFlux::initialize ( )

overridevirtual

Implements GeneralUserObject.

Definition at line 188 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 ( )

overridevirtual

Reimplemented from GeneralUserObject.

Definition at line 141 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<LinearFVAnisotropicDiffusion *>(flux_kernel[0]);
   if (!_p_diffusion_kernel)
     paramError("p_diffusion_kernel",
                "The provided diffusion kernel should of type LinearFVAnisotropicDiffusion!");
 }

◆ linkMomentumPressureSystems()

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

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

Definition at line 111 of file RhieChowMassFlux.C.

Referenced by LinearAssemblySegregatedSolve::linkRhieChowUserObject().

 {
   _momentum_systems = momentum_systems;
   _momentum_system_numbers = momentum_system_numbers;
   _pressure_system = &pressure_system;
   _global_pressure_system_number = _pressure_system->number();
 
   _momentum_implicit_systems.clear();
   for (auto & system : _momentum_systems)
   {
     _global_momentum_system_numbers.push_back(system->number());
     _momentum_implicit_systems.push_back(dynamic_cast<LinearImplicitSystem *>(&system->system()));
   }
 
   setupMeshInformation();
 }

◆ meshChanged()

void RhieChowMassFlux::meshChanged ( )

overridevirtual

Reimplemented from GeneralUserObject.

Definition at line 132 of file RhieChowMassFlux.C.

 {
   _HbyA_flux.clear();
   _Ainv.clear();
   _face_mass_flux.clear();
   setupMeshInformation();
 }

◆ populateCouplingFunctors()

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

protected

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

Definition at line 388 of file RhieChowMassFlux.C.

Referenced by computeHbyA().

 {
   // 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/H)
   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(InterpMethod::Average,
                     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];
 
       // If it is a Dirichlet BC, we use the dirichlet value the make sure the face flux
       // is consistent
       if (_vel[0]->isDirichletBoundaryFace(*fi))
       {
         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) =
               -boundary_normal_multiplier *
               MetaPhysicL::raw_value((*_vel[dim_i])(boundary_face, Moose::currentState()));
       }
       // 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;
   }
 }

◆ selectPressureGradient()

std::vector< std::unique_ptr< NumericVector< Number > > > & RhieChowMassFlux::selectPressureGradient ( const bool updated_pressure )

protected

Select the right pressure gradient field and return a reference to the container.

Definition at line 666 of file RhieChowMassFlux.C.

Referenced by computeHbyA().

 {
   if (updated_pressure)
   {
     _grad_p_current.clear();
     for (const auto & component : _pressure_system->gradientContainer())
       _grad_p_current.push_back(component->clone());
   }
 
   return _grad_p_current;
 }

◆ setupMeshInformation()

void RhieChowMassFlux::setupMeshInformation ( )

protected

Compute the cell volumes on the mesh.

Definition at line 164 of file RhieChowMassFlux.C.

Referenced by linkMomentumPressureSystems(), and meshChanged().

 {
   // We cache the cell volumes into a petsc vector for corrections here so we can use
   // the optimized petsc operations for the normalization
   _cell_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_volumes->set(elem_dof, elem_info->volume() * elem_info->coordFactor());
     }
 
   _cell_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);
 }

◆ supportMeshVelocity()

virtual bool RhieChowMassFlux::supportMeshVelocity ( ) const

inlineoverrideprotectedvirtual

Returns whether the UO can support mesh velocity advection.

Reimplemented from RhieChowFaceFluxProvider.

Definition at line 105 of file RhieChowMassFlux.h.

105 { return false; }

◆ validParams()

InputParameters RhieChowMassFlux::validParams ( )

static

Definition at line 32 of file RhieChowMassFlux.C.

 {
   auto params = RhieChowFaceFluxProvider::validParams();
   params += NonADFunctorInterface::validParams();
 
   params.addClassDescription("Computes H/A and 1/A together with face mass fluxes for segregated "
                              "momentum-pressure equations using linear systems.");
 
   params.addRequiredParam<VariableName>(NS::pressure, "The pressure variable.");
   params.addRequiredParam<VariableName>("u", "The x-component of velocity");
   params.addParam<VariableName>("v", "The y-component of velocity");
   params.addParam<VariableName>("w", "The z-component of velocity");
   params.addRequiredParam<std::string>("p_diffusion_kernel",
                                        "The diffusion kernel acting on the pressure.");
 
   params.addRequiredParam<MooseFunctorName>(NS::density, "Density functor");
 
   // We disable the execution of this, should only provide functions
   // for the SIMPLE executioner
   ExecFlagEnum & exec_enum = params.set<ExecFlagEnum>("execute_on", true);
   exec_enum.addAvailableFlags(EXEC_NONE);
   exec_enum = {EXEC_NONE};
   params.suppressParameter<ExecFlagEnum>("execute_on");
 
   // Pressure projection
   params.addParam<MooseEnum>("pressure_projection_method",
                              MooseEnum("standard consistent", "standard"),
                              "The method to use in the pressure projection for Ainv - "
                              "standard (SIMPLE) or consistent (SIMPLEC)");
 
   return params;
 }

Member Data Documentation

◆ _Ainv

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

protected

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 143 of file RhieChowMassFlux.h.

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

◆ _Ainv_raw

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

protected

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

Definition at line 149 of file RhieChowMassFlux.h.

Referenced by computeCellVelocity(), and computeHbyA().

◆ _cell_volumes

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

protected

We will hold a vector of cell volumes to make sure we can do volume corrections rapidly.

Definition at line 186 of file RhieChowMassFlux.h.

Referenced by computeHbyA(), and setupMeshInformation().

◆ _dim

const unsigned int RhieChowMassFlux::_dim

protected

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

Definition at line 114 of file RhieChowMassFlux.h.

Referenced by populateCouplingFunctors().

◆ _face_mass_flux

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

protected

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

Definition at line 154 of file RhieChowMassFlux.h.

Referenced by computeFaceMassFlux(), getMassFlux(), getVolumetricFaceFlux(), initFaceMassFlux(), and meshChanged().

◆ _flow_face_info

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

private

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 194 of file RhieChowMassFlux.h.

Referenced by computeFaceMassFlux(), initFaceMassFlux(), populateCouplingFunctors(), and setupMeshInformation().

◆ _global_momentum_system_numbers

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

protected

Global numbers of the momentum system(s)

Definition at line 174 of file RhieChowMassFlux.h.

Referenced by linkMomentumPressureSystems(), and populateCouplingFunctors().

◆ _global_pressure_system_number

unsigned int RhieChowMassFlux::_global_pressure_system_number

protected

Global number of the pressure system.

Definition at line 183 of file RhieChowMassFlux.h.

Referenced by computeFaceMassFlux(), linkMomentumPressureSystems(), and setupMeshInformation().

◆ _grad_p_current

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

protected

for a PISO iteration we need to hold on to the original pressure gradient field.

Should not be used in other conditions.

Definition at line 160 of file RhieChowMassFlux.h.

Referenced by selectPressureGradient().

◆ _HbyA_flux

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

protected

A map functor from faces to $HbyA_{ij} = (A_{offdiag}*{(predicted~velocity)} - {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 131 of file RhieChowMassFlux.h.

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

◆ _HbyA_raw

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

protected

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

Definition at line 137 of file RhieChowMassFlux.h.

Referenced by computeCellVelocity(), and computeHbyA().

◆ _mesh

const libMesh::MeshBase& RhieChowMassFlux::_mesh

protected

The libMesh mesh that this object acts on.

Definition at line 111 of file RhieChowMassFlux.h.

◆ _momentum_implicit_systems

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

protected

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

Definition at line 177 of file RhieChowMassFlux.h.

Referenced by computeCellVelocity(), computeHbyA(), and linkMomentumPressureSystems().

◆ _momentum_system_numbers

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

protected

Numbers of the momentum system(s)

Definition at line 171 of file RhieChowMassFlux.h.

Referenced by linkMomentumPressureSystems().

◆ _momentum_systems

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

protected

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

Definition at line 168 of file RhieChowMassFlux.h.

Referenced by computeCellVelocity(), computeHbyA(), and linkMomentumPressureSystems().

◆ _moose_mesh

const MooseMesh& RhieChowMassFlux::_moose_mesh

protected

The MooseMesh that this user object operates on.

Definition at line 108 of file RhieChowMassFlux.h.

Referenced by checkBlocks().

◆ _p

const MooseLinearVariableFVReal* const RhieChowMassFlux::_p

protected

The thread 0 copy of the pressure variable.

Definition at line 117 of file RhieChowMassFlux.h.

Referenced by computeFaceMassFlux(), initialSetup(), and RhieChowMassFlux().

◆ _p_diffusion_kernel

LinearFVAnisotropicDiffusion* RhieChowMassFlux::_p_diffusion_kernel

protected

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

Definition at line 123 of file RhieChowMassFlux.h.

Referenced by computeFaceMassFlux(), and initialSetup().

◆ _pressure_projection_method

const MooseEnum RhieChowMassFlux::_pressure_projection_method

protected

Enumerator for the method used for pressure projection.

Definition at line 189 of file RhieChowMassFlux.h.

Referenced by computeHbyA().

◆ _pressure_system

const LinearSystem* RhieChowMassFlux::_pressure_system

protected

Pointer to the pressure system.

Definition at line 180 of file RhieChowMassFlux.h.

Referenced by computeCellVelocity(), computeFaceMassFlux(), linkMomentumPressureSystems(), selectPressureGradient(), and setupMeshInformation().

◆ _rho

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

protected

Functor describing the density of the fluid.

Definition at line 165 of file RhieChowMassFlux.h.

Referenced by getVolumetricFaceFlux(), initFaceMassFlux(), and populateCouplingFunctors().

◆ _vel

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

protected

The thread 0 copy of the x-velocity variable.

Definition at line 120 of file RhieChowMassFlux.h.

Referenced by initFaceMassFlux(), populateCouplingFunctors(), and RhieChowMassFlux().

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

navier_stokes/include/userobjects/RhieChowMassFlux.h
navier_stokes/src/userobjects/RhieChowMassFlux.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 Attributes

Detailed Description

Constructor & Destructor Documentation

◆ RhieChowMassFlux()

Member Function Documentation

◆ checkBlocks()

◆ computeCellVelocity()

◆ computeFaceMassFlux()

◆ computeHbyA()

◆ execute()

◆ finalize()

◆ getMassFlux()

◆ getVolumetricFaceFlux() [1/2]

◆ getVolumetricFaceFlux() [2/2]

◆ hasFaceSide()

◆ initCouplingField()

◆ initFaceMassFlux()

◆ initialize()

◆ initialSetup()

◆ linkMomentumPressureSystems()

◆ meshChanged()

◆ populateCouplingFunctors()

◆ selectPressureGradient()

◆ setupMeshInformation()

◆ supportMeshVelocity()

◆ validParams()

Member Data Documentation

◆ _Ainv

◆ _Ainv_raw

◆ _cell_volumes

◆ _dim

◆ _face_mass_flux

◆ _flow_face_info

◆ _global_momentum_system_numbers

◆ _global_pressure_system_number

◆ _grad_p_current

◆ _HbyA_flux

◆ _HbyA_raw

◆ _mesh

◆ _momentum_implicit_systems

◆ _momentum_system_numbers

◆ _momentum_systems

◆ _moose_mesh

◆ _p

◆ _p_diffusion_kernel

◆ _pressure_projection_method

◆ _pressure_system

◆ _rho

◆ _vel