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)

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

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

void	initFaceMassFlux ()
	Initialize the container for face velocities.

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

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	meshChanged () override

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.

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

void	computeHbyA (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.

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.

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.

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

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_volumes
	We will hold a vector of cell volumes to make sure we can do volume corrections rapidly.

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.

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

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

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

Constructor & Destructor Documentation

◆ RhieChowMassFlux()

RhieChowMassFlux::RhieChowMassFlux ( const InputParameters & params )

Definition at line 78 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_system(nullptr),
    _pressure_gradient_field(nullptr),
    _base_pressure_gradient_field(nullptr),
    _global_pressure_system_number(0),
    _pressure_projection_method(getParam<MooseEnum>("pressure_projection_method")),
    _pressure_diffusion_interp_method(getParam<MooseEnum>("pressure_diffusion_interpolation") ==
                                              "harmonic"
                                          ? Moose::FV::InterpMethod::HarmonicAverage
                                          : Moose::FV::InterpMethod::Average)
{
  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(UserObject::_subproblem.numThreads()))
  {
    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

◆ AinvComponents()

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

Get the momentum-layout 1/A component vectors.

Definition at line 718 of file RhieChowMassFlux.C.

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

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

◆ basePressureGradientComponents()

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

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

Definition at line 726 of file RhieChowMassFlux.C.

{
  return basePressureGradientField().components();
}

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

◆ basePressureGradientField()

const LinearFVGradientReader & RhieChowMassFlux::basePressureGradientField ( ) const

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

Definition at line 699 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 basePressureGradientComponents().

◆ 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 313 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 RhieChowMassFlux().

◆ checkReconstructedPressureGradientCompatibility()

void RhieChowMassFlux::checkReconstructedPressureGradientCompatibility ( ) const

protected

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

Definition at line 1185 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 linkMomentumPressureSystems().

◆ computeFaceMassFlux()

void RhieChowMassFlux::computeFaceMassFlux ( )

Update the values of the face velocities in the containers.

Definition at line 755 of file RhieChowMassFlux.C.

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

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

◆ computeHbyA()

void RhieChowMassFlux::computeHbyA ( 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 952 of file RhieChowMassFlux.C.

{
  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!");
 
  mooseAssert(!_grad_p_current.empty(),
              "A coupling pressure-gradient snapshot must exist before computing H/A.");
  mooseAssert(_grad_p_current.size() == _momentum_implicit_systems.size(),
              "The coupling pressure-gradient snapshot must have one component per momentum "
              "system.");
 
#ifndef NDEBUG
  for (const auto system_i : index_range(_momentum_implicit_systems))
  {
    const auto & snapshot = *_grad_p_current[system_i];
    const auto & momentum_layout = *_momentum_implicit_systems[system_i]->current_local_solution;
    mooseAssert(snapshot.size() == momentum_layout.size() &&
                    snapshot.local_size() == momentum_layout.local_size() &&
                    snapshot.first_local_index() == momentum_layout.first_local_index() &&
                    snapshot.last_local_index() == momentum_layout.last_local_index(),
                "The coupling pressure-gradient snapshot layout must match its momentum system.");
  }
#endif
 
  const auto & coupling_pressure_gradient = _grad_p_current;
 
  _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 using the same coupling gradient that
    // assembled the momentum pressure source.
    working_vector_petsc->pointwise_mult(*coupling_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;
      coupling_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, *coupling_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);
 
    if (verbose)
    {
      _console << " 1/A" << std::endl;
      Ainv.print();
    }
  }
 
  // 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;
  }
}

Referenced by LinearAssemblySegregatedSolve::correctVelocity().

◆ dimension()

unsigned int RhieChowMassFlux::dimension ( ) const

inline

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

Definition at line 68 of file RhieChowMassFlux.h.

68{ return _dim; }

Referenced by FVReconstructedPressureGradient::assembleFaceProjection(), FVReconstructedPressureGradient::computeCandidateFromCorrectedFlux(), FVReconstructedPressureGradient::linkFlowSystem(), preparePISOCorrector(), FVReconstructedPressureGradient::reconstructionVelocityGradient(), FVReconstructedPressureGradient::saveLaggedVelocityGradient(), and FVReconstructedPressureGradient::validateSetup().

◆ execute()

virtual void RhieChowMassFlux::execute ( )

inlineoverridevirtual

Implements GeneralUserObject.

Definition at line 143 of file RhieChowMassFlux.h.

143{}

◆ faceMassFluxGeneration()

dof_id_type RhieChowMassFlux::faceMassFluxGeneration ( ) const

inline

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

96{ return _face_mass_flux_generation; }

Referenced by FVReconstructedPressureGradient::computeCandidateFromCorrectedFlux().

◆ finalize()

virtual void RhieChowMassFlux::finalize ( )

inlineoverridevirtual

Implements GeneralUserObject.

Definition at line 144 of file RhieChowMassFlux.h.

144{}

◆ finalizeMomentumPredictor()

void RhieChowMassFlux::finalizeMomentumPredictor ( )

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

Definition at line 412 of file RhieChowMassFlux.C.

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

Referenced by LinearAssemblySegregatedSolve::solveMomentumPredictor().

◆ finalizePressureCorrector()

void RhieChowMassFlux::finalizePressureCorrector ( )

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 445 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().

◆ getMassFlux()

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

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

◆ getVolumetricFaceFlux() [1/2]

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

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,
               ".");
 
  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());
  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

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

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

◆ HbyAComponents()

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

Get the momentum-layout H/A component vectors.

Definition at line 710 of file RhieChowMassFlux.C.

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

Referenced by FVReconstructedPressureGradient::reconstructPressureGradient().

◆ initCouplingField()

void RhieChowMassFlux::initCouplingField ( )

Initialize the coupling fields (HbyA and Ainv)

Definition at line 827 of file RhieChowMassFlux.C.

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

Referenced by LinearAssemblySegregatedSolve::linkRhieChowUserObject().

◆ initFaceMassFlux()

void RhieChowMassFlux::initFaceMassFlux ( )

Initialize the container for face velocities.

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

Referenced by LinearAssemblySegregatedSolve::linkRhieChowUserObject().

◆ initialize()

void RhieChowMassFlux::initialize ( )

overridevirtual

Implements GeneralUserObject.

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

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

Definition at line 464 of file RhieChowMassFlux.C.

{
  _pressure_system->computeGradients();
}

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

◆ linkMomentumPressureSystems()

void RhieChowMassFlux::linkMomentumPressureSystems	(	const std::vector< LinearSystem * > &	momentum_systems,
		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 132 of file RhieChowMassFlux.C.

{
  _momentum_systems = momentum_systems;
  _momentum_system_numbers = momentum_system_numbers;
  _pressure_system = &pressure_system;
  _global_pressure_system_number = _pressure_system->number();
 
  auto * const pressure_var =
      dynamic_cast<MooseLinearVariableFVReal *>(&_pressure_system->getVariable(0, _p->number()));
  if (!pressure_var)
    mooseError("The pressure variable in system '",
               _pressure_system->name(),
               "' must be a MooseLinearVariableFVReal.");
 
  // For each momentum system, find the LinearFVMomentumPressure kernels applicable to this RC
  // object, i.e. those whose blocks overlap the blocks this RC object handles. Kernels entirely
  // outside our blocks are irrelevant and ignored; multiple applicable kernels per system are
  // allowed as long as they partition our blocks without overlapping (checked below).
  std::vector<std::vector<const LinearFVMomentumPressure *>> applicable_kernels(
      momentum_systems.size());
  for (const auto system_index : index_range(momentum_systems))
  {
    std::vector<LinearFVElementalKernel *> kernels;
    _fe_problem.theWarehouse()
        .query()
        .template condition<AttribThread>(_tid)
        .template condition<AttribSystem>("LinearFVElementalKernel")
        .template condition<AttribSysNum>(momentum_system_numbers[system_index])
        .queryInto(kernels);
 
    for (const auto * const kernel : kernels)
    {
      const auto * const candidate = dynamic_cast<const LinearFVMomentumPressure *>(kernel);
      if (candidate && MooseUtils::setsIntersect(candidate->blockIDs(), blockIDs()))
        applicable_kernels[system_index].push_back(candidate);
    }
  }
 
  for (const auto system_index : index_range(momentum_systems))
  {
    const auto & kernels = applicable_kernels[system_index];
    const auto & system_name = momentum_systems[system_index]->name();
 
    // Coverage: the applicable kernels must together cover every block this RC object handles.
    std::set<SubdomainID> covered_blocks;
    for (const auto * const kernel : kernels)
      covered_blocks.insert(kernel->blockIDs().begin(), kernel->blockIDs().end());
 
    std::set<SubdomainID> missing_blocks;
    std::set_difference(blockIDs().begin(),
                        blockIDs().end(),
                        covered_blocks.begin(),
                        covered_blocks.end(),
                        std::inserter(missing_blocks, missing_blocks.end()));
 
    if (!missing_blocks.empty())
      mooseError("RhieChowMassFlux '",
                 name(),
                 "' found no applicable LinearFVMomentumPressure kernel for momentum system '",
                 system_name,
                 "' on block(s) ",
                 Moose::stringify(missing_blocks),
                 ".");
 
    // Component and pairwise block-overlap checks among the applicable kernels for this system.
    for (const auto i : index_range(kernels))
    {
      if (kernels[i]->momentumComponent() != system_index)
        mooseError("LinearFVMomentumPressure kernel '",
                   kernels[i]->name(),
                   "' declares momentum component ",
                   kernels[i]->momentumComponent(),
                   " but is linked to momentum system '",
                   system_name,
                   "' (component ",
                   system_index,
                   ") through RhieChowMassFlux '",
                   name(),
                   "'.");
 
      for (const auto j : make_range(i + 1, kernels.size()))
      {
        std::set<SubdomainID> overlap;
        for (const auto block : kernels[i]->blockIDs())
          if (hasBlocks(block) && kernels[j]->blockIDs().count(block))
            overlap.insert(block);
        if (!overlap.empty())
          mooseError("Momentum system '",
                     system_name,
                     "' has more than one LinearFVMomentumPressure kernel contributing a "
                     "pressure source on the same block(s) for RhieChowMassFlux '",
                     name(),
                     "': '",
                     kernels[i]->name(),
                     "' and '",
                     kernels[j]->name(),
                     "' overlap on block(s) ",
                     Moose::stringify(overlap),
                     ".");
      }
    }
  }
 
  // Flatten every system's applicable kernels into one list spanning the whole RC object. Even
  // kernels on disjoint blocks/components must share one coupling-gradient field, because H/A
  // has a single field source for this RC object.
  std::vector<const LinearFVMomentumPressure *> momentum_pressure_kernels;
  for (auto & kernels : applicable_kernels)
    momentum_pressure_kernels.insert(
        momentum_pressure_kernels.end(), kernels.begin(), kernels.end());
 
  const auto * const coupling_kernel = momentum_pressure_kernels.front();
  const auto & coupling_reader = coupling_kernel->pressureGradientField();
 
  if (dynamic_cast<const FVReconstructedPressureGradient *>(&coupling_reader.method()) &&
      coupling_kernel->pressureVariableNumber() != _p->number())
    mooseError("FVReconstructedPressureGradient can only be used for the pressure variable "
               "registered on RhieChowMassFlux '",
               name(),
               "'.");
 
  for (const auto * const kernel : momentum_pressure_kernels)
  {
    const auto & reader = kernel->pressureGradientField();
 
    if (&reader.system() != &coupling_reader.system() ||
        reader.systemNumber() != coupling_reader.systemNumber())
      mooseError("RhieChowMassFlux '",
                 name(),
                 "': momentum pressure kernels '",
                 coupling_kernel->name(),
                 "' (block(s) ",
                 Moose::stringify(coupling_kernel->blockIDs()),
                 ") and '",
                 kernel->name(),
                 "' (block(s) ",
                 Moose::stringify(kernel->blockIDs()),
                 ") must use pressure gradients from the same system.");
 
    if (reader.variableNumber() != coupling_reader.variableNumber())
      mooseError("RhieChowMassFlux '",
                 name(),
                 "': momentum pressure kernels '",
                 coupling_kernel->name(),
                 "' (pressure variable number ",
                 coupling_reader.variableNumber(),
                 ") and '",
                 kernel->name(),
                 "' (pressure variable number ",
                 reader.variableNumber(),
                 ") must use the same pressure variable.");
 
    if (&reader.method() != &coupling_reader.method())
      mooseError("RhieChowMassFlux '",
                 name(),
                 "': momentum pressure kernels '",
                 coupling_kernel->name(),
                 "' and '",
                 kernel->name(),
                 "' must use the same pressure gradient method.");
 
    if (&reader.components() != &coupling_reader.components())
      mooseError("RhieChowMassFlux '",
                 name(),
                 "': momentum pressure kernels '",
                 coupling_kernel->name(),
                 "' and '",
                 kernel->name(),
                 "' must share the same registered pressure gradient field.");
  }
 
  _pressure_gradient_field = &coupling_reader;
 
  if (usingReconstructedPressureGradientMethod())
  {
    reconstructedGradientMethod().linkFlowSystem(*this, coupling_reader);
    const auto & base_reader =
        pressure_var->requestCellGradients(reconstructedGradientMethod().baseGradientMethodName());
    _base_pressure_gradient_field = &base_reader;
 
    mooseAssert(_base_pressure_gradient_field != _pressure_gradient_field,
                "Reconstructed and base pressure gradient readers must be distinct when "
                "FVReconstructedPressureGradient is active.");
  }
  else
    _base_pressure_gradient_field = _pressure_gradient_field;
 
  _global_momentum_system_numbers.clear();
  _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()));
  }
 
  if (usingReconstructedPressureGradientMethod())
  {
    checkReconstructedPressureGradientCompatibility();
    if (_p_diffusion_kernel && _p_diffusion_kernel->useNonorthogonalCorrection() &&
        _pressure_projection_method != "consistent")
      paramError("pressure_projection_method",
                 "FVReconstructedPressureGradient with nonorthogonal pressure diffusion requires "
                 "the consistent pressure projection.");
  }
 
  setupMeshInformation();
 
  std::set<BoundaryID> velocity_boundary_ids;
  for (const auto dim_i : make_range(_dim))
    for (const auto & [boundary_id, _] : _vel[dim_i]->getBoundaryConditionMap())
      velocity_boundary_ids.insert(boundary_id);
 
  const auto is_dirichlet =
      [](const MooseLinearVariableFVReal & variable, const BoundaryID boundary_id)
  {
    return dynamic_cast<const LinearFVAdvectionDiffusionFunctorDirichletBC *>(
               variable.getBoundaryCondition(boundary_id)) != nullptr;
  };
 
  // The legacy boundary HbyA reconstruction uses the x-velocity BC as a proxy for every velocity
  // component, so all components must have the same Dirichlet classification on those boundaries.
  for (const auto boundary_id : velocity_boundary_ids)
  {
    const auto * const pressure_bc = _p->getBoundaryCondition(boundary_id);
    if (dynamic_cast<const LinearFVPressureFluxBC *>(pressure_bc))
      continue;
 
    const bool velocity_is_dirichlet = is_dirichlet(*_vel[0], boundary_id);
    for (const auto dim_i : make_range(_dim))
      if (is_dirichlet(*_vel[dim_i], boundary_id) != velocity_is_dirichlet)
        mooseError("All velocity components must either have Dirichlet boundary conditions or "
                   "non-Dirichlet boundary conditions on boundary '",
                   _moose_mesh.getBoundaryName(boundary_id),
                   "' when the pressure boundary condition is not a LinearFVPressureFluxBC.");
  }
}

Referenced by LinearAssemblySegregatedSolve::linkRhieChowUserObject().

◆ meshChanged()

void RhieChowMassFlux::meshChanged ( )

overridevirtual

Reimplemented from GeneralUserObject.

Definition at line 373 of file RhieChowMassFlux.C.

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

◆ momentumSystem() [1/2]

LinearSystem & RhieChowMassFlux::momentumSystem ( unsigned int component )

inline

Momentum linear system for one spatial component.

Definition at line 80 of file RhieChowMassFlux.h.

80{ return *_momentum_systems[component]; }

RankTwoScalarTools::component

T component(const RankTwoTensorTempl< T > &r2tensor, unsigned int i, unsigned int j)

Definition RankTwoScalarTools.h:67

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

◆ momentumSystem() [2/2]

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

inline

Momentum linear system for one spatial component.

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

protected

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

Definition at line 840 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 computeHbyA().

◆ prepareMomentumPredictor()

void RhieChowMassFlux::prepareMomentumPredictor ( )

Snapshot the fields read by the next momentum predictor.

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

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

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

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 433 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().

◆ pressureGradientComponents()

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

protected

Get the registered pressure gradient component vectors.

Definition at line 1154 of file RhieChowMassFlux.C.

{
  return pressureGradientField().components();
}

Referenced by finalizePressureCorrector(), and prepareMomentumPredictor().

◆ pressureGradientField()

const LinearFVGradientReader & RhieChowMassFlux::pressureGradientField ( ) const

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

Definition at line 689 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 finalizePressureCorrector(), pressureGradientComponents(), reconstructedGradientMethod(), reconstructedGradientMethod(), FVReconstructedPressureGradient::resetForTimeStep(), and usingReconstructedPressureGradientMethod().

◆ pressureSystem()

const LinearSystem & RhieChowMassFlux::pressureSystem ( ) const

inline

Pressure linear system.

Definition at line 89 of file RhieChowMassFlux.h.

89{ return *_pressure_system; }

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

◆ pressureVariableNumber()

unsigned int RhieChowMassFlux::pressureVariableNumber ( ) const

Variable number of the pressure variable reconstructed by this object.

Definition at line 732 of file RhieChowMassFlux.C.

{
  return _p->number();
}

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

◆ reconstructedGradientMethod() [1/2]

FVReconstructedPressureGradient & RhieChowMassFlux::reconstructedGradientMethod ( )

protected

Access the reconstructed gradient method when it is selected.

Definition at line 1176 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 checkReconstructedPressureGradientCompatibility(), finalizeMomentumPredictor(), finalizePressureCorrector(), linkMomentumPressureSystems(), preparePISOCorrector(), preparePressureRelaxation(), and timestepSetup().

◆ reconstructedGradientMethod() [2/2]

const FVReconstructedPressureGradient & RhieChowMassFlux::reconstructedGradientMethod ( ) const

protected

Access the reconstructed gradient method when it is selected.

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

protected

Compute the cell volumes on the mesh.

Definition at line 494 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_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);
}

Referenced by linkMomentumPressureSystems(), and meshChanged().

◆ supportMeshVelocity()

virtual bool RhieChowMassFlux::supportMeshVelocity ( ) const

inlineoverrideprotectedvirtual

Returns whether the UO can support mesh velocity advection.

Reimplemented from RhieChowFaceFluxProvider.

Definition at line 202 of file RhieChowMassFlux.h.

202{ return false; }

◆ timestepSetup()

void RhieChowMassFlux::timestepSetup ( )

overridevirtual

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

◆ updateCellVelocity()

template<typename GradientComponent >

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

protected

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

Definition at line 519 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 finalizePressureCorrector(), and preparePressureRelaxation().

◆ usingReconstructedPressureGradientMethod()

bool RhieChowMassFlux::usingReconstructedPressureGradientMethod ( ) const

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

Definition at line 1160 of file RhieChowMassFlux.C.

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

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

◆ validParams()

InputParameters RhieChowMassFlux::validParams ( )

static

Definition at line 41 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 LinearFVPressureCorrectionDiffusion 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)");
  params.addParam<MooseEnum>(
      "pressure_diffusion_interpolation",
      MooseEnum("average harmonic", "average"),
      "The face interpolation method for Ainv in the pressure correction diffusion term.");
  return params;
}

Referenced by WCNSLinearFVFlowPhysics::validParams().

◆ velocityVariable() [1/2]

MooseLinearVariableFVReal & RhieChowMassFlux::velocityVariable ( unsigned int component )

inline

Velocity variable for one spatial component.

Definition at line 71 of file RhieChowMassFlux.h.

71{ return *_vel[component]; }

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

◆ velocityVariable() [2/2]

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

inline

Velocity variable for one spatial component.

Definition at line 74 of file RhieChowMassFlux.h.

  {
    return *_vel[component];
  }

Member Data Documentation

◆ _A_avg

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

protected

Definition at line 249 of file RhieChowMassFlux.h.

◆ _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 241 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 247 of file RhieChowMassFlux.h.

Referenced by AinvComponents(), computeHbyA(), and updateCellVelocity().

◆ _base_pressure_gradient_field

const LinearFVGradientReader* RhieChowMassFlux::_base_pressure_gradient_field

protected

Base pressure gradient field used to seed reconstructed gradient updates.

Definition at line 291 of file RhieChowMassFlux.h.

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

◆ _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 297 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 211 of file RhieChowMassFlux.h.

Referenced by checkReconstructedPressureGradientCompatibility(), dimension(), linkMomentumPressureSystems(), and 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 254 of file RhieChowMassFlux.h.

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

◆ _face_mass_flux_generation

dof_id_type RhieChowMassFlux::_face_mass_flux_generation = 0

protected

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

Referenced by computeFaceMassFlux(), and faceMassFluxGeneration().

◆ _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 308 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 279 of file RhieChowMassFlux.h.

Referenced by checkReconstructedPressureGradientCompatibility(), linkMomentumPressureSystems(), and populateCouplingFunctors().

◆ _global_pressure_system_number

unsigned int RhieChowMassFlux::_global_pressure_system_number

protected

Global number of the pressure system.

Definition at line 294 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

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

Definition at line 257 of file RhieChowMassFlux.h.

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

◆ _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}*\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 229 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 235 of file RhieChowMassFlux.h.

Referenced by computeHbyA(), HbyAComponents(), and updateCellVelocity().

◆ _mesh

const libMesh::MeshBase& RhieChowMassFlux::_mesh

protected

The libMesh mesh that this object acts on.

Definition at line 208 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 282 of file RhieChowMassFlux.h.

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

◆ _momentum_system_numbers

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

protected

Numbers of the momentum system(s)

Definition at line 276 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 273 of file RhieChowMassFlux.h.

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

◆ _moose_mesh

const MooseMesh& RhieChowMassFlux::_moose_mesh

protected

The MooseMesh that this user object operates on.

Definition at line 205 of file RhieChowMassFlux.h.

Referenced by checkBlocks(), and linkMomentumPressureSystems().

◆ _p

const MooseLinearVariableFVReal* const RhieChowMassFlux::_p

protected

The thread 0 copy of the pressure variable.

Definition at line 214 of file RhieChowMassFlux.h.

Referenced by computeFaceMassFlux(), initialSetup(), linkMomentumPressureSystems(), populateCouplingFunctors(), pressureVariableNumber(), and RhieChowMassFlux().

◆ _p_diffusion_kernel

LinearFVPressureCorrectionDiffusion* RhieChowMassFlux::_p_diffusion_kernel

protected

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

Definition at line 221 of file RhieChowMassFlux.h.

Referenced by checkReconstructedPressureGradientCompatibility(), computeFaceMassFlux(), initialSetup(), and linkMomentumPressureSystems().

◆ _pressure_diffusion_interp_method

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

protected

Interpolation method used for the pressure diffusion coefficient on faces.

Definition at line 303 of file RhieChowMassFlux.h.

Referenced by populateCouplingFunctors().

◆ _pressure_gradient_field

const LinearFVGradientReader* RhieChowMassFlux::_pressure_gradient_field

protected

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

Definition at line 288 of file RhieChowMassFlux.h.

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

◆ _pressure_projection_method

const MooseEnum RhieChowMassFlux::_pressure_projection_method

protected

Enumerator for the method used for pressure projection.

Definition at line 300 of file RhieChowMassFlux.h.

Referenced by computeHbyA(), and linkMomentumPressureSystems().

◆ _pressure_system

LinearSystem* RhieChowMassFlux::_pressure_system

protected

Pointer to the pressure system.

Definition at line 285 of file RhieChowMassFlux.h.

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

◆ _rho

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

protected

Functor describing the density of the fluid.

Definition at line 270 of file RhieChowMassFlux.h.

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

◆ _vel

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

protected

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

Definition at line 218 of file RhieChowMassFlux.h.

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

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

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ RhieChowMassFlux()

Member Function Documentation

◆ AinvComponents()

◆ basePressureGradientComponents()

◆ basePressureGradientField()

◆ checkBlocks()

◆ checkReconstructedPressureGradientCompatibility()

◆ computeFaceMassFlux()

◆ computeHbyA()

◆ dimension()

◆ execute()

◆ faceMassFluxGeneration()

◆ finalize()

◆ finalizeMomentumPredictor()

◆ finalizePressureCorrector()

◆ getMassFlux()

◆ getVolumetricFaceFlux() [1/2]

◆ getVolumetricFaceFlux() [2/2]

◆ hasFaceSide()

◆ HbyAComponents()

◆ initCouplingField()

◆ initFaceMassFlux()

◆ initialize()

◆ initialSetup()

◆ initPressureGradient()

◆ linkMomentumPressureSystems()

◆ meshChanged()

◆ momentumSystem() [1/2]

◆ momentumSystem() [2/2]

◆ populateCouplingFunctors()

◆ prepareMomentumPredictor()

◆ preparePISOCorrector()

◆ preparePressureRelaxation()

◆ pressureGradientComponents()

◆ pressureGradientField()

◆ pressureSystem()

◆ pressureVariableNumber()

◆ reconstructedGradientMethod() [1/2]

◆ reconstructedGradientMethod() [2/2]

◆ setupMeshInformation()

◆ supportMeshVelocity()

◆ timestepSetup()

◆ updateCellVelocity()

◆ usingReconstructedPressureGradientMethod()

◆ validParams()

◆ velocityVariable() [1/2]

◆ velocityVariable() [2/2]

Member Data Documentation

◆ _A_avg

◆ _Ainv

◆ _Ainv_raw

◆ _base_pressure_gradient_field

◆ _cell_volumes

◆ _dim

◆ _face_mass_flux

◆ _face_mass_flux_generation

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