SubChannel1PhaseProblem Class Reference

Base class for the 1-phase steady-state/transient subchannel solver. More...

#include <SubChannel1PhaseProblem.h>

Inheritance diagram for SubChannel1PhaseProblem:

Classes
struct	FrictionStruct
	structure with the needed information to compute the friction factor at a specific subchannel cell More...
struct	NusseltStruct
	structure with the needed information to compute the Nusselt number at a specific subchannel cell and heated surface More...

Public Types
enum	Direction
enum	CoverageCheckMode
typedef DataFileName	DataFileParameterType

Public Member Functions
	SubChannel1PhaseProblem (const InputParameters &params)
virtual	~SubChannel1PhaseProblem ()
virtual void	externalSolve () override
virtual void	syncSolutions (Direction direction) override
virtual bool	solverSystemConverged (const unsigned int) override
virtual void	initialSetup () override
const SCMHTCClosureBase *	getDuctHTCClosure () const
const SCMHTCClosureBase *	getPinHTCClosure () const
const SCMFrictionClosureBase *	getFrictionClosure () const
Real	getBulkReynoldsNumber () const
Real	getBulkVelocity () const
Real	getAddedHeatPin (unsigned int i_ch, unsigned int iz) const
	Return the added heat coming from the fuel pins.
Real	getAddedHeatDuct (unsigned int i_ch, unsigned int iz) const
	Return the added heat coming from the duct.
const PostprocessorValue &	getOutletPressure () const
	Get outlet pressure.
const SinglePhaseFluidProperties *	getSinglePhaseFluidProperties () const
	Get fluid properties object.
virtual void	solve (unsigned int nl_sys_num=0) override final
virtual void	addExternalVariables ()
bool	initialized () const
virtual libMesh::EquationSystems &	es () override
virtual MooseMesh &	mesh () override
virtual const MooseMesh &	mesh () const override
const MooseMesh &	mesh (bool use_displaced) const override
MooseMesh &	mesh (bool use_displaced)
void	setCoordSystem (const std::vector< SubdomainName > &blocks, const MultiMooseEnum &coord_sys)
void	setAxisymmetricCoordAxis (const MooseEnum &rz_coord_axis)
void	setCoupling (Moose::CouplingType type)
Moose::CouplingType	coupling () const
void	setCouplingMatrix (std::unique_ptr< libMesh::CouplingMatrix > cm, const unsigned int nl_sys_num)
void	setCouplingMatrix (libMesh::CouplingMatrix *cm, const unsigned int nl_sys_num)
const libMesh::CouplingMatrix *	couplingMatrix (const unsigned int nl_sys_num) const override
void	setNonlocalCouplingMatrix ()
bool	areCoupled (const unsigned int ivar, const unsigned int jvar, const unsigned int nl_sys_num) const
bool	hasUOAuxStateCheck () const
bool	checkingUOAuxState () const
virtual bool	checkResidualForNans () const override
void	setCheckResidualForNans (bool check_residual_for_nans)
void	trustUserCouplingMatrix ()
std::vector< std::pair< MooseVariableFieldBase *, MooseVariableFieldBase * > > &	couplingEntries (const THREAD_ID tid, const unsigned int nl_sys_num)
std::vector< std::pair< MooseVariableFieldBase *, MooseVariableFieldBase * > > &	nonlocalCouplingEntries (const THREAD_ID tid, const unsigned int nl_sys_num)
const std::vector< std::pair< MooseVariableFieldBase *, MooseVariableScalar * > > &	fieldScalarCouplingEntries (const THREAD_ID tid, const unsigned int nl_sys_num) const
virtual bool	hasVariable (const std::string &var_name) const override
bool	hasSolverVariable (const std::string &var_name) const
virtual const MooseVariableFieldBase &	getVariable (const THREAD_ID tid, const std::string &var_name, Moose::VarKindType expected_var_type=Moose::VarKindType::VAR_ANY, Moose::VarFieldType expected_var_field_type=Moose::VarFieldType::VAR_FIELD_ANY) const override
virtual const MooseVariableFieldBase &	getVariable (const THREAD_ID tid, const std::string &var_name, Moose::VarKindType expected_var_type=Moose::VarKindType::VAR_ANY, Moose::VarFieldType expected_var_field_type=Moose::VarFieldType::VAR_FIELD_ANY) const =0
virtual MooseVariableFieldBase &	getVariable (const THREAD_ID tid, const std::string &var_name, Moose::VarKindType expected_var_type=Moose::VarKindType::VAR_ANY, Moose::VarFieldType expected_var_field_type=Moose::VarFieldType::VAR_FIELD_ANY)
MooseVariableFieldBase &	getActualFieldVariable (const THREAD_ID tid, const std::string &var_name) override
virtual MooseVariable &	getStandardVariable (const THREAD_ID tid, const std::string &var_name) override
virtual VectorMooseVariable &	getVectorVariable (const THREAD_ID tid, const std::string &var_name) override
virtual ArrayMooseVariable &	getArrayVariable (const THREAD_ID tid, const std::string &var_name) override
virtual bool	hasScalarVariable (const std::string &var_name) const override
virtual MooseVariableScalar &	getScalarVariable (const THREAD_ID tid, const std::string &var_name) override
virtual libMesh::System &	getSystem (const std::string &var_name) override
const RestartableEquationSystems &	getRestartableEquationSystems () const
virtual void	setActiveElementalMooseVariables (const std::set< MooseVariableFEBase * > &moose_vars, const THREAD_ID tid) override
virtual void	clearActiveElementalMooseVariables (const THREAD_ID tid) override
virtual void	clearActiveFEVariableCoupleableMatrixTags (const THREAD_ID tid) override
virtual void	clearActiveFEVariableCoupleableVectorTags (const THREAD_ID tid) override
virtual void	setActiveFEVariableCoupleableVectorTags (std::set< TagID > &vtags, const THREAD_ID tid) override
virtual void	setActiveFEVariableCoupleableMatrixTags (std::set< TagID > &mtags, const THREAD_ID tid) override
virtual void	clearActiveScalarVariableCoupleableMatrixTags (const THREAD_ID tid) override
virtual void	clearActiveScalarVariableCoupleableVectorTags (const THREAD_ID tid) override
virtual void	setActiveScalarVariableCoupleableVectorTags (std::set< TagID > &vtags, const THREAD_ID tid) override
virtual void	setActiveScalarVariableCoupleableMatrixTags (std::set< TagID > &mtags, const THREAD_ID tid) override
virtual void	createQRules (libMesh::QuadratureType type, libMesh::Order order, libMesh::Order volume_order=libMesh::INVALID_ORDER, libMesh::Order face_order=libMesh::INVALID_ORDER, SubdomainID block=Moose::ANY_BLOCK_ID, bool allow_negative_qweights=true)
void	bumpVolumeQRuleOrder (libMesh::Order order, SubdomainID block)
void	bumpAllQRuleOrder (libMesh::Order order, SubdomainID block)
unsigned int	getMaxQps () const
libMesh::Order	getMaxScalarOrder () const
void	checkNonlocalCoupling ()
void	checkUserObjectJacobianRequirement (THREAD_ID tid)
void	setVariableAllDoFMap (const std::vector< const MooseVariableFEBase * > &moose_vars)
const std::vector< const MooseVariableFEBase * > &	getUserObjectJacobianVariables (const THREAD_ID tid) const
virtual Assembly &	assembly (const THREAD_ID tid, const unsigned int sys_num) override
virtual const Assembly &	assembly (const THREAD_ID tid, const unsigned int sys_num) const override
Moose::Kokkos::Assembly &	kokkosAssembly ()
const Moose::Kokkos::Assembly &	kokkosAssembly () const
virtual std::vector< VariableName >	getVariableNames ()
void	checkDuplicatePostprocessorVariableNames ()
void	timestepSetup () override
void	customSetup (const ExecFlagType &exec_type) override
void	residualSetup () override
void	jacobianSetup () override
virtual void	prepare (const Elem *elem, const THREAD_ID tid) override
virtual void	prepare (const Elem *elem, unsigned int ivar, unsigned int jvar, const std::vector< dof_id_type > &dof_indices, const THREAD_ID tid) override
virtual void	prepareFace (const Elem *elem, const THREAD_ID tid) override
virtual void	setCurrentSubdomainID (const Elem *elem, const THREAD_ID tid) override
virtual void	setNeighborSubdomainID (const Elem *elem, unsigned int side, const THREAD_ID tid) override
virtual void	setNeighborSubdomainID (const Elem *elem, const THREAD_ID tid)
virtual void	prepareAssembly (const THREAD_ID tid) override
virtual void	prepareAssemblyNeighbor (const THREAD_ID tid)
virtual void	addGhostedElem (dof_id_type elem_id) override
virtual void	addGhostedBoundary (BoundaryID boundary_id) override
virtual void	ghostGhostedBoundaries () override
virtual void	sizeZeroes (unsigned int size, const THREAD_ID tid)
virtual bool	reinitDirac (const Elem *elem, const THREAD_ID tid) override
virtual void	reinitElem (const Elem *elem, const THREAD_ID tid) override
virtual void	reinitElemPhys (const Elem *elem, const std::vector< Point > &phys_points_in_elem, const THREAD_ID tid) override
void	reinitElemFace (const Elem *elem, unsigned int side, BoundaryID, const THREAD_ID tid)
virtual void	reinitElemFace (const Elem *elem, unsigned int side, const THREAD_ID tid) override
virtual void	reinitLowerDElem (const Elem *lower_d_elem, const THREAD_ID tid, const std::vector< Point > *const pts=nullptr, const std::vector< Real > *const weights=nullptr) override
virtual void	reinitNode (const Node *node, const THREAD_ID tid) override
virtual void	reinitNodeFace (const Node *node, BoundaryID bnd_id, const THREAD_ID tid) override
virtual void	reinitNeighbor (const Elem *elem, unsigned int side, const THREAD_ID tid) override
virtual void	reinitNeighborPhys (const Elem *neighbor, unsigned int neighbor_side, const std::vector< Point > &physical_points, const THREAD_ID tid) override
virtual void	reinitNeighborPhys (const Elem *neighbor, const std::vector< Point > &physical_points, const THREAD_ID tid) override
virtual void	reinitElemNeighborAndLowerD (const Elem *elem, unsigned int side, const THREAD_ID tid) override
virtual void	reinitScalars (const THREAD_ID tid, bool reinit_for_derivative_reordering=false) override
virtual void	reinitOffDiagScalars (const THREAD_ID tid) override
virtual void	getDiracElements (std::set< const Elem * > &elems) override
virtual void	clearDiracInfo () override
virtual void	subdomainSetup (SubdomainID subdomain, const THREAD_ID tid)
virtual void	neighborSubdomainSetup (SubdomainID subdomain, const THREAD_ID tid)
virtual void	newAssemblyArray (std::vector< std::shared_ptr< SolverSystem > > &solver_systems)
virtual void	initNullSpaceVectors (const InputParameters &parameters, std::vector< std::shared_ptr< NonlinearSystemBase > > &nl)
virtual void	init () override
void	initKokkos ()
virtual void	solveLinearSystem (const unsigned int linear_sys_num, const Moose::PetscSupport::PetscOptions *po=nullptr)
virtual void	setException (const std::string &message)
virtual bool	hasException ()
virtual void	checkExceptionAndStopSolve (bool print_message=true)
virtual unsigned int	nNonlinearIterations (const unsigned int nl_sys_num) const override
virtual unsigned int	nLinearIterations (const unsigned int nl_sys_num) const override
virtual Real	finalNonlinearResidual (const unsigned int nl_sys_num) const override
virtual bool	computingPreSMOResidual (const unsigned int nl_sys_num) const override
virtual std::string	solverTypeString (unsigned int solver_sys_num=0)
virtual bool	startedInitialSetup ()
virtual void	onTimestepBegin () override
virtual void	onTimestepEnd () override
virtual Real &	time () const
virtual Real &	timeOld () const
virtual Real &	timeOlder () const
virtual int &	timeStep () const
virtual Real &	dt () const
virtual Real &	dtOld () const
Real	getTimeFromStateArg (const Moose::StateArg &state) const
virtual void	transient (bool trans)
virtual bool	isTransient () const override
virtual void	addTimeIntegrator (const std::string &type, const std::string &name, InputParameters &parameters)
virtual void	addPredictor (const std::string &type, const std::string &name, InputParameters &parameters)
virtual void	copySolutionsBackwards ()
void	skipNextForwardSolutionCopyToOld ()
virtual void	advanceState ()
virtual void	restoreSolutions ()
void	backupGeometricSearchState ()
void	restoreGeometricSearchState ()
virtual void	saveOldSolutions ()
virtual void	restoreOldSolutions ()
void	needSolutionState (unsigned int oldest_needed, Moose::SolutionIterationType iteration_type)
bool	hasSolutionState (unsigned int state, Moose::SolutionIterationType iteration_type) const
virtual void	outputStep (ExecFlagType type)
virtual void	postExecute ()
void	forceOutput ()
virtual void	initPetscOutputAndSomeSolverSettings ()
Moose::PetscSupport::PetscOptions &	getPetscOptions ()
void	logAdd (const std::string &system, const std::string &name, const std::string &type, const InputParameters &params) const
virtual void	addFunction (const std::string &type, const std::string &name, InputParameters &parameters)
virtual bool	hasFunction (const std::string &name, const THREAD_ID tid=0)
virtual Function &	getFunction (const std::string &name, const THREAD_ID tid=0)
virtual void	addKokkosFunction (const std::string &type, const std::string &name, InputParameters &parameters)
virtual bool	hasKokkosFunction (const std::string &name) const
virtual Moose::Kokkos::Function	getKokkosFunction (const std::string &name)
T &	getKokkosFunction (const std::string &name)
virtual void	addMeshDivision (const std::string &type, const std::string &name, InputParameters &params)
MeshDivision &	getMeshDivision (const std::string &name, const THREAD_ID tid=0) const
virtual void	addConvergence (const std::string &type, const std::string &name, InputParameters &parameters)
virtual Convergence &	getConvergence (const std::string &name, const THREAD_ID tid=0) const
virtual const std::vector< std::shared_ptr< Convergence > > &	getConvergenceObjects (const THREAD_ID tid=0) const
virtual bool	hasConvergence (const std::string &name, const THREAD_ID tid=0) const
bool	needToAddDefaultNonlinearConvergence () const
bool	needToAddDefaultMultiAppFixedPointConvergence () const
bool	needToAddDefaultSteadyStateConvergence () const
void	setNeedToAddDefaultNonlinearConvergence ()
void	setNeedToAddDefaultMultiAppFixedPointConvergence ()
void	setNeedToAddDefaultSteadyStateConvergence ()
bool	hasSetMultiAppFixedPointConvergenceName () const
bool	hasSetSteadyStateConvergenceName () const
virtual void	addDefaultNonlinearConvergence (const InputParameters &params)
virtual bool	onlyAllowDefaultNonlinearConvergence () const
void	addDefaultMultiAppFixedPointConvergence (const InputParameters &params)
void	addDefaultSteadyStateConvergence (const InputParameters &params)
virtual void	addLineSearch (const InputParameters &)
virtual void	lineSearch ()
LineSearch *	getLineSearch () override
virtual void	addDistribution (const std::string &type, const std::string &name, InputParameters &parameters)
virtual bool	hasDistribution (const std::string &name) const
virtual Distribution &	getDistribution (const std::string &name)
virtual void	addSampler (const std::string &type, const std::string &name, InputParameters &parameters)
virtual Sampler &	getSampler (const std::string &name, const THREAD_ID tid=0)
NonlinearSystemBase &	getNonlinearSystemBase (const unsigned int sys_num)
const NonlinearSystemBase &	getNonlinearSystemBase (const unsigned int sys_num) const
void	setCurrentNonlinearSystem (const unsigned int nl_sys_num)
NonlinearSystemBase &	currentNonlinearSystem ()
const NonlinearSystemBase &	currentNonlinearSystem () const
virtual const SystemBase &	systemBaseNonlinear (const unsigned int sys_num) const override
virtual SystemBase &	systemBaseNonlinear (const unsigned int sys_num) override
virtual const SystemBase &	systemBaseSolver (const unsigned int sys_num) const override
virtual SystemBase &	systemBaseSolver (const unsigned int sys_num) override
virtual const SystemBase &	systemBaseAuxiliary () const override
virtual SystemBase &	systemBaseAuxiliary () override
virtual NonlinearSystem &	getNonlinearSystem (const unsigned int sys_num)
virtual const SystemBase &	getSystemBase (const unsigned int sys_num) const
virtual SystemBase &	getSystemBase (const unsigned int sys_num)
SystemBase &	getSystemBase (const std::string &sys_name)
LinearSystem &	getLinearSystem (unsigned int sys_num)
const LinearSystem &	getLinearSystem (unsigned int sys_num) const
SolverSystem &	getSolverSystem (unsigned int sys_num)
const SolverSystem &	getSolverSystem (unsigned int sys_num) const
void	setCurrentLinearSystem (unsigned int sys_num)
LinearSystem &	currentLinearSystem ()
const LinearSystem &	currentLinearSystem () const
virtual const SystemBase &	systemBaseLinear (unsigned int sys_num) const override
virtual SystemBase &	systemBaseLinear (unsigned int sys_num) override
virtual void	addVariable (const std::string &var_type, const std::string &var_name, InputParameters &params)
virtual void	addKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
virtual void	addHDGKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
virtual void	addNodalKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
virtual void	addScalarKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
virtual void	addBoundaryCondition (const std::string &bc_name, const std::string &name, InputParameters &parameters)
virtual void	addKokkosKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
virtual void	addKokkosNodalKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
virtual void	addKokkosBoundaryCondition (const std::string &bc_name, const std::string &name, InputParameters &parameters)
virtual void	addKokkosLinearFVKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
virtual void	addKokkosLinearFVBC (const std::string &bc_name, const std::string &name, InputParameters &parameters)
virtual void	addConstraint (const std::string &c_name, const std::string &name, InputParameters &parameters)
virtual void	setInputParametersFEProblem (InputParameters &parameters)
virtual void	addAuxVariable (const std::string &var_type, const std::string &var_name, InputParameters &params)
virtual void	addAuxVariable (const std::string &var_name, const libMesh::FEType &type, const std::set< SubdomainID > *const active_subdomains=NULL)
virtual void	addElementalFieldVariable (const std::string &var_type, const std::string &var_name, InputParameters &params)
virtual void	addAuxArrayVariable (const std::string &var_name, const libMesh::FEType &type, unsigned int components, const std::set< SubdomainID > *const active_subdomains=NULL)
virtual void	addAuxScalarVariable (const std::string &var_name, libMesh::Order order, Real scale_factor=1., const std::set< SubdomainID > *const active_subdomains=NULL)
virtual void	addAuxKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
virtual void	addAuxScalarKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
virtual void	addKokkosAuxKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
AuxiliarySystem &	getAuxiliarySystem ()
virtual void	addDiracKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
virtual void	addDGKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
virtual void	addFVKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
virtual void	addLinearFVKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
virtual void	addFVBC (const std::string &fv_bc_name, const std::string &name, InputParameters &parameters)
virtual void	addLinearFVBC (const std::string &fv_bc_name, const std::string &name, InputParameters &parameters)
virtual void	addFVInterfaceKernel (const std::string &fv_ik_name, const std::string &name, InputParameters &parameters)
virtual void	addInterfaceKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
virtual void	addInitialCondition (const std::string &ic_name, const std::string &name, InputParameters &parameters)
virtual void	addFVInitialCondition (const std::string &ic_name, const std::string &name, InputParameters &parameters)
void	projectSolution ()
unsigned short	getCurrentICState ()
void	projectInitialConditionOnCustomRange (libMesh::ConstElemRange &elem_range, ConstBndNodeRange &bnd_node_range, const std::optional< std::set< VariableName > > &target_vars=std::nullopt)
void	projectFunctionOnCustomRange (ConstElemRange &elem_range, Number(*func)(const Point &, const libMesh::Parameters &, const std::string &, const std::string &), Gradient(*func_grad)(const Point &, const libMesh::Parameters &, const std::string &, const std::string &), const libMesh::Parameters &params, const std::vector< VariableName > &target_vars)
virtual void	addMaterial (const std::string &material_name, const std::string &name, InputParameters &parameters)
virtual void	addMaterialHelper (std::vector< MaterialWarehouse * > warehouse, const std::string &material_name, const std::string &name, InputParameters &parameters)
virtual void	addInterfaceMaterial (const std::string &material_name, const std::string &name, InputParameters &parameters)
virtual void	addFunctorMaterial (const std::string &functor_material_name, const std::string &name, InputParameters &parameters)
virtual void	addKokkosMaterial (const std::string &material_name, const std::string &name, InputParameters &parameters)
void	prepareMaterials (const std::unordered_set< unsigned int > &consumer_needed_mat_props, const SubdomainID blk_id, const THREAD_ID tid)
void	reinitMaterials (SubdomainID blk_id, const THREAD_ID tid, bool swap_stateful=true)
void	reinitMaterialsFace (SubdomainID blk_id, const THREAD_ID tid, bool swap_stateful=true, const std::deque< MaterialBase * > *reinit_mats=nullptr)
void	reinitMaterialsFaceOnBoundary (const BoundaryID boundary_id, const SubdomainID blk_id, const THREAD_ID tid, const bool swap_stateful=true, const std::deque< MaterialBase * > *const reinit_mats=nullptr)
void	reinitMaterialsNeighborOnBoundary (const BoundaryID boundary_id, const SubdomainID blk_id, const THREAD_ID tid, const bool swap_stateful=true, const std::deque< MaterialBase * > *const reinit_mats=nullptr)
void	reinitMaterialsNeighbor (SubdomainID blk_id, const THREAD_ID tid, bool swap_stateful=true, const std::deque< MaterialBase * > *reinit_mats=nullptr)
void	reinitMaterialsBoundary (BoundaryID boundary_id, const THREAD_ID tid, bool swap_stateful=true, const std::deque< MaterialBase * > *reinit_mats=nullptr)
void	reinitMaterialsInterface (BoundaryID boundary_id, const THREAD_ID tid, bool swap_stateful=true)
void	prepareKokkosMaterials (const std::unordered_set< unsigned int > &consumer_needed_mat_props)
void	reinitKokkosMaterials ()
virtual void	swapBackMaterials (const THREAD_ID tid)
virtual void	swapBackMaterialsFace (const THREAD_ID tid)
virtual void	swapBackMaterialsNeighbor (const THREAD_ID tid)
void	setActiveMaterialProperties (const std::unordered_set< unsigned int > &mat_prop_ids, const THREAD_ID tid)
bool	hasActiveMaterialProperties (const THREAD_ID tid) const
void	clearActiveMaterialProperties (const THREAD_ID tid)
std::vector< std::shared_ptr< T > >	addObject (const std::string &type, const std::string &name, InputParameters &parameters, const bool threaded=true, const std::string &var_param_name="variable")
virtual void	addPostprocessor (const std::string &pp_name, const std::string &name, InputParameters &parameters)
virtual void	addVectorPostprocessor (const std::string &pp_name, const std::string &name, InputParameters &parameters)
virtual void	addReporter (const std::string &type, const std::string &name, InputParameters &parameters)
virtual void	addKokkosPostprocessor (const std::string &pp_name, const std::string &name, InputParameters &parameters)
virtual void	addKokkosVectorPostprocessor (const std::string &pp_name, const std::string &name, InputParameters &parameters)
virtual void	addKokkosReporter (const std::string &type, const std::string &name, InputParameters &parameters)
const ReporterData &	getReporterData () const
ReporterData &	getReporterData (ReporterData::WriteKey)
virtual std::vector< std::shared_ptr< UserObject > >	addUserObject (const std::string &user_object_name, const std::string &name, InputParameters &parameters)
T &	getUserObject (const std::string &name, unsigned int tid=0) const
const UserObject &	getUserObjectBase (const std::string &name, const THREAD_ID tid=0) const
bool	hasUserObject (const std::string &name) const
virtual void	addKokkosUserObject (const std::string &user_object_name, const std::string &name, InputParameters &parameters)
const T &	getKokkosUserObject (const std::string &name) const
bool	hasKokkosUserObject (const std::string &name) const
void	checkUserObjectNameCollision (const std::string &name, const std::string &type) const
const Positions &	getPositionsObject (const std::string &name) const
virtual void	addFVInterpolationMethod (const std::string &method_type, const std::string &name, InputParameters &parameters)
virtual void	addFVGradientMethod (const std::string &method_type, const std::string &name, InputParameters &parameters)
FVGradientMethod &	getFVGradientMethod (const GradientMethodName &name, const THREAD_ID tid=0)
const FVGradientMethod &	getFVGradientMethod (const GradientMethodName &name, const THREAD_ID tid=0) const
bool	hasFVGradientMethod (const GradientMethodName &name) const
const FVInterpolationMethod &	getFVInterpolationMethod (const InterpolationMethodName &name, const THREAD_ID tid=0) const
const FVFaceInterpolationMethod &	getFVFaceInterpolationMethod (const InterpolationMethodName &name, const THREAD_ID tid=0) const
const FVAdvectedInterpolationMethod &	getFVAdvectedInterpolationMethod (const InterpolationMethodName &name, const THREAD_ID tid=0) const
bool	hasFVInterpolationMethod (const InterpolationMethodName &name) const
bool	hasPostprocessorValueByName (const PostprocessorName &name) const
const Postprocessor &	getPostprocessorObjectByName (const PostprocessorName &object_name, const THREAD_ID tid=0) const
const PostprocessorValue &	getPostprocessorValueByName (const PostprocessorName &name, std::size_t t_index=0) const
void	setPostprocessorValueByName (const PostprocessorName &name, const PostprocessorValue &value, std::size_t t_index=0)
bool	hasPostprocessor (const std::string &name) const
const VectorPostprocessorValue &	getVectorPostprocessorValueByName (const std::string &object_name, const std::string &vector_name, std::size_t t_index=0) const
void	setVectorPostprocessorValueByName (const std::string &object_name, const std::string &vector_name, const VectorPostprocessorValue &value, std::size_t t_index=0)
const VectorPostprocessor &	getVectorPostprocessorObjectByName (const std::string &object_name, const THREAD_ID tid=0) const
virtual void	addDamper (const std::string &damper_name, const std::string &name, InputParameters &parameters)
void	setupDampers ()
bool	hasDampers ()
virtual void	addIndicator (const std::string &indicator_name, const std::string &name, InputParameters &parameters)
virtual void	addMarker (const std::string &marker_name, const std::string &name, InputParameters &parameters)
virtual void	addMultiApp (const std::string &multi_app_name, const std::string &name, InputParameters &parameters)
std::shared_ptr< MultiApp >	getMultiApp (const std::string &multi_app_name) const
std::vector< std::shared_ptr< Transfer > >	getTransfers (ExecFlagType type, Transfer::DIRECTION direction) const
std::vector< std::shared_ptr< Transfer > >	getTransfers (Transfer::DIRECTION direction) const
const ExecuteMooseObjectWarehouse< Transfer > &	getMultiAppTransferWarehouse (Transfer::DIRECTION direction) const
void	execMultiAppTransfers (ExecFlagType type, Transfer::DIRECTION direction, const MultiAppName &source_app="")
bool	execMultiApps (ExecFlagType type, bool auto_advance=true)
unsigned int	numConcurrentMultiApps () const
void	partitionConcurrentMultiApps ()
void	finalizeMultiApps ()
void	incrementMultiAppTStep (ExecFlagType type)
void	advanceMultiApps (ExecFlagType type)
void	finishMultiAppStep (ExecFlagType type, bool recurse_through_multiapp_levels=false)
void	backupMultiApps (ExecFlagType type)
void	restoreMultiApps (ExecFlagType type, bool force=false)
Real	computeMultiAppsDT (ExecFlagType type)
virtual void	addTransfer (const std::string &transfer_name, const std::string &name, InputParameters &parameters)
Real	computeResidualL2Norm (NonlinearSystemBase &sys)
Real	computeResidualL2Norm (LinearSystem &sys)
virtual Real	computeResidualL2Norm ()
virtual void	computeResidualSys (libMesh::NonlinearImplicitSystem &sys, const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual)
void	computeResidual (libMesh::NonlinearImplicitSystem &sys, const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual)
virtual void	computeResidual (const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual, const unsigned int nl_sys_num)
void	computeResidualAndJacobian (const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual, libMesh::SparseMatrix< libMesh::Number > &jacobian)
virtual void	computeResidualTag (const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual, TagID tag)
virtual void	computeResidualType (const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual, TagID tag)
virtual void	computeResidualInternal (const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual, const std::set< TagID > &tags)
virtual void	computeResidualTags (const std::set< TagID > &tags)
virtual void	computeJacobianSys (libMesh::NonlinearImplicitSystem &sys, const NumericVector< libMesh::Number > &soln, libMesh::SparseMatrix< libMesh::Number > &jacobian)
virtual void	computeJacobian (const NumericVector< libMesh::Number > &soln, libMesh::SparseMatrix< libMesh::Number > &jacobian, const unsigned int nl_sys_num)
virtual void	computeJacobianTag (const NumericVector< libMesh::Number > &soln, libMesh::SparseMatrix< libMesh::Number > &jacobian, TagID tag)
virtual void	computeJacobianInternal (const NumericVector< libMesh::Number > &soln, libMesh::SparseMatrix< libMesh::Number > &jacobian, const std::set< TagID > &tags)
virtual void	computeJacobianTags (const std::set< TagID > &tags)
virtual void	computeJacobianBlocks (std::vector< JacobianBlock * > &blocks, const unsigned int nl_sys_num)
virtual void	computeJacobianBlock (libMesh::SparseMatrix< libMesh::Number > &jacobian, libMesh::System &precond_system, unsigned int ivar, unsigned int jvar)
virtual void	computeLinearSystemSys (libMesh::LinearImplicitSystem &sys, libMesh::SparseMatrix< libMesh::Number > &system_matrix, NumericVector< libMesh::Number > &rhs, const bool compute_gradients=true)
void	computeLinearSystemTags (const NumericVector< libMesh::Number > &soln, const std::set< TagID > &vector_tags, const std::set< TagID > &matrix_tags, const bool compute_gradients=true)
virtual Real	computeDamping (const NumericVector< libMesh::Number > &soln, const NumericVector< libMesh::Number > &update)
virtual bool	shouldUpdateSolution ()
virtual bool	updateSolution (NumericVector< libMesh::Number > &vec_solution, NumericVector< libMesh::Number > &ghosted_solution)
virtual void	predictorCleanup (NumericVector< libMesh::Number > &ghosted_solution)
virtual void	computeBounds (libMesh::NonlinearImplicitSystem &sys, NumericVector< libMesh::Number > &lower, NumericVector< libMesh::Number > &upper)
virtual void	computeNearNullSpace (libMesh::NonlinearImplicitSystem &sys, std::vector< NumericVector< libMesh::Number > * > &sp)
virtual void	computeNullSpace (libMesh::NonlinearImplicitSystem &sys, std::vector< NumericVector< libMesh::Number > * > &sp)
virtual void	computeTransposeNullSpace (libMesh::NonlinearImplicitSystem &sys, std::vector< NumericVector< libMesh::Number > * > &sp)
virtual void	computePostCheck (libMesh::NonlinearImplicitSystem &sys, const NumericVector< libMesh::Number > &old_soln, NumericVector< libMesh::Number > &search_direction, NumericVector< libMesh::Number > &new_soln, bool &changed_search_direction, bool &changed_new_soln)
virtual void	computeIndicatorsAndMarkers ()
virtual void	computeIndicators ()
virtual void	computeMarkers ()
virtual void	addResidual (const THREAD_ID tid) override
virtual void	addResidualNeighbor (const THREAD_ID tid) override
virtual void	addResidualLower (const THREAD_ID tid) override
virtual void	addResidualScalar (const THREAD_ID tid=0)
virtual void	cacheResidual (const THREAD_ID tid) override
virtual void	cacheResidualNeighbor (const THREAD_ID tid) override
virtual void	addCachedResidual (const THREAD_ID tid) override
virtual void	addCachedResidualDirectly (NumericVector< libMesh::Number > &residual, const THREAD_ID tid)
virtual void	setResidual (NumericVector< libMesh::Number > &residual, const THREAD_ID tid) override
virtual void	setResidual (libMesh::NumericVector< libMesh::Number > &residual, const THREAD_ID tid)=0
virtual void	setResidualNeighbor (NumericVector< libMesh::Number > &residual, const THREAD_ID tid) override
virtual void	setResidualNeighbor (libMesh::NumericVector< libMesh::Number > &residual, const THREAD_ID tid)=0
virtual void	addJacobian (const THREAD_ID tid) override
virtual void	addJacobianNeighbor (const THREAD_ID tid) override
virtual void	addJacobianNeighbor (libMesh::SparseMatrix< libMesh::Number > &jacobian, unsigned int ivar, unsigned int jvar, const DofMap &dof_map, std::vector< dof_id_type > &dof_indices, std::vector< dof_id_type > &neighbor_dof_indices, const std::set< TagID > &tags, const THREAD_ID tid) override
virtual void	addJacobianNeighbor (libMesh::SparseMatrix< libMesh::Number > &jacobian, unsigned int ivar, unsigned int jvar, const libMesh::DofMap &dof_map, std::vector< dof_id_type > &dof_indices, std::vector< dof_id_type > &neighbor_dof_indices, const std::set< TagID > &tags, const THREAD_ID tid)=0
virtual void	addJacobianNeighborLowerD (const THREAD_ID tid) override
virtual void	addJacobianLowerD (const THREAD_ID tid) override
virtual void	addJacobianBlockTags (libMesh::SparseMatrix< libMesh::Number > &jacobian, unsigned int ivar, unsigned int jvar, const DofMap &dof_map, std::vector< dof_id_type > &dof_indices, const std::set< TagID > &tags, const THREAD_ID tid)
virtual void	addJacobianScalar (const THREAD_ID tid=0)
virtual void	addJacobianOffDiagScalar (unsigned int ivar, const THREAD_ID tid=0)
virtual void	cacheJacobian (const THREAD_ID tid) override
virtual void	cacheJacobianNeighbor (const THREAD_ID tid) override
virtual void	addCachedJacobian (const THREAD_ID tid) override
virtual void	prepareShapes (unsigned int var, const THREAD_ID tid) override
virtual void	prepareFaceShapes (unsigned int var, const THREAD_ID tid) override
virtual void	prepareNeighborShapes (unsigned int var, const THREAD_ID tid) override
virtual void	addDisplacedProblem (std::shared_ptr< DisplacedProblem > displaced_problem)
virtual std::shared_ptr< const DisplacedProblem >	getDisplacedProblem () const
virtual std::shared_ptr< DisplacedProblem >	getDisplacedProblem ()
virtual void	updateGeomSearch (GeometricSearchData::GeometricSearchType type=GeometricSearchData::ALL) override
virtual void	updateMortarMesh ()
void	createMortarInterface (const std::pair< BoundaryID, BoundaryID > &primary_secondary_boundary_pair, const std::pair< SubdomainID, SubdomainID > &primary_secondary_subdomain_pair, bool on_displaced, bool periodic, const bool debug, const bool correct_edge_dropping, const Real minimum_projection_angle, const Mortar3DSubpatchPlane mortar_3d_subpatch_plane, const MooseEnum &triangulation, const bool triangulate_triangles, const Mortar3DQuadraturePointMapping mortar_3d_qp_mapping=Mortar3DQuadraturePointMapping::NORMAL_PROJECTION)
const std::unordered_map< std::pair< BoundaryID, BoundaryID >, MortarInterfaceConfig > &	getMortarInterfaces (bool on_displaced) const
virtual void	possiblyRebuildGeomSearchPatches ()
virtual GeometricSearchData &	geomSearchData () override
void	setRestartFile (const std::string &file_name)
const MaterialPropertyRegistry &	getMaterialPropertyRegistry () const
const InitialConditionWarehouse &	getInitialConditionWarehouse () const
const FVInitialConditionWarehouse &	getFVInitialConditionWarehouse () const
SolverParams &	solverParams (unsigned int solver_sys_num=0)
const SolverParams &	solverParams (unsigned int solver_sys_num=0) const
Adaptivity &	adaptivity ()
virtual void	initialAdaptMesh ()
virtual bool	adaptMesh ()
unsigned int	getNumCyclesCompleted ()
bool	hasInitialAdaptivity () const
bool	hasInitialAdaptivity () const
void	initXFEM (std::shared_ptr< XFEMInterface > xfem)
std::shared_ptr< XFEMInterface >	getXFEM ()
bool	haveXFEM ()
virtual bool	updateMeshXFEM ()
virtual bool	allowMeshContractionAfterMeshChanged () const
virtual void	meshChanged (bool intermediate_change, bool contract_mesh, bool clean_refinement_flags)
void	notifyWhenMeshChanges (MeshChangedInterface *mci)
void	notifyWhenMeshDisplaces (MeshDisplacedInterface *mdi)
void	initElementStatefulProps (const libMesh::ConstElemRange &elem_range, const bool threaded)
void	initKokkosStatefulProps ()
virtual void	checkProblemIntegrity ()
void	registerRandomInterface (RandomInterface &random_interface, const std::string &name)
void	setConstJacobian (bool state)
void	setKernelCoverageCheck (CoverageCheckMode mode)
void	setKernelCoverageCheck (bool flag)
void	setKernelCoverageCheck (CoverageCheckMode mode)
void	setMaterialCoverageCheck (CoverageCheckMode mode)
void	setMaterialCoverageCheck (bool flag)
void	setMaterialCoverageCheck (CoverageCheckMode mode)
void	setParallelBarrierMessaging (bool flag)
void	setVerboseProblem (bool verbose)
bool	verboseMultiApps () const
void	parentOutputPositionChanged ()
unsigned int	subspaceDim (const std::string &prefix) const
const MooseObjectWarehouse< Function > &	getFunctionWarehouse ()
const MaterialWarehouse &	getMaterialWarehouse () const
const MaterialWarehouse &	getRegularMaterialsWarehouse () const
const MaterialWarehouse &	getDiscreteMaterialWarehouse () const
const MaterialWarehouse &	getInterfaceMaterialsWarehouse () const
const MaterialWarehouse &	getKokkosMaterialsWarehouse () const
std::shared_ptr< MaterialBase >	getMaterial (std::string name, Moose::MaterialDataType type, const THREAD_ID tid=0, bool no_warn=false)
MaterialData &	getMaterialData (Moose::MaterialDataType type, const THREAD_ID tid=0, const MooseObject *object=nullptr) const
MaterialData &	getKokkosMaterialData (Moose::MaterialDataType type, const MooseObject *object=nullptr) const
const std::set< const MooseObject * > &	getMaterialPropertyStorageConsumers (Moose::MaterialDataType type) const
const std::set< const MooseObject * > &	getKokkosMaterialPropertyStorageConsumers (Moose::MaterialDataType type) const
bool	restoreOriginalNonzeroPattern () const
bool	errorOnJacobianNonzeroReallocation () const
void	setErrorOnJacobianNonzeroReallocation (bool state)
bool	preserveMatrixSparsityPattern () const
void	setPreserveMatrixSparsityPattern (bool preserve)
bool	ignoreZerosInJacobian () const
void	setIgnoreZerosInJacobian (bool state)
bool	acceptInvalidSolution () const
bool	allowInvalidSolution () const
bool	showInvalidSolutionConsole () const
bool	immediatelyPrintInvalidSolution () const
bool	hasTimeIntegrator () const
virtual void	execute (const ExecFlagType &exec_type)
virtual void	executeAllObjects (const ExecFlagType &exec_type)
virtual Executor &	getExecutor (const std::string &name)
virtual void	computeUserObjects (const ExecFlagType &type, const Moose::AuxGroup &group)
virtual void	computeUserObjectByName (const ExecFlagType &type, const Moose::AuxGroup &group, const std::string &name)
void	needsPreviousNewtonIteration (bool state)
bool	needsPreviousNewtonIteration () const
void	needsPreviousMultiAppFixedPointIterationSolution (bool needed, const unsigned int solver_sys_num)
bool	needsPreviousMultiAppFixedPointIterationSolution (const unsigned int solver_sys_num) const
void	needsPreviousMultiAppFixedPointIterationAuxiliary (bool state)
bool	needsPreviousMultiAppFixedPointIterationAuxiliary () const
void	needsPreviousMultiSystemFixedPointIterationSolution (bool needed, const unsigned int solver_sys_num)
bool	needsPreviousMultiSystemFixedPointIterationSolution (const unsigned int solver_sys_num) const
void	needsPreviousMultiSystemFixedPointIterationAuxiliary (bool state)
bool	needsPreviousMultiSystemFixedPointIterationAuxiliary () const
ExecuteMooseObjectWarehouse< Control > &	getControlWarehouse ()
void	executeControls (const ExecFlagType &exec_type)
void	executeSamplers (const ExecFlagType &exec_type)
virtual void	updateActiveObjects ()
void	reportMooseObjectDependency (MooseObject *a, MooseObject *b)
ExecuteMooseObjectWarehouse< MultiApp > &	getMultiAppWarehouse ()
bool	hasJacobian () const
bool	constJacobian () const
void	addOutput (const std::string &, const std::string &, InputParameters &)
TheWarehouse &	theWarehouse () const
void	setSNESMFReuseBase (bool reuse, bool set_by_user)
bool	useSNESMFReuseBase ()
void	skipExceptionCheck (bool skip_exception_check)
bool	isSNESMFReuseBaseSetbyUser ()
bool &	petscOptionsInserted ()
PetscOptions &	petscOptionsDatabase ()
virtual void	setUDotRequested (const bool u_dot_requested)
virtual void	setUDotDotRequested (const bool u_dotdot_requested)
virtual void	setUDotOldRequested (const bool u_dot_old_requested)
virtual void	setUDotDotOldRequested (const bool u_dotdot_old_requested)
virtual bool	uDotRequested ()
virtual bool	uDotDotRequested ()
virtual bool	uDotOldRequested ()
virtual bool	uDotDotOldRequested ()
void	haveADObjects (bool have_ad_objects) override
virtual void	haveADObjects (bool have_ad_objects)
bool	haveADObjects () const
bool	shouldSolve () const
const MortarInterfaceWarehouse &	mortarData () const
MortarInterfaceWarehouse &	mortarData ()
virtual bool	hasNeighborCoupling () const
virtual bool	hasMortarCoupling () const
void	computingNonlinearResid (bool computing_nonlinear_residual) final
bool	computingNonlinearResid () const
virtual void	computingNonlinearResid (const bool computing_nonlinear_residual)
void	setCurrentlyComputingResidual (bool currently_computing_residual) final
void	numGridSteps (unsigned int num_grid_steps)
void	uniformRefine ()
void	automaticScaling (bool automatic_scaling) override
virtual void	automaticScaling (bool automatic_scaling)
bool	automaticScaling () const
virtual void	reinitElemFaceRef (const Elem *elem, unsigned int side, Real tolerance, const std::vector< Point > *const pts, const std::vector< Real > *const weights=nullptr, const THREAD_ID tid=0) override
virtual void	reinitNeighborFaceRef (const Elem *neighbor_elem, unsigned int neighbor_side, Real tolerance, const std::vector< Point > *const pts, const std::vector< Real > *const weights=nullptr, const THREAD_ID tid=0) override
bool	fvBCsIntegrityCheck () const
void	fvBCsIntegrityCheck (bool fv_bcs_integrity_check)
bool	sideUOInterfaceMatPropIntegrityCheck () const
void	getFVMatsAndDependencies (SubdomainID block_id, std::vector< std::shared_ptr< MaterialBase > > &face_materials, std::vector< std::shared_ptr< MaterialBase > > &neighbor_materials, std::set< MooseVariableFieldBase * > &variables, const THREAD_ID tid)
void	resizeMaterialData (Moose::MaterialDataType data_type, unsigned int nqp, const THREAD_ID tid)
bool	haveDisplaced () const override final
bool	hasLinearConvergenceObjects () const
void	setNonlinearConvergenceNames (const std::vector< ConvergenceName > &convergence_names)
void	setLinearConvergenceNames (const std::vector< ConvergenceName > &convergence_names)
void	setMultiAppFixedPointConvergenceName (const ConvergenceName &convergence_name)
void	setSteadyStateConvergenceName (const ConvergenceName &convergence_name)
const std::vector< ConvergenceName > &	getNonlinearConvergenceNames () const
const std::vector< ConvergenceName > &	getLinearConvergenceNames () const
const ConvergenceName &	getMultiAppFixedPointConvergenceName () const
const ConvergenceName &	getSteadyStateConvergenceName () const
void	computingScalingJacobian (bool computing_scaling_jacobian)
bool	computingScalingJacobian () const override final
void	computingScalingResidual (bool computing_scaling_residual)
bool	computingScalingResidual () const override final
MooseAppCoordTransform &	coordTransform ()
virtual std::size_t	numNonlinearSystems () const override
virtual std::size_t	numLinearSystems () const override
virtual std::size_t	numSolverSystems () const override
bool	isSolverSystemNonlinear (const unsigned int sys_num)
virtual unsigned int	currentNlSysNum () const override
virtual unsigned int	currentLinearSysNum () const override
virtual unsigned int	nlSysNum (const NonlinearSystemName &nl_sys_name) const override
unsigned int	linearSysNum (const LinearSystemName &linear_sys_name) const override
unsigned int	solverSysNum (const SolverSystemName &solver_sys_name) const override
unsigned int	systemNumForVariable (const VariableName &variable_name) const
bool	getFailNextNonlinearConvergenceCheck () const
bool	getFailNextSystemConvergenceCheck () const
void	setFailNextNonlinearConvergenceCheck ()
void	setFailNextSystemConvergenceCheck ()
void	resetFailNextNonlinearConvergenceCheck ()
void	resetFailNextSystemConvergenceCheck ()
void	setExecutionPrinting (const ExecFlagEnum &print_exec)
bool	shouldPrintExecution (const THREAD_ID tid) const
void	reinitMortarUserObjects (BoundaryID primary_boundary_id, BoundaryID secondary_boundary_id, bool displaced)
virtual const std::vector< VectorTag > &	currentResidualVectorTags () const override
void	setCurrentResidualVectorTags (const std::set< TagID > &vector_tags)
void	clearCurrentResidualVectorTags ()
void	clearCurrentJacobianMatrixTags ()
virtual void	needFV () override
virtual bool	haveFV () const override
virtual bool	hasNonlocalCoupling () const override
bool	identifyVariableGroupsInNL () const
virtual void	setCurrentLowerDElem (const Elem *const lower_d_elem, const THREAD_ID tid) override
virtual void	setCurrentBoundaryID (BoundaryID bid, const THREAD_ID tid) override
const std::vector< NonlinearSystemName > &	getNonlinearSystemNames () const
const std::vector< LinearSystemName > &	getLinearSystemNames () const
const std::vector< SolverSystemName > &	getSolverSystemNames () const
virtual const libMesh::CouplingMatrix &	nonlocalCouplingMatrix (const unsigned i) const override
virtual bool	checkNonlocalCouplingRequirement () const override
virtual Moose::FEBackend	feBackend () const
void	createTagMatrices (CreateTaggedMatrixKey)
bool	useHashTableMatrixAssembly () const
bool	hasKokkosObjects () const
bool	hasKokkosResidualObjects () const
void	addKokkosMeshInitializationHook (std::function< void()> function)
const bool &	currentlyComputingResidual () const
THREAD_ID	numThreads () const
virtual bool	nlConverged (const unsigned int nl_sys_num)
virtual bool	converged (const unsigned int sys_num)
bool	defaultGhosting ()
virtual TagID	addVectorTag (const TagName &tag_name, const Moose::VectorTagType type=Moose::VECTOR_TAG_RESIDUAL)
void	addNotZeroedVectorTag (const TagID tag)
bool	vectorTagNotZeroed (const TagID tag) const
virtual const VectorTag &	getVectorTag (const TagID tag_id) const
std::vector< VectorTag >	getVectorTags (const std::set< TagID > &tag_ids) const
virtual const std::vector< VectorTag > &	getVectorTags (const Moose::VectorTagType type=Moose::VECTOR_TAG_ANY) const
virtual TagID	getVectorTagID (const TagName &tag_name) const
virtual TagName	vectorTagName (const TagID tag) const
virtual bool	vectorTagExists (const TagID tag_id) const
virtual bool	vectorTagExists (const TagName &tag_name) const
virtual unsigned int	numVectorTags (const Moose::VectorTagType type=Moose::VECTOR_TAG_ANY) const
virtual Moose::VectorTagType	vectorTagType (const TagID tag_id) const
virtual TagID	addMatrixTag (TagName tag_name)
virtual TagID	getMatrixTagID (const TagName &tag_name) const
virtual TagName	matrixTagName (TagID tag)
virtual bool	matrixTagExists (const TagName &tag_name) const
virtual bool	matrixTagExists (TagID tag_id) const
virtual unsigned int	numMatrixTags () const
virtual std::map< TagName, TagID > &	getMatrixTags ()
virtual bool	hasLinearVariable (const std::string &var_name) const
virtual bool	hasAuxiliaryVariable (const std::string &var_name) const
virtual const std::set< MooseVariableFieldBase * > &	getActiveElementalMooseVariables (const THREAD_ID tid) const
virtual bool	hasActiveElementalMooseVariables (const THREAD_ID tid) const
Moose::CoordinateSystemType	getCoordSystem (SubdomainID sid) const
unsigned int	getAxisymmetricRadialCoord () const
virtual DiracKernelInfo &	diracKernelInfo ()
void	reinitNodes (const std::vector< dof_id_type > &nodes, const THREAD_ID tid)
void	reinitNodesNeighbor (const std::vector< dof_id_type > &nodes, const THREAD_ID tid)
void	reinitNeighborLowerDElem (const Elem *elem, const THREAD_ID tid=0)
void	reinitMortarElem (const Elem *elem, const THREAD_ID tid=0)
void	reinitGeomSearch ()
virtual void	storeSubdomainMatPropName (SubdomainID block_id, const std::string &name)
virtual void	storeBoundaryMatPropName (BoundaryID boundary_id, const std::string &name)
virtual void	storeSubdomainZeroMatProp (SubdomainID block_id, const MaterialPropertyName &name)
virtual void	storeBoundaryZeroMatProp (BoundaryID boundary_id, const MaterialPropertyName &name)
virtual void	storeSubdomainDelayedCheckMatProp (const std::string &requestor, SubdomainID block_id, const std::string &name)
virtual void	storeBoundaryDelayedCheckMatProp (const std::string &requestor, BoundaryID boundary_id, const std::string &name)
virtual void	checkBlockMatProps ()
virtual void	checkBoundaryMatProps ()
virtual void	markMatPropRequested (const std::string &)
virtual bool	isMatPropRequested (const std::string &prop_name) const
void	addConsumedPropertyName (const MooseObjectName &obj_name, const std::string &prop_name)
const std::map< MooseObjectName, std::set< std::string > > &	getConsumedPropertyMap () const
virtual std::set< SubdomainID >	getMaterialPropertyBlocks (const std::string &prop_name)
virtual std::vector< SubdomainName >	getMaterialPropertyBlockNames (const std::string &prop_name)
virtual bool	hasBlockMaterialProperty (SubdomainID block_id, const std::string &prop_name)
virtual std::set< BoundaryID >	getMaterialPropertyBoundaryIDs (const std::string &prop_name)
virtual std::vector< BoundaryName >	getMaterialPropertyBoundaryNames (const std::string &prop_name)
virtual bool	hasBoundaryMaterialProperty (BoundaryID boundary_id, const std::string &prop_name)
virtual std::set< dof_id_type > &	ghostedElems ()
const bool &	currentlyComputingJacobian () const
void	setCurrentlyComputingJacobian (const bool currently_computing_jacobian)
const bool &	currentlyComputingResidualAndJacobian () const
void	setCurrentlyComputingResidualAndJacobian (bool currently_computing_residual_and_jacobian)
virtual bool	safeAccessTaggedMatrices () const
virtual bool	safeAccessTaggedVectors () const
const std::set< TagID > &	getActiveScalarVariableCoupleableVectorTags (const THREAD_ID tid) const
const std::set< TagID > &	getActiveScalarVariableCoupleableMatrixTags (const THREAD_ID tid) const
const std::set< TagID > &	getActiveFEVariableCoupleableVectorTags (const THREAD_ID tid) const
const std::set< TagID > &	getActiveFEVariableCoupleableMatrixTags (const THREAD_ID tid) const
void	addAlgebraicGhostingFunctor (libMesh::GhostingFunctor &algebraic_gf, bool to_mesh=true)
void	addCouplingGhostingFunctor (libMesh::GhostingFunctor &coupling_gf, bool to_mesh=true)
void	removeAlgebraicGhostingFunctor (libMesh::GhostingFunctor &algebraic_gf)
void	removeCouplingGhostingFunctor (libMesh::GhostingFunctor &coupling_gf)
void	clearAllDofIndices ()
const Moose::Functor< T > &	getFunctor (const std::string &name, const THREAD_ID tid, const std::string &requestor_name, bool requestor_is_ad)
bool	hasFunctor (const std::string &name, const THREAD_ID tid) const
bool	hasFunctorWithType (const std::string &name, const THREAD_ID tid) const
void	addFunctor (const std::string &name, const Moose::FunctorBase< T > &functor, const THREAD_ID tid)
const Moose::FunctorBase< T > &	addPiecewiseByBlockLambdaFunctor (const std::string &name, PolymorphicLambda my_lammy, const std::set< ExecFlagType > &clearance_schedule, const MooseMesh &mesh, const std::set< SubdomainID > &block_ids, const THREAD_ID tid)
void	setFunctorOutput (bool set_output)
void	setChainControlDataOutput (bool set_output)
void	registerUnfilledFunctorRequest (T *functor_interface, const std::string &functor_name, const THREAD_ID tid)
void	reinitFVFace (const THREAD_ID tid, const FaceInfo &fi)
void	preparePRefinement ()
bool	doingPRefinement () const
MooseVariableFEBase &	getVariableHelper (const THREAD_ID tid, const std::string &var_name, Moose::VarKindType expected_var_type, Moose::VarFieldType expected_var_field_type, const std::vector< T > &systems, const SystemBase &aux) const
void	_setCLIOption ()
virtual void	terminateSolve ()
virtual bool	isSolveTerminationRequested () const
const ConsoleStream &	console () 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
PerfGraph &	perfGraph ()
const libMesh::ConstElemRange &	getEvaluableElementRange ()
const libMesh::ConstElemRange &	getEvaluableElementRange ()
const libMesh::ConstElemRange &	getNonlinearEvaluableElementRange ()
const libMesh::ConstElemRange &	getNonlinearEvaluableElementRange ()
const libMesh::ConstElemRange &	getCurrentAlgebraicElementRange ()
const libMesh::ConstElemRange &	getCurrentAlgebraicElementRange ()
const libMesh::ConstNodeRange &	getCurrentAlgebraicNodeRange ()
const libMesh::ConstNodeRange &	getCurrentAlgebraicNodeRange ()
const ConstBndNodeRange &	getCurrentAlgebraicBndNodeRange ()
const ConstBndNodeRange &	getCurrentAlgebraicBndNodeRange ()
void	setCurrentAlgebraicElementRange (libMesh::ConstElemRange *range)
void	setCurrentAlgebraicElementRange (libMesh::ConstElemRange *range)
void	setCurrentAlgebraicNodeRange (libMesh::ConstNodeRange *range)
void	setCurrentAlgebraicNodeRange (libMesh::ConstNodeRange *range)
void	setCurrentAlgebraicBndNodeRange (ConstBndNodeRange *range)
void	setCurrentAlgebraicBndNodeRange (ConstBndNodeRange *range)
void	allowOutput (bool state)
void	allowOutput (bool state)
void	allowOutput (bool state)
void	allowOutput (bool state)
Moose::Kokkos::Array< Moose::Kokkos::System > &	getKokkosSystems ()
const Moose::Kokkos::Array< Moose::Kokkos::System > &	getKokkosSystems () const
Moose::Kokkos::Array< Moose::Kokkos::System > &	getKokkosSystems ()
const Moose::Kokkos::Array< Moose::Kokkos::System > &	getKokkosSystems () const
Moose::Kokkos::Array< Moose::Kokkos::FESystem > &	getKokkosFESystems ()
const Moose::Kokkos::Array< Moose::Kokkos::FESystem > &	getKokkosFESystems () const
Moose::Kokkos::Array< Moose::Kokkos::FESystem > &	getKokkosFESystems ()
const Moose::Kokkos::Array< Moose::Kokkos::FESystem > &	getKokkosFESystems () const
Moose::Kokkos::System &	getKokkosSystem (const unsigned int sys_num)
const Moose::Kokkos::System &	getKokkosSystem (const unsigned int sys_num) const
Moose::Kokkos::System &	getKokkosSystem (const unsigned int sys_num)
const Moose::Kokkos::System &	getKokkosSystem (const unsigned int sys_num) const
Moose::Kokkos::FESystem &	getKokkosFESystem (const unsigned int sys_num)
const Moose::Kokkos::FESystem &	getKokkosFESystem (const unsigned int sys_num) const
Moose::Kokkos::FESystem &	getKokkosFESystem (const unsigned int sys_num)
const Moose::Kokkos::FESystem &	getKokkosFESystem (const unsigned int sys_num) const
bool	hasMultiApps () const
bool	hasMultiApps (ExecFlagType type) const
bool	hasMultiApps () const
bool	hasMultiApps (ExecFlagType type) const
bool	hasMultiApp (const std::string &name) const
bool	hasMultiApp (const std::string &name) const
const AutomaticMortarGeneration &	getMortarInterface (const std::pair< BoundaryID, BoundaryID > &primary_secondary_boundary_pair, const std::pair< SubdomainID, SubdomainID > &primary_secondary_subdomain_pair, bool on_displaced) const
AutomaticMortarGeneration &	getMortarInterface (const std::pair< BoundaryID, BoundaryID > &primary_secondary_boundary_pair, const std::pair< SubdomainID, SubdomainID > &primary_secondary_subdomain_pair, bool on_displaced)
const AutomaticMortarGeneration &	getMortarInterface (const std::pair< BoundaryID, BoundaryID > &primary_secondary_boundary_pair, const std::pair< SubdomainID, SubdomainID > &primary_secondary_subdomain_pair, bool on_displaced) const
AutomaticMortarGeneration &	getMortarInterface (const std::pair< BoundaryID, BoundaryID > &primary_secondary_boundary_pair, const std::pair< SubdomainID, SubdomainID > &primary_secondary_subdomain_pair, bool on_displaced)
const MaterialPropertyStorage &	getMaterialPropertyStorage ()
const MaterialPropertyStorage &	getMaterialPropertyStorage ()
const MaterialPropertyStorage &	getBndMaterialPropertyStorage ()
const MaterialPropertyStorage &	getBndMaterialPropertyStorage ()
const MaterialPropertyStorage &	getNeighborMaterialPropertyStorage ()
const MaterialPropertyStorage &	getNeighborMaterialPropertyStorage ()
Moose::Kokkos::MaterialPropertyStorage &	getKokkosMaterialPropertyStorage ()
Moose::Kokkos::MaterialPropertyStorage &	getKokkosMaterialPropertyStorage ()
Moose::Kokkos::MaterialPropertyStorage &	getKokkosBndMaterialPropertyStorage ()
Moose::Kokkos::MaterialPropertyStorage &	getKokkosBndMaterialPropertyStorage ()
Moose::Kokkos::MaterialPropertyStorage &	getKokkosNeighborMaterialPropertyStorage ()
Moose::Kokkos::MaterialPropertyStorage &	getKokkosNeighborMaterialPropertyStorage ()
const MooseObjectWarehouse< Indicator > &	getIndicatorWarehouse ()
const MooseObjectWarehouse< Indicator > &	getIndicatorWarehouse ()
const MooseObjectWarehouse< InternalSideIndicatorBase > &	getInternalSideIndicatorWarehouse ()
const MooseObjectWarehouse< InternalSideIndicatorBase > &	getInternalSideIndicatorWarehouse ()
const MooseObjectWarehouse< Marker > &	getMarkerWarehouse ()
const MooseObjectWarehouse< Marker > &	getMarkerWarehouse ()
bool	needBoundaryMaterialOnSide (BoundaryID bnd_id, const THREAD_ID tid)
bool	needBoundaryMaterialOnSide (BoundaryID bnd_id, const THREAD_ID tid)
bool	needInterfaceMaterialOnSide (BoundaryID bnd_id, const THREAD_ID tid)
bool	needInterfaceMaterialOnSide (BoundaryID bnd_id, const THREAD_ID tid)
bool	needInternalNeighborSideMaterial (SubdomainID subdomain_id, const THREAD_ID tid)
bool	needInternalNeighborSideMaterial (SubdomainID subdomain_id, const THREAD_ID tid)
const ExecFlagType &	getCurrentExecuteOnFlag () const
const ExecFlagType &	getCurrentExecuteOnFlag () const
void	setCurrentExecuteOnFlag (const ExecFlagType &)
void	setCurrentExecuteOnFlag (const ExecFlagType &)
const Parallel::Communicator &	comm () const
processor_id_type	n_processors () const
processor_id_type	processor_id () 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 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
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

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	selectVectorTagsFromSystem (const SystemBase &system, const std::vector< VectorTag > &input_vector_tags, std::set< TagID > &selected_tags)
static void	selectMatrixTagsFromSystem (const SystemBase &system, const std::map< TagName, TagID > &input_matrix_tags, std::set< TagID > &selected_tags)
static void	objectSetupHelper (const std::vector< T * > &objects, const ExecFlagType &exec_flag)
static void	objectSetupHelper (const std::vector< T * > &objects, const ExecFlagType &exec_flag)
static void	objectExecuteHelper (const std::vector< T * > &objects)
static void	objectExecuteHelper (const std::vector< T * > &objects)

Public Attributes
struct SubChannel1PhaseProblem::FrictionStruct	_friction_args
struct SubChannel1PhaseProblem::NusseltStruct	_nusselt_args
const PostprocessorValue &	_P_out
	Outlet pressure postprocessor value.
const SinglePhaseFluidProperties *	_fp
	Non-owning pointer to fluid properties user object.
std::map< std::string, std::vector< dof_id_type > >	_var_dof_map
	usingCombinedWarningSolutionWarnings
const ConsoleStream	_console
std::vector< Real >	_real_zero
std::vector< VariableValue >	_scalar_zero
std::vector< VariableValue >	_zero
std::vector< VariablePhiValue >	_phi_zero
std::vector< MooseArray< ADReal > >	_ad_zero
std::vector< VariableGradient >	_grad_zero
std::vector< MooseArray< ADRealVectorValue > >	_ad_grad_zero
std::vector< VariablePhiGradient >	_grad_phi_zero
std::vector< VariableSecond >	_second_zero
std::vector< MooseArray< ADRealTensorValue > >	_ad_second_zero
std::vector< VariablePhiSecond >	_second_phi_zero
std::vector< Point >	_point_zero
std::vector< VectorVariableValue >	_vector_zero
std::vector< VectorVariableCurl >	_vector_curl_zero

Static Public Attributes
static const std::string	type_param
static const std::string	name_param
static const std::string	unique_name_param
static const std::string	app_param
static const std::string	moose_base_param
static const std::string	kokkos_object_param

Protected Member Functions
virtual Real	computeAddedHeatPin (unsigned int i_ch, unsigned int iz) const =0
	Pure virtual: daughters provide different implementations.
virtual Real	computeAddedHeatDuct (unsigned int i_ch, unsigned int iz) const
	Non-pure: implemented in the base (or override in a child if needed)
void	computeWijFromSolve (int iblock)
	Computes diversion crossflow per gap for block iblock.
void	computeSumWij (int iblock)
	Computes net diversion crossflow per channel for block iblock.
void	computeMdot (int iblock)
	Computes mass flow per channel for block iblock.
void	computeWijPrime (int iblock)
	Computes turbulent crossflow per gap for block iblock.
Real	computeMixingParameter (unsigned int i_gap, unsigned int iz) const
	Computes and validates the turbulent mixing parameter.
Real	computeSweepFlowMixingParameter (unsigned int i_gap, unsigned int iz) const
	Computes and validates the sweep-flow mixing parameter.
void	computeDP (int iblock)
	Computes Pressure Drop per channel for block iblock.
void	computeP (int iblock)
	Computes Pressure per channel for block iblock.
virtual void	computeh (int iblock)=0
	Computes Enthalpy per channel for block iblock.
Real	computeT (int iblock)
	Computes and relaxes Temperature per channel for block iblock.
void	computeRho (int iblock)
	Computes Density per channel for block iblock.
void	computeMu (int iblock)
	Computes Viscosity per channel for block iblock.
void	computeWijResidual (int iblock)
	Computes Residual Matrix based on the lateral momentum conservation equation for block iblock.
virtual Real	getSubChannelPeripheralDuctWidth (unsigned int i_ch) const =0
	Function that computes the width of the duct cell that the peripheral subchannel i_ch sees.
libMesh::DenseVector< Real >	residualFunction (int iblock, libMesh::DenseVector< Real > solution)
	Computes Residual Vector based on the lateral momentum conservation equation for block iblock & updates flow variables based on current crossflow solution.
PetscErrorCode	petscSnesSolver (int iblock, const libMesh::DenseVector< Real > &solution, libMesh::DenseVector< Real > &root)
	Computes solution of nonlinear equation using snes and provided a residual in a formFunction.
PetscErrorCode	implicitPetscSolve (int iblock)
	Computes implicit solve using PetSc.
virtual void	initializeSolution ()=0
	Function to initialize the solution & geometry fields.
void	detectDeformation ()
	Detects whether pin diameter or duct displacement fields require geometry recalculation.
void	computeBulkReynoldsNumber ()
	Computes the assembly bulk Reynolds number from inlet flow conditions.
PetscScalar	computeInterpolationCoefficients (PetscScalar Peclet=0.0)
	Functions that computes the interpolation scheme given the Peclet number.
PetscScalar	computeInterpolatedValue (PetscScalar topValue, PetscScalar botValue, PetscScalar Peclet=0.0)
Real	computeGravityDir (const MooseEnum &dir) const
	inline function that is used to define the gravity direction
PetscErrorCode	solveAndPopulateEnthalpy (Mat A, Vec rhs, unsigned int first_node, unsigned int last_node, const char *ksp_prefix)
	Solve a linear system (A * x = rhs) with a simple PCJACOBI KSP and populate the enthalpy solution into _h_soln for nodes [first_node, last_node].
PetscErrorCode	cleanUp ()
PetscErrorCode	createPetscVector (Vec &v, PetscInt n)
	Petsc Functions.
PetscErrorCode	createPetscMatrix (Mat &M, PetscInt n, PetscInt m)
template<class T >
PetscErrorCode	populateVectorFromDense (Vec &x, const T &solution, const unsigned int first_axial_level, const unsigned int last_axial_level, const unsigned int cross_dimension)
template<class T >
PetscErrorCode	populateDenseFromVector (const Vec &x, T &solution, const unsigned int first_axial_level, const unsigned int last_axial_level, const unsigned int cross_dimension)
template<class T >
PetscErrorCode	populateVectorFromHandle (Vec &x, const T &solution, const unsigned int first_axial_level, const unsigned int last_axial_level, const unsigned int cross_dimension)
template<class T >
PetscErrorCode	populateSolutionChan (const Vec &x, T &solution, const unsigned int first_axial_level, const unsigned int last_axial_level, const unsigned int cross_dimension)
virtual void	meshChanged ()
MooseVariableFieldBase &	getVariableHelper (const THREAD_ID tid, const std::string &var_name, Moose::VarKindType expected_var_type, Moose::VarFieldType expected_var_field_type, const std::vector< T > &nls, const SystemBase &aux) const
void	createTagVectors ()
void	createTagSolutions ()
virtual void	meshDisplaced ()
void	computeSystems (const ExecFlagType &type)
bool	duplicateVariableCheck (const std::string &var_name, const libMesh::FEType &type, bool is_aux, const std::set< SubdomainID > *const active_subdomains)
void	computeUserObjectsInternal (const ExecFlagType &type, TheWarehouse::Query &query)
void	computeKokkosUserObjectsInternal (const ExecFlagType &type, TheWarehouse::Query &query)
void	checkDisplacementOrders ()
void	checkUserObjects ()
void	checkGradientMethods ()
void	checkDependMaterialsHelper (const std::map< SubdomainID, std::vector< std::shared_ptr< MaterialBase > > > &materials_map)
void	checkCoordinateSystems ()
void	reinitBecauseOfGhostingOrNewGeomObjects (bool mortar_changed=false)
void	addObjectParamsHelper (InputParameters &params, const std::string &object_name, const std::string &var_param_name="variable")
bool	verifyVectorTags () const
void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const
InvalidSolutionID	registerInvalidSolutionInternal (const std::string &message, const bool warning) 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
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
virtual void	addPostprocessorDependencyHelper (const PostprocessorName &) const

Protected Attributes
SubChannelMesh &	_subchannel_mesh
unsigned int	_n_blocks
	number of axial blocks
libMesh::DenseMatrix< Real >	_DP
libMesh::DenseMatrix< Real > &	_Wij
libMesh::DenseMatrix< Real > &	_Wij_old
libMesh::DenseMatrix< Real >	_WijPrime
libMesh::DenseMatrix< Real >	_Wij_residual_matrix
const Real	_g_grav
const Real &	_kij
unsigned int	_n_cells
unsigned int	_n_gaps
unsigned int	_n_pins
unsigned int	_n_channels
unsigned int	_block_size
std::vector< Real >	_z_grid
	axial location of nodes
Real	_one
Real	_TR
	Flag that activates or deactivates the transient parts of the equations we solve by multiplication.
const bool	_compute_density
	Flag that activates or deactivates the calculation of density.
const bool	_compute_viscosity
	Flag that activates or deactivates the calculation of viscosity.
const bool	_compute_power
	Flag that informs if we need to solve the Enthalpy/Temperature equations or not.
const bool	_pin_mesh_exist
	Flag that informs if there is a pin mesh or not.
const bool	_duct_mesh_exist
	Flag that informs if there is a duct mesh or not.
bool	_converged
	Variable that informs whether we exited external solve with a converged solution or not.
Real	_bulk_Re
	Assembly bulk Reynolds number.
Real	_bulk_V
	Assembly bulk velocity.
bool	_time_integrator_checked = false
	Whether the time integrator has been checked for consistency with the implementation.
Real	_dt
	Time step.
Real	_CT
	Turbulent modeling parameter used in axial momentum equation.
const Real &	_P_tol
	Convergence tolerance for the pressure loop in external solve.
const int &	_P_maxit
	Maximum number of pressure iterations; zero selects the solver's existing automatic limit.
const Real &	_T_tol
	Convergence tolerance for the temperature loop in internal solve.
const int &	_T_maxit
	Maximum iterations for the inner temperature loop.
const Real &	_T_relaxation
	Relaxation factor for temperature updates in the inner thermal-hydraulic iteration.
const unsigned int &	_enthalpy_subcycles
	Number of enthalpy, temperature, and property updates performed per flow solve.
const Real &	_mass_flow_equation_relaxation
	Equation relaxation factor for mass flow rate in the coupled implicit solve.
const Real &	_pressure_equation_relaxation
	Equation relaxation factor for pressure in the coupled implicit solve.
const Real &	_crossflow_equation_relaxation
	Equation relaxation factor for crossflow in the coupled implicit solve.
const Real &	_mass_flow_relaxation
	Relaxation factor for mass flow rate updates in the coupled implicit solve.
const Real &	_pressure_relaxation
	Relaxation factor for pressure updates in the coupled implicit solve.
const Real &	_crossflow_relaxation
	Relaxation factor for crossflow updates in the coupled implicit solve.
const PetscReal &	_rtol
	The relative convergence tolerance, (relative decrease) for the ksp linear solver.
const PetscReal &	_atol
	The absolute convergence tolerance for the ksp linear solver.
const PetscReal &	_dtol
	The divergence tolerance for the ksp linear solver.
const PetscInt &	_maxit
	The maximum number of iterations to use for the ksp linear solver.
const MooseEnum	_interpolation_scheme
	The interpolation method used in constructing the systems.
const MooseEnum	_gravity_direction
	The direction of gravity.
const Real	_dir_grav
const bool	_implicit_bool
	Flag to define the usage of a implicit or explicit solution.
const bool	_staggered_pressure_bool
	Flag to define the usage of staggered or collocated pressure.
const bool	_segregated_bool
	Segregated solve.
const bool	_verbose_subchannel
	Boolean to printout information related to subchannel solve.
bool	_deformation = false
	Flag that activates the effect of deformation (pin/duct) based on the auxvalues for displacement, Dpin.
const SCMFrictionClosureBase *	_friction_closure
	Friction closure object.
const SCMMixingClosureBase *	_mixing_closure
	Turbulent Mixing closure object.
const SCMHTCClosureBase *	_pin_HTC_closure
	HTC closure objects.
const SCMHTCClosureBase *	_duct_HTC_closure
std::unique_ptr< SolutionHandle >	_mdot_soln
	Solutions handles and link to TH tables properties.
std::unique_ptr< SolutionHandle >	_SumWij_soln
std::unique_ptr< SolutionHandle >	_P_soln
std::unique_ptr< SolutionHandle >	_DP_soln
std::unique_ptr< SolutionHandle >	_h_soln
std::unique_ptr< SolutionHandle >	_T_soln
std::unique_ptr< SolutionHandle >	_Tpin_soln
std::unique_ptr< SolutionHandle >	_Dpin_soln
std::unique_ptr< SolutionHandle >	_rho_soln
std::unique_ptr< SolutionHandle >	_mu_soln
std::unique_ptr< SolutionHandle >	_S_flow_soln
std::unique_ptr< SolutionHandle >	_w_perim_soln
std::unique_ptr< SolutionHandle >	_q_prime_soln
std::unique_ptr< SolutionHandle >	_duct_heat_flux_soln
std::unique_ptr< SolutionHandle >	_Tduct_soln
std::unique_ptr< SolutionHandle >	_displacement_soln
std::unique_ptr< SolutionHandle >	_ff_soln
std::unique_ptr< SolutionHandle >	_HTC_soln
Mat	_mc_sumWij_mat
	Matrices and vectors to be used in implicit assembly Mass conservation Mass conservation - sum of cross fluxes.
Vec	_Wij_vec
Vec	_prod
Vec	_prodp
Mat	_mc_axial_convection_mat
	Mass conservation - axial convection.
Vec	_mc_axial_convection_rhs
Mat	_mc_density_pressure_mat
	Mass conservation - pressure derivative of transient density.
Mat	_amc_turbulent_cross_flows_mat
	Axial momentum Axial momentum conservation - compute turbulent cross fluxes.
Vec	_amc_turbulent_cross_flows_rhs
Mat	_amc_time_derivative_mat
	Axial momentum conservation - time derivative.
Vec	_amc_time_derivative_rhs
Mat	_amc_advective_derivative_mat
	Axial momentum conservation - advective (Eulerian) derivative.
Vec	_amc_advective_derivative_rhs
Mat	_amc_cross_derivative_mat
	Axial momentum conservation - cross flux derivative.
Vec	_amc_cross_derivative_rhs
Mat	_amc_friction_force_mat
	Axial momentum conservation - friction force.
Vec	_amc_friction_force_rhs
Vec	_amc_gravity_rhs
	Axial momentum conservation - buoyancy force No implicit matrix.
Mat	_amc_pressure_force_mat
	Axial momentum conservation - pressure force.
Vec	_amc_pressure_force_rhs
Mat	_amc_sys_mdot_mat
	Axial momentum system matrix.
Vec	_amc_sys_mdot_rhs
Mat	_cmc_time_derivative_mat
	Cross momentum Cross momentum conservation - time derivative.
Vec	_cmc_time_derivative_rhs
Mat	_cmc_advective_derivative_mat
	Cross momentum conservation - advective (Eulerian) derivative.
Vec	_cmc_advective_derivative_rhs
Mat	_cmc_friction_force_mat
	Cross momentum conservation - friction force.
Vec	_cmc_friction_force_rhs
Mat	_cmc_pressure_force_mat
	Cross momentum conservation - pressure force.
Vec	_cmc_pressure_force_rhs
Mat	_cmc_sys_Wij_mat
	Lateral momentum system matrix.
Vec	_cmc_sys_Wij_rhs
Mat	_hc_time_derivative_mat
	Enthalpy Enthalpy conservation - time derivative.
Vec	_hc_time_derivative_rhs
Mat	_hc_advective_derivative_mat
	Enthalpy conservation - advective (Eulerian) derivative;.
Vec	_hc_advective_derivative_rhs
Mat	_hc_cross_derivative_mat
	Enthalpy conservation - cross flux derivative.
Vec	_hc_cross_derivative_rhs
Vec	_hc_added_heat_rhs
	Enthalpy conservation - source and sink.
Mat	_hc_sys_h_mat
	System matrices.
Vec	_hc_sys_h_rhs
PetscScalar	_added_K = 0.0
	Added resistances for monolithic convergence.
PetscScalar	_added_K_old = 1000.0
PetscScalar	_max_sumWij
PetscScalar	_max_sumWij_new
PetscScalar	_correction_factor = 1.0
Real	_pressure_fixed_point_error = 1.0
	Maximum pressure fixed-point update before solution relaxation over the blocks.
MooseMesh &	_mesh
bool	_initialized
std::optional< std::vector< ConvergenceName > >	_nonlinear_convergence_names
std::optional< std::vector< ConvergenceName > >	_linear_convergence_names
std::optional< ConvergenceName >	_multiapp_fixed_point_convergence_name
std::optional< ConvergenceName >	_steady_state_convergence_name
std::set< TagID >	_fe_vector_tags
std::set< TagID >	_fe_matrix_tags
std::set< TagID >	_linear_vector_tags
std::set< TagID >	_linear_matrix_tags
const bool &	_solve
bool	_transient
Real &	_time
Real &	_time_old
Real &	_time_older
int &	_t_step
Real &	_dt_old
bool	_need_to_add_default_nonlinear_convergence
bool	_need_to_add_default_multiapp_fixed_point_convergence
bool	_need_to_add_default_steady_state_convergence
const std::vector< LinearSystemName >	_linear_sys_names
const std::size_t	_num_linear_sys
std::vector< std::shared_ptr< LinearSystem > >	_linear_systems
std::map< LinearSystemName, unsigned int >	_linear_sys_name_to_num
LinearSystem *	_current_linear_sys
const bool	_using_default_nl
const std::vector< NonlinearSystemName >	_nl_sys_names
const std::size_t	_num_nl_sys
std::vector< std::shared_ptr< NonlinearSystemBase > >	_nl
std::map< NonlinearSystemName, unsigned int >	_nl_sys_name_to_num
NonlinearSystemBase *	_current_nl_sys
SolverSystem *	_current_solver_sys
std::vector< std::shared_ptr< SolverSystem > >	_solver_systems
std::map< SolverVariableName, unsigned int >	_solver_var_to_sys_num
std::map< SolverSystemName, unsigned int >	_solver_sys_name_to_num
std::vector< SolverSystemName >	_solver_sys_names
std::shared_ptr< AuxiliarySystem >	_aux
Moose::CouplingType	_coupling
std::vector< std::unique_ptr< libMesh::CouplingMatrix > >	_cm
Moose::Kokkos::Array< Moose::Kokkos::System >	_kokkos_systems
Moose::Kokkos::Array< Moose::Kokkos::FESystem >	_kokkos_fe_systems
std::map< std::string, unsigned int >	_subspace_dim
std::vector< std::vector< std::unique_ptr< Assembly > > >	_assembly
Moose::Kokkos::Assembly	_kokkos_assembly
MooseObjectWarehouse< MeshDivision >	_mesh_divisions
MooseObjectWarehouse< Function >	_functions
MooseObjectWarehouse< Moose::FunctionBase >	_kokkos_functions
MooseObjectWarehouse< Convergence >	_convergences
MooseObjectWarehouse< KernelBase >	_nonlocal_kernels
MooseObjectWarehouse< IntegratedBCBase >	_nonlocal_integrated_bcs
MaterialPropertyRegistry	_material_prop_registry
MaterialPropertyStorage &	_material_props
MaterialPropertyStorage &	_bnd_material_props
MaterialPropertyStorage &	_neighbor_material_props
Moose::Kokkos::MaterialPropertyStorage &	_kokkos_material_props
Moose::Kokkos::MaterialPropertyStorage &	_kokkos_bnd_material_props
Moose::Kokkos::MaterialPropertyStorage &	_kokkos_neighbor_material_props
MooseObjectWarehouse< Marker >	_markers
ReporterData	_reporter_data
ExecuteMooseObjectWarehouse< MultiApp >	_multi_apps
ExecuteMooseObjectWarehouse< TransientMultiApp >	_transient_multi_apps
ExecuteMooseObjectWarehouse< Transfer >	_transfers
ExecuteMooseObjectWarehouse< Transfer >	_to_multi_app_transfers
ExecuteMooseObjectWarehouse< Transfer >	_from_multi_app_transfers
ExecuteMooseObjectWarehouse< Transfer >	_between_multi_app_transfers
const unsigned int	_num_concurrent_multiapps
std::map< std::string, std::unique_ptr< RandomData > >	_random_data_objects
std::vector< std::unordered_map< SubdomainID, bool > >	_block_mat_side_cache
std::vector< std::unordered_map< BoundaryID, bool > >	_bnd_mat_side_cache
std::vector< std::unordered_map< BoundaryID, bool > >	_interface_mat_side_cache
std::vector< MeshChangedInterface * >	_notify_when_mesh_changes
std::vector< MeshDisplacedInterface * >	_notify_when_mesh_displaces
Adaptivity	_adaptivity
unsigned int	_cycles_completed
std::shared_ptr< XFEMInterface >	_xfem
MooseMesh *	_displaced_mesh
std::shared_ptr< DisplacedProblem >	_displaced_problem
GeometricSearchData	_geometric_search_data
std::unique_ptr< MortarInterfaceWarehouse >	_mortar_data
bool	_reinit_displaced_elem
bool	_reinit_displaced_face
bool	_reinit_displaced_neighbor
bool	_input_file_saved
bool	_has_dampers
bool	_has_constraints
bool	_snesmf_reuse_base
bool	_skip_exception_check
bool	_snesmf_reuse_base_set_by_user
bool	_has_initialized_stateful
bool	_const_jacobian
bool	_has_jacobian
bool	_needs_old_newton_iter
bool	_previous_nl_solution_required
std::vector< bool >	_previous_multiapp_fp_nl_solution_required
bool	_previous_multiapp_fp_aux_solution_required
std::vector< bool >	_previous_multisystem_fp_nl_solution_required
bool	_previous_multisystem_fp_aux_solution_required
bool	_has_nonlocal_coupling
bool	_calculate_jacobian_in_uo
std::vector< std::vector< const MooseVariableFEBase * > >	_uo_jacobian_moose_vars
std::vector< unsigned char >	_has_active_material_properties
std::vector< SolverParams >	_solver_params
CoverageCheckMode	_kernel_coverage_check
std::vector< SubdomainName >	_kernel_coverage_blocks
const bool	_boundary_restricted_node_integrity_check
const bool	_boundary_restricted_elem_integrity_check
const bool	_side_uo_interface_mat_prop_integrity_check
CoverageCheckMode	_material_coverage_check
std::vector< SubdomainName >	_material_coverage_blocks
bool	_fv_bcs_integrity_check
const bool	_fv_face_integrity_check
const bool	_material_dependency_check
const bool	_uo_aux_state_check
bool	_check_residual_for_nans
unsigned int	_max_qps
libMesh::Order	_max_scalar_order
bool	_has_time_integrator
bool	_has_exception
bool	_parallel_barrier_messaging
MooseEnum	_verbose_setup
bool	_verbose_multiapps
bool	_verbose_restore
std::string	_exception_message
ExecFlagType	_current_execute_on_flag
ExecuteMooseObjectWarehouse< Control >	_control_warehouse
Moose::PetscSupport::PetscOptions	_petsc_options
PetscOptions	_petsc_option_data_base
bool	_is_petsc_options_inserted
std::shared_ptr< LineSearch >	_line_search
std::unique_ptr< libMesh::ConstElemRange >	_evaluable_local_elem_range
std::unique_ptr< libMesh::ConstElemRange >	_nl_evaluable_local_elem_range
std::unique_ptr< libMesh::ConstElemRange >	_aux_evaluable_local_elem_range
std::unique_ptr< libMesh::ConstElemRange >	_current_algebraic_elem_range
std::unique_ptr< libMesh::ConstNodeRange >	_current_algebraic_node_range
std::unique_ptr< ConstBndNodeRange >	_current_algebraic_bnd_node_range
bool	_using_ad_mat_props
unsigned short	_current_ic_state
const bool	_use_hash_table_matrix_assembly
std::map< TagName, TagID >	_matrix_tag_name_to_tag_id
std::map< TagID, TagName >	_matrix_tag_id_to_tag_name
Factory &	_factory
DiracKernelInfo	_dirac_kernel_info
std::map< SubdomainID, std::set< std::string > >	_map_block_material_props
std::map< BoundaryID, std::set< std::string > >	_map_boundary_material_props
std::map< SubdomainID, std::set< MaterialPropertyName > >	_zero_block_material_props
std::map< BoundaryID, std::set< MaterialPropertyName > >	_zero_boundary_material_props
std::set< std::string >	_material_property_requested
std::vector< std::set< MooseVariableFieldBase * > >	_active_elemental_moose_variables
std::vector< unsigned int >	_has_active_elemental_moose_variables
std::vector< std::set< TagID > >	_active_fe_var_coupleable_matrix_tags
std::vector< std::set< TagID > >	_active_fe_var_coupleable_vector_tags
std::vector< std::set< TagID > >	_active_sc_var_coupleable_matrix_tags
std::vector< std::set< TagID > >	_active_sc_var_coupleable_vector_tags
bool	_default_ghosting
std::set< dof_id_type >	_ghosted_elems
bool	_currently_computing_jacobian
bool	_currently_computing_residual_and_jacobian
bool	_computing_nonlinear_residual
bool	_currently_computing_residual
bool	_safe_access_tagged_matrices
bool	_safe_access_tagged_vectors
bool	_have_ad_objects
std::unordered_set< TagID >	_not_zeroed_tagged_vectors
bool	_cli_option_found
bool	_color_output
bool	_termination_requested
const bool &	_enabled
MooseApp &	_app
ActionFactory &	_action_factory
const std::string &	_type
const std::string &	_name
const InputParameters &	_pars
MooseApp &	_pg_moose_app
const std::string	_prefix
MooseApp &	_restartable_app
const std::string	_restartable_system_name
const THREAD_ID	_restartable_tid
const bool	_restartable_read_only
InitialConditionWarehouse	_ics
FVInitialConditionWarehouse	_fv_ics
ScalarInitialConditionWarehouse	_scalar_ics
MaterialWarehouse	_materials
MaterialWarehouse	_interface_materials
MaterialWarehouse	_discrete_materials
MaterialWarehouse	_all_materials
MaterialWarehouse	_kokkos_materials
MooseObjectWarehouse< Indicator >	_indicators
MooseObjectWarehouse< InternalSideIndicatorBase >	_internal_side_indicators
std::map< SubdomainID, std::multimap< std::string, std::string > >	_map_block_material_props_check
std::map< BoundaryID, std::multimap< std::string, std::string > >	_map_boundary_material_props_check
const Parallel::Communicator &	_communicator

Private Types
enum	TrueFunctorIs

Private Member Functions
void	setResidualObjectParamsAndLog (const std::string &ro_name, const std::string &name, InputParameters &parameters, const unsigned int nl_sys_num, const std::string &base_name, bool &reinit_displaced)
void	setAuxKernelParamsAndLog (const std::string &ak_name, const std::string &name, InputParameters &parameters, const std::string &base_name)
TheWarehouse::Query	getUOQuery (const std::string &system, const ExecFlagType &type, const Moose::AuxGroup &group) const
void	getUOExecutionGroups (TheWarehouse::Query &query, std::set< int > &execution_groups) const
void	handleException (const std::string &calling_method)
std::vector< MortarUserObject * >	getMortarUserObjects (BoundaryID primary_boundary_id, BoundaryID secondary_boundary_id, bool displaced, const std::vector< MortarUserObject * > &mortar_uo_superset)
std::vector< MortarUserObject * >	getMortarUserObjects (BoundaryID primary_boundary_id, BoundaryID secondary_boundary_id, bool displaced)
virtual std::pair< bool, unsigned int >	determineSolverSystem (const std::string &var_name, bool error_if_not_found=false) const override
void	checkICRestartError (const std::string &ic_name, const std::string &name, const VariableName &var_name)
void	addAnyRedistributers ()
void	updateMaxQps ()
void	joinAndFinalize (TheWarehouse::Query query, bool isgen=false)
void	kokkosJoinAndFinalize (const std::vector< Moose::Kokkos::UserObject * > &userobjs)
virtual void	resetState ()
void	cloneAlgebraicGhostingFunctor (libMesh::GhostingFunctor &algebraic_gf, bool to_mesh=true)
void	cloneCouplingGhostingFunctor (libMesh::GhostingFunctor &coupling_gf, bool to_mesh=true)
void	showFunctors () const
void	showFunctorRequestors () 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
std::string	restrictionSubdomainCheckName (SubdomainID check_id)
std::string	restrictionSubdomainCheckName (SubdomainID check_id)
std::string	restrictionBoundaryCheckName (BoundaryID check_id)
std::string	restrictionBoundaryCheckName (BoundaryID check_id)
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 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

Static Private Member Functions
static const hit::Node *	getHitNode (const InputParameters &params)
static std::string	messagePrefix (const InputParameters &params, const bool hit_prefix)
static SolverParams	makeLinearSolverParams ()

Private Attributes
Restartable::ManagedValue< RestartableEquationSystems >	_req
bool	_error_on_jacobian_nonzero_reallocation
const bool	_restore_original_nonzero_pattern
bool	_ignore_zeros_in_jacobian
bool	_preserve_matrix_sparsity_pattern
const bool	_force_restart
const bool	_allow_ics_during_restart
const bool	_skip_nl_system_check
bool	_fail_next_system_convergence_check
const bool	_allow_invalid_solution
const bool	_show_invalid_solution_console
const bool &	_immediately_print_invalid_solution
bool	_started_initial_setup
bool	_has_internal_edge_residual_objects
bool	_u_dot_requested
bool	_u_dotdot_requested
bool	_u_dot_old_requested
bool	_u_dotdot_old_requested
bool	_has_mortar
unsigned int	_num_grid_steps
bool	_trust_user_coupling_matrix
bool	_computing_scaling_jacobian
bool	_computing_scaling_residual
bool	_checking_uo_aux_state
ExecFlagEnum	_print_execution_on
const bool	_identify_variable_groups_in_nl
std::vector< VectorTag >	_current_residual_vector_tags
bool	_have_fv
const bool	_regard_general_exceptions_as_errors
std::vector< libMesh::CouplingMatrix >	_nonlocal_cm
bool	_requires_nonlocal_coupling
bool	_has_kokkos_objects
bool	_has_kokkos_residual_objects
std::vector< std::function< void()> >	_kokkos_mesh_initialization_hooks
std::vector< std::multimap< std::string, std::tuple< TrueFunctorIs, std::unique_ptr< Moose::FunctorEnvelopeBase >, std::unique_ptr< Moose::FunctorEnvelopeBase > > > >	_functors
std::vector< std::map< std::string, std::unique_ptr< Moose::FunctorAbstract > > >	_pbblf_functors
std::map< std::string, std::set< std::string > >	_functor_to_requestors
std::vector< std::multimap< std::string, std::pair< bool, bool > > >	_functor_to_request_info
bool	_show_functors
bool	_show_chain_control_data
std::vector< VectorTag >	_vector_tags
std::vector< std::vector< VectorTag > >	_typed_vector_tags
std::map< TagName, TagID >	_vector_tags_name_map
std::map< MooseObjectName, std::set< std::string > >	_consumed_material_properties
std::unordered_map< libMesh::GhostingFunctor *, std::vector< std::shared_ptr< libMesh::GhostingFunctor > > >	_root_alg_gf_to_sys_clones
std::unordered_map< libMesh::GhostingFunctor *, std::vector< std::shared_ptr< libMesh::GhostingFunctor > > >	_root_coupling_gf_to_sys_clones
const ParallelParamObject &	_parent
const MooseBase &	_si_moose_base
const FEProblemBase *	_si_problem
const RestartableDataMapName	_metaname
std::string	_restartable_name
const MooseObject &	_ppi_moose_object
const InputParameters &	_ppi_params
const FEProblemBase &	_ppi_feproblem
std::map< PostprocessorName, std::unique_ptr< PostprocessorValue > >	_default_values

Friends
PetscErrorCode	formFunction (SNES snes, Vec x, Vec f, void *ctx)
	This is the residual Vector function in a form compatible with the SNES PETC solvers.

Detailed Description

Base class for the 1-phase steady-state/transient subchannel solver.

Definition at line 33 of file SubChannel1PhaseProblem.h.

Constructor & Destructor Documentation

SubChannel1PhaseProblem()

SubChannel1PhaseProblem::SubChannel1PhaseProblem

(

const InputParameters &

params

)

Definition at line 189 of file SubChannel1PhaseProblem.C.

  : ExternalProblem(params),
    PostprocessorInterface(this),
    _friction_args(/*i_ch=*/0, /*Re=*/1.0, /*S=*/0.0, /*w_perim=*/0.0),
    _nusselt_args(
        /*Re=*/1.0, /*Pr=*/1.0, std::numeric_limits<unsigned int>::max(), /*iz=*/0, /*i_ch=*/0),
    _P_out(getPostprocessorValue("P_out")),
    _fp(nullptr),
    _subchannel_mesh(SCM::getMesh<SubChannelMesh>(_mesh)),
    _n_blocks(getParam<unsigned int>("n_blocks")),
    _Wij(declareRestartableData<libMesh::DenseMatrix<Real>>("Wij")),
    _Wij_old(declareRestartableData<libMesh::DenseMatrix<Real>>("Wij_old")),
    _g_grav(9.81),
    _kij(_subchannel_mesh.getKij()),
    _one(1.0),
    _compute_density(getParam<bool>("compute_density")),
    _compute_viscosity(getParam<bool>("compute_viscosity")),
    _compute_power(getParam<bool>("compute_power")),
    _pin_mesh_exist(_subchannel_mesh.pinMeshExist()),
    _duct_mesh_exist(_subchannel_mesh.ductMeshExist()),
    _bulk_Re(1.0),
    _bulk_V(1.0),
    _P_tol(getParam<Real>("P_tol")),
    _P_maxit(getParam<int>("P_maxit")),
    _T_tol(getParam<Real>("T_tol")),
    _T_maxit(getParam<int>("T_maxit")),
    _T_relaxation(getParam<Real>("T_relaxation")),
    _enthalpy_subcycles(getParam<unsigned int>("enthalpy_subcycles")),
    _mass_flow_equation_relaxation(getParam<Real>("mass_flow_equation_relaxation")),
    _pressure_equation_relaxation(getParam<Real>("pressure_equation_relaxation")),
    _crossflow_equation_relaxation(getParam<Real>("crossflow_equation_relaxation")),
    _mass_flow_relaxation(getParam<Real>("mass_flow_relaxation")),
    _pressure_relaxation(getParam<Real>("pressure_relaxation")),
    _crossflow_relaxation(getParam<Real>("crossflow_relaxation")),
    _rtol(getParam<PetscReal>("rtol")),
    _atol(getParam<PetscReal>("atol")),
    _dtol(getParam<PetscReal>("dtol")),
    _maxit(getParam<PetscInt>("maxit")),
    _interpolation_scheme(getParam<MooseEnum>("interpolation_scheme")),
    _gravity_direction(getParam<MooseEnum>("gravity")),
    _dir_grav(computeGravityDir(_gravity_direction)),
    _implicit_bool(getParam<bool>("implicit")),
    _staggered_pressure_bool(getParam<bool>("staggered_pressure")),
    _segregated_bool(getParam<bool>("segregated")),
    _verbose_subchannel(getParam<bool>("verbose_subchannel")),
    _friction_closure(nullptr),
    _mixing_closure(nullptr),
    _pin_HTC_closure(nullptr),
    _duct_HTC_closure(nullptr),
    _Tpin_soln(nullptr),
    _duct_heat_flux_soln(nullptr),
    _Tduct_soln(nullptr),
    _HTC_soln(nullptr)
{
  if (params.isParamSetByUser("beta") || params.isParamSetByUser("constant_beta"))
    paramError("beta",
               "You are using a deprecated parameter. Please use the mixing_closure system.");
  if (_pin_mesh_exist && !isParamValid("pin_HTC_closure"))
    paramError("pin_HTC_closure", "required when a pin mesh exists.");
  if (_duct_mesh_exist && !isParamValid("duct_HTC_closure"))
    paramError("duct_HTC_closure", "required when a duct mesh exists.");
  if (!_implicit_bool && !_segregated_bool)
    paramError("segregated", "A non-segregated solve requires 'implicit = true'.");
  if (_segregated_bool)
    for (const auto * relaxation_param : {"mass_flow_equation_relaxation",
                                          "pressure_equation_relaxation",
                                          "crossflow_equation_relaxation",
                                          "mass_flow_relaxation",
                                          "pressure_relaxation",
                                          "crossflow_relaxation"})
      if (params.isParamSetByUser(relaxation_param))
        paramError(relaxation_param,
                   "The '",
                   relaxation_param,
                   "' parameter is only used by the implicit non-segregated solve. Set "
                   "'implicit = true' and 'segregated = false' to use it.");
  // NOTE: The four quantities below are 0 for processor_id != 0
  _n_cells = _subchannel_mesh.getNumOfAxialCells();
  _n_gaps = _subchannel_mesh.getNumOfGapsPerLayer();
  _n_pins = _subchannel_mesh.getNumOfPins();
  _n_channels = _subchannel_mesh.getNumOfChannels();
  // NOTE: The four quantities above are 0 for processor_id != 0
  _z_grid = _subchannel_mesh.getZGrid();
  _block_size = _n_cells / _n_blocks;
  // Pressure drop (lives on subchannel nodes)
  _DP.resize(_n_channels, _n_cells + 1);
  _DP.zero();
  // Turbulent crossflow (stuff that live on the gaps)
  if (!_app.isRestarting() && !_app.isRecovering())
  {
    _Wij.resize(_n_gaps, _n_cells + 1);
    _Wij.zero();
    _Wij_old.resize(_n_gaps, _n_cells + 1);
    _Wij_old.zero();
  }
 
  _WijPrime.resize(_n_gaps, _n_cells + 1);
  _WijPrime.zero();
  _Wij_residual_matrix.resize(_n_gaps, _block_size);
  _Wij_residual_matrix.zero();
  _converged = true;
 
  // Mass conservation components
  LibmeshPetscCall(
      createPetscMatrix(_mc_sumWij_mat, _block_size * _n_channels, _block_size * _n_gaps));
  LibmeshPetscCall(createPetscVector(_Wij_vec, _block_size * _n_gaps));
  LibmeshPetscCall(createPetscVector(_prod, _block_size * _n_channels));
  LibmeshPetscCall(createPetscVector(_prodp, _block_size * _n_channels));
  LibmeshPetscCall(createPetscMatrix(
      _mc_axial_convection_mat, _block_size * _n_channels, _block_size * _n_channels));
  LibmeshPetscCall(createPetscVector(_mc_axial_convection_rhs, _block_size * _n_channels));
  LibmeshPetscCall(createPetscMatrix(
      _mc_density_pressure_mat, _block_size * _n_channels, _block_size * _n_channels));
 
  // Axial momentum conservation components
  LibmeshPetscCall(createPetscMatrix(
      _amc_turbulent_cross_flows_mat, _block_size * _n_gaps, _block_size * _n_channels));
  LibmeshPetscCall(createPetscVector(_amc_turbulent_cross_flows_rhs, _block_size * _n_gaps));
  LibmeshPetscCall(createPetscMatrix(
      _amc_time_derivative_mat, _block_size * _n_channels, _block_size * _n_channels));
  LibmeshPetscCall(createPetscVector(_amc_time_derivative_rhs, _block_size * _n_channels));
  LibmeshPetscCall(createPetscMatrix(
      _amc_advective_derivative_mat, _block_size * _n_channels, _block_size * _n_channels));
  LibmeshPetscCall(createPetscVector(_amc_advective_derivative_rhs, _block_size * _n_channels));
  LibmeshPetscCall(createPetscMatrix(
      _amc_cross_derivative_mat, _block_size * _n_channels, _block_size * _n_channels));
  LibmeshPetscCall(createPetscVector(_amc_cross_derivative_rhs, _block_size * _n_channels));
  LibmeshPetscCall(createPetscMatrix(
      _amc_friction_force_mat, _block_size * _n_channels, _block_size * _n_channels));
  LibmeshPetscCall(createPetscVector(_amc_friction_force_rhs, _block_size * _n_channels));
  LibmeshPetscCall(createPetscVector(_amc_gravity_rhs, _block_size * _n_channels));
  LibmeshPetscCall(createPetscMatrix(
      _amc_pressure_force_mat, _block_size * _n_channels, _block_size * _n_channels));
  LibmeshPetscCall(createPetscVector(_amc_pressure_force_rhs, _block_size * _n_channels));
  LibmeshPetscCall(
      createPetscMatrix(_amc_sys_mdot_mat, _block_size * _n_channels, _block_size * _n_channels));
  LibmeshPetscCall(createPetscVector(_amc_sys_mdot_rhs, _block_size * _n_channels));
 
  // Lateral momentum conservation components
  LibmeshPetscCall(
      createPetscMatrix(_cmc_time_derivative_mat, _block_size * _n_gaps, _block_size * _n_gaps));
  LibmeshPetscCall(createPetscVector(_cmc_time_derivative_rhs, _block_size * _n_gaps));
  LibmeshPetscCall(createPetscMatrix(
      _cmc_advective_derivative_mat, _block_size * _n_gaps, _block_size * _n_gaps));
  LibmeshPetscCall(createPetscVector(_cmc_advective_derivative_rhs, _block_size * _n_gaps));
  LibmeshPetscCall(
      createPetscMatrix(_cmc_friction_force_mat, _block_size * _n_gaps, _block_size * _n_gaps));
  LibmeshPetscCall(createPetscVector(_cmc_friction_force_rhs, _block_size * _n_gaps));
  LibmeshPetscCall(
      createPetscMatrix(_cmc_pressure_force_mat, _block_size * _n_gaps, _block_size * _n_channels));
  LibmeshPetscCall(createPetscVector(_cmc_pressure_force_rhs, _block_size * _n_gaps));
  LibmeshPetscCall(
      createPetscMatrix(_cmc_sys_Wij_mat, _block_size * _n_gaps, _block_size * _n_gaps));
  LibmeshPetscCall(createPetscVector(_cmc_sys_Wij_rhs, _block_size * _n_gaps));
 
  // Energy conservation components
  LibmeshPetscCall(createPetscMatrix(
      _hc_time_derivative_mat, _block_size * _n_channels, _block_size * _n_channels));
  LibmeshPetscCall(createPetscVector(_hc_time_derivative_rhs, _block_size * _n_channels));
  LibmeshPetscCall(createPetscMatrix(
      _hc_advective_derivative_mat, _block_size * _n_channels, _block_size * _n_channels));
  LibmeshPetscCall(createPetscVector(_hc_advective_derivative_rhs, _block_size * _n_channels));
  LibmeshPetscCall(createPetscMatrix(
      _hc_cross_derivative_mat, _block_size * _n_channels, _block_size * _n_channels));
  LibmeshPetscCall(createPetscVector(_hc_cross_derivative_rhs, _block_size * _n_channels));
  LibmeshPetscCall(createPetscVector(_hc_added_heat_rhs, _block_size * _n_channels));
  LibmeshPetscCall(
      createPetscMatrix(_hc_sys_h_mat, _block_size * _n_channels, _block_size * _n_channels));
  LibmeshPetscCall(createPetscVector(_hc_sys_h_rhs, _block_size * _n_channels));
 
  if ((_n_blocks == _n_cells) && _implicit_bool)
  {
    mooseError(name(),
               ": When implicit number of blocks can't be equal to number of cells. This will "
               "cause problems with the subchannel interpolation scheme.");
  }
}

~SubChannel1PhaseProblem()

SubChannel1PhaseProblem::~SubChannel1PhaseProblem ( )

virtual

Definition at line 488 of file SubChannel1PhaseProblem.C.

{
  PetscErrorCode ierr = cleanUp();
  if (ierr)
    mooseError(name(), ": Error in memory cleanup");
}

Member Function Documentation

cleanUp()

PetscErrorCode SubChannel1PhaseProblem::cleanUp ( )

protected

Definition at line 496 of file SubChannel1PhaseProblem.C.

{
  PetscFunctionBegin;
  // We need to clean up the petsc matrices/vectors
  // Mass conservation components
  LibmeshPetscCall(MatDestroy(&_mc_sumWij_mat));
  LibmeshPetscCall(VecDestroy(&_Wij_vec));
  LibmeshPetscCall(VecDestroy(&_prod));
  LibmeshPetscCall(VecDestroy(&_prodp));
  LibmeshPetscCall(MatDestroy(&_mc_axial_convection_mat));
  LibmeshPetscCall(VecDestroy(&_mc_axial_convection_rhs));
  LibmeshPetscCall(MatDestroy(&_mc_density_pressure_mat));
 
  // Axial momentum conservation components
  LibmeshPetscCall(MatDestroy(&_amc_turbulent_cross_flows_mat));
  LibmeshPetscCall(VecDestroy(&_amc_turbulent_cross_flows_rhs));
  LibmeshPetscCall(MatDestroy(&_amc_time_derivative_mat));
  LibmeshPetscCall(VecDestroy(&_amc_time_derivative_rhs));
  LibmeshPetscCall(MatDestroy(&_amc_advective_derivative_mat));
  LibmeshPetscCall(VecDestroy(&_amc_advective_derivative_rhs));
  LibmeshPetscCall(MatDestroy(&_amc_cross_derivative_mat));
  LibmeshPetscCall(VecDestroy(&_amc_cross_derivative_rhs));
  LibmeshPetscCall(MatDestroy(&_amc_friction_force_mat));
  LibmeshPetscCall(VecDestroy(&_amc_friction_force_rhs));
  LibmeshPetscCall(VecDestroy(&_amc_gravity_rhs));
  LibmeshPetscCall(MatDestroy(&_amc_pressure_force_mat));
  LibmeshPetscCall(VecDestroy(&_amc_pressure_force_rhs));
  LibmeshPetscCall(MatDestroy(&_amc_sys_mdot_mat));
  LibmeshPetscCall(VecDestroy(&_amc_sys_mdot_rhs));
 
  // Lateral momentum conservation components
  LibmeshPetscCall(MatDestroy(&_cmc_time_derivative_mat));
  LibmeshPetscCall(VecDestroy(&_cmc_time_derivative_rhs));
  LibmeshPetscCall(MatDestroy(&_cmc_advective_derivative_mat));
  LibmeshPetscCall(VecDestroy(&_cmc_advective_derivative_rhs));
  LibmeshPetscCall(MatDestroy(&_cmc_friction_force_mat));
  LibmeshPetscCall(VecDestroy(&_cmc_friction_force_rhs));
  LibmeshPetscCall(MatDestroy(&_cmc_pressure_force_mat));
  LibmeshPetscCall(VecDestroy(&_cmc_pressure_force_rhs));
  LibmeshPetscCall(MatDestroy(&_cmc_sys_Wij_mat));
  LibmeshPetscCall(VecDestroy(&_cmc_sys_Wij_rhs));
 
  // Energy conservation components
  LibmeshPetscCall(MatDestroy(&_hc_time_derivative_mat));
  LibmeshPetscCall(VecDestroy(&_hc_time_derivative_rhs));
  LibmeshPetscCall(MatDestroy(&_hc_advective_derivative_mat));
  LibmeshPetscCall(VecDestroy(&_hc_advective_derivative_rhs));
  LibmeshPetscCall(MatDestroy(&_hc_cross_derivative_mat));
  LibmeshPetscCall(VecDestroy(&_hc_cross_derivative_rhs));
  LibmeshPetscCall(VecDestroy(&_hc_added_heat_rhs));
  LibmeshPetscCall(MatDestroy(&_hc_sys_h_mat));
  LibmeshPetscCall(VecDestroy(&_hc_sys_h_rhs));
 
  PetscFunctionReturn(LIBMESH_PETSC_SUCCESS);
}

Referenced by ~SubChannel1PhaseProblem().

computeAddedHeatDuct()

Real SubChannel1PhaseProblem::computeAddedHeatDuct ( unsigned int  i_ch, unsigned int  iz  ) const

protectedvirtual

Non-pure: implemented in the base (or override in a child if needed)

Definition at line 2246 of file SubChannel1PhaseProblem.C.

{
  mooseAssert(iz > 0, "Trapezoidal rule requires starting at index 1 at least");
  if (_duct_mesh_exist)
  {
    auto subch_type = _subchannel_mesh.getSubchannelType(i_ch);
    if (subch_type == EChannelType::EDGE || subch_type == EChannelType::CORNER)
    {
      auto dz = _z_grid[iz] - _z_grid[iz - 1];
      auto * node_in_chan = _subchannel_mesh.getChannelNode(i_ch, iz - 1);
      auto * node_out_chan = _subchannel_mesh.getChannelNode(i_ch, iz);
      auto * node_in_duct = _subchannel_mesh.getDuctNodeFromChannel(node_in_chan);
      auto * node_out_duct = _subchannel_mesh.getDuctNodeFromChannel(node_out_chan);
      auto heat_rate_in = (*_duct_heat_flux_soln)(node_in_duct);
      auto heat_rate_out = (*_duct_heat_flux_soln)(node_out_duct);
      auto width = getSubChannelPeripheralDuctWidth(i_ch);
      return 0.5 * (heat_rate_in + heat_rate_out) * dz * width;
    }
    else
    {
      return 0.0;
    }
  }
  else
  {
    return 0.0;
  }
}

Referenced by TriSubChannel1PhaseProblem::computeh(), and getAddedHeatDuct().

computeAddedHeatPin()

virtual Real SubChannel1PhaseProblem::computeAddedHeatPin ( unsigned int  i_ch, unsigned int  iz  ) const

protectedpure virtual

Pure virtual: daughters provide different implementations.

Implemented in QuadSubChannel1PhaseProblem, and TriSubChannel1PhaseProblem.

Referenced by getAddedHeatPin().

computeBulkReynoldsNumber()

void SubChannel1PhaseProblem::computeBulkReynoldsNumber ( )

protected

Computes the assembly bulk Reynolds number from inlet flow conditions.

Definition at line 419 of file SubChannel1PhaseProblem.C.

{
  if (processor_id() == 0)
  {
    Real viscosity_in = 0.0;
    Real volumetric_flow_in = 0.0;
    Real mass_flow_in = 0.0;
    for (const auto i_ch : make_range(_n_channels))
    {
      auto * node_in = _subchannel_mesh.getChannelNode(i_ch, 0);
      const Real mdot_in = (*_mdot_soln)(node_in);
      const Real rho_in = (*_rho_soln)(node_in);
      viscosity_in += mdot_in * (*_mu_soln)(node_in);
      volumetric_flow_in += mdot_in / rho_in;
      mass_flow_in += mdot_in;
    }
    const Real bulk_Dh = _subchannel_mesh.getAssemblyHydraulicDiameter();
    const Real flow_area = _subchannel_mesh.getAssemblyFlowArea();
    const Real inlet_mu = viscosity_in / mass_flow_in;
    _bulk_Re = mass_flow_in * bulk_Dh / (inlet_mu * flow_area);
    _bulk_V = volumetric_flow_in / flow_area;
  }
  // Only rank 0 owns the subchannel DOFs (SingleRankPartitioner), so share the result
  _communicator.broadcast(_bulk_Re);
  _communicator.broadcast(_bulk_V);
 
  if (MooseUtils::absoluteFuzzyEqual(_bulk_Re, 0.0))
    mooseError("The computed bulk Reynolds number is zero.");
 
  if (MooseUtils::absoluteFuzzyEqual(_bulk_V, 0.0))
    mooseError("The computed bulk velocity is zero.");
 
  _mixing_closure->computeBulkMixingParameters();
}

Referenced by externalSolve().

computeDP()

void SubChannel1PhaseProblem::computeDP ( int  iblock )

protected

Computes Pressure Drop per channel for block iblock.

Upwind local form loss

Upwind local form loss

Advective derivative term

Cross derivative term

Friction term

Upwind local form loss

Gravity force

Assembling system

Definition at line 830 of file SubChannel1PhaseProblem.C.

{
  const unsigned int last_node = (iblock + 1) * _block_size;
  const unsigned int first_node = iblock * _block_size + 1;
  if (!_implicit_bool)
  {
    for (unsigned int iz = first_node; iz < last_node + 1; iz++)
    {
      auto k_grid = _subchannel_mesh.getKGrid();
      auto dz = _z_grid[iz] - _z_grid[iz - 1];
      for (unsigned int i_ch = 0; i_ch < _n_channels; i_ch++)
      {
        auto * node_in = _subchannel_mesh.getChannelNode(i_ch, iz - 1);
        auto * node_out = _subchannel_mesh.getChannelNode(i_ch, iz);
        auto rho_in = (*_rho_soln)(node_in);
        auto rho_out = (*_rho_soln)(node_out);
        auto mu_in = (*_mu_soln)(node_in);
        auto S = (*_S_flow_soln)(node_in);
        auto w_perim = (*_w_perim_soln)(node_in);
        // hydraulic diameter in the i direction
        auto Dh_i = 4.0 * S / w_perim;
        auto time_term = _TR * ((*_mdot_soln)(node_out)-_mdot_soln->old(node_out)) * dz / _dt -
                         dz * 2.0 * (*_mdot_soln)(node_out) * (rho_out - _rho_soln->old(node_out)) /
                             rho_in / _dt;
        auto mass_term1 =
            Utility::pow<2>((*_mdot_soln)(node_out)) * (1.0 / S / rho_out - 1.0 / S / rho_in);
        auto mass_term2 = -2.0 * (*_mdot_soln)(node_out) * (*_SumWij_soln)(node_out) / S / rho_in;
        auto crossflow_term = 0.0;
        auto turbulent_term = 0.0;
        unsigned int counter = 0;
        for (auto i_gap : _subchannel_mesh.getChannelGaps(i_ch))
        {
          auto chans = _subchannel_mesh.getGapChannels(i_gap);
          unsigned int ii_ch = chans.first;
          unsigned int jj_ch = chans.second;
          auto * node_in_i = _subchannel_mesh.getChannelNode(ii_ch, iz - 1);
          auto * node_in_j = _subchannel_mesh.getChannelNode(jj_ch, iz - 1);
          auto * node_out_i = _subchannel_mesh.getChannelNode(ii_ch, iz);
          auto * node_out_j = _subchannel_mesh.getChannelNode(jj_ch, iz);
          auto rho_i = (*_rho_soln)(node_in_i);
          auto rho_j = (*_rho_soln)(node_in_j);
          auto Si = (*_S_flow_soln)(node_in_i);
          auto Sj = (*_S_flow_soln)(node_in_j);
          Real u_star = 0.0;
          // figure out donor axial velocity
          if (_Wij(i_gap, iz) > 0.0)
            u_star = (*_mdot_soln)(node_out_i) / Si / rho_i;
          else
            u_star = (*_mdot_soln)(node_out_j) / Sj / rho_j;
 
          crossflow_term +=
              _subchannel_mesh.getCrossflowSign(i_ch, counter) * _Wij(i_gap, iz) * u_star;
 
          turbulent_term += _WijPrime(i_gap, iz) * (2 * (*_mdot_soln)(node_out) / rho_in / S -
                                                    (*_mdot_soln)(node_out_j) / Sj / rho_j -
                                                    (*_mdot_soln)(node_out_i) / Si / rho_i);
          counter++;
        }
        turbulent_term *= _CT;
        auto Re = (((*_mdot_soln)(node_in) / S) * Dh_i / mu_in);
        _friction_args = FrictionStruct(i_ch, Re, S, w_perim);
        Real ff = _friction_closure->computeFrictionFactor(_friction_args);
        if (_ff_soln)
          _ff_soln->set(node_out, ff);
        auto ki = 0.0;
        if ((*_mdot_soln)(node_out) >= 0)
          ki = k_grid[i_ch][iz - 1];
        else
          ki = k_grid[i_ch][iz];
        auto friction_term = (ff * dz / Dh_i + ki) * 0.5 *
                             (*_mdot_soln)(node_out)*std::abs((*_mdot_soln)(node_out)) /
                             (S * (*_rho_soln)(node_out));
        auto gravity_term = _dir_grav * _g_grav * (*_rho_soln)(node_out)*dz * S;
        auto DP = (1 / S) * (time_term + mass_term1 + mass_term2 + crossflow_term + turbulent_term +
                             friction_term + gravity_term); // Pa
        _DP(i_ch, iz) = DP;
        if (_DP_soln)
          _DP_soln->set(node_out, DP);
      }
    }
  }
  else
  {
    LibmeshPetscCall(MatZeroEntries(_amc_time_derivative_mat));
    LibmeshPetscCall(MatZeroEntries(_amc_advective_derivative_mat));
    LibmeshPetscCall(MatZeroEntries(_amc_cross_derivative_mat));
    LibmeshPetscCall(MatZeroEntries(_amc_friction_force_mat));
    LibmeshPetscCall(VecZeroEntries(_amc_time_derivative_rhs));
    LibmeshPetscCall(VecZeroEntries(_amc_advective_derivative_rhs));
    LibmeshPetscCall(VecZeroEntries(_amc_cross_derivative_rhs));
    LibmeshPetscCall(VecZeroEntries(_amc_friction_force_rhs));
    LibmeshPetscCall(VecZeroEntries(_amc_gravity_rhs));
    LibmeshPetscCall(MatZeroEntries(_amc_sys_mdot_mat));
    LibmeshPetscCall(VecZeroEntries(_amc_sys_mdot_rhs));
    for (unsigned int iz = first_node; iz < last_node + 1; iz++)
    {
      auto k_grid = _subchannel_mesh.getKGrid();
      auto dz = _z_grid[iz] - _z_grid[iz - 1];
      auto iz_ind = iz - first_node;
      for (unsigned int i_ch = 0; i_ch < _n_channels; i_ch++)
      {
        // inlet and outlet nodes
        auto * node_in = _subchannel_mesh.getChannelNode(i_ch, iz - 1);
        auto * node_out = _subchannel_mesh.getChannelNode(i_ch, iz);
 
        // interpolation weight coefficient
        PetscScalar Pe = 0.5;
        if (_interpolation_scheme == 3)
        {
          // Compute the Peclet number
          auto S_in = (*_S_flow_soln)(node_in);
          auto S_out = (*_S_flow_soln)(node_out);
          auto S_interp = computeInterpolatedValue(S_out, S_in, 0.5);
          auto w_perim_in = (*_w_perim_soln)(node_in);
          auto w_perim_out = (*_w_perim_soln)(node_out);
          auto w_perim_interp = this->computeInterpolatedValue(w_perim_out, w_perim_in, 0.5);
          auto mdot_loc =
              this->computeInterpolatedValue((*_mdot_soln)(node_out), (*_mdot_soln)(node_in), 0.5);
          auto mu_in = (*_mu_soln)(node_in);
          auto mu_out = (*_mu_soln)(node_out);
          auto mu_interp = this->computeInterpolatedValue(mu_out, mu_in, 0.5);
          auto Dh_i = 4.0 * S_interp / w_perim_interp;
          // Compute friction factor
          auto Re = ((mdot_loc / S_interp) * Dh_i / mu_interp);
          _friction_args = FrictionStruct(i_ch, Re, S_interp, w_perim_interp);
          Real ff = _friction_closure->computeFrictionFactor(_friction_args);
          if (_ff_soln)
            _ff_soln->set(node_out, ff);
          auto ki = 0.0;
          if ((*_mdot_soln)(node_out) >= 0)
            ki = k_grid[i_ch][iz - 1];
          else
            ki = k_grid[i_ch][iz];
          Pe = 1.0 / ((ff * dz / Dh_i + ki) * 0.5) * mdot_loc / std::abs(mdot_loc);
        }
        auto alpha = computeInterpolationCoefficients(Pe);
 
        // inlet, outlet, and interpolated density
        auto rho_in = (*_rho_soln)(node_in);
        auto rho_out = (*_rho_soln)(node_out);
        auto rho_interp = computeInterpolatedValue(rho_out, rho_in, Pe);
 
        // inlet, outlet, and interpolated viscosity
        auto mu_in = (*_mu_soln)(node_in);
        auto mu_out = (*_mu_soln)(node_out);
        auto mu_interp = computeInterpolatedValue(mu_out, mu_in, Pe);
 
        // inlet, outlet, and interpolated axial surface area
        auto S_in = (*_S_flow_soln)(node_in);
        auto S_out = (*_S_flow_soln)(node_out);
        auto S_interp = computeInterpolatedValue(S_out, S_in, Pe);
 
        // inlet, outlet, and interpolated wetted perimeter
        auto w_perim_in = (*_w_perim_soln)(node_in);
        auto w_perim_out = (*_w_perim_soln)(node_out);
        auto w_perim_interp = computeInterpolatedValue(w_perim_out, w_perim_in, Pe);
 
        // hydraulic diameter in the i direction
        auto Dh_i = 4.0 * S_interp / w_perim_interp;
 
        // Keep temporal storage independent of the spatial interpolation scheme. Applying the
        // upwind coefficient to this term puts the storage on the upstream node and leaves the
        // first axial row without transient inertia in the upwind limit.
        PetscInt row_tt = i_ch + _n_channels * iz_ind;
        PetscInt col_tt = i_ch + _n_channels * iz_ind;
        PetscScalar value_tt = _TR * dz / _dt;
        LibmeshPetscCall(MatSetValues(
            _amc_time_derivative_mat, 1, &row_tt, 1, &col_tt, &value_tt, INSERT_VALUES));
 
        PetscScalar value_vec_tt = _TR * _mdot_soln->old(node_out) * dz / _dt;
        PetscInt row_vec_tt = i_ch + _n_channels * iz_ind;
        LibmeshPetscCall(
            VecSetValues(_amc_time_derivative_rhs, 1, &row_vec_tt, &value_vec_tt, ADD_VALUES));
 
        if (iz == first_node)
        {
          PetscScalar value_vec_at = Utility::pow<2>((*_mdot_soln)(node_in)) / (S_in * rho_in);
          PetscInt row_vec_at = i_ch + _n_channels * iz_ind;
          LibmeshPetscCall(VecSetValues(
              _amc_advective_derivative_rhs, 1, &row_vec_at, &value_vec_at, ADD_VALUES));
        }
        else
        {
          PetscInt row_at = i_ch + _n_channels * iz_ind;
          PetscInt col_at = i_ch + _n_channels * (iz_ind - 1);
          PetscScalar value_at = -1.0 * std::abs((*_mdot_soln)(node_in)) / (S_in * rho_in);
          LibmeshPetscCall(MatSetValues(
              _amc_advective_derivative_mat, 1, &row_at, 1, &col_at, &value_at, INSERT_VALUES));
        }
 
        // Adding diagonal elements
        PetscInt row_at = i_ch + _n_channels * iz_ind;
        PetscInt col_at = i_ch + _n_channels * iz_ind;
        PetscScalar value_at = std::abs((*_mdot_soln)(node_out)) / (S_out * rho_out);
        LibmeshPetscCall(MatSetValues(
            _amc_advective_derivative_mat, 1, &row_at, 1, &col_at, &value_at, INSERT_VALUES));
 
        unsigned int counter = 0;
        unsigned int cross_index = iz; // iz-1;
        for (auto i_gap : _subchannel_mesh.getChannelGaps(i_ch))
        {
          auto chans = _subchannel_mesh.getGapChannels(i_gap);
          unsigned int ii_ch = chans.first;
          unsigned int jj_ch = chans.second;
          auto * node_in_i = _subchannel_mesh.getChannelNode(ii_ch, iz - 1);
          auto * node_in_j = _subchannel_mesh.getChannelNode(jj_ch, iz - 1);
          auto * node_out_i = _subchannel_mesh.getChannelNode(ii_ch, iz);
          auto * node_out_j = _subchannel_mesh.getChannelNode(jj_ch, iz);
          auto rho_i =
              computeInterpolatedValue((*_rho_soln)(node_out_i), (*_rho_soln)(node_in_i), Pe);
          auto rho_j =
              computeInterpolatedValue((*_rho_soln)(node_out_j), (*_rho_soln)(node_in_j), Pe);
          auto S_i =
              computeInterpolatedValue((*_S_flow_soln)(node_out_i), (*_S_flow_soln)(node_in_i), Pe);
          auto S_j =
              computeInterpolatedValue((*_S_flow_soln)(node_out_j), (*_S_flow_soln)(node_in_j), Pe);
          auto u_star = 0.0;
          // figure out donor axial velocity
          if (_Wij(i_gap, cross_index) > 0.0)
          {
            if (iz == first_node)
            {
              u_star = (*_mdot_soln)(node_in_i) / S_i / rho_i;
              PetscScalar value_vec_ct = -1.0 * alpha *
                                         _subchannel_mesh.getCrossflowSign(i_ch, counter) *
                                         _Wij(i_gap, cross_index) * u_star;
              PetscInt row_vec_ct = i_ch + _n_channels * iz_ind;
              LibmeshPetscCall(VecSetValues(
                  _amc_cross_derivative_rhs, 1, &row_vec_ct, &value_vec_ct, ADD_VALUES));
            }
            else
            {
              PetscScalar value_ct = alpha * _subchannel_mesh.getCrossflowSign(i_ch, counter) *
                                     _Wij(i_gap, cross_index) / S_i / rho_i;
              PetscInt row_ct = i_ch + _n_channels * iz_ind;
              PetscInt col_ct = ii_ch + _n_channels * (iz_ind - 1);
              LibmeshPetscCall(MatSetValues(
                  _amc_cross_derivative_mat, 1, &row_ct, 1, &col_ct, &value_ct, ADD_VALUES));
            }
            PetscScalar value_ct = (1.0 - alpha) *
                                   _subchannel_mesh.getCrossflowSign(i_ch, counter) *
                                   _Wij(i_gap, cross_index) / S_i / rho_i;
            PetscInt row_ct = i_ch + _n_channels * iz_ind;
            PetscInt col_ct = ii_ch + _n_channels * iz_ind;
            LibmeshPetscCall(MatSetValues(
                _amc_cross_derivative_mat, 1, &row_ct, 1, &col_ct, &value_ct, ADD_VALUES));
          }
          else if (_Wij(i_gap, cross_index) < 0.0) // _Wij=0 operations not necessary
          {
            if (iz == first_node)
            {
              u_star = (*_mdot_soln)(node_in_j) / S_j / rho_j;
              PetscScalar value_vec_ct = -1.0 * alpha *
                                         _subchannel_mesh.getCrossflowSign(i_ch, counter) *
                                         _Wij(i_gap, cross_index) * u_star;
              PetscInt row_vec_ct = i_ch + _n_channels * iz_ind;
              LibmeshPetscCall(VecSetValues(
                  _amc_cross_derivative_rhs, 1, &row_vec_ct, &value_vec_ct, ADD_VALUES));
            }
            else
            {
              PetscScalar value_ct = alpha * _subchannel_mesh.getCrossflowSign(i_ch, counter) *
                                     _Wij(i_gap, cross_index) / S_j / rho_j;
              PetscInt row_ct = i_ch + _n_channels * iz_ind;
              PetscInt col_ct = jj_ch + _n_channels * (iz_ind - 1);
              LibmeshPetscCall(MatSetValues(
                  _amc_cross_derivative_mat, 1, &row_ct, 1, &col_ct, &value_ct, ADD_VALUES));
            }
            PetscScalar value_ct = (1.0 - alpha) *
                                   _subchannel_mesh.getCrossflowSign(i_ch, counter) *
                                   _Wij(i_gap, cross_index) / S_j / rho_j;
            PetscInt row_ct = i_ch + _n_channels * iz_ind;
            PetscInt col_ct = jj_ch + _n_channels * iz_ind;
            LibmeshPetscCall(MatSetValues(
                _amc_cross_derivative_mat, 1, &row_ct, 1, &col_ct, &value_ct, ADD_VALUES));
          }
 
          if (iz == first_node)
          {
            PetscScalar value_vec_ct = -2.0 * alpha * (*_mdot_soln)(node_in)*_CT *
                                       _WijPrime(i_gap, cross_index) / (rho_interp * S_interp);
            value_vec_ct += alpha * (*_mdot_soln)(node_in_j)*_CT * _WijPrime(i_gap, cross_index) /
                            (rho_j * S_j);
            value_vec_ct += alpha * (*_mdot_soln)(node_in_i)*_CT * _WijPrime(i_gap, cross_index) /
                            (rho_i * S_i);
            PetscInt row_vec_ct = i_ch + _n_channels * iz_ind;
            LibmeshPetscCall(
                VecSetValues(_amc_cross_derivative_rhs, 1, &row_vec_ct, &value_vec_ct, ADD_VALUES));
          }
          else
          {
            PetscScalar value_center_ct =
                2.0 * alpha * _CT * _WijPrime(i_gap, cross_index) / (rho_interp * S_interp);
            PetscInt row_ct = i_ch + _n_channels * iz_ind;
            PetscInt col_ct = i_ch + _n_channels * (iz_ind - 1);
            LibmeshPetscCall(MatSetValues(
                _amc_cross_derivative_mat, 1, &row_ct, 1, &col_ct, &value_center_ct, ADD_VALUES));
 
            PetscScalar value_left_ct =
                -1.0 * alpha * _CT * _WijPrime(i_gap, cross_index) / (rho_j * S_j);
            row_ct = i_ch + _n_channels * iz_ind;
            col_ct = jj_ch + _n_channels * (iz_ind - 1);
            LibmeshPetscCall(MatSetValues(
                _amc_cross_derivative_mat, 1, &row_ct, 1, &col_ct, &value_left_ct, ADD_VALUES));
 
            PetscScalar value_right_ct =
                -1.0 * alpha * _CT * _WijPrime(i_gap, cross_index) / (rho_i * S_i);
            row_ct = i_ch + _n_channels * iz_ind;
            col_ct = ii_ch + _n_channels * (iz_ind - 1);
            LibmeshPetscCall(MatSetValues(
                _amc_cross_derivative_mat, 1, &row_ct, 1, &col_ct, &value_right_ct, ADD_VALUES));
          }
 
          PetscScalar value_center_ct =
              2.0 * (1.0 - alpha) * _CT * _WijPrime(i_gap, cross_index) / (rho_interp * S_interp);
          PetscInt row_ct = i_ch + _n_channels * iz_ind;
          PetscInt col_ct = i_ch + _n_channels * iz_ind;
          LibmeshPetscCall(MatSetValues(
              _amc_cross_derivative_mat, 1, &row_ct, 1, &col_ct, &value_center_ct, ADD_VALUES));
 
          PetscScalar value_left_ct =
              -1.0 * (1.0 - alpha) * _CT * _WijPrime(i_gap, cross_index) / (rho_j * S_j);
          row_ct = i_ch + _n_channels * iz_ind;
          col_ct = jj_ch + _n_channels * iz_ind;
          LibmeshPetscCall(MatSetValues(
              _amc_cross_derivative_mat, 1, &row_ct, 1, &col_ct, &value_left_ct, ADD_VALUES));
 
          PetscScalar value_right_ct =
              -1.0 * (1.0 - alpha) * _CT * _WijPrime(i_gap, cross_index) / (rho_i * S_i);
          row_ct = i_ch + _n_channels * iz_ind;
          col_ct = ii_ch + _n_channels * iz_ind;
          LibmeshPetscCall(MatSetValues(
              _amc_cross_derivative_mat, 1, &row_ct, 1, &col_ct, &value_right_ct, ADD_VALUES));
          counter++;
        }
 
        PetscScalar mdot_interp =
            computeInterpolatedValue((*_mdot_soln)(node_out), (*_mdot_soln)(node_in), Pe);
        auto Re = ((mdot_interp / S_interp) * Dh_i / mu_interp);
        _friction_args = FrictionStruct(i_ch, Re, S_interp, w_perim_interp);
        Real ff = _friction_closure->computeFrictionFactor(_friction_args);
        if (_ff_soln)
          _ff_soln->set(node_out, ff);
        auto ki = 0.0;
        if ((*_mdot_soln)(node_out) >= 0)
          ki = k_grid[i_ch][iz - 1];
        else
          ki = k_grid[i_ch][iz];
        auto coef = (ff * dz / Dh_i + ki) * 0.5 * std::abs((*_mdot_soln)(node_out)) /
                    (S_interp * rho_interp);
        if (iz == first_node)
        {
          PetscScalar value_vec = -1.0 * alpha * coef * (*_mdot_soln)(node_in);
          PetscInt row_vec = i_ch + _n_channels * iz_ind;
          LibmeshPetscCall(
              VecSetValues(_amc_friction_force_rhs, 1, &row_vec, &value_vec, ADD_VALUES));
        }
        else
        {
          PetscInt row = i_ch + _n_channels * iz_ind;
          PetscInt col = i_ch + _n_channels * (iz_ind - 1);
          PetscScalar value = alpha * coef;
          LibmeshPetscCall(
              MatSetValues(_amc_friction_force_mat, 1, &row, 1, &col, &value, INSERT_VALUES));
        }
 
        // Adding diagonal elements
        PetscInt row = i_ch + _n_channels * iz_ind;
        PetscInt col = i_ch + _n_channels * iz_ind;
        PetscScalar value = (1.0 - alpha) * coef;
        LibmeshPetscCall(
            MatSetValues(_amc_friction_force_mat, 1, &row, 1, &col, &value, INSERT_VALUES));
 
        PetscScalar value_vec = _dir_grav * -1.0 * _g_grav * rho_interp * dz * S_interp;
        PetscInt row_vec = i_ch + _n_channels * iz_ind;
        LibmeshPetscCall(VecSetValues(_amc_gravity_rhs, 1, &row_vec, &value_vec, ADD_VALUES));
      }
    }
    LibmeshPetscCall(MatZeroEntries(_amc_sys_mdot_mat));
    LibmeshPetscCall(VecZeroEntries(_amc_sys_mdot_rhs));
    LibmeshPetscCall(MatAssemblyBegin(_amc_time_derivative_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(MatAssemblyEnd(_amc_time_derivative_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(MatAssemblyBegin(_amc_advective_derivative_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(MatAssemblyEnd(_amc_advective_derivative_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(MatAssemblyBegin(_amc_cross_derivative_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(MatAssemblyEnd(_amc_cross_derivative_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(MatAssemblyBegin(_amc_friction_force_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(MatAssemblyEnd(_amc_friction_force_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(MatAssemblyBegin(_amc_sys_mdot_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(MatAssemblyEnd(_amc_sys_mdot_mat, MAT_FINAL_ASSEMBLY));
    // Matrix
#if !PETSC_VERSION_LESS_THAN(3, 15, 0)
    LibmeshPetscCall(
        MatAXPY(_amc_sys_mdot_mat, 1.0, _amc_time_derivative_mat, UNKNOWN_NONZERO_PATTERN));
    LibmeshPetscCall(MatAssemblyBegin(_amc_sys_mdot_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(MatAssemblyEnd(_amc_sys_mdot_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(
        MatAXPY(_amc_sys_mdot_mat, 1.0, _amc_advective_derivative_mat, UNKNOWN_NONZERO_PATTERN));
    LibmeshPetscCall(MatAssemblyBegin(_amc_sys_mdot_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(MatAssemblyEnd(_amc_sys_mdot_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(
        MatAXPY(_amc_sys_mdot_mat, 1.0, _amc_cross_derivative_mat, UNKNOWN_NONZERO_PATTERN));
    LibmeshPetscCall(MatAssemblyBegin(_amc_sys_mdot_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(MatAssemblyEnd(_amc_sys_mdot_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(
        MatAXPY(_amc_sys_mdot_mat, 1.0, _amc_friction_force_mat, UNKNOWN_NONZERO_PATTERN));
#else
    LibmeshPetscCall(
        MatAXPY(_amc_sys_mdot_mat, 1.0, _amc_time_derivative_mat, DIFFERENT_NONZERO_PATTERN));
    LibmeshPetscCall(MatAssemblyBegin(_amc_sys_mdot_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(MatAssemblyEnd(_amc_sys_mdot_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(
        MatAXPY(_amc_sys_mdot_mat, 1.0, _amc_advective_derivative_mat, DIFFERENT_NONZERO_PATTERN));
    LibmeshPetscCall(MatAssemblyBegin(_amc_sys_mdot_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(MatAssemblyEnd(_amc_sys_mdot_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(
        MatAXPY(_amc_sys_mdot_mat, 1.0, _amc_cross_derivative_mat, DIFFERENT_NONZERO_PATTERN));
    LibmeshPetscCall(MatAssemblyBegin(_amc_sys_mdot_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(MatAssemblyEnd(_amc_sys_mdot_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(
        MatAXPY(_amc_sys_mdot_mat, 1.0, _amc_friction_force_mat, DIFFERENT_NONZERO_PATTERN));
#endif
    LibmeshPetscCall(MatAssemblyBegin(_amc_sys_mdot_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(MatAssemblyEnd(_amc_sys_mdot_mat, MAT_FINAL_ASSEMBLY));
    // RHS
    LibmeshPetscCall(VecAXPY(_amc_sys_mdot_rhs, 1.0, _amc_time_derivative_rhs));
    LibmeshPetscCall(VecAXPY(_amc_sys_mdot_rhs, 1.0, _amc_advective_derivative_rhs));
    LibmeshPetscCall(VecAXPY(_amc_sys_mdot_rhs, 1.0, _amc_cross_derivative_rhs));
    LibmeshPetscCall(VecAXPY(_amc_sys_mdot_rhs, 1.0, _amc_friction_force_rhs));
    LibmeshPetscCall(VecAXPY(_amc_sys_mdot_rhs, 1.0, _amc_gravity_rhs));
    if (_segregated_bool)
    {
      // Assembly the matrix system
      LibmeshPetscCall(populateVectorFromHandle<SolutionHandle>(
          _prod, *_mdot_soln, first_node, last_node, _n_channels));
      Vec ls;
      LibmeshPetscCall(VecDuplicate(_amc_sys_mdot_rhs, &ls));
      LibmeshPetscCall(MatMult(_amc_sys_mdot_mat, _prod, ls));
      LibmeshPetscCall(VecAXPY(ls, -1.0, _amc_sys_mdot_rhs));
      PetscScalar * xx;
      LibmeshPetscCall(VecGetArray(ls, &xx));
      for (unsigned int iz = first_node; iz < last_node + 1; iz++)
      {
        auto iz_ind = iz - first_node;
        for (unsigned int i_ch = 0; i_ch < _n_channels; i_ch++)
        {
          // Setting nodes
          auto * node_in = _subchannel_mesh.getChannelNode(i_ch, iz - 1);
          auto * node_out = _subchannel_mesh.getChannelNode(i_ch, iz);
 
          // inlet, outlet, and interpolated axial surface area
          auto S_in = (*_S_flow_soln)(node_in);
          auto S_out = (*_S_flow_soln)(node_out);
          auto S_interp = computeInterpolatedValue(S_out, S_in, 0.5);
 
          // Setting solutions
          if (S_interp != 0)
          {
            auto DP = (1 / S_interp) * xx[iz_ind * _n_channels + i_ch];
            _DP(i_ch, iz) = DP;
            if (_DP_soln)
              _DP_soln->set(node_out, DP);
          }
          else
          {
            auto DP = 0.0;
            _DP(i_ch, iz) = DP;
            if (_DP_soln)
              _DP_soln->set(node_out, DP);
          }
        }
      }
      LibmeshPetscCall(VecDestroy(&ls));
    }
  }
}

Referenced by implicitPetscSolve(), and residualFunction().

computeGravityDir()

Real SubChannel1PhaseProblem::computeGravityDir ( const MooseEnum &  dir ) const

inlineprotected

inline function that is used to define the gravity direction

Definition at line 166 of file SubChannel1PhaseProblem.h.

  {
    switch (dir)
    {
      case 0: // counter_flow
        return 1.0;
      case 1: // co_flow
        return -1.0;
      case 2: // none
        return 0.0;
      default:
        mooseError(name(), ": Invalid gravity direction: expected counter_flow, co_flow, or none");
    }
  }

computeh()

virtual void SubChannel1PhaseProblem::computeh ( int  iblock )

protectedpure virtual

Computes Enthalpy per channel for block iblock.

Implemented in QuadSubChannel1PhaseProblem, and TriSubChannel1PhaseProblem.

Referenced by externalSolve().

computeInterpolatedValue()

PetscScalar SubChannel1PhaseProblem::computeInterpolatedValue ( PetscScalar  topValue, PetscScalar  botValue, PetscScalar  Peclet = 0.0  )

protected

Definition at line 579 of file SubChannel1PhaseProblem.C.

{
  PetscScalar alpha = computeInterpolationCoefficients(Peclet);
  return alpha * botValue + (1.0 - alpha) * topValue;
}

Referenced by computeDP(), QuadSubChannel1PhaseProblem::computeh(), TriSubChannel1PhaseProblem::computeh(), computeP(), and computeWijResidual().

computeInterpolationCoefficients()

PetscScalar SubChannel1PhaseProblem::computeInterpolationCoefficients ( PetscScalar  Peclet = 0.0 )

protected

Functions that computes the interpolation scheme given the Peclet number.

Definition at line 559 of file SubChannel1PhaseProblem.C.

{
  switch (_interpolation_scheme)
  {
    case 0: // upwind interpolation
      return 1.0;
    case 1: // downwind interpolation
      return 0.0;
    case 2: // central_difference interpolation
      return 0.5;
    case 3: // exponential interpolation (Peclet limited)
      return ((Peclet - 1.0) * std::exp(Peclet) + 1) / (Peclet * (std::exp(Peclet) - 1.) + 1e-10);
    default:
      mooseError(name(),
                 ": Interpolation scheme should be a string: upwind, downwind, central_difference, "
                 "exponential");
  }
}

Referenced by computeDP(), QuadSubChannel1PhaseProblem::computeh(), TriSubChannel1PhaseProblem::computeh(), computeInterpolatedValue(), computeP(), and computeWijResidual().

computeMdot()

void SubChannel1PhaseProblem::computeMdot ( int  iblock )

protected

Computes mass flow per channel for block iblock.

Definition at line 687 of file SubChannel1PhaseProblem.C.

{
  const unsigned int last_node = (iblock + 1) * _block_size;
  const unsigned int first_node = iblock * _block_size + 1;
  if (!_implicit_bool)
  {
    for (unsigned int iz = first_node; iz < last_node + 1; iz++)
    {
      auto dz = _z_grid[iz] - _z_grid[iz - 1];
      for (unsigned int i_ch = 0; i_ch < _n_channels; i_ch++)
      {
        auto * node_in = _subchannel_mesh.getChannelNode(i_ch, iz - 1);
        auto * node_out = _subchannel_mesh.getChannelNode(i_ch, iz);
        auto volume = dz * (*_S_flow_soln)(node_in);
        auto time_term = _TR * ((*_rho_soln)(node_out)-_rho_soln->old(node_out)) * volume / _dt;
        // Wij positive out of i into j;
        auto mdot_out = (*_mdot_soln)(node_in) - (*_SumWij_soln)(node_out)-time_term;
        if (mdot_out < 0)
        {
          _console << "Wij = : " << _Wij << "\n";
          mooseError(name(),
                     " : Calculation of negative mass flow mdot_out = : ",
                     mdot_out,
                     " Axial Level= : ",
                     iz,
                     " - Implicit solves are required for recirculating flow.");
        }
        _mdot_soln->set(node_out, mdot_out); // kg/sec
      }
    }
  }
  else
  {
    for (unsigned int iz = first_node; iz < last_node + 1; iz++)
    {
      auto dz = _z_grid[iz] - _z_grid[iz - 1];
      auto iz_ind = iz - first_node;
      for (unsigned int i_ch = 0; i_ch < _n_channels; i_ch++)
      {
        auto * node_in = _subchannel_mesh.getChannelNode(i_ch, iz - 1);
        auto * node_out = _subchannel_mesh.getChannelNode(i_ch, iz);
        auto volume = dz * (*_S_flow_soln)(node_in);
 
        // Adding time derivative to the RHS
        auto time_term = _TR * ((*_rho_soln)(node_out)-_rho_soln->old(node_out)) * volume / _dt;
        PetscInt row_vec = i_ch + _n_channels * iz_ind;
        PetscScalar value_vec = -1.0 * time_term;
        LibmeshPetscCall(
            VecSetValues(_mc_axial_convection_rhs, 1, &row_vec, &value_vec, INSERT_VALUES));
 
        // Linearize transient density with respect to pressure at constant enthalpy. The
        // temperature response at constant h is required even for a rho(T)-only liquid model:
        //
        //   (d rho / d p)_h = (d rho / d p)_T
        //                      - (d rho / d T)_p (d h / d p)_T / (d h / d T)_p.
        //
        // Without this Jacobian contribution, pressure-density coupling remains in the outer
        // fixed-point iteration and scales as O(1 / dt). As the time step decreases, the iteration
        // can become increasingly slow or noncontractive and may require stronger relaxation.
        if (_TR && _compute_density && _compute_power && iz < last_node)
        {
          Real rho, drho_dp_T, drho_dT;
          _fp->rho_from_p_T(
              (*_P_soln)(node_out) + _P_out, (*_T_soln)(node_out), rho, drho_dp_T, drho_dT);
          Real h, dh_dp_T, dh_dT;
          _fp->h_from_p_T((*_P_soln)(node_out) + _P_out, (*_T_soln)(node_out), h, dh_dp_T, dh_dT);
          const Real drho_dp_h = drho_dp_T - drho_dT * dh_dp_T / dh_dT;
          const PetscScalar pressure_coefficient = volume / _dt * drho_dp_h;
          const PetscInt pressure_col = i_ch + _n_channels * (iz_ind + 1);
          LibmeshPetscCall(MatSetValues(_mc_density_pressure_mat,
                                        1,
                                        &row_vec,
                                        1,
                                        &pressure_col,
                                        &pressure_coefficient,
                                        INSERT_VALUES));
          const PetscScalar linearization_rhs = pressure_coefficient * (*_P_soln)(node_out);
          LibmeshPetscCall(
              VecSetValues(_mc_axial_convection_rhs, 1, &row_vec, &linearization_rhs, ADD_VALUES));
        }
 
        // Imposing bottom boundary condition or adding of diagonal elements
        if (iz == first_node)
        {
          PetscScalar value_vec = (*_mdot_soln)(node_in);
          PetscInt row_vec = i_ch + _n_channels * iz_ind;
          LibmeshPetscCall(
              VecSetValues(_mc_axial_convection_rhs, 1, &row_vec, &value_vec, ADD_VALUES));
        }
        else
        {
          PetscInt row = i_ch + _n_channels * iz_ind;
          PetscInt col = i_ch + _n_channels * (iz_ind - 1);
          PetscScalar value = -1.0;
          LibmeshPetscCall(
              MatSetValues(_mc_axial_convection_mat, 1, &row, 1, &col, &value, INSERT_VALUES));
        }
 
        // Adding diagonal elements
        PetscInt row = i_ch + _n_channels * iz_ind;
        PetscInt col = i_ch + _n_channels * iz_ind;
        PetscScalar value = 1.0;
        LibmeshPetscCall(
            MatSetValues(_mc_axial_convection_mat, 1, &row, 1, &col, &value, INSERT_VALUES));
 
        // Adding cross flows RHS
        if (_segregated_bool)
        {
          PetscScalar value_vec_2 = -1.0 * (*_SumWij_soln)(node_out);
          PetscInt row_vec_2 = i_ch + _n_channels * iz_ind;
          LibmeshPetscCall(
              VecSetValues(_mc_axial_convection_rhs, 1, &row_vec_2, &value_vec_2, ADD_VALUES));
        }
      }
    }
    LibmeshPetscCall(MatAssemblyBegin(_mc_axial_convection_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(MatAssemblyEnd(_mc_axial_convection_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(MatAssemblyBegin(_mc_density_pressure_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(MatAssemblyEnd(_mc_density_pressure_mat, MAT_FINAL_ASSEMBLY));
 
    if (_segregated_bool)
    {
      KSP ksploc;
      PC pc;
      Vec sol;
      LibmeshPetscCall(VecDuplicate(_mc_axial_convection_rhs, &sol));
      LibmeshPetscCall(KSPCreate(PETSC_COMM_SELF, &ksploc));
      LibmeshPetscCall(KSPSetOperators(ksploc, _mc_axial_convection_mat, _mc_axial_convection_mat));
      LibmeshPetscCall(KSPGetPC(ksploc, &pc));
      LibmeshPetscCall(PCSetType(pc, PCJACOBI));
      LibmeshPetscCall(KSPSetTolerances(ksploc, _rtol, _atol, _dtol, _maxit));
      LibmeshPetscCall(KSPSetFromOptions(ksploc));
      LibmeshPetscCall(KSPSolve(ksploc, _mc_axial_convection_rhs, sol));
      LibmeshPetscCall(populateSolutionChan<SolutionHandle>(
          sol, *_mdot_soln, first_node, last_node, _n_channels));
      LibmeshPetscCall(VecZeroEntries(_mc_axial_convection_rhs));
      LibmeshPetscCall(KSPDestroy(&ksploc));
      LibmeshPetscCall(VecDestroy(&sol));
    }
  }
}

Referenced by implicitPetscSolve(), and residualFunction().

computeMixingParameter()

Real SubChannel1PhaseProblem::computeMixingParameter ( unsigned int  i_gap, unsigned int  iz  ) const

protected

Computes and validates the turbulent mixing parameter.

Definition at line 2050 of file SubChannel1PhaseProblem.C.

{
  auto beta = _mixing_closure->computeMixingParameter(i_gap, iz);
  if (!std::isfinite(beta) || beta < 0.0)
    mooseError(name(),
               ": Mixing closure returned invalid beta = ",
               beta,
               " for gap ",
               i_gap,
               " at axial index ",
               iz,
               ". Beta must be finite and non-negative.");
 
  return beta;
}

Referenced by computeWijPrime().

computeMu()

void SubChannel1PhaseProblem::computeMu ( int  iblock )

protected

Computes Viscosity per channel for block iblock.

Definition at line 1607 of file SubChannel1PhaseProblem.C.

{
  const unsigned int last_node = (iblock + 1) * _block_size;
  const unsigned int first_node = iblock * _block_size + 1;
  if (iblock == 0)
  {
    for (unsigned int i_ch = 0; i_ch < _n_channels; i_ch++)
    {
      auto * node = _subchannel_mesh.getChannelNode(i_ch, 0);
      _mu_soln->set(node, _fp->mu_from_p_T((*_P_soln)(node) + _P_out, (*_T_soln)(node)));
    }
  }
  for (unsigned int iz = first_node; iz < last_node + 1; iz++)
  {
    for (unsigned int i_ch = 0; i_ch < _n_channels; i_ch++)
    {
      auto * node = _subchannel_mesh.getChannelNode(i_ch, iz);
      _mu_soln->set(node, _fp->mu_from_p_T((*_P_soln)(node) + _P_out, (*_T_soln)(node)));
    }
  }
}

Referenced by externalSolve().

computeP()

void SubChannel1PhaseProblem::computeP ( int  iblock )

protected

Computes Pressure per channel for block iblock.

Definition at line 1316 of file SubChannel1PhaseProblem.C.

{
  const unsigned int last_node = (iblock + 1) * _block_size;
  const unsigned int first_node = iblock * _block_size + 1;
  if (!_implicit_bool)
  {
    if (!_staggered_pressure_bool)
    {
      for (unsigned int iz = last_node; iz > first_node - 1; iz--)
      {
        // Calculate pressure in the inlet of the cell assuming known outlet
        for (unsigned int i_ch = 0; i_ch < _n_channels; i_ch++)
        {
          auto * node_out = _subchannel_mesh.getChannelNode(i_ch, iz);
          auto * node_in = _subchannel_mesh.getChannelNode(i_ch, iz - 1);
          // update Pressure solution
          _P_soln->set(node_in, (*_P_soln)(node_out) + _DP(i_ch, iz));
        }
      }
    }
    else
    {
      for (unsigned int iz = last_node; iz > first_node - 1; iz--)
      {
        // Calculate pressure in the inlet of the cell assuming known outlet
        for (unsigned int i_ch = 0; i_ch < _n_channels; i_ch++)
        {
          auto * node_out = _subchannel_mesh.getChannelNode(i_ch, iz);
          auto * node_in = _subchannel_mesh.getChannelNode(i_ch, iz - 1);
          // update Pressure solution
          // Note: assuming uniform axial discretization in the curren code
          // We will need to update this later if we allow non-uniform refinements in the axial
          // direction
          PetscScalar Pe = 0.5;
          auto alpha = computeInterpolationCoefficients(Pe);
          if (iz == last_node)
          {
            _P_soln->set(node_in, (*_P_soln)(node_out) + _DP(i_ch, iz) / 2.0);
          }
          else
          {
            _P_soln->set(node_in,
                         (*_P_soln)(node_out) + (1.0 - alpha) * _DP(i_ch, iz) +
                             alpha * _DP(i_ch, iz - 1));
          }
        }
      }
    }
  }
  else
  {
    if (!_staggered_pressure_bool)
    {
      LibmeshPetscCall(VecZeroEntries(_amc_pressure_force_rhs));
      for (unsigned int iz = last_node; iz > first_node - 1; iz--)
      {
        auto iz_ind = iz - first_node;
        // Calculate pressure in the inlet of the cell assuming known outlet
        for (unsigned int i_ch = 0; i_ch < _n_channels; i_ch++)
        {
          auto * node_out = _subchannel_mesh.getChannelNode(i_ch, iz);
          auto * node_in = _subchannel_mesh.getChannelNode(i_ch, iz - 1);
 
          // inlet, outlet, and interpolated axial surface area
          auto S_in = (*_S_flow_soln)(node_in);
          auto S_out = (*_S_flow_soln)(node_out);
          auto S_interp = computeInterpolatedValue(S_out, S_in, 0.5);
 
          // Creating matrix of coefficients
          PetscInt row = i_ch + _n_channels * iz_ind;
          PetscInt col = i_ch + _n_channels * iz_ind;
          PetscScalar value = -1.0 * S_interp;
          LibmeshPetscCall(
              MatSetValues(_amc_pressure_force_mat, 1, &row, 1, &col, &value, INSERT_VALUES));
 
          if (iz == last_node)
          {
            PetscScalar value = -1.0 * (*_P_soln)(node_out)*S_interp;
            PetscInt row = i_ch + _n_channels * iz_ind;
            LibmeshPetscCall(VecSetValues(_amc_pressure_force_rhs, 1, &row, &value, ADD_VALUES));
          }
          else
          {
            PetscInt row = i_ch + _n_channels * iz_ind;
            PetscInt col = i_ch + _n_channels * (iz_ind + 1);
            PetscScalar value = 1.0 * S_interp;
            LibmeshPetscCall(
                MatSetValues(_amc_pressure_force_mat, 1, &row, 1, &col, &value, INSERT_VALUES));
          }
 
          if (_segregated_bool)
          {
            auto dp_out = _DP(i_ch, iz);
            PetscScalar value_v = -1.0 * dp_out * S_interp;
            PetscInt row_v = i_ch + _n_channels * iz_ind;
            LibmeshPetscCall(
                VecSetValues(_amc_pressure_force_rhs, 1, &row_v, &value_v, ADD_VALUES));
          }
        }
      }
      // Solving pressure problem
      LibmeshPetscCall(MatAssemblyBegin(_amc_pressure_force_mat, MAT_FINAL_ASSEMBLY));
      LibmeshPetscCall(MatAssemblyEnd(_amc_pressure_force_mat, MAT_FINAL_ASSEMBLY));
      if (_segregated_bool)
      {
        KSP ksploc;
        PC pc;
        Vec sol;
        LibmeshPetscCall(VecDuplicate(_amc_pressure_force_rhs, &sol));
        LibmeshPetscCall(KSPCreate(PETSC_COMM_SELF, &ksploc));
        LibmeshPetscCall(KSPSetOperators(ksploc, _amc_pressure_force_mat, _amc_pressure_force_mat));
        LibmeshPetscCall(KSPGetPC(ksploc, &pc));
        LibmeshPetscCall(PCSetType(pc, PCJACOBI));
        LibmeshPetscCall(KSPSetTolerances(ksploc, _rtol, _atol, _dtol, _maxit));
        LibmeshPetscCall(KSPSetFromOptions(ksploc));
        LibmeshPetscCall(KSPSolve(ksploc, _amc_pressure_force_rhs, sol));
        PetscScalar * xx;
        LibmeshPetscCall(VecGetArray(sol, &xx));
        // update Pressure solution
        for (unsigned int iz = last_node; iz > first_node - 1; iz--)
        {
          auto iz_ind = iz - first_node;
          for (unsigned int i_ch = 0; i_ch < _n_channels; i_ch++)
          {
            auto * node_in = _subchannel_mesh.getChannelNode(i_ch, iz - 1);
            PetscScalar value = xx[iz_ind * _n_channels + i_ch];
            _P_soln->set(node_in, value);
          }
        }
        LibmeshPetscCall(VecZeroEntries(_amc_pressure_force_rhs));
        LibmeshPetscCall(KSPDestroy(&ksploc));
        LibmeshPetscCall(VecDestroy(&sol));
      }
    }
    else
    {
      LibmeshPetscCall(VecZeroEntries(_amc_pressure_force_rhs));
      for (unsigned int iz = last_node; iz > first_node - 1; iz--)
      {
        auto iz_ind = iz - first_node;
        // Calculate pressure in the inlet of the cell assuming known outlet
        for (unsigned int i_ch = 0; i_ch < _n_channels; i_ch++)
        {
          auto * node_out = _subchannel_mesh.getChannelNode(i_ch, iz);
          auto * node_in = _subchannel_mesh.getChannelNode(i_ch, iz - 1);
 
          // inlet, outlet, and interpolated axial surface area
          auto S_in = (*_S_flow_soln)(node_in);
          auto S_out = (*_S_flow_soln)(node_out);
          auto S_interp = computeInterpolatedValue(S_out, S_in, 0.5);
 
          // Creating matrix of coefficients
          PetscInt row = i_ch + _n_channels * iz_ind;
          PetscInt col = i_ch + _n_channels * iz_ind;
          PetscScalar value = -1.0 * S_interp;
          LibmeshPetscCall(
              MatSetValues(_amc_pressure_force_mat, 1, &row, 1, &col, &value, INSERT_VALUES));
 
          if (iz == last_node)
          {
            PetscScalar value = -1.0 * (*_P_soln)(node_out)*S_interp;
            PetscInt row = i_ch + _n_channels * iz_ind;
            LibmeshPetscCall(VecSetValues(_amc_pressure_force_rhs, 1, &row, &value, ADD_VALUES));
 
            auto dp_out = _DP(i_ch, iz);
            PetscScalar value_v = -1.0 * dp_out / 2.0 * S_interp;
            PetscInt row_v = i_ch + _n_channels * iz_ind;
            LibmeshPetscCall(
                VecSetValues(_amc_pressure_force_rhs, 1, &row_v, &value_v, ADD_VALUES));
          }
          else
          {
            PetscInt row = i_ch + _n_channels * iz_ind;
            PetscInt col = i_ch + _n_channels * (iz_ind + 1);
            PetscScalar value = 1.0 * S_interp;
            LibmeshPetscCall(
                MatSetValues(_amc_pressure_force_mat, 1, &row, 1, &col, &value, INSERT_VALUES));
 
            if (_segregated_bool)
            {
              auto dp_in = _DP(i_ch, iz - 1);
              auto dp_out = _DP(i_ch, iz);
              auto dp_interp = computeInterpolatedValue(dp_out, dp_in, 0.5);
              PetscScalar value_v = -1.0 * dp_interp * S_interp;
              PetscInt row_v = i_ch + _n_channels * iz_ind;
              LibmeshPetscCall(
                  VecSetValues(_amc_pressure_force_rhs, 1, &row_v, &value_v, ADD_VALUES));
            }
          }
        }
      }
      // Solving pressure problem
      LibmeshPetscCall(MatAssemblyBegin(_amc_pressure_force_mat, MAT_FINAL_ASSEMBLY));
      LibmeshPetscCall(MatAssemblyEnd(_amc_pressure_force_mat, MAT_FINAL_ASSEMBLY));
      if (_verbose_subchannel)
        _console << "Block: " << iblock << " - Axial momentum pressure force matrix assembled"
                 << std::endl;
 
      if (_segregated_bool)
      {
        KSP ksploc;
        PC pc;
        Vec sol;
        LibmeshPetscCall(VecDuplicate(_amc_pressure_force_rhs, &sol));
        LibmeshPetscCall(KSPCreate(PETSC_COMM_SELF, &ksploc));
        LibmeshPetscCall(KSPSetOperators(ksploc, _amc_pressure_force_mat, _amc_pressure_force_mat));
        LibmeshPetscCall(KSPGetPC(ksploc, &pc));
        LibmeshPetscCall(PCSetType(pc, PCJACOBI));
        LibmeshPetscCall(KSPSetTolerances(ksploc, _rtol, _atol, _dtol, _maxit));
        LibmeshPetscCall(KSPSetFromOptions(ksploc));
        LibmeshPetscCall(KSPSolve(ksploc, _amc_pressure_force_rhs, sol));
        PetscScalar * xx;
        LibmeshPetscCall(VecGetArray(sol, &xx));
        // update Pressure solution
        for (unsigned int iz = last_node; iz > first_node - 1; iz--)
        {
          auto iz_ind = iz - first_node;
          for (unsigned int i_ch = 0; i_ch < _n_channels; i_ch++)
          {
            auto * node_in = _subchannel_mesh.getChannelNode(i_ch, iz - 1);
            PetscScalar value = xx[iz_ind * _n_channels + i_ch];
            _P_soln->set(node_in, value);
          }
        }
        LibmeshPetscCall(VecZeroEntries(_amc_pressure_force_rhs));
        LibmeshPetscCall(KSPDestroy(&ksploc));
        LibmeshPetscCall(VecDestroy(&sol));
      }
    }
  }
}

Referenced by implicitPetscSolve(), and residualFunction().

computeRho()

void SubChannel1PhaseProblem::computeRho ( int  iblock )

protected

Computes Density per channel for block iblock.

Definition at line 1584 of file SubChannel1PhaseProblem.C.

{
  const unsigned int last_node = (iblock + 1) * _block_size;
  const unsigned int first_node = iblock * _block_size + 1;
  if (iblock == 0)
  {
    for (unsigned int i_ch = 0; i_ch < _n_channels; i_ch++)
    {
      auto * node = _subchannel_mesh.getChannelNode(i_ch, 0);
      _rho_soln->set(node, _fp->rho_from_p_T((*_P_soln)(node) + _P_out, (*_T_soln)(node)));
    }
  }
  for (unsigned int iz = first_node; iz < last_node + 1; iz++)
  {
    for (unsigned int i_ch = 0; i_ch < _n_channels; i_ch++)
    {
      auto * node = _subchannel_mesh.getChannelNode(i_ch, iz);
      _rho_soln->set(node, _fp->rho_from_p_T((*_P_soln)(node) + _P_out, (*_T_soln)(node)));
    }
  }
}

Referenced by externalSolve().

computeSumWij()

void SubChannel1PhaseProblem::computeSumWij ( int  iblock )

protected

Computes net diversion crossflow per channel for block iblock.

Definition at line 621 of file SubChannel1PhaseProblem.C.

{
  const unsigned int last_node = (iblock + 1) * _block_size;
  const unsigned int first_node = iblock * _block_size + 1;
  // Add to solution vector if explicit
  if (!_implicit_bool)
  {
    for (unsigned int iz = first_node; iz < last_node + 1; iz++)
    {
      for (unsigned int i_ch = 0; i_ch < _n_channels; i_ch++)
      {
        auto * node_out = _subchannel_mesh.getChannelNode(i_ch, iz);
        Real sumWij = 0.0;
        // Calculate sum of crossflow into channel i from channels j around i
        unsigned int counter = 0;
        for (auto i_gap : _subchannel_mesh.getChannelGaps(i_ch))
        {
          sumWij += _subchannel_mesh.getCrossflowSign(i_ch, counter) * _Wij(i_gap, iz);
          counter++;
        }
        // The net crossflow coming out of cell i [kg/sec]
        _SumWij_soln->set(node_out, sumWij);
      }
    }
  }
  // Add to matrix if implicit
  else
  {
    LibmeshPetscCall(MatZeroEntries(_mc_density_pressure_mat));
    for (unsigned int iz = first_node; iz < last_node + 1; iz++)
    {
      unsigned int iz_ind = iz - first_node;
      for (unsigned int i_ch = 0; i_ch < _n_channels; i_ch++)
      {
        // Calculate sum of crossflow into channel i from channels j around i
        unsigned int counter = 0;
        for (auto i_gap : _subchannel_mesh.getChannelGaps(i_ch))
        {
          PetscInt row = i_ch + _n_channels * iz_ind;
          PetscInt col = i_gap + _n_gaps * iz_ind;
          PetscScalar value = _subchannel_mesh.getCrossflowSign(i_ch, counter);
          LibmeshPetscCall(MatSetValues(_mc_sumWij_mat, 1, &row, 1, &col, &value, INSERT_VALUES));
          counter++;
        }
      }
    }
    LibmeshPetscCall(MatAssemblyBegin(_mc_sumWij_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(MatAssemblyEnd(_mc_sumWij_mat, MAT_FINAL_ASSEMBLY));
    if (_segregated_bool)
    {
      Vec loc_prod;
      Vec loc_Wij;
      LibmeshPetscCall(VecDuplicate(_amc_sys_mdot_rhs, &loc_prod));
      LibmeshPetscCall(VecDuplicate(_Wij_vec, &loc_Wij));
      LibmeshPetscCall(populateVectorFromDense<libMesh::DenseMatrix<Real>>(
          loc_Wij, _Wij, first_node, last_node, _n_gaps));
      LibmeshPetscCall(MatMult(_mc_sumWij_mat, loc_Wij, loc_prod));
      LibmeshPetscCall(populateSolutionChan<SolutionHandle>(
          loc_prod, *_SumWij_soln, first_node, last_node, _n_channels));
      LibmeshPetscCall(VecDestroy(&loc_prod));
      LibmeshPetscCall(VecDestroy(&loc_Wij));
    }
  }
}

Referenced by implicitPetscSolve(), and residualFunction().

computeSweepFlowMixingParameter()

Real SubChannel1PhaseProblem::computeSweepFlowMixingParameter ( unsigned int  i_gap, unsigned int  iz  ) const

protected

Computes and validates the sweep-flow mixing parameter.

Definition at line 2067 of file SubChannel1PhaseProblem.C.

{
  auto beta = _mixing_closure->computeSweepFlowMixingParameter(i_gap, iz);
  if (!std::isfinite(beta) || beta < 0.0)
    mooseError(name(),
               ": Mixing closure returned invalid sweep-flow coefficient = ",
               beta,
               " for gap ",
               i_gap,
               " at axial index ",
               iz,
               ". sweep-flow coefficient must be finite and non-negative.");
 
  return beta;
}

Referenced by TriSubChannel1PhaseProblem::computeh().

computeT()

Real SubChannel1PhaseProblem::computeT ( int  iblock )

protected

Computes and relaxes Temperature per channel for block iblock.

Returns

The normalized norm of (T - T_prev).

Definition at line 1549 of file SubChannel1PhaseProblem.C.

{
  const unsigned int last_node = (iblock + 1) * _block_size;
  const unsigned int first_node = iblock * _block_size + 1;
  std::vector<Real> residual;
  residual.reserve(_block_size * _n_channels);
  Real residual_norm_sq = 0.0;
  Real temperature_norm_sq = 0.0;
  for (unsigned int iz = first_node; iz < last_node + 1; iz++)
  {
    for (unsigned int i_ch = 0; i_ch < _n_channels; i_ch++)
    {
      auto * node = _subchannel_mesh.getChannelNode(i_ch, iz);
      const Real T = (*_T_soln)(node);
      const Real T_from_ph = _fp->T_from_p_h((*_P_soln)(node) + _P_out, (*_h_soln)(node));
      residual.push_back(T_from_ph - T);
      residual_norm_sq += Utility::pow<2>(residual.back());
      temperature_norm_sq += Utility::pow<2>(T);
    }
  }
 
  // Set the temperature solution with relaxation if needed
  std::size_t i = 0;
  for (unsigned int iz = first_node; iz < last_node + 1; iz++)
    for (unsigned int i_ch = 0; i_ch < _n_channels; i_ch++)
    {
      auto * node = _subchannel_mesh.getChannelNode(i_ch, iz);
      _T_soln->set(node, (*_T_soln)(node) + _T_relaxation * residual[i]);
      ++i;
    }
 
  return std::sqrt(residual_norm_sq) / (std::sqrt(temperature_norm_sq) + 1e-14);
}

Referenced by externalSolve().

computeWijFromSolve()

void SubChannel1PhaseProblem::computeWijFromSolve ( int  iblock )

protected

Computes diversion crossflow per gap for block iblock.

Definition at line 588 of file SubChannel1PhaseProblem.C.

{
  const unsigned int last_node = (iblock + 1) * _block_size;
  const unsigned int first_node = iblock * _block_size + 1;
  // Initial guess, port crossflow of block (iblock) into a vector that will act as my initial guess
  libMesh::DenseVector<Real> solution_seed(_n_gaps * _block_size, 0.0);
  for (unsigned int iz = first_node; iz < last_node + 1; iz++)
  {
    for (unsigned int i_gap = 0; i_gap < _n_gaps; i_gap++)
    {
      int i = _n_gaps * (iz - first_node) + i_gap; // column wise transfer
      solution_seed(i) = _Wij(i_gap, iz);
    }
  }
 
  // Solving the combined lateral momentum equation for Wij using a PETSc solver and update vector
  // root
  libMesh::DenseVector<Real> root(_n_gaps * _block_size, 0.0);
  LibmeshPetscCall(petscSnesSolver(iblock, solution_seed, root));
 
  // Assign the solution to the cross-flow matrix
  int i = 0;
  for (unsigned int iz = first_node; iz < last_node + 1; iz++)
  {
    for (unsigned int i_gap = 0; i_gap < _n_gaps; i_gap++)
    {
      _Wij(i_gap, iz) = root(i);
      i++;
    }
  }
}

Referenced by externalSolve().

computeWijPrime()

void SubChannel1PhaseProblem::computeWijPrime ( int  iblock )

protected

Computes turbulent crossflow per gap for block iblock.

Update turbulent crossflow

Definition at line 1949 of file SubChannel1PhaseProblem.C.

{
  const unsigned int last_node = (iblock + 1) * _block_size;
  const unsigned int first_node = iblock * _block_size + 1;
  _mixing_closure->computeBlockMixingParameters(first_node, last_node);
  for (unsigned int iz = first_node; iz < last_node + 1; iz++)
  {
    auto dz = _z_grid[iz] - _z_grid[iz - 1];
    for (unsigned int i_gap = 0; i_gap < _n_gaps; i_gap++)
    {
      auto chans = _subchannel_mesh.getGapChannels(i_gap);
      unsigned int i_ch = chans.first;
      unsigned int j_ch = chans.second;
      auto * node_in_i = _subchannel_mesh.getChannelNode(i_ch, iz - 1);
      auto * node_out_i = _subchannel_mesh.getChannelNode(i_ch, iz);
      auto * node_in_j = _subchannel_mesh.getChannelNode(j_ch, iz - 1);
      auto * node_out_j = _subchannel_mesh.getChannelNode(j_ch, iz);
      auto Si_in = (*_S_flow_soln)(node_in_i);
      auto Sj_in = (*_S_flow_soln)(node_in_j);
      auto Si_out = (*_S_flow_soln)(node_out_i);
      auto Sj_out = (*_S_flow_soln)(node_out_j);
      auto gap = _subchannel_mesh.getGapWidth(iz, i_gap);
      auto Sij = dz * gap;
      // Mass flux of the gap: total mass flow rate of the two subchannels over their total flow
      // area, averaged over the inlet and outlet of the cell. This is the area-weighted mean of rho
      // V of the two subchannels; Eq. (30) of Pacio et al. (2022) uses the arithmetic mean rho (V_i
      // + V_j) / 2, which differs when the two subchannels have different flow areas
      auto avg_massflux =
          0.5 * (((*_mdot_soln)(node_in_i) + (*_mdot_soln)(node_in_j)) / (Si_in + Sj_in) +
                 ((*_mdot_soln)(node_out_i) + (*_mdot_soln)(node_out_j)) / (Si_out + Sj_out));
      auto beta = computeMixingParameter(i_gap, iz);
 
      if (!_implicit_bool)
      {
        _WijPrime(i_gap, iz) = beta * avg_massflux * Sij;
      }
      else
      {
        auto iz_ind = iz - first_node;
        PetscScalar base_value = beta * 0.5 * Sij;
 
        // Bottom values
        if (iz == first_node)
        {
          PetscScalar value_tl = -1.0 * base_value / (Si_in + Sj_in) *
                                 ((*_mdot_soln)(node_in_i) + (*_mdot_soln)(node_in_j));
          PetscInt row = i_gap + _n_gaps * iz_ind;
          LibmeshPetscCall(
              VecSetValues(_amc_turbulent_cross_flows_rhs, 1, &row, &value_tl, INSERT_VALUES));
        }
        else
        {
          PetscScalar value_tl = base_value / (Si_in + Sj_in);
          PetscInt row = i_gap + _n_gaps * iz_ind;
 
          PetscInt col_ich = i_ch + _n_channels * (iz_ind - 1);
          LibmeshPetscCall(MatSetValues(
              _amc_turbulent_cross_flows_mat, 1, &row, 1, &col_ich, &value_tl, INSERT_VALUES));
 
          PetscInt col_jch = j_ch + _n_channels * (iz_ind - 1);
          LibmeshPetscCall(MatSetValues(
              _amc_turbulent_cross_flows_mat, 1, &row, 1, &col_jch, &value_tl, INSERT_VALUES));
        }
 
        // Top values
        PetscScalar value_bl = base_value / (Si_out + Sj_out);
        PetscInt row = i_gap + _n_gaps * iz_ind;
 
        PetscInt col_ich = i_ch + _n_channels * iz_ind;
        LibmeshPetscCall(MatSetValues(
            _amc_turbulent_cross_flows_mat, 1, &row, 1, &col_ich, &value_bl, INSERT_VALUES));
 
        PetscInt col_jch = j_ch + _n_channels * iz_ind;
        LibmeshPetscCall(MatSetValues(
            _amc_turbulent_cross_flows_mat, 1, &row, 1, &col_jch, &value_bl, INSERT_VALUES));
      }
    }
  }
 
  if (_implicit_bool)
  {
    LibmeshPetscCall(MatAssemblyBegin(_amc_turbulent_cross_flows_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(MatAssemblyEnd(_amc_turbulent_cross_flows_mat, MAT_FINAL_ASSEMBLY));
 
    Vec loc_prod;
    Vec loc_Wij;
    LibmeshPetscCall(VecDuplicate(_amc_sys_mdot_rhs, &loc_prod));
    LibmeshPetscCall(VecDuplicate(_Wij_vec, &loc_Wij));
    LibmeshPetscCall(populateVectorFromHandle<SolutionHandle>(
        loc_prod, *_mdot_soln, first_node, last_node, _n_channels));
    LibmeshPetscCall(MatMult(_amc_turbulent_cross_flows_mat, loc_prod, loc_Wij));
    LibmeshPetscCall(VecAXPY(loc_Wij, -1.0, _amc_turbulent_cross_flows_rhs));
    LibmeshPetscCall(populateDenseFromVector<libMesh::DenseMatrix<Real>>(
        loc_Wij, _WijPrime, first_node, last_node, _n_gaps));
    LibmeshPetscCall(VecDestroy(&loc_prod));
    LibmeshPetscCall(VecDestroy(&loc_Wij));
  }
}

Referenced by externalSolve(), implicitPetscSolve(), and residualFunction().

computeWijResidual()

void SubChannel1PhaseProblem::computeWijResidual ( int  iblock )

protected

Computes Residual Matrix based on the lateral momentum conservation equation for block iblock.

Assembling system

Definition at line 1630 of file SubChannel1PhaseProblem.C.

{
  const unsigned int last_node = (iblock + 1) * _block_size;
  const unsigned int first_node = iblock * _block_size + 1;
  // Cross flow residual
  if (!_implicit_bool)
  {
    const Real & pitch = _subchannel_mesh.getPitch();
    for (unsigned int iz = first_node; iz < last_node + 1; iz++)
    {
      auto dz = _z_grid[iz] - _z_grid[iz - 1];
      for (unsigned int i_gap = 0; i_gap < _n_gaps; i_gap++)
      {
        auto chans = _subchannel_mesh.getGapChannels(i_gap);
        unsigned int i_ch = chans.first;
        unsigned int j_ch = chans.second;
        auto * node_in_i = _subchannel_mesh.getChannelNode(i_ch, iz - 1);
        auto * node_out_i = _subchannel_mesh.getChannelNode(i_ch, iz);
        auto * node_in_j = _subchannel_mesh.getChannelNode(j_ch, iz - 1);
        auto * node_out_j = _subchannel_mesh.getChannelNode(j_ch, iz);
        auto rho_i = (*_rho_soln)(node_in_i);
        auto rho_j = (*_rho_soln)(node_in_j);
        auto Si = (*_S_flow_soln)(node_in_i);
        auto Sj = (*_S_flow_soln)(node_in_j);
        auto Sij = dz * _subchannel_mesh.getGapWidth(iz, i_gap);
        auto Lij = pitch;
        // total local form loss in the ij direction
        auto friction_term = _kij * _Wij(i_gap, iz) * std::abs(_Wij(i_gap, iz));
        auto DPij = (*_P_soln)(node_in_i) - (*_P_soln)(node_in_j);
        // Figure out donor cell density
        auto rho_star = 0.0;
        if (_Wij(i_gap, iz) > 0.0)
          rho_star = rho_i;
        else if (_Wij(i_gap, iz) < 0.0)
          rho_star = rho_j;
        else
          rho_star = (rho_i + rho_j) / 2.0;
        auto mass_term_out =
            (*_mdot_soln)(node_out_i) / (*_S_flow_soln)(node_out_i) / (*_rho_soln)(node_out_i) +
            (*_mdot_soln)(node_out_j) / (*_S_flow_soln)(node_out_j) / (*_rho_soln)(node_out_j);
        auto mass_term_in =
            (*_mdot_soln)(node_in_i) / Si / rho_i + (*_mdot_soln)(node_in_j) / Sj / rho_j;
        auto term_out = Sij * rho_star * (Lij / dz) * mass_term_out * _Wij(i_gap, iz);
        auto term_in = Sij * rho_star * (Lij / dz) * mass_term_in * _Wij(i_gap, iz - 1);
        auto inertia_term = term_out - term_in;
        auto pressure_term = 2 * Utility::pow<2>(Sij) * DPij * rho_star;
        auto time_term =
            _TR * 2.0 * (_Wij(i_gap, iz) - _Wij_old(i_gap, iz)) * Lij * Sij * rho_star / _dt;
 
        _Wij_residual_matrix(i_gap, iz - 1 - iblock * _block_size) =
            time_term + friction_term + inertia_term - pressure_term;
      }
    }
  }
  else
  {
    // Initializing to zero the elements of the lateral momentum assembly
    LibmeshPetscCall(MatZeroEntries(_cmc_time_derivative_mat));
    LibmeshPetscCall(MatZeroEntries(_cmc_advective_derivative_mat));
    LibmeshPetscCall(MatZeroEntries(_cmc_friction_force_mat));
    LibmeshPetscCall(MatZeroEntries(_cmc_pressure_force_mat));
    LibmeshPetscCall(VecZeroEntries(_cmc_time_derivative_rhs));
    LibmeshPetscCall(VecZeroEntries(_cmc_advective_derivative_rhs));
    LibmeshPetscCall(VecZeroEntries(_cmc_friction_force_rhs));
    LibmeshPetscCall(VecZeroEntries(_cmc_pressure_force_rhs));
    LibmeshPetscCall(MatZeroEntries(_cmc_sys_Wij_mat));
    LibmeshPetscCall(VecZeroEntries(_cmc_sys_Wij_rhs));
    const Real & pitch = _subchannel_mesh.getPitch();
    for (unsigned int iz = first_node; iz < last_node + 1; iz++)
    {
      auto dz = _z_grid[iz] - _z_grid[iz - 1];
      auto iz_ind = iz - first_node;
      for (unsigned int i_gap = 0; i_gap < _n_gaps; i_gap++)
      {
        auto chans = _subchannel_mesh.getGapChannels(i_gap);
        unsigned int i_ch = chans.first;
        unsigned int j_ch = chans.second;
        auto * node_in_i = _subchannel_mesh.getChannelNode(i_ch, iz - 1);
        auto * node_out_i = _subchannel_mesh.getChannelNode(i_ch, iz);
        auto * node_in_j = _subchannel_mesh.getChannelNode(j_ch, iz - 1);
        auto * node_out_j = _subchannel_mesh.getChannelNode(j_ch, iz);
 
        // inlet, outlet, and interpolated densities
        auto rho_i_in = (*_rho_soln)(node_in_i);
        auto rho_i_out = (*_rho_soln)(node_out_i);
        auto rho_i_interp = computeInterpolatedValue(rho_i_out, rho_i_in, 0.5);
        auto rho_j_in = (*_rho_soln)(node_in_j);
        auto rho_j_out = (*_rho_soln)(node_out_j);
        auto rho_j_interp = computeInterpolatedValue(rho_j_out, rho_j_in, 0.5);
 
        // inlet, outlet, and interpolated areas
        auto S_i_in = (*_S_flow_soln)(node_in_i);
        auto S_i_out = (*_S_flow_soln)(node_out_i);
        auto S_j_in = (*_S_flow_soln)(node_in_j);
        auto S_j_out = (*_S_flow_soln)(node_out_j);
 
        // Cross-sectional gap area
        auto Sij = dz * _subchannel_mesh.getGapWidth(iz, i_gap);
        auto Lij = pitch;
 
        // Figure out donor cell density
        auto rho_star = 0.0;
        if (_Wij(i_gap, iz) > 0.0)
          rho_star = rho_i_interp;
        else if (_Wij(i_gap, iz) < 0.0)
          rho_star = rho_j_interp;
        else
          rho_star = (rho_i_interp + rho_j_interp) / 2.0;
 
        // Assembling time derivative
        PetscScalar time_factor = _TR * Lij * Sij * rho_star / _dt;
        PetscInt row_td = i_gap + _n_gaps * iz_ind;
        PetscInt col_td = i_gap + _n_gaps * iz_ind;
        PetscScalar value_td = time_factor;
        LibmeshPetscCall(MatSetValues(
            _cmc_time_derivative_mat, 1, &row_td, 1, &col_td, &value_td, INSERT_VALUES));
        PetscScalar value_td_rhs = time_factor * _Wij_old(i_gap, iz);
        LibmeshPetscCall(
            VecSetValues(_cmc_time_derivative_rhs, 1, &row_td, &value_td_rhs, INSERT_VALUES));
 
        // Assembling inertial term
        PetscScalar Pe = 0.5;
        auto alpha = computeInterpolationCoefficients(Pe);
        auto mass_term_out = (*_mdot_soln)(node_out_i) / S_i_out / rho_i_out +
                             (*_mdot_soln)(node_out_j) / S_j_out / rho_j_out;
        auto mass_term_in = (*_mdot_soln)(node_in_i) / S_i_in / rho_i_in +
                            (*_mdot_soln)(node_in_j) / S_j_in / rho_j_in;
        auto term_out = Sij * rho_star * (Lij / dz) * mass_term_out / 2.0;
        auto term_in = Sij * rho_star * (Lij / dz) * mass_term_in / 2.0;
        if (iz == first_node)
        {
          PetscInt row_ad = i_gap + _n_gaps * iz_ind;
          PetscScalar value_ad = term_in * alpha * _Wij(i_gap, iz - 1);
          LibmeshPetscCall(
              VecSetValues(_cmc_advective_derivative_rhs, 1, &row_ad, &value_ad, ADD_VALUES));
 
          PetscInt col_ad = i_gap + _n_gaps * iz_ind;
          value_ad = -1.0 * term_in * (1.0 - alpha) + term_out * alpha;
          LibmeshPetscCall(MatSetValues(
              _cmc_advective_derivative_mat, 1, &row_ad, 1, &col_ad, &value_ad, INSERT_VALUES));
 
          col_ad = i_gap + _n_gaps * (iz_ind + 1);
          value_ad = term_out * (1.0 - alpha);
          LibmeshPetscCall(MatSetValues(
              _cmc_advective_derivative_mat, 1, &row_ad, 1, &col_ad, &value_ad, INSERT_VALUES));
        }
        else if (iz == last_node)
        {
          PetscInt row_ad = i_gap + _n_gaps * iz_ind;
          PetscInt col_ad = i_gap + _n_gaps * (iz_ind - 1);
          PetscScalar value_ad = -1.0 * term_in * alpha;
          LibmeshPetscCall(MatSetValues(
              _cmc_advective_derivative_mat, 1, &row_ad, 1, &col_ad, &value_ad, INSERT_VALUES));
 
          col_ad = i_gap + _n_gaps * iz_ind;
          value_ad = -1.0 * term_in * (1.0 - alpha) + term_out * alpha;
          LibmeshPetscCall(MatSetValues(
              _cmc_advective_derivative_mat, 1, &row_ad, 1, &col_ad, &value_ad, INSERT_VALUES));
 
          value_ad = -1.0 * term_out * (1.0 - alpha) * _Wij(i_gap, iz);
          LibmeshPetscCall(
              VecSetValues(_cmc_advective_derivative_rhs, 1, &row_ad, &value_ad, ADD_VALUES));
        }
        else
        {
          PetscInt row_ad = i_gap + _n_gaps * iz_ind;
          PetscInt col_ad = i_gap + _n_gaps * (iz_ind - 1);
          PetscScalar value_ad = -1.0 * term_in * alpha;
          LibmeshPetscCall(MatSetValues(
              _cmc_advective_derivative_mat, 1, &row_ad, 1, &col_ad, &value_ad, INSERT_VALUES));
 
          col_ad = i_gap + _n_gaps * iz_ind;
          value_ad = -1.0 * term_in * (1.0 - alpha) + term_out * alpha;
          LibmeshPetscCall(MatSetValues(
              _cmc_advective_derivative_mat, 1, &row_ad, 1, &col_ad, &value_ad, INSERT_VALUES));
 
          col_ad = i_gap + _n_gaps * (iz_ind + 1);
          value_ad = term_out * (1.0 - alpha);
          LibmeshPetscCall(MatSetValues(
              _cmc_advective_derivative_mat, 1, &row_ad, 1, &col_ad, &value_ad, INSERT_VALUES));
        }
        // Assembling friction force
        PetscInt row_ff = i_gap + _n_gaps * iz_ind;
        PetscInt col_ff = i_gap + _n_gaps * iz_ind;
        PetscScalar value_ff = _kij * std::abs(_Wij(i_gap, iz)) / 2.0;
        LibmeshPetscCall(MatSetValues(
            _cmc_friction_force_mat, 1, &row_ff, 1, &col_ff, &value_ff, INSERT_VALUES));
 
        // Assembling pressure force
        alpha = computeInterpolationCoefficients(Pe);
 
        if (!_staggered_pressure_bool)
        {
          PetscScalar pressure_factor = Utility::pow<2>(Sij) * rho_star;
          PetscInt row_pf = i_gap + _n_gaps * iz_ind;
          PetscInt col_pf = i_ch + _n_channels * iz_ind;
          PetscScalar value_pf = -1.0 * alpha * pressure_factor;
          LibmeshPetscCall(
              MatSetValues(_cmc_pressure_force_mat, 1, &row_pf, 1, &col_pf, &value_pf, ADD_VALUES));
          col_pf = j_ch + _n_channels * iz_ind;
          value_pf = alpha * pressure_factor;
          LibmeshPetscCall(
              MatSetValues(_cmc_pressure_force_mat, 1, &row_pf, 1, &col_pf, &value_pf, ADD_VALUES));
 
          if (iz == last_node)
          {
            PetscInt row_pf = i_gap + _n_gaps * iz_ind;
            PetscScalar value_pf = (1.0 - alpha) * pressure_factor * (*_P_soln)(node_out_i);
            LibmeshPetscCall(
                VecSetValues(_cmc_pressure_force_rhs, 1, &row_pf, &value_pf, ADD_VALUES));
            value_pf = -1.0 * (1.0 - alpha) * pressure_factor * (*_P_soln)(node_out_j);
            LibmeshPetscCall(
                VecSetValues(_cmc_pressure_force_rhs, 1, &row_pf, &value_pf, ADD_VALUES));
          }
          else
          {
            row_pf = i_gap + _n_gaps * iz_ind;
            col_pf = i_ch + _n_channels * (iz_ind + 1);
            value_pf = -1.0 * (1.0 - alpha) * pressure_factor;
            LibmeshPetscCall(MatSetValues(
                _cmc_pressure_force_mat, 1, &row_pf, 1, &col_pf, &value_pf, ADD_VALUES));
            col_pf = j_ch + _n_channels * (iz_ind + 1);
            value_pf = (1.0 - alpha) * pressure_factor;
            LibmeshPetscCall(MatSetValues(
                _cmc_pressure_force_mat, 1, &row_pf, 1, &col_pf, &value_pf, ADD_VALUES));
          }
        }
        else
        {
          PetscScalar pressure_factor = Utility::pow<2>(Sij) * rho_star;
          PetscInt row_pf = i_gap + _n_gaps * iz_ind;
          PetscInt col_pf = i_ch + _n_channels * iz_ind;
          PetscScalar value_pf = -1.0 * pressure_factor;
          LibmeshPetscCall(
              MatSetValues(_cmc_pressure_force_mat, 1, &row_pf, 1, &col_pf, &value_pf, ADD_VALUES));
          col_pf = j_ch + _n_channels * iz_ind;
          value_pf = pressure_factor;
          LibmeshPetscCall(
              MatSetValues(_cmc_pressure_force_mat, 1, &row_pf, 1, &col_pf, &value_pf, ADD_VALUES));
        }
      }
    }
    LibmeshPetscCall(MatZeroEntries(_cmc_sys_Wij_mat));
    LibmeshPetscCall(VecZeroEntries(_cmc_sys_Wij_rhs));
    LibmeshPetscCall(MatAssemblyBegin(_cmc_time_derivative_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(MatAssemblyEnd(_cmc_time_derivative_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(MatAssemblyBegin(_cmc_advective_derivative_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(MatAssemblyEnd(_cmc_advective_derivative_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(MatAssemblyBegin(_cmc_friction_force_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(MatAssemblyEnd(_cmc_friction_force_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(MatAssemblyBegin(_cmc_pressure_force_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(MatAssemblyEnd(_cmc_pressure_force_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(MatAssemblyBegin(_cmc_sys_Wij_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(MatAssemblyEnd(_cmc_sys_Wij_mat, MAT_FINAL_ASSEMBLY));
    // Matrix
#if !PETSC_VERSION_LESS_THAN(3, 15, 0)
    LibmeshPetscCall(
        MatAXPY(_cmc_sys_Wij_mat, 1.0, _cmc_time_derivative_mat, UNKNOWN_NONZERO_PATTERN));
    LibmeshPetscCall(MatAssemblyBegin(_cmc_sys_Wij_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(MatAssemblyEnd(_cmc_sys_Wij_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(
        MatAXPY(_cmc_sys_Wij_mat, 1.0, _cmc_advective_derivative_mat, UNKNOWN_NONZERO_PATTERN));
    LibmeshPetscCall(MatAssemblyBegin(_cmc_sys_Wij_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(MatAssemblyEnd(_cmc_sys_Wij_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(
        MatAXPY(_cmc_sys_Wij_mat, 1.0, _cmc_friction_force_mat, UNKNOWN_NONZERO_PATTERN));
#else
    LibmeshPetscCall(
        MatAXPY(_cmc_sys_Wij_mat, 1.0, _cmc_time_derivative_mat, DIFFERENT_NONZERO_PATTERN));
    LibmeshPetscCall(MatAssemblyBegin(_cmc_sys_Wij_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(MatAssemblyEnd(_cmc_sys_Wij_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(
        MatAXPY(_cmc_sys_Wij_mat, 1.0, _cmc_advective_derivative_mat, DIFFERENT_NONZERO_PATTERN));
    LibmeshPetscCall(MatAssemblyBegin(_cmc_sys_Wij_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(MatAssemblyEnd(_cmc_sys_Wij_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(
        MatAXPY(_cmc_sys_Wij_mat, 1.0, _cmc_friction_force_mat, DIFFERENT_NONZERO_PATTERN));
#endif
    LibmeshPetscCall(MatAssemblyBegin(_cmc_sys_Wij_mat, MAT_FINAL_ASSEMBLY));
    LibmeshPetscCall(MatAssemblyEnd(_cmc_sys_Wij_mat, MAT_FINAL_ASSEMBLY));
    // RHS
    LibmeshPetscCall(VecAXPY(_cmc_sys_Wij_rhs, 1.0, _cmc_time_derivative_rhs));
    LibmeshPetscCall(VecAXPY(_cmc_sys_Wij_rhs, 1.0, _cmc_advective_derivative_rhs));
    LibmeshPetscCall(VecAXPY(_cmc_sys_Wij_rhs, 1.0, _cmc_friction_force_rhs));
 
    if (_segregated_bool)
    {
      // Assembly the matrix system
      Vec sol_holder_P;
      LibmeshPetscCall(createPetscVector(sol_holder_P, _block_size * _n_gaps));
      Vec sol_holder_W;
      LibmeshPetscCall(createPetscVector(sol_holder_W, _block_size * _n_gaps));
      LibmeshPetscCall(populateVectorFromHandle<SolutionHandle>(
          _prodp, *_P_soln, first_node - 1, last_node - 1, _n_channels));
      LibmeshPetscCall(populateVectorFromDense<libMesh::DenseMatrix<Real>>(
          _Wij_vec, _Wij, first_node, last_node, _n_gaps));
      LibmeshPetscCall(MatMult(_cmc_sys_Wij_mat, _Wij_vec, sol_holder_W));
      LibmeshPetscCall(VecAXPY(sol_holder_W, -1.0, _cmc_sys_Wij_rhs));
      LibmeshPetscCall(MatMult(_cmc_pressure_force_mat, _prodp, sol_holder_P));
      LibmeshPetscCall(VecAXPY(sol_holder_P, -1.0, _cmc_pressure_force_rhs));
      LibmeshPetscCall(VecAXPY(sol_holder_W, 1.0, sol_holder_P));
      PetscScalar * xx;
      LibmeshPetscCall(VecGetArray(sol_holder_W, &xx));
      for (unsigned int iz = first_node; iz < last_node + 1; iz++)
      {
        auto iz_ind = iz - first_node;
        for (unsigned int i_gap = 0; i_gap < _n_gaps; i_gap++)
        {
          _Wij_residual_matrix(i_gap, iz - 1 - iblock * _block_size) = xx[iz_ind * _n_gaps + i_gap];
        }
      }
      LibmeshPetscCall(VecDestroy(&sol_holder_P));
      LibmeshPetscCall(VecDestroy(&sol_holder_W));
    }
  }
}

Referenced by implicitPetscSolve(), and residualFunction().

createPetscMatrix()

PetscErrorCode SubChannel1PhaseProblem::createPetscMatrix ( Mat &  M, PetscInt  n, PetscInt  m  )

inlineprotected

Definition at line 327 of file SubChannel1PhaseProblem.h.

  {
    PetscFunctionBegin;
    LibmeshPetscCall(MatCreate(PETSC_COMM_SELF, &M));
    LibmeshPetscCall(MatSetSizes(M, PETSC_DECIDE, PETSC_DECIDE, n, m));
    LibmeshPetscCall(MatSetFromOptions(M));
    LibmeshPetscCall(MatSetUp(M));
    PetscFunctionReturn(LIBMESH_PETSC_SUCCESS);
  }

Referenced by SubChannel1PhaseProblem(), and TriSubChannel1PhaseProblem::TriSubChannel1PhaseProblem().

createPetscVector()

PetscErrorCode SubChannel1PhaseProblem::createPetscVector ( Vec &  v, PetscInt  n  )

inlineprotected

Petsc Functions.

Definition at line 316 of file SubChannel1PhaseProblem.h.

  {
    PetscFunctionBegin;
    LibmeshPetscCall(VecCreate(PETSC_COMM_SELF, &v));
    LibmeshPetscCall(PetscObjectSetName((PetscObject)v, "Solution"));
    LibmeshPetscCall(VecSetSizes(v, PETSC_DECIDE, n));
    LibmeshPetscCall(VecSetFromOptions(v));
    LibmeshPetscCall(VecZeroEntries(v));
    PetscFunctionReturn(LIBMESH_PETSC_SUCCESS);
  }

Referenced by computeWijResidual(), implicitPetscSolve(), SubChannel1PhaseProblem(), and TriSubChannel1PhaseProblem::TriSubChannel1PhaseProblem().

detectDeformation()

void SubChannel1PhaseProblem::detectDeformation ( )

protected

Detects whether pin diameter or duct displacement fields require geometry recalculation.

Definition at line 455 of file SubChannel1PhaseProblem.C.

{
  const Real tol = libMesh::TOLERANCE;
  const auto pin_diameter = _subchannel_mesh.getPinDiameter();
 
  if (_pin_mesh_exist)
  {
    for (unsigned int iz = 0; iz < _n_cells + 1; iz++)
      for (unsigned int i_pin = 0; i_pin < _n_pins; i_pin++)
      {
        auto * node = _subchannel_mesh.getPinNode(i_pin, iz);
        const Real Dpin = (*_Dpin_soln)(node);
        if (std::abs(Dpin) <= tol)
          mooseError("Dpin is zero at node ",
                     node->id(),
                     ". You must initialize Dpin to a non-zero value.");
        if (std::abs(Dpin - pin_diameter) > tol)
          _deformation = true;
      }
  }
 
  for (unsigned int iz = 0; iz < _n_cells + 1 && !_deformation; iz++)
    for (unsigned int i_ch = 0; i_ch < _n_channels && !_deformation; i_ch++)
    {
      auto * node = _subchannel_mesh.getChannelNode(i_ch, iz);
      auto subch_type = _subchannel_mesh.getSubchannelType(i_ch);
 
      if ((subch_type == EChannelType::CORNER || subch_type == EChannelType::EDGE) &&
          std::abs((*_displacement_soln)(node)) > tol)
        _deformation = true;
    }
}

Referenced by QuadSubChannel1PhaseProblem::initializeSolution(), and TriSubChannel1PhaseProblem::initializeSolution().

externalSolve()

void SubChannel1PhaseProblem::externalSolve ( )

overridevirtual

Assigning temperatures to duct

Implements ExternalProblem.

Definition at line 2758 of file SubChannel1PhaseProblem.C.

{
  _console << "Executing subchannel solver\n";
  _dt = (isTransient() ? dt() : _one);
  _TR = isTransient();
 
  // The subchannel solver hardcodes a first-order backward (implicit) Euler time discretization, so
  // any other time integrator a user selects is silently ignored. Warn once if one is requested.
  if (!_time_integrator_checked)
  {
    _time_integrator_checked = true;
    if (isTransient())
      if (auto * transient = dynamic_cast<TransientBase *>(_app.getExecutioner()))
        for (const auto * ti : transient->getTimeIntegrators())
          if (!dynamic_cast<const ImplicitEuler *>(ti))
            mooseWarning("The subchannel solver always uses implicit (backward) Euler time "
                         "integration; the requested '",
                         ti->type(),
                         "' time integrator is ignored.");
  }
 
  initializeSolution();
  computeBulkReynoldsNumber();
  // Small helper functions to reduce repetition
  // Verbose print helper (no-op unless _verbose_subchannel is true)
  auto V = [&](const std::string & s)
  {
    if (_verbose_subchannel)
      _console << s << std::endl;
  };
  auto saveValues = [&](const SolutionHandle & solution,
                        const unsigned int first_node,
                        const unsigned int last_node)
  {
    std::vector<Real> values;
    values.reserve((last_node - first_node + 1) * _n_channels);
    for (unsigned int iz = first_node; iz <= last_node; ++iz)
      for (unsigned int i_ch = 0; i_ch < _n_channels; ++i_ch)
        values.push_back(solution(_subchannel_mesh.getChannelNode(i_ch, iz)));
    return values;
  };
  auto relativeChange = [&](const SolutionHandle & solution,
                            const std::vector<Real> & old_values,
                            const unsigned int first_node,
                            const unsigned int last_node,
                            const Real reference_offset)
  {
    Real difference_norm_sq = 0.0;
    Real reference_norm_sq = 0.0;
    std::size_t i = 0;
    for (unsigned int iz = first_node; iz <= last_node; ++iz)
      for (unsigned int i_ch = 0; i_ch < _n_channels; ++i_ch)
      {
        const Real value = solution(_subchannel_mesh.getChannelNode(i_ch, iz));
        difference_norm_sq += Utility::pow<2>(value - old_values[i]);
        reference_norm_sq += Utility::pow<2>(old_values[i] + reference_offset);
        ++i;
      }
    return std::sqrt(difference_norm_sq) / (std::sqrt(reference_norm_sq) + 1e-14);
  };
  V("Solution initialized");
  Real P_error = 1.0;
  unsigned int P_it = 0;
  unsigned int P_it_max;
  bool temperature_converged = true;
 
  if (_segregated_bool)
    P_it_max = 20 * _n_blocks;
  else
    P_it_max = 100;
 
  if ((_n_blocks == 1) && (_segregated_bool))
    P_it_max = 5;
 
  if (_P_maxit > 0)
    P_it_max = _P_maxit;
 
  while ((P_error > _P_tol && P_it < P_it_max))
  {
    P_it += 1;
    temperature_converged = true;
    _pressure_fixed_point_error = 0.0;
    _console << "Solving Outer Iteration : " << P_it << std::endl;
    const auto P_old = saveValues(*_P_soln, 0, _n_cells);
    for (unsigned int iblock = 0; iblock < _n_blocks; iblock++)
    {
      int last_level = (iblock + 1) * _block_size;
      int first_level = iblock * _block_size + 1;
      Real T_block_error = 1.0;
      auto T_it = 0;
      _console << "Solving Block: " << iblock << " From first level: " << first_level
               << " to last level: " << last_level << std::endl;
 
      while (T_block_error > _T_tol && T_it < _T_maxit)
      {
        if (processor_id() == 0)
        {
          if (_segregated_bool)
            computeWijFromSolve(iblock);
          else
          {
            LibmeshPetscCall(implicitPetscSolve(iblock));
            computeWijPrime(iblock);
            V("Done with main solve.");
          }
        }
 
        // A value of one preserves the original ordering by refreshing the flow solution before
        // every thermal update. Larger values opt into lagging flow during thermal subcycles.
        for (const auto enthalpy_subcycle : make_range(_enthalpy_subcycles))
        {
          if (T_block_error <= _T_tol || T_it >= _T_maxit)
            break;
 
          V("Enthalpy subcycle: " + std::to_string(enthalpy_subcycle + 1));
          T_it += 1;
          const auto T_old = saveValues(*_T_soln, first_level, last_level);
          // We are only computing quantities on rank 0
          if (processor_id() > 0)
          {
            // Rank zero supplies the error through the maximum reduction below.
            T_block_error = 0.0;
            goto aux_close;
          }
 
          if (_compute_power)
          {
            computeh(iblock);
            T_block_error = computeT(iblock);
            V("Done with thermal solve.");
          }
 
          V("Start updating thermophysical properties.");
          if (_compute_density)
            computeRho(iblock);
          if (_compute_viscosity)
            computeMu(iblock);
          V("Done updating thermophysical properties.");
 
          // We must do a global assembly to make sure data is parallel consistent before we do
          // things like compute L2 norms
        aux_close:
          _aux->solution().close();
 
          if (!_compute_power)
            T_block_error =
                relativeChange(*_T_soln, T_old, first_level, last_level, /*reference_offset=*/0.0);
          _console << "T_block_error: " << T_block_error << std::endl;
 
          // All processes must have the same iteration count
          comm().max(T_block_error);
        }
      }
      const bool block_converged = T_block_error <= _T_tol;
      temperature_converged &= block_converged;
      if (!block_converged)
      {
        _console << "Reached maximum number of temperature iterations for block: " << iblock
                 << std::endl;
      }
    }
    P_error = _segregated_bool ? relativeChange(*_P_soln, P_old, 0, _n_cells, _P_out)
                               : _pressure_fixed_point_error;
    comm().max(P_error);
    _console << "P_error :" << P_error << std::endl;
    V("Iteration:  " + std::to_string(P_it));
    V("Maximum iterations: " + std::to_string(P_it_max));
  }
  // Cache only the final iteration status. Earlier outer iterations may fail their thermal
  // tolerance and subsequently recover.
  const bool pressure_converged = P_error <= _P_tol;
  if (!pressure_converged)
  {
    _console << "Reached maximum number of axial pressure iterations" << std::endl;
  }
  _converged = pressure_converged && temperature_converged;
  // update old crossflow matrix
  _Wij_old = _Wij;
  _console << "Finished executing subchannel solver\n";
 
  // set SumWij at the inlet equal to the one on the first axial level  (for visualization purposes)
  for (unsigned int i_ch = 0; i_ch < _n_channels; i_ch++)
  {
    auto * node_in = _subchannel_mesh.getChannelNode(i_ch, 0);
    auto * node_out = _subchannel_mesh.getChannelNode(i_ch, 1);
    _SumWij_soln->set(node_in, (*_SumWij_soln)(node_out)); // kg/sec
  }
 
  if (_pin_mesh_exist)
  {
    // Assign average HTC to subchannels. This is exact if all pins have the same diameter
    for (unsigned int iz = 0; iz < _n_cells + 1; ++iz)
    {
      for (unsigned int i_ch = 0; i_ch < _n_channels; i_ch++)
      {
        const auto * node = _subchannel_mesh.getChannelNode(i_ch, iz);
        auto mu = (*_mu_soln)(node);
        auto S = (*_S_flow_soln)(node);
        auto w_perim = (*_w_perim_soln)(node);
        auto Dh_i = 4.0 * S / w_perim;
        auto Re = (((*_mdot_soln)(node) / S) * Dh_i / mu);
        auto k = _fp->k_from_p_T((*_P_soln)(node) + _P_out, (*_T_soln)(node));
        auto cp = _fp->cp_from_p_T((*_P_soln)(node) + _P_out, (*_T_soln)(node));
        auto Pr = (*_mu_soln)(node)*cp / k;
        // Create Friction structure
        _friction_args = FrictionStruct(i_ch, Re, S, w_perim);
 
        Real sumhw = 0.0;
        for (auto i_pin : _subchannel_mesh.getChannelPins(i_ch))
        {
          // Create nusselt number structure
          _nusselt_args = NusseltStruct(Re, Pr, i_pin, iz, i_ch);
 
          // Compute HTC
          sumhw += _pin_HTC_closure->computeHTC(_friction_args, _nusselt_args, k);
        }
 
        // Set HTC
        _HTC_soln->set(node, sumhw / _subchannel_mesh.getChannelPins(i_ch).size());
      }
    }
    _HTC_soln->close();
 
    _console << "Commencing calculation of Pin surface temperature \n";
    for (unsigned int i_pin = 0; i_pin < _n_pins; i_pin++)
    {
      for (unsigned int iz = 0; iz < _n_cells + 1; ++iz)
      {
        const auto * pin_node = _subchannel_mesh.getPinNode(i_pin, iz);
        Real sumTemp = 0.0;
        // Calculate sum of pin surface temperatures that the channels around the pin see
        for (auto i_ch : _subchannel_mesh.getPinChannels(i_pin))
        {
          const auto * node = _subchannel_mesh.getChannelNode(i_ch, iz);
          auto mu = (*_mu_soln)(node);
          auto S = (*_S_flow_soln)(node);
          auto w_perim = (*_w_perim_soln)(node);
          auto Dh_i = 4.0 * S / w_perim;
          auto Re = (((*_mdot_soln)(node) / S) * Dh_i / mu);
          auto k = _fp->k_from_p_T((*_P_soln)(node) + _P_out, (*_T_soln)(node));
          auto cp = _fp->cp_from_p_T((*_P_soln)(node) + _P_out, (*_T_soln)(node));
          auto Pr = (*_mu_soln)(node)*cp / k;
          // Create Friction structure
          _friction_args = FrictionStruct(i_ch, Re, S, w_perim);
          // Create nusselt number structure
          _nusselt_args = NusseltStruct(Re, Pr, i_pin, iz, i_ch);
          // Compute HTC
          auto hw = _pin_HTC_closure->computeHTC(_friction_args, _nusselt_args, k);
          // Compute surface temperature contribution from subchannel side
          sumTemp +=
              (*_q_prime_soln)(pin_node) / ((*_Dpin_soln)(pin_node)*M_PI * hw) + (*_T_soln)(node);
        }
        if (_subchannel_mesh.getPinChannels(i_pin).size() > 0)
          _Tpin_soln->set(pin_node, sumTemp / _subchannel_mesh.getPinChannels(i_pin).size());
        else
          mooseError("Pin was not found for pin index:  " + std::to_string(i_pin));
      }
    }
  }
 
  if (_duct_mesh_exist && processor_id() == 0)
  {
    _console << "Commencing calculation of duct surface temperature " << std::endl;
    auto duct_nodes = _subchannel_mesh.getDuctNodes();
    for (Node * dn : duct_nodes)
    {
      auto * node_chan = _subchannel_mesh.getChannelNodeFromDuct(dn);
      auto mu = (*_mu_soln)(node_chan);
      auto S = (*_S_flow_soln)(node_chan);
      auto w_perim = (*_w_perim_soln)(node_chan);
      auto Dh_i = 4.0 * S / w_perim;
      auto Re = (((*_mdot_soln)(node_chan) / S) * Dh_i / mu);
      auto k = _fp->k_from_p_T((*_P_soln)(node_chan) + _P_out, (*_T_soln)(node_chan));
      auto cp = _fp->cp_from_p_T((*_P_soln)(node_chan) + _P_out, (*_T_soln)(node_chan));
      auto Pr = (*_mu_soln)(node_chan)*cp / k;
 
      // Create nusselt number structure (consistent with pin case)
      const libMesh::Point & node_point = *_subchannel_mesh.getChannelNodeFromDuct(dn);
      const unsigned int iz = _subchannel_mesh.getZIndex(node_point);
      const unsigned int i_ch = _subchannel_mesh.channelIndex(node_point);
 
      // Create nusselt number structure
      _nusselt_args = NusseltStruct(Re, Pr, std::numeric_limits<unsigned int>::max(), iz, i_ch);
 
      // Create Friction structure
      _friction_args = FrictionStruct(i_ch, Re, S, w_perim);
 
      // Compute HTC
      auto hw = _duct_HTC_closure->computeHTC(_friction_args, _nusselt_args, k);
 
      // Compute Channel Temperature
      auto T_chan = (*_duct_heat_flux_soln)(dn) / hw + (*_T_soln)(node_chan);
      _Tduct_soln->set(dn, T_chan);
    }
  }
  _aux->solution().close();
  _aux->update();
 
  // Called before the rank-0 early return since it broadcasts to all ranks
  computeBulkReynoldsNumber();
 
  if (processor_id() != 0)
    return;
  Real power_in = 0.0;
  Real power_out = 0.0;
  Real mass_flow_in = 0.0;
  Real mass_flow_out = 0.0;
  for (unsigned int i_ch = 0; i_ch < _n_channels; i_ch++)
  {
    auto * node_in = _subchannel_mesh.getChannelNode(i_ch, 0);
    auto * node_out = _subchannel_mesh.getChannelNode(i_ch, _n_cells);
    const Real mdot_in = (*_mdot_soln)(node_in);
    power_in += mdot_in * (*_h_soln)(node_in);
    power_out += (*_mdot_soln)(node_out) * (*_h_soln)(node_out);
    mass_flow_in += mdot_in;
    mass_flow_out += (*_mdot_soln)(node_out);
  }
  auto h_bulk_out = power_out / mass_flow_out;
  auto T_bulk_out = _fp->T_from_p_h(_P_out, h_bulk_out);
 
  const Real bulk_Dh = _subchannel_mesh.getAssemblyHydraulicDiameter();
  if (_verbose_subchannel)
  {
    _console << " ======================================= " << std::endl;
    _console << " ======== Subchannel Print Outs ======== " << std::endl;
    _console << " ======================================= " << std::endl;
    _console << "Total flow area :" << _subchannel_mesh.getAssemblyFlowArea() << " m^2"
             << std::endl;
    _console << "Assembly hydraulic diameter :" << bulk_Dh << " m" << std::endl;
    _console << "Assembly Re number :" << _bulk_Re << " [-]" << std::endl;
    _console << "Bulk coolant temperature at outlet :" << T_bulk_out << " K" << std::endl;
    _console << "Power added to coolant is : " << power_out - power_in << " Watt" << std::endl;
    _console << "Mass flow rate in is : " << mass_flow_in << " kg/sec" << std::endl;
    _console << "Mass balance is : " << mass_flow_out - mass_flow_in << " kg/sec" << std::endl;
    _console << "User defined outlet pressure is : " << _P_out << " Pa" << std::endl;
    _console << " ======================================= " << std::endl;
  }
 
  if (MooseUtils::absoluteFuzzyLessEqual((power_out - power_in), -1.0))
    mooseWarning(
        "Energy conservation equation might not be solved correctly, Power added to coolant:  " +
        std::to_string(power_out - power_in) + " Watt ");
}

getAddedHeatDuct()

Real SubChannel1PhaseProblem::getAddedHeatDuct ( unsigned int  i_ch, unsigned int  iz  ) const

inline

Return the added heat coming from the duct.

Definition at line 88 of file SubChannel1PhaseProblem.h.

  {
    return computeAddedHeatDuct(i_ch, iz);
  }

getAddedHeatPin()

Real SubChannel1PhaseProblem::getAddedHeatPin ( unsigned int  i_ch, unsigned int  iz  ) const

inline

Return the added heat coming from the fuel pins.

Definition at line 82 of file SubChannel1PhaseProblem.h.

  {
    return computeAddedHeatPin(i_ch, iz);
  }

getBulkReynoldsNumber()

Real SubChannel1PhaseProblem::getBulkReynoldsNumber ( ) const

inline

Definition at line 47 of file SubChannel1PhaseProblem.h.

{ return _bulk_Re; }

Referenced by SCMMixingChenTodreas::computeBulkMixingParameters(), SCMMixingChenTodreas::computePacioMixingParameter(), SCMFrictionChenTodreas::computeQuadLatticeFrictionFactor(), and SCMFrictionChenTodreas::computeTriLatticeFrictionFactor().

getBulkVelocity()

Real SubChannel1PhaseProblem::getBulkVelocity ( ) const

inline

Definition at line 48 of file SubChannel1PhaseProblem.h.

{ return _bulk_V; }

Referenced by SCMMixingChenTodreas::computeBlockMixingParameters().

getDuctHTCClosure()

const SCMHTCClosureBase * SubChannel1PhaseProblem::getDuctHTCClosure ( ) const

inline

Definition at line 44 of file SubChannel1PhaseProblem.h.

{ return _duct_HTC_closure; }

Referenced by SCMHTCBorishanskii::SCMHTCBorishanskii(), SCMHTCGraberRieger::SCMHTCGraberRieger(), SCMHTCKazimiCarelli::SCMHTCKazimiCarelli(), and SCMHTCSchadModified::SCMHTCSchadModified().

getFrictionClosure()

const SCMFrictionClosureBase * SubChannel1PhaseProblem::getFrictionClosure ( ) const

inline

Definition at line 46 of file SubChannel1PhaseProblem.h.

{ return _friction_closure; }

Referenced by SCMMixingKimAndChung::computeLatticeMixingParameter(), and SCMHTCGnielinski::computeNusseltNumber().

getOutletPressure()

const PostprocessorValue & SubChannel1PhaseProblem::getOutletPressure ( ) const

inline

Get outlet pressure.

Definition at line 97 of file SubChannel1PhaseProblem.h.

{ return _P_out; }

Referenced by SCMMixingKimAndChung::computeLatticeMixingParameter().

getPinHTCClosure()

const SCMHTCClosureBase * SubChannel1PhaseProblem::getPinHTCClosure ( ) const

inline

Definition at line 45 of file SubChannel1PhaseProblem.h.

{ return _pin_HTC_closure; } // optional

getSinglePhaseFluidProperties()

const SinglePhaseFluidProperties * SubChannel1PhaseProblem::getSinglePhaseFluidProperties ( ) const

inline

Get fluid properties object.

Definition at line 103 of file SubChannel1PhaseProblem.h.

{ return _fp; }

Referenced by SCMMixingKimAndChung::computeLatticeMixingParameter().

getSubChannelPeripheralDuctWidth()

virtual Real SubChannel1PhaseProblem::getSubChannelPeripheralDuctWidth ( unsigned int  i_ch ) const

protectedpure virtual

Function that computes the width of the duct cell that the peripheral subchannel i_ch sees.

Implemented in QuadSubChannel1PhaseProblem, and TriSubChannel1PhaseProblem.

Referenced by computeAddedHeatDuct().

implicitPetscSolve()

PetscErrorCode SubChannel1PhaseProblem::implicitPetscSolve ( int  iblock )

protected

Computes implicit solve using PetSc.

Definition at line 2276 of file SubChannel1PhaseProblem.C.

{
  PetscFunctionBegin;
  // ---------- helper functions -----------------------------
  auto V = [&](const std::string & s)
  {
    if (_verbose_subchannel)
      _console << s << std::endl;
  };
 
  auto DupMatAssembled = [&](Mat src, Mat * dst)
  {
    if (src)
    {
      LibmeshPetscCall(MatDuplicate(src, MAT_COPY_VALUES, dst));
      LibmeshPetscCall(MatAssemblyBegin(*dst, MAT_FINAL_ASSEMBLY));
      LibmeshPetscCall(MatAssemblyEnd(*dst, MAT_FINAL_ASSEMBLY));
    }
    else
      *dst = NULL;
  };
 
  auto DupVecCopy = [&](Vec src, Vec * dst)
  {
    LibmeshPetscCall(VecDuplicate(src, dst));
    LibmeshPetscCall(VecCopy(src, *dst));
  };
 
  const PetscInt Q = 3; // [mass conservation, axial momentum, cross momentum]
 
  // small indexer
  auto Idx = [&](PetscInt r, PetscInt c) { return Q * r + c; };
 
  // arrays that MUST be declared before lambdas use them
  std::vector<Mat> mat_array(Q * Q, NULL);
  std::vector<Vec> vec_array(Q, NULL);
 
  // generic assembler for one governing equation row in the nested matrix
  auto AssembleEquation = [&](PetscInt f,
                              Mat A0,
                              Mat A1,
                              Mat A2,             // three blocks in row f (can be nullptr)
                              Vec rhs,            // base RHS for equation f
                              Vec rhs_add,        // optional extra RHS to add (can be nullptr)
                              const char * label) // e.g. "Mass", "Lin mom", "Cross mom"
  {
    DupMatAssembled(A0, &mat_array[Idx(f, 0)]);
    DupMatAssembled(A1, &mat_array[Idx(f, 1)]);
    DupMatAssembled(A2, &mat_array[Idx(f, 2)]);
    DupVecCopy(rhs, &vec_array[f]);
    if (rhs_add)
      LibmeshPetscCall(VecAXPY(vec_array[f], 1.0, rhs_add));
    V(std::string(label) + " system assembled");
  };
 
  // -----------------------------------------------------------------------------
  // Helper lambda that applies per-equation under-relaxation by modifying BOTH the
  // matrix block and the RHS for that equation.
  //
  // Specifically, with A_ff for the equation and D = diag(A_ff):
  //   1) Matrix diagonal scaling: D <- D / alpha, then A_ff's diagonal is replaced
  //      with D. For alpha < 1 this increases diagonal dominance (more damping).
  //   2) RHS blending with the previous solution x_old:
  //        rhs_f <- rhs_f + (1 - alpha) * (D / alpha) * x_old
  //      where x_old is provided by the caller via `populate(work)`.
  //
  // Net effect: the solved x satisfies
  //        A_ff x = rhs_f_original + ((1 - alpha)/alpha) * D * (x_old - x),
  // which damps updates toward x_old without changing the converged solution.
  // This equation relaxation is independent of the optional post-solve solution relaxation.
  // -----------------------------------------------------------------------------
  auto relaxEquation =
      [&](Mat diagonal_block, Vec rhs, Vec work, const Real relaxation, auto && populate)
  {
    if (relaxation == 1.0)
      return;
 
    Vec diagonal = nullptr;
    LibmeshPetscCall(VecDuplicate(rhs, &diagonal));
 
    // 1) diagonal_block: diag <- diag / relaxation
    LibmeshPetscCall(MatGetDiagonal(diagonal_block, diagonal));
    LibmeshPetscCall(VecScale(diagonal, 1.0 / relaxation));
    LibmeshPetscCall(MatDiagonalSet(diagonal_block, diagonal, INSERT_VALUES));
 
    // 2) work <- x_old (caller-provided populator)
    LibmeshPetscCall(populate(work));
 
    // 3) rhs += (1 - relaxation) * (diag .* work)
    LibmeshPetscCall(VecScale(diagonal, 1.0 - relaxation));
    LibmeshPetscCall(VecPointwiseMult(work, work, diagonal));
    LibmeshPetscCall(VecAXPY(rhs, 1.0, work));
 
    LibmeshPetscCall(VecDestroy(&diagonal));
  };
 
  // indices
  const unsigned int first_node = iblock * _block_size + 1;
  const unsigned int last_node = (iblock + 1) * _block_size;
 
  // ---------- assemble per-block operators -----------------
  computeSumWij(iblock);
  computeMdot(iblock);
  computeWijPrime(iblock);
  computeDP(iblock);
  computeP(iblock);
  computeWijResidual(iblock);
 
  V("Starting nested system.");
 
  // Populate nested matrix with the individual physics
  // equation 0: Mass conservation
  AssembleEquation(/*f=*/0,
                   /*A0=*/_mc_axial_convection_mat,
                   /*A1=*/_mc_density_pressure_mat,
                   /*A2=*/_mc_sumWij_mat,
                   /*rhs=*/_mc_axial_convection_rhs,
                   /*rhs_add=*/nullptr,
                   /*label=*/"Mass");
 
  // equation 1: Axial momentum conservation
  AssembleEquation(/*f=*/1,
                   /*A0=*/_amc_sys_mdot_mat,
                   /*A1=*/_amc_pressure_force_mat,
                   /*A2=*/nullptr,
                   /*rhs=*/_amc_pressure_force_rhs,
                   /*rhs_add=*/_amc_sys_mdot_rhs,
                   /*label=*/"Lin mom");
 
  // equation 2: Cross momentum conservation
  AssembleEquation(/*f=*/2,
                   /*A0=*/nullptr,
                   /*A1=*/_cmc_pressure_force_mat,
                   /*A2=*/_cmc_sys_Wij_mat,
                   /*rhs=*/_cmc_sys_Wij_rhs,
                   /*rhs_add=*/_cmc_pressure_force_rhs,
                   /*label=*/"Cross mom");
 
  // ========================== Relaxation  ====================
  if (true)
  {
    LibmeshPetscCall(populateVectorFromHandle<SolutionHandle>(
        _prod, *_mdot_soln, first_node, last_node, _n_channels));
 
    Vec mdot_estimate;
    LibmeshPetscCall(createPetscVector(mdot_estimate, _block_size * _n_channels));
    Vec pmat_diag;
    LibmeshPetscCall(createPetscVector(pmat_diag, _block_size * _n_channels));
    Vec p_estimate;
    LibmeshPetscCall(createPetscVector(p_estimate, _block_size * _n_channels));
    Vec unity_vec;
    LibmeshPetscCall(createPetscVector(unity_vec, _block_size * _n_channels));
    LibmeshPetscCall(VecSet(unity_vec, 1.0));
    Vec sol_holder_P;
    LibmeshPetscCall(createPetscVector(sol_holder_P, _block_size * _n_gaps));
    Vec unity_vec_Wij;
    LibmeshPetscCall(createPetscVector(unity_vec_Wij, _block_size * _n_gaps));
    LibmeshPetscCall(VecSet(unity_vec_Wij, 1.0));
    Vec _Wij_loc_vec;
    LibmeshPetscCall(createPetscVector(_Wij_loc_vec, _block_size * _n_gaps));
    Vec _Wij_old_loc_vec;
    LibmeshPetscCall(createPetscVector(_Wij_old_loc_vec, _block_size * _n_gaps));
 
    // ---- scale estimates ----
    // mdot_estimate = A(1,0) * mdot
    LibmeshPetscCall(MatMult(mat_array[Q /* (1,0) */], _prod, mdot_estimate));
 
    // p_estimate = mdot_est / (diag(A(1,1)) + eps)
    LibmeshPetscCall(MatGetDiagonal(mat_array[Q + 1], pmat_diag));
    LibmeshPetscCall(VecAXPY(pmat_diag, 1e-10, unity_vec));
    LibmeshPetscCall(VecPointwiseDivide(p_estimate, mdot_estimate, pmat_diag));
 
    // sol_holder_P = A(2,1) * p_estimate - rhs_cmc_pressure
    LibmeshPetscCall(MatMult(mat_array[2 * Q + 1], p_estimate, sol_holder_P));
    LibmeshPetscCall(VecAXPY(sol_holder_P, -1.0, _cmc_pressure_force_rhs));
 
    // sumWij_loc from sol_holder_P (accumulate)
    Vec sumWij_loc;
    LibmeshPetscCall(createPetscVector(sumWij_loc, _block_size * _n_channels));
    for (unsigned int iz = first_node; iz <= last_node; ++iz)
    {
      const auto iz_ind = iz - first_node;
      for (unsigned int i_ch = 0; i_ch < _n_channels; ++i_ch)
      {
        PetscScalar sumWij = 0.0;
        unsigned int counter = 0;
        for (auto i_gap : _subchannel_mesh.getChannelGaps(i_ch))
        {
          PetscInt row_vec = i_gap + _n_gaps * iz_ind;
          PetscScalar loc_Wij_value;
          LibmeshPetscCall(VecGetValues(sol_holder_P, 1, &row_vec, &loc_Wij_value));
          sumWij += _subchannel_mesh.getCrossflowSign(i_ch, counter) * loc_Wij_value;
          counter++;
        }
        PetscInt row_vec = i_ch + _n_channels * iz_ind;
        LibmeshPetscCall(VecSetValues(sumWij_loc, 1, &row_vec, &sumWij, INSERT_VALUES));
      }
    }
    LibmeshPetscCall(VecAssemblyBegin(sumWij_loc));
    LibmeshPetscCall(VecAssemblyEnd(sumWij_loc));
 
    // ---- robust scale measurements ----
    PetscScalar min_mdot, sum_mdot, avg_mdot;
    PetscInt n;
    LibmeshPetscCall(VecAbs(_prod));
    LibmeshPetscCall(VecMin(_prod, NULL, &min_mdot));
    LibmeshPetscCall(VecSum(_prod, &sum_mdot)); // Sum all entries
    LibmeshPetscCall(VecGetSize(_prod, &n));    // Number of entries
    avg_mdot = sum_mdot / static_cast<PetscScalar>(n);
 
    V("Average estimated mdot: " + std::to_string(avg_mdot));
    V("Minimum estimated mdot: " + std::to_string(min_mdot));
 
    LibmeshPetscCall(VecAbs(sumWij_loc));
    LibmeshPetscCall(VecMax(sumWij_loc, NULL, &_max_sumWij));
    _max_sumWij = std::max(1e-10, _max_sumWij);
    V("Maximum estimated Wij: " + std::to_string(_max_sumWij));
 
    LibmeshPetscCall(populateVectorFromDense<libMesh::DenseMatrix<Real>>(
        _Wij_loc_vec, _Wij, first_node, last_node, _n_gaps));
    LibmeshPetscCall(VecAbs(_Wij_loc_vec));
    LibmeshPetscCall(populateVectorFromDense<libMesh::DenseMatrix<Real>>(
        _Wij_old_loc_vec, _Wij_old, first_node, last_node, _n_gaps));
    LibmeshPetscCall(VecAbs(_Wij_old_loc_vec));
    LibmeshPetscCall(VecAXPY(_Wij_loc_vec, -1.0, _Wij_old_loc_vec));
 
    PetscScalar relax_factor;
    LibmeshPetscCall(VecAbs(_Wij_loc_vec));
#if !PETSC_VERSION_LESS_THAN(3, 16, 0)
    LibmeshPetscCall(VecMean(_Wij_loc_vec, &relax_factor));
#else
    VecSum(_Wij_loc_vec, &relax_factor);
    relax_factor /= _block_size * _n_gaps;
#endif
    relax_factor = relax_factor / _max_sumWij + 0.5;
    V("Relax base value: " + std::to_string(relax_factor));
 
    // ---- crossflow resistance inflation ----
    const PetscScalar resistance_relaxation = 0.9;
    _added_K = _max_sumWij / min_mdot;
    V("New cross resistance: " + std::to_string(_added_K));
    _added_K = (_added_K * resistance_relaxation + (1.0 - resistance_relaxation) * _added_K_old) *
               relax_factor;
    V("Relaxed cross resistance: " + std::to_string(_added_K));
 
    // Snap-up lower-bounding
    if (_added_K < 10 && _added_K >= 1.0)
      _added_K = 1.0;
    if (_added_K < 1.0 && _added_K >= 0.1)
      _added_K = 0.5;
    if (_added_K < 0.1 && _added_K >= 0.01)
      _added_K = 1. / 3.;
    if (_added_K < 1e-2 && _added_K >= 1e-3)
      _added_K = 0.1;
    V("Actual added cross resistance: " + std::to_string(_added_K));
    LibmeshPetscCall(VecScale(unity_vec_Wij, _added_K));
    _added_K_old = _added_K;
 
    LibmeshPetscCall(MatDiagonalSet(mat_array[2 * Q + 2], unity_vec_Wij, ADD_VALUES));
 
    // ---- cleanup temp vectors used above ----
    LibmeshPetscCall(VecDestroy(&mdot_estimate));
    LibmeshPetscCall(VecDestroy(&pmat_diag));
    LibmeshPetscCall(VecDestroy(&unity_vec));
    LibmeshPetscCall(VecDestroy(&p_estimate));
    LibmeshPetscCall(VecDestroy(&sol_holder_P));
    LibmeshPetscCall(VecDestroy(&unity_vec_Wij));
    LibmeshPetscCall(VecDestroy(&sumWij_loc));
    LibmeshPetscCall(VecDestroy(&_Wij_loc_vec));
    LibmeshPetscCall(VecDestroy(&_Wij_old_loc_vec));
  }
 
  V("Relax mdot: " + std::to_string(_mass_flow_equation_relaxation));
  V("Relax P: " + std::to_string(_pressure_equation_relaxation));
  V("Relax Wij: " + std::to_string(_crossflow_equation_relaxation));
 
  relaxEquation(mat_array[Idx(0, 0)],
                vec_array[0],
                _prod,
                _mass_flow_equation_relaxation,
                [&](Vec work)
                {
                  return populateVectorFromHandle<SolutionHandle>(
                      work, *_mdot_soln, first_node, last_node, _n_channels);
                });
  V("mdot relaxed");
 
  relaxEquation(mat_array[Idx(1, 1)],
                vec_array[1],
                _prodp,
                _pressure_equation_relaxation,
                [&](Vec work)
                {
                  // The pressure block represents the node below each axial momentum cell because
                  // the outlet pressure is prescribed.
                  return populateVectorFromHandle<SolutionHandle>(
                      work, *_P_soln, first_node - 1, last_node - 1, _n_channels);
                });
  V("P relaxed");
 
  relaxEquation(mat_array[Idx(2, 2)],
                vec_array[2],
                _Wij_vec,
                _crossflow_equation_relaxation,
                [&](Vec work)
                {
                  return populateVectorFromDense<libMesh::DenseMatrix<Real>>(
                      work, _Wij, first_node, last_node, _n_gaps);
                });
  V("Wij relaxed");
  V("Linear solver relaxed");
 
  // ======================== Create and configure KSP =========================
  Mat A_nest;
  Vec b_nest;
  Vec x_nest;
  LibmeshPetscCall(MatCreateNest(PETSC_COMM_SELF, Q, NULL, Q, NULL, mat_array.data(), &A_nest));
  LibmeshPetscCall(VecCreateNest(PETSC_COMM_SELF, Q, NULL, vec_array.data(), &b_nest));
  V("Nested system created");
 
  KSP ksp;
  PC pc;
  LibmeshPetscCall(KSPCreate(PETSC_COMM_SELF, &ksp));
  LibmeshPetscCall(KSPSetOptionsPrefix(ksp, "scm_coupled_"));
  LibmeshPetscCall(KSPSetType(ksp, KSPFGMRES));
  LibmeshPetscCall(KSPSetOperators(ksp, A_nest, A_nest));
  LibmeshPetscCall(KSPGetPC(ksp, &pc));
  LibmeshPetscCall(PCSetType(pc, PCFIELDSPLIT));
  LibmeshPetscCall(KSPSetTolerances(ksp, _rtol, _atol, _dtol, _maxit));
 
  // split equations
  std::vector<IS> rows(Q);
  LibmeshPetscCall(MatNestGetISs(A_nest, rows.data(), NULL));
  for (PetscInt j = 0; j < Q; ++j)
  {
    IS part;
    LibmeshPetscCall(ISDuplicate(rows[j], &part));
    LibmeshPetscCall(PCFieldSplitSetIS(pc, NULL, part));
    LibmeshPetscCall(ISDestroy(&part));
  }
  LibmeshPetscCall(KSPSetFromOptions(ksp));
  V("Linear solver assembled");
 
  // ============================== Solve =====================================
  LibmeshPetscCall(VecDuplicate(b_nest, &x_nest));
  LibmeshPetscCall(VecSet(x_nest, 0.0));
  LibmeshPetscCall(KSPSolve(ksp, b_nest, x_nest));
  KSPConvergedReason reason;
  LibmeshPetscCall(KSPGetConvergedReason(ksp, &reason));
  if (reason < 0)
  {
    PetscInt iterations;
    PetscReal residual_norm;
    LibmeshPetscCall(KSPGetIterationNumber(ksp, &iterations));
    LibmeshPetscCall(KSPGetResidualNorm(ksp, &residual_norm));
    mooseError(name(),
               ": coupled mass/momentum linear solve failed: ",
               KSPConvergedReasons[reason],
               " (",
               static_cast<int>(reason),
               ") after ",
               iterations,
               " iterations; residual norm = ",
               residual_norm,
               ".");
  }
 
  // destroy solver containers first
  LibmeshPetscCall(VecDestroy(&b_nest));
  LibmeshPetscCall(MatDestroy(&A_nest));
  LibmeshPetscCall(KSPDestroy(&ksp));
  for (PetscInt i = 0; i < Q * Q; i++)
    LibmeshPetscCall(MatDestroy(&mat_array[i]));
  for (PetscInt i = 0; i < Q; i++)
    LibmeshPetscCall(VecDestroy(&vec_array[i]));
  V("Solver elements destroyed");
 
  // ====================== Extract & scatter the solution =====================
  Vec sol_mdot, sol_p, sol_Wij;
  V("Vectors to hold solution created");
  PetscInt num_vecs;
  Vec * loc_vecs;
  LibmeshPetscCall(VecNestGetSubVecs(x_nest, &num_vecs, &loc_vecs));
  LibmeshPetscCall(VecDuplicate(_mc_axial_convection_rhs, &sol_mdot));
  LibmeshPetscCall(VecCopy(loc_vecs[0], sol_mdot));
  LibmeshPetscCall(VecDuplicate(_amc_sys_mdot_rhs, &sol_p));
  LibmeshPetscCall(VecCopy(loc_vecs[1], sol_p));
  LibmeshPetscCall(VecDuplicate(_cmc_sys_Wij_rhs, &sol_Wij));
  LibmeshPetscCall(VecCopy(loc_vecs[2], sol_Wij));
  V("Solution from coupled solver copied to solution vectors");
 
  // Apply independent post-solve relaxation to the fixed-point solution update.
  auto relaxSolution = [&](Vec solution, Vec old_solution, const Real relaxation)
  {
    LibmeshPetscCall(VecScale(solution, relaxation));
    LibmeshPetscCall(VecAXPY(solution, 1.0 - relaxation, old_solution));
  };
  LibmeshPetscCall(populateVectorFromHandle<SolutionHandle>(
      _prod, *_mdot_soln, first_node, last_node, _n_channels));
  LibmeshPetscCall(populateVectorFromHandle<SolutionHandle>(
      _prodp, *_P_soln, first_node - 1, last_node - 1, _n_channels));
 
  // Measure the pressure update before post-solve relaxation so changing that relaxation does
  // not change the meaning of the outer pressure tolerance.
  Vec pressure_residual;
  LibmeshPetscCall(VecDuplicate(sol_p, &pressure_residual));
  LibmeshPetscCall(VecCopy(sol_p, pressure_residual));
  LibmeshPetscCall(VecAXPY(pressure_residual, -1.0, _prodp));
 
  const PetscScalar * residual_array;
  const PetscScalar * old_pressure_array;
  PetscInt pressure_size;
  LibmeshPetscCall(VecGetSize(pressure_residual, &pressure_size));
  LibmeshPetscCall(VecGetArrayRead(pressure_residual, &residual_array));
  LibmeshPetscCall(VecGetArrayRead(_prodp, &old_pressure_array));
  Real residual_norm_sq = 0.0;
  Real pressure_norm_sq = 0.0;
  for (PetscInt i = 0; i < pressure_size; ++i)
  {
    residual_norm_sq += Utility::pow<2>(residual_array[i]);
    pressure_norm_sq += Utility::pow<2>(old_pressure_array[i] + _P_out);
  }
  LibmeshPetscCall(VecRestoreArrayRead(pressure_residual, &residual_array));
  LibmeshPetscCall(VecRestoreArrayRead(_prodp, &old_pressure_array));
  LibmeshPetscCall(VecDestroy(&pressure_residual));
  _pressure_fixed_point_error =
      std::max(_pressure_fixed_point_error,
               std::sqrt(residual_norm_sq) / (std::sqrt(pressure_norm_sq) + 1e-14));
 
  relaxSolution(sol_mdot, _prod, _mass_flow_relaxation);
  relaxSolution(sol_p, _prodp, _pressure_relaxation);
  LibmeshPetscCall(populateVectorFromDense<libMesh::DenseMatrix<Real>>(
      _Wij_vec, _Wij, first_node, last_node, _n_gaps));
  relaxSolution(sol_Wij, _Wij_vec, _crossflow_relaxation);
 
  // mass flow
  LibmeshPetscCall(populateSolutionChan<SolutionHandle>(
      sol_mdot, *_mdot_soln, first_node, last_node, _n_channels));
 
  // pressure
  {
    PetscScalar * sol_p_array;
    LibmeshPetscCall(VecGetArray(sol_p, &sol_p_array));
    for (unsigned int iz = last_node; iz > first_node - 1; iz--)
    {
      const auto iz_ind = iz - first_node;
      for (unsigned int i_ch = 0; i_ch < _n_channels; i_ch++)
      {
        auto * node_in = _subchannel_mesh.getChannelNode(i_ch, iz - 1);
        PetscScalar value = sol_p_array[iz_ind * _n_channels + i_ch];
        _P_soln->set(node_in, value);
      }
    }
    LibmeshPetscCall(VecRestoreArray(sol_p, &sol_p_array));
  }
 
  // crossflow dense + sumWij + correction factor
  LibmeshPetscCall(populateDenseFromVector<libMesh::DenseMatrix<Real>>(
      sol_Wij, _Wij, first_node, last_node, _n_gaps));
 
  LibmeshPetscCall(MatMult(_mc_sumWij_mat, sol_Wij, _prod));
  LibmeshPetscCall(populateSolutionChan<SolutionHandle>(
      _prod, *_SumWij_soln, first_node, last_node, _n_channels));
 
  LibmeshPetscCall(VecAbs(_prod));
  LibmeshPetscCall(VecMax(_prod, NULL, &_max_sumWij_new));
  V("Maximum estimated Wij new: " + std::to_string(_max_sumWij_new));
  _correction_factor = _max_sumWij_new / _max_sumWij;
  V("Correction factor: " + std::to_string(_correction_factor));
  V("Solutions assigned to MOOSE variables.");
 
  // cleanup solution objects
  LibmeshPetscCall(VecDestroy(&x_nest));
  LibmeshPetscCall(VecDestroy(&sol_mdot));
  LibmeshPetscCall(VecDestroy(&sol_p));
  LibmeshPetscCall(VecDestroy(&sol_Wij));
  V("Solutions destroyed.");
 
  PetscFunctionReturn(LIBMESH_PETSC_SUCCESS);
}

Referenced by externalSolve().

initializeSolution()

virtual void SubChannel1PhaseProblem::initializeSolution ( )

protectedpure virtual

Function to initialize the solution & geometry fields.

Implemented in QuadSubChannel1PhaseProblem, and TriSubChannel1PhaseProblem.

Referenced by externalSolve().

initialSetup()

void SubChannel1PhaseProblem::initialSetup ( )

overridevirtual

Set value for turbulent momentum modeling parameter CT

Reimplemented from ExternalProblem.

Definition at line 368 of file SubChannel1PhaseProblem.C.

{
  ExternalProblem::initialSetup();
 
  _fp = &getUserObject<SinglePhaseFluidProperties>(getParam<UserObjectName>("fp"));
  _friction_closure =
      &getUserObject<SCMFrictionClosureBase>(getParam<UserObjectName>("friction_closure"));
  _mixing_closure =
      &getUserObject<SCMMixingClosureBase>(getParam<UserObjectName>("mixing_closure"));
 
  _CT = _mixing_closure->getCT();
 
  // Create variables for output and storage
  _mdot_soln = std::make_unique<SolutionHandle>(getVariable(0, SubChannelApp::MASS_FLOW_RATE));
  _SumWij_soln = std::make_unique<SolutionHandle>(getVariable(0, SubChannelApp::SUM_CROSSFLOW));
  _P_soln = std::make_unique<SolutionHandle>(getVariable(0, SubChannelApp::PRESSURE));
  if (getParam<bool>("full_output"))
  {
    _DP_soln = std::make_unique<SolutionHandle>(getVariable(0, SubChannelApp::PRESSURE_DROP));
    _ff_soln = std::make_unique<SolutionHandle>(getVariable(0, SubChannelApp::FRICTION_FACTOR));
  }
  _h_soln = std::make_unique<SolutionHandle>(getVariable(0, SubChannelApp::ENTHALPY));
  _T_soln = std::make_unique<SolutionHandle>(getVariable(0, SubChannelApp::TEMPERATURE));
  if (_pin_mesh_exist)
  {
    _Tpin_soln = std::make_unique<SolutionHandle>(getVariable(0, SubChannelApp::PIN_TEMPERATURE));
    _Dpin_soln = std::make_unique<SolutionHandle>(getVariable(0, SubChannelApp::PIN_DIAMETER));
    _HTC_soln =
        std::make_unique<SolutionHandle>(getVariable(0, SubChannelApp::HEAT_TRANSFER_COEFFICIENT));
    _pin_HTC_closure =
        &getUserObject<SCMHTCClosureBase>(getParam<UserObjectName>("pin_HTC_closure"));
  }
  _rho_soln = std::make_unique<SolutionHandle>(getVariable(0, SubChannelApp::DENSITY));
  _mu_soln = std::make_unique<SolutionHandle>(getVariable(0, SubChannelApp::VISCOSITY));
  _S_flow_soln = std::make_unique<SolutionHandle>(getVariable(0, SubChannelApp::SURFACE_AREA));
  _w_perim_soln = std::make_unique<SolutionHandle>(getVariable(0, SubChannelApp::WETTED_PERIMETER));
  _q_prime_soln = std::make_unique<SolutionHandle>(getVariable(0, SubChannelApp::LINEAR_HEAT_RATE));
  _displacement_soln =
      std::make_unique<SolutionHandle>(getVariable(0, SubChannelApp::DISPLACEMENT));
  if (_duct_mesh_exist)
  {
    _duct_heat_flux_soln =
        std::make_unique<SolutionHandle>(getVariable(0, SubChannelApp::DUCT_HEAT_FLUX));
    _Tduct_soln = std::make_unique<SolutionHandle>(getVariable(0, SubChannelApp::DUCT_TEMPERATURE));
    _duct_HTC_closure =
        &getUserObject<SCMHTCClosureBase>(getParam<UserObjectName>("duct_HTC_closure"));
  }
}

petscSnesSolver()

PetscErrorCode SubChannel1PhaseProblem::petscSnesSolver ( int  iblock, const libMesh::DenseVector< Real > &  solution, libMesh::DenseVector< Real > &  root  )

protected

Computes solution of nonlinear equation using snes and provided a residual in a formFunction.

Definition at line 2126 of file SubChannel1PhaseProblem.C.

{
  SNES snes;
  KSP ksp;
  PC pc;
  Vec x, r;
  PetscScalar * xx;
 
  PetscFunctionBegin;
  LibmeshPetscCall(SNESCreate(PETSC_COMM_SELF, &snes));
  LibmeshPetscCall(VecCreate(PETSC_COMM_SELF, &x));
  LibmeshPetscCall(VecSetSizes(x, PETSC_DECIDE, _block_size * _n_gaps));
  LibmeshPetscCall(VecSetFromOptions(x));
  LibmeshPetscCall(VecDuplicate(x, &r));
 
#if PETSC_VERSION_LESS_THAN(3, 13, 0)
  LibmeshPetscCall(PetscOptionsSetValue(PETSC_NULL, "-snes_mf", PETSC_NULL));
#else
  LibmeshPetscCall(SNESSetUseMatrixFree(snes, PETSC_FALSE, PETSC_TRUE));
#endif
  Ctx ctx;
  ctx.iblock = iblock;
  ctx.schp = this;
  LibmeshPetscCall(SNESSetFunction(snes, r, formFunction, &ctx));
  LibmeshPetscCall(SNESGetKSP(snes, &ksp));
  LibmeshPetscCall(KSPGetPC(ksp, &pc));
  LibmeshPetscCall(PCSetType(pc, PCNONE));
  LibmeshPetscCall(KSPSetTolerances(ksp, _rtol, _atol, _dtol, _maxit));
  LibmeshPetscCall(SNESSetFromOptions(snes));
  LibmeshPetscCall(VecGetArray(x, &xx));
  for (unsigned int i = 0; i < _block_size * _n_gaps; i++)
  {
    xx[i] = solution(i);
  }
  LibmeshPetscCall(VecRestoreArray(x, &xx));
 
  LibmeshPetscCall(SNESSolve(snes, NULL, x));
  LibmeshPetscCall(VecGetArray(x, &xx));
  for (unsigned int i = 0; i < _block_size * _n_gaps; i++)
    root(i) = xx[i];
 
  LibmeshPetscCall(VecRestoreArray(x, &xx));
  LibmeshPetscCall(VecDestroy(&x));
  LibmeshPetscCall(VecDestroy(&r));
  LibmeshPetscCall(SNESDestroy(&snes));
  PetscFunctionReturn(LIBMESH_PETSC_SUCCESS);
}

Referenced by computeWijFromSolve().

populateDenseFromVector()

template<class T >

PetscErrorCode SubChannel1PhaseProblem::populateDenseFromVector ( const Vec &  x, T &  solution, const unsigned int  first_axial_level, const unsigned int  last_axial_level, const unsigned int  cross_dimension  )

protected

Definition at line 449 of file SubChannel1PhaseProblem.h.

{
  PetscScalar * xx;
 
  PetscFunctionBegin;
  LibmeshPetscCall(VecGetArray(x, &xx));
  for (unsigned int iz = first_axial_level; iz < last_axial_level + 1; iz++)
  {
    unsigned int iz_ind = iz - first_axial_level;
    for (unsigned int i_l = 0; i_l < cross_dimension; i_l++)
    {
      loc_solution(i_l, iz) = xx[iz_ind * cross_dimension + i_l];
    }
  }
  LibmeshPetscCall(VecRestoreArray(x, &xx));
 
  PetscFunctionReturn(LIBMESH_PETSC_SUCCESS);
}

Referenced by computeWijPrime(), and implicitPetscSolve().

populateSolutionChan()

template<class T >

PetscErrorCode SubChannel1PhaseProblem::populateSolutionChan ( const Vec &  x, T &  solution, const unsigned int  first_axial_level, const unsigned int  last_axial_level, const unsigned int  cross_dimension  )

protected

Definition at line 523 of file SubChannel1PhaseProblem.h.

{
  PetscScalar * xx;
  PetscFunctionBegin;
  LibmeshPetscCall(VecGetArray(x, &xx));
  Node * loc_node;
  for (unsigned int iz = first_axial_level; iz < last_axial_level + 1; iz++)
  {
    unsigned int iz_ind = iz - first_axial_level;
    for (unsigned int i_l = 0; i_l < cross_dimension; i_l++)
    {
      loc_node = _subchannel_mesh.getChannelNode(i_l, iz);
      loc_solution.set(loc_node, xx[iz_ind * cross_dimension + i_l]);
    }
  }
  PetscFunctionReturn(LIBMESH_PETSC_SUCCESS);
}

populateVectorFromDense()

template<class T >

PetscErrorCode SubChannel1PhaseProblem::populateVectorFromDense ( Vec &  x, const T &  solution, const unsigned int  first_axial_level, const unsigned int  last_axial_level, const unsigned int  cross_dimension  )

protected

Definition at line 500 of file SubChannel1PhaseProblem.h.

{
  PetscScalar * xx;
  PetscFunctionBegin;
  LibmeshPetscCall(VecGetArray(x, &xx));
  for (unsigned int iz = first_axial_level; iz < last_axial_level + 1; iz++)
  {
    unsigned int iz_ind = iz - first_axial_level;
    for (unsigned int i_l = 0; i_l < cross_dimension; i_l++)
    {
      xx[iz_ind * cross_dimension + i_l] = loc_solution(i_l, iz);
    }
  }
  LibmeshPetscCall(VecRestoreArray(x, &xx));
  PetscFunctionReturn(LIBMESH_PETSC_SUCCESS);
}

Referenced by computeSumWij(), computeWijResidual(), and implicitPetscSolve().

populateVectorFromHandle()

template<class T >

PetscErrorCode SubChannel1PhaseProblem::populateVectorFromHandle ( Vec &  x, const T &  solution, const unsigned int  first_axial_level, const unsigned int  last_axial_level, const unsigned int  cross_dimension  )

protected

Definition at line 474 of file SubChannel1PhaseProblem.h.

{
  PetscScalar * xx;
 
  PetscFunctionBegin;
  LibmeshPetscCall(VecGetArray(x, &xx));
  for (unsigned int iz = first_axial_level; iz < last_axial_level + 1; iz++)
  {
    unsigned int iz_ind = iz - first_axial_level;
    for (unsigned int i_l = 0; i_l < cross_dimension; i_l++)
    {
      auto * loc_node = _subchannel_mesh.getChannelNode(i_l, iz);
      xx[iz_ind * cross_dimension + i_l] = loc_solution(loc_node);
    }
  }
  LibmeshPetscCall(VecRestoreArray(x, &xx));
 
  PetscFunctionReturn(LIBMESH_PETSC_SUCCESS);
}

residualFunction()

libMesh::DenseVector< Real > SubChannel1PhaseProblem::residualFunction ( int  iblock, libMesh::DenseVector< Real >  solution  )

protected

Computes Residual Vector based on the lateral momentum conservation equation for block iblock & updates flow variables based on current crossflow solution.

Definition at line 2084 of file SubChannel1PhaseProblem.C.

{
  const unsigned int last_node = (iblock + 1) * _block_size;
  const unsigned int first_node = iblock * _block_size + 1;
  libMesh::DenseVector<Real> Wij_residual_vector(_n_gaps * _block_size, 0.0);
  // Assign the solution to the cross-flow matrix
  int i = 0;
  for (unsigned int iz = first_node; iz < last_node + 1; iz++)
  {
    for (unsigned int i_gap = 0; i_gap < _n_gaps; i_gap++)
    {
      _Wij(i_gap, iz) = solution(i);
      i++;
    }
  }
 
  // Calculating sum of crossflows
  computeSumWij(iblock);
  // Solving axial flux
  computeMdot(iblock);
  // Calculation of turbulent Crossflow
  computeWijPrime(iblock);
  // Solving for Pressure Drop
  computeDP(iblock);
  // Solving for pressure
  computeP(iblock);
  // Populating lateral crossflow residual matrix
  computeWijResidual(iblock);
 
  // Turn the residual matrix into a residual vector
  for (unsigned int iz = 0; iz < _block_size; iz++)
  {
    for (unsigned int i_gap = 0; i_gap < _n_gaps; i_gap++)
    {
      int i = _n_gaps * iz + i_gap; // column wise transfer
      Wij_residual_vector(i) = _Wij_residual_matrix(i_gap, iz);
    }
  }
  return Wij_residual_vector;
}

solveAndPopulateEnthalpy()

PetscErrorCode SubChannel1PhaseProblem::solveAndPopulateEnthalpy ( Mat  A, Vec  rhs, unsigned int  first_node, unsigned int  last_node, const char *  ksp_prefix  )

protected

Solve a linear system (A * x = rhs) with a simple PCJACOBI KSP and populate the enthalpy solution into _h_soln for nodes [first_node, last_node].

Uses member tolerances (_rtol, _atol, _dtol, _maxit), mesh (_subchannel_mesh), channel count (_n_channels), and error/solution handles (mooseError, _h_soln).

Parameters

A	PETSc matrix (operators)
rhs	PETSc vector (right-hand side)
first_node	inclusive start axial node index
last_node	inclusive end axial node index
ksp_prefix	options prefix for KSP (e.g. "h_sys_"), may be nullptr

Definition at line 2177 of file SubChannel1PhaseProblem.C.

{
  PetscFunctionBegin;
 
  // Create solution vector with rhs layout
  Vec x = nullptr;
  LibmeshPetscCall(VecDuplicate(rhs, &x));
 
  // KSP setup
  KSP ksp = nullptr;
  PC pc = nullptr;
  LibmeshPetscCall(KSPCreate(PETSC_COMM_SELF, &ksp));
  LibmeshPetscCall(KSPSetOperators(ksp, A, A));
  LibmeshPetscCall(KSPGetPC(ksp, &pc));
  LibmeshPetscCall(PCSetType(pc, PCJACOBI));
  LibmeshPetscCall(KSPSetTolerances(ksp, _rtol, _atol, _dtol, _maxit));
  if (ksp_prefix && *ksp_prefix)
    LibmeshPetscCall(KSPSetOptionsPrefix(ksp, ksp_prefix));
  LibmeshPetscCall(KSPSetFromOptions(ksp));
 
  // Solve
  LibmeshPetscCall(KSPSolve(ksp, rhs, x));
  KSPConvergedReason reason;
  LibmeshPetscCall(KSPGetConvergedReason(ksp, &reason));
  if (reason < 0)
  {
    PetscInt iterations;
    PetscReal residual_norm;
    LibmeshPetscCall(KSPGetIterationNumber(ksp, &iterations));
    LibmeshPetscCall(KSPGetResidualNorm(ksp, &residual_norm));
    mooseError(name(),
               ": enthalpy linear solve failed: ",
               KSPConvergedReasons[reason],
               " (",
               static_cast<int>(reason),
               ") after ",
               iterations,
               " iterations; residual norm = ",
               residual_norm,
               ".");
  }
 
  // Scatter to _h_soln with sanity checks
  PetscScalar * xx = nullptr;
  LibmeshPetscCall(VecGetArray(x, &xx));
  for (unsigned int iz = first_node; iz <= last_node; ++iz)
  {
    const unsigned int iz_ind = iz - first_node;
    for (unsigned int i_ch = 0; i_ch < _n_channels; ++i_ch)
    {
      auto * node_out = _subchannel_mesh.getChannelNode(i_ch, iz);
      const PetscScalar h_out = xx[iz_ind * _n_channels + i_ch];
      if (h_out < 0.0)
        mooseError(
            name(), " : Calculation of negative Enthalpy h_out = ", h_out, " Axial Level = ", iz);
      _h_soln->set(node_out, h_out);
    }
  }
  LibmeshPetscCall(VecRestoreArray(x, &xx));
 
  // Cleanup
  LibmeshPetscCall(KSPDestroy(&ksp));
  LibmeshPetscCall(VecDestroy(&x));
 
  PetscFunctionReturn(LIBMESH_PETSC_SUCCESS);
}

Referenced by QuadSubChannel1PhaseProblem::computeh(), and TriSubChannel1PhaseProblem::computeh().

solverSystemConverged()

bool SubChannel1PhaseProblem::solverSystemConverged ( const unsigned int  )

overridevirtual

Reimplemented from ExternalProblem.

Definition at line 553 of file SubChannel1PhaseProblem.C.

{
  return _converged;
}

syncSolutions()

void SubChannel1PhaseProblem::syncSolutions ( Direction  direction )

overridevirtual

Implements ExternalProblem.

Definition at line 3104 of file SubChannel1PhaseProblem.C.

{
}

validParams()

InputParameters SubChannel1PhaseProblem::validParams ( )

static

Definition at line 62 of file SubChannel1PhaseProblem.C.

{
  // Enumerations
  MooseEnum schemes("upwind downwind central_difference exponential", "central_difference");
  MooseEnum gravity_direction("counter_flow co_flow none", "counter_flow");
 
  // Inputs
  InputParameters params = ExternalProblem::validParams();
  params += PostprocessorInterface::validParams();
  params.addClassDescription("Base class of the subchannel solvers");
  params.addParam<unsigned int>("n_blocks", 1, "The number of blocks in the axial direction");
  params.addParam<Real>("P_tol", 1e-6, "Pressure tolerance");
  params.addRangeCheckedParam<int>(
      "P_maxit",
      0,
      "P_maxit >= 0",
      "Maximum number of pressure iterations; zero selects the solver's automatic limit");
  params.addParam<Real>("T_tol", 1e-6, "Temperature tolerance");
  params.addParam<int>("T_maxit", 100, "Maximum number of iterations for inner temperature loop");
  params.addRangeCheckedParam<Real>(
      "T_relaxation",
      1.0,
      "T_relaxation > 0 & T_relaxation <= 1",
      "Relaxation factor for temperature updates in the inner thermal-hydraulic iteration");
  params.addRangeCheckedParam<unsigned int>(
      "enthalpy_subcycles",
      1,
      "enthalpy_subcycles > 0",
      "Number of enthalpy, temperature, and property updates performed per flow solve");
  params.addRangeCheckedParam<Real>(
      "mass_flow_equation_relaxation",
      1.0,
      "mass_flow_equation_relaxation > 0 & mass_flow_equation_relaxation <= 1",
      "Equation relaxation factor for mass flow rate in the implicit non-segregated solve");
  params.addRangeCheckedParam<Real>(
      "pressure_equation_relaxation",
      1.0,
      "pressure_equation_relaxation > 0 & pressure_equation_relaxation <= 1",
      "Equation relaxation factor for pressure in the implicit non-segregated solve");
  params.addRangeCheckedParam<Real>(
      "crossflow_equation_relaxation",
      0.1,
      "crossflow_equation_relaxation > 0 & crossflow_equation_relaxation <= 1",
      "Equation relaxation factor for crossflow in the implicit non-segregated solve");
  params.addRangeCheckedParam<Real>(
      "mass_flow_relaxation",
      1.0,
      "mass_flow_relaxation > 0 & mass_flow_relaxation <= 1",
      "Post-solve relaxation factor for mass flow rate updates in the implicit non-segregated "
      "solve");
  params.addRangeCheckedParam<Real>(
      "pressure_relaxation",
      1.0,
      "pressure_relaxation > 0 & pressure_relaxation <= 1",
      "Post-solve relaxation factor for pressure updates in the implicit non-segregated solve");
  params.addRangeCheckedParam<Real>(
      "crossflow_relaxation",
      1.0,
      "crossflow_relaxation > 0 & crossflow_relaxation <= 1",
      "Post-solve relaxation factor for crossflow updates in the implicit non-segregated solve");
  params.addParam<PetscReal>("rtol", 1e-6, "Relative tolerance for ksp solver");
  params.addParam<PetscReal>("atol", 1e-6, "Absolute tolerance for ksp solver");
  params.addParam<PetscReal>("dtol", 1e5, "Divergence tolerance or ksp solver");
  params.addParam<PetscInt>("maxit", 1e4, "Maximum number of iterations for ksp solver");
  params.addParam<MooseEnum>(
      "interpolation_scheme",
      schemes,
      "Interpolation scheme used for the method. Default is central_difference");
  params.addParam<MooseEnum>(
      "gravity", gravity_direction, "Direction of gravity. Default is counter_flow");
  params.addParam<bool>(
      "implicit", false, "Boolean to define the use of explicit or implicit solution.");
  params.addParam<bool>("staggered_pressure",
                        false,
                        "Boolean to define the use of staggered or collocated pressure.");
  params.addParam<bool>(
      "segregated", true, "Boolean to define whether to use a segregated solution.");
  params.addParam<bool>(
      "verbose_subchannel", false, "Boolean to print out information related to subchannel solve.");
  params.addRequiredParam<bool>("compute_density", "Flag that enables the calculation of density");
  params.addRequiredParam<bool>("compute_viscosity",
                                "Flag that enables the calculation of viscosity");
  params.addRequiredParam<bool>(
      "compute_power",
      "Flag that informs whether we solve the Enthalpy/Temperature equations or not");
  params.addRequiredParam<PostprocessorName>(
      "P_out",
      "The postprocessor (or scalar) that provides the absolute outlet pressure [Pa]. The solved "
      "pressure variable P is relative to this value.");
  params.addRequiredParam<UserObjectName>("fp", "Fluid properties user object name");
  params.addRequiredParam<UserObjectName>("friction_closure",
                                          "Closure computing the friction factor");
  params.addRequiredParam<UserObjectName>(
      "mixing_closure",
      "Closure computing the turbulent mixing, wire-induced "
      "mixing and sweep flow mixing parameter where applicable");
  params.addParam<UserObjectName>(
      "pin_HTC_closure", "Closure computing HTC on fuel pin (required if pin mesh exists).");
  params.addParam<UserObjectName>("duct_HTC_closure",
                                  "Closure computing HTC on duct (required if duct mesh exists).");
  params.addParam<bool>(
      "full_output", false, "Flag that enables the output of the maximum number of variables.");
  params.addDeprecatedParam<Real>("beta",
                                  "Thermal diffusion coefficient used in turbulent crossflow.",
                                  "Use closure system instead.");
  params.addDeprecatedParam<bool>(
      "constant_beta",
      true,
      "Boolean to define the use of a constant beta or beta correlation (Kim and Chung, 2001)",
      "Use closure system instead.");
 
  params.addParamNamesToGroup(
      "P_tol P_maxit T_tol T_maxit T_relaxation enthalpy_subcycles "
      "mass_flow_equation_relaxation pressure_equation_relaxation crossflow_equation_relaxation "
      "mass_flow_relaxation pressure_relaxation crossflow_relaxation rtol atol dtol maxit",
      "Solver tolerances and iterations");
  params.addParamNamesToGroup("implicit segregated staggered_pressure interpolation_scheme",
                              "Solution method");
  params.addParamNamesToGroup("fp friction_closure mixing_closure pin_HTC_closure duct_HTC_closure",
                              "Closures");
  params.addParamNamesToGroup("compute_density compute_viscosity compute_power gravity",
                              "Physics models");
  params.addParamNamesToGroup("verbose_subchannel full_output", "Output");
 
  return params;
}

Referenced by QuadSubChannel1PhaseProblem::validParams(), and TriSubChannel1PhaseProblem::validParams().

Friends And Related Symbol Documentation

formFunction

PetscErrorCode formFunction ( SNES  snes, Vec  x, Vec  f, void *  ctx  )

friend

This is the residual Vector function in a form compatible with the SNES PETC solvers.

Definition at line 33 of file SubChannel1PhaseProblem.C.

{
  const PetscScalar * xx;
  PetscScalar * ff;
  PetscInt size;
 
  PetscFunctionBegin;
  Ctx * cc = static_cast<Ctx *>(ctx);
  LibmeshPetscCallQ(VecGetSize(x, &size));
 
  libMesh::DenseVector<Real> solution_seed(size, 0.0);
  LibmeshPetscCallQ(VecGetArrayRead(x, &xx));
  for (PetscInt i = 0; i < size; i++)
    solution_seed(i) = xx[i];
 
  LibmeshPetscCallQ(VecRestoreArrayRead(x, &xx));
 
  libMesh::DenseVector<Real> Wij_residual_vector =
      cc->schp->residualFunction(cc->iblock, solution_seed);
 
  LibmeshPetscCallQ(VecGetArray(f, &ff));
  for (int i = 0; i < size; i++)
    ff[i] = Wij_residual_vector(i);
 
  LibmeshPetscCallQ(VecRestoreArray(f, &ff));
  PetscFunctionReturn(LIBMESH_PETSC_SUCCESS);
}

Referenced by petscSnesSolver().

Member Data Documentation

_added_K

PetscScalar SubChannel1PhaseProblem::_added_K = 0.0

protected

Added resistances for monolithic convergence.

Definition at line 435 of file SubChannel1PhaseProblem.h.

Referenced by implicitPetscSolve().

_added_K_old

PetscScalar SubChannel1PhaseProblem::_added_K_old = 1000.0

protected

Definition at line 436 of file SubChannel1PhaseProblem.h.

Referenced by implicitPetscSolve().

_amc_advective_derivative_mat

Mat SubChannel1PhaseProblem::_amc_advective_derivative_mat

protected

Axial momentum conservation - advective (Eulerian) derivative.

Definition at line 383 of file SubChannel1PhaseProblem.h.

Referenced by cleanUp(), computeDP(), and SubChannel1PhaseProblem().

_amc_advective_derivative_rhs

Vec SubChannel1PhaseProblem::_amc_advective_derivative_rhs

protected

Definition at line 384 of file SubChannel1PhaseProblem.h.

Referenced by cleanUp(), computeDP(), and SubChannel1PhaseProblem().

_amc_cross_derivative_mat

Mat SubChannel1PhaseProblem::_amc_cross_derivative_mat

protected

Axial momentum conservation - cross flux derivative.

Definition at line 386 of file SubChannel1PhaseProblem.h.

Referenced by cleanUp(), computeDP(), and SubChannel1PhaseProblem().

_amc_cross_derivative_rhs

Vec SubChannel1PhaseProblem::_amc_cross_derivative_rhs

protected

Definition at line 387 of file SubChannel1PhaseProblem.h.

Referenced by cleanUp(), computeDP(), and SubChannel1PhaseProblem().

_amc_friction_force_mat

Mat SubChannel1PhaseProblem::_amc_friction_force_mat

protected

Axial momentum conservation - friction force.

Definition at line 389 of file SubChannel1PhaseProblem.h.

Referenced by cleanUp(), computeDP(), and SubChannel1PhaseProblem().

_amc_friction_force_rhs

Vec SubChannel1PhaseProblem::_amc_friction_force_rhs

protected

Definition at line 390 of file SubChannel1PhaseProblem.h.

Referenced by cleanUp(), computeDP(), and SubChannel1PhaseProblem().

_amc_gravity_rhs

Vec SubChannel1PhaseProblem::_amc_gravity_rhs

protected

Axial momentum conservation - buoyancy force No implicit matrix.

Definition at line 393 of file SubChannel1PhaseProblem.h.

Referenced by cleanUp(), computeDP(), and SubChannel1PhaseProblem().

_amc_pressure_force_mat

Mat SubChannel1PhaseProblem::_amc_pressure_force_mat

protected

Axial momentum conservation - pressure force.

Definition at line 395 of file SubChannel1PhaseProblem.h.

Referenced by cleanUp(), computeP(), implicitPetscSolve(), and SubChannel1PhaseProblem().

_amc_pressure_force_rhs

Vec SubChannel1PhaseProblem::_amc_pressure_force_rhs

protected

Definition at line 396 of file SubChannel1PhaseProblem.h.

Referenced by cleanUp(), computeP(), implicitPetscSolve(), and SubChannel1PhaseProblem().

_amc_sys_mdot_mat

Mat SubChannel1PhaseProblem::_amc_sys_mdot_mat

protected

Axial momentum system matrix.

Definition at line 398 of file SubChannel1PhaseProblem.h.

Referenced by cleanUp(), computeDP(), implicitPetscSolve(), and SubChannel1PhaseProblem().

_amc_sys_mdot_rhs

Vec SubChannel1PhaseProblem::_amc_sys_mdot_rhs

protected

Definition at line 399 of file SubChannel1PhaseProblem.h.

Referenced by cleanUp(), computeDP(), computeSumWij(), computeWijPrime(), implicitPetscSolve(), and SubChannel1PhaseProblem().

_amc_time_derivative_mat

Mat SubChannel1PhaseProblem::_amc_time_derivative_mat

protected

Axial momentum conservation - time derivative.

Definition at line 380 of file SubChannel1PhaseProblem.h.

Referenced by cleanUp(), computeDP(), and SubChannel1PhaseProblem().

_amc_time_derivative_rhs

Vec SubChannel1PhaseProblem::_amc_time_derivative_rhs

protected

Definition at line 381 of file SubChannel1PhaseProblem.h.

Referenced by cleanUp(), computeDP(), and SubChannel1PhaseProblem().

_amc_turbulent_cross_flows_mat

Mat SubChannel1PhaseProblem::_amc_turbulent_cross_flows_mat

protected

Axial momentum Axial momentum conservation - compute turbulent cross fluxes.

Definition at line 377 of file SubChannel1PhaseProblem.h.

Referenced by cleanUp(), computeWijPrime(), and SubChannel1PhaseProblem().

_amc_turbulent_cross_flows_rhs

Vec SubChannel1PhaseProblem::_amc_turbulent_cross_flows_rhs

protected

Definition at line 378 of file SubChannel1PhaseProblem.h.

Referenced by cleanUp(), computeWijPrime(), and SubChannel1PhaseProblem().

_atol

const PetscReal& SubChannel1PhaseProblem::_atol

protected

The absolute convergence tolerance for the ksp linear solver.

Definition at line 267 of file SubChannel1PhaseProblem.h.

Referenced by computeMdot(), computeP(), implicitPetscSolve(), petscSnesSolver(), and solveAndPopulateEnthalpy().

_block_size

unsigned int SubChannel1PhaseProblem::_block_size

protected

Definition at line 212 of file SubChannel1PhaseProblem.h.

Referenced by computeDP(), QuadSubChannel1PhaseProblem::computeh(), TriSubChannel1PhaseProblem::computeh(), computeMdot(), computeMu(), computeP(), computeRho(), computeSumWij(), computeT(), computeWijFromSolve(), computeWijPrime(), computeWijResidual(), externalSolve(), implicitPetscSolve(), petscSnesSolver(), residualFunction(), SubChannel1PhaseProblem(), and TriSubChannel1PhaseProblem::TriSubChannel1PhaseProblem().

_bulk_Re

Real SubChannel1PhaseProblem::_bulk_Re

protected

Assembly bulk Reynolds number.

Definition at line 231 of file SubChannel1PhaseProblem.h.

Referenced by computeBulkReynoldsNumber(), externalSolve(), and getBulkReynoldsNumber().

_bulk_V

Real SubChannel1PhaseProblem::_bulk_V

protected

Assembly bulk velocity.

Definition at line 233 of file SubChannel1PhaseProblem.h.

Referenced by computeBulkReynoldsNumber(), and getBulkVelocity().

_cmc_advective_derivative_mat

Mat SubChannel1PhaseProblem::_cmc_advective_derivative_mat

protected

Cross momentum conservation - advective (Eulerian) derivative.

Definition at line 406 of file SubChannel1PhaseProblem.h.

Referenced by cleanUp(), computeWijResidual(), and SubChannel1PhaseProblem().

_cmc_advective_derivative_rhs

Vec SubChannel1PhaseProblem::_cmc_advective_derivative_rhs

protected

Definition at line 407 of file SubChannel1PhaseProblem.h.

Referenced by cleanUp(), computeWijResidual(), and SubChannel1PhaseProblem().

_cmc_friction_force_mat

Mat SubChannel1PhaseProblem::_cmc_friction_force_mat

protected

Cross momentum conservation - friction force.

Definition at line 409 of file SubChannel1PhaseProblem.h.

Referenced by cleanUp(), computeWijResidual(), and SubChannel1PhaseProblem().

_cmc_friction_force_rhs

Vec SubChannel1PhaseProblem::_cmc_friction_force_rhs

protected

Definition at line 410 of file SubChannel1PhaseProblem.h.

Referenced by cleanUp(), computeWijResidual(), and SubChannel1PhaseProblem().

_cmc_pressure_force_mat

Mat SubChannel1PhaseProblem::_cmc_pressure_force_mat

protected

Cross momentum conservation - pressure force.

Definition at line 412 of file SubChannel1PhaseProblem.h.

Referenced by cleanUp(), computeWijResidual(), implicitPetscSolve(), and SubChannel1PhaseProblem().

_cmc_pressure_force_rhs

Vec SubChannel1PhaseProblem::_cmc_pressure_force_rhs

protected

Definition at line 413 of file SubChannel1PhaseProblem.h.

Referenced by cleanUp(), computeWijResidual(), implicitPetscSolve(), and SubChannel1PhaseProblem().

_cmc_sys_Wij_mat

Mat SubChannel1PhaseProblem::_cmc_sys_Wij_mat

protected

Lateral momentum system matrix.

Definition at line 415 of file SubChannel1PhaseProblem.h.

Referenced by cleanUp(), computeWijResidual(), implicitPetscSolve(), and SubChannel1PhaseProblem().

_cmc_sys_Wij_rhs

Vec SubChannel1PhaseProblem::_cmc_sys_Wij_rhs

protected

Definition at line 416 of file SubChannel1PhaseProblem.h.

Referenced by cleanUp(), computeWijResidual(), implicitPetscSolve(), and SubChannel1PhaseProblem().

_cmc_time_derivative_mat

Mat SubChannel1PhaseProblem::_cmc_time_derivative_mat

protected

Cross momentum Cross momentum conservation - time derivative.

Definition at line 403 of file SubChannel1PhaseProblem.h.

Referenced by cleanUp(), computeWijResidual(), and SubChannel1PhaseProblem().

_cmc_time_derivative_rhs

Vec SubChannel1PhaseProblem::_cmc_time_derivative_rhs

protected

Definition at line 404 of file SubChannel1PhaseProblem.h.

Referenced by cleanUp(), computeWijResidual(), and SubChannel1PhaseProblem().

_compute_density

const bool SubChannel1PhaseProblem::_compute_density

protected

Flag that activates or deactivates the calculation of density.

Definition at line 219 of file SubChannel1PhaseProblem.h.

Referenced by computeMdot(), and externalSolve().

_compute_power

const bool SubChannel1PhaseProblem::_compute_power

protected

Flag that informs if we need to solve the Enthalpy/Temperature equations or not.

Definition at line 223 of file SubChannel1PhaseProblem.h.

Referenced by computeMdot(), and externalSolve().

_compute_viscosity

const bool SubChannel1PhaseProblem::_compute_viscosity

protected

Flag that activates or deactivates the calculation of viscosity.

Definition at line 221 of file SubChannel1PhaseProblem.h.

Referenced by externalSolve().

_converged

bool SubChannel1PhaseProblem::_converged

protected

Variable that informs whether we exited external solve with a converged solution or not.

Definition at line 229 of file SubChannel1PhaseProblem.h.

Referenced by externalSolve(), solverSystemConverged(), and SubChannel1PhaseProblem().

_correction_factor

PetscScalar SubChannel1PhaseProblem::_correction_factor = 1.0

protected

Definition at line 439 of file SubChannel1PhaseProblem.h.

Referenced by implicitPetscSolve().

_crossflow_equation_relaxation

const Real& SubChannel1PhaseProblem::_crossflow_equation_relaxation

protected

Equation relaxation factor for crossflow in the coupled implicit solve.

Definition at line 257 of file SubChannel1PhaseProblem.h.

Referenced by implicitPetscSolve().

_crossflow_relaxation

const Real& SubChannel1PhaseProblem::_crossflow_relaxation

protected

Relaxation factor for crossflow updates in the coupled implicit solve.

Definition at line 263 of file SubChannel1PhaseProblem.h.

Referenced by implicitPetscSolve().

_CT

Real SubChannel1PhaseProblem::_CT

protected

Turbulent modeling parameter used in axial momentum equation.

Definition at line 239 of file SubChannel1PhaseProblem.h.

Referenced by computeDP(), and initialSetup().

_deformation

bool SubChannel1PhaseProblem::_deformation = false

protected

Flag that activates the effect of deformation (pin/duct) based on the auxvalues for displacement, Dpin.

Definition at line 286 of file SubChannel1PhaseProblem.h.

Referenced by detectDeformation(), QuadSubChannel1PhaseProblem::initializeSolution(), and TriSubChannel1PhaseProblem::initializeSolution().

_dir_grav

const Real SubChannel1PhaseProblem::_dir_grav

protected

Definition at line 276 of file SubChannel1PhaseProblem.h.

Referenced by computeDP().

_displacement_soln

std::unique_ptr<SolutionHandle> SubChannel1PhaseProblem::_displacement_soln

protected

Definition at line 311 of file SubChannel1PhaseProblem.h.

Referenced by detectDeformation(), QuadSubChannel1PhaseProblem::initializeSolution(), and initialSetup().

_DP

libMesh::DenseMatrix<Real> SubChannel1PhaseProblem::_DP

protected

Definition at line 201 of file SubChannel1PhaseProblem.h.

Referenced by computeDP(), computeP(), and SubChannel1PhaseProblem().

_DP_soln

std::unique_ptr<SolutionHandle> SubChannel1PhaseProblem::_DP_soln

protected

Definition at line 299 of file SubChannel1PhaseProblem.h.

Referenced by computeDP(), and initialSetup().

_Dpin_soln

std::unique_ptr<SolutionHandle> SubChannel1PhaseProblem::_Dpin_soln

protected

Definition at line 303 of file SubChannel1PhaseProblem.h.

Referenced by externalSolve(), QuadSubChannel1PhaseProblem::initializeSolution(), TriSubChannel1PhaseProblem::initializeSolution(), and initialSetup().

_dt

Real SubChannel1PhaseProblem::_dt

protected

Time step.

Definition at line 237 of file SubChannel1PhaseProblem.h.

Referenced by computeDP(), QuadSubChannel1PhaseProblem::computeh(), TriSubChannel1PhaseProblem::computeh(), computeMdot(), computeWijResidual(), and externalSolve().

_dtol

const PetscReal& SubChannel1PhaseProblem::_dtol

protected

The divergence tolerance for the ksp linear solver.

Definition at line 269 of file SubChannel1PhaseProblem.h.

Referenced by computeMdot(), computeP(), implicitPetscSolve(), petscSnesSolver(), and solveAndPopulateEnthalpy().

_duct_heat_flux_soln

std::unique_ptr<SolutionHandle> SubChannel1PhaseProblem::_duct_heat_flux_soln

protected

Definition at line 309 of file SubChannel1PhaseProblem.h.

Referenced by initialSetup().

_duct_HTC_closure

const SCMHTCClosureBase* SubChannel1PhaseProblem::_duct_HTC_closure

protected

Definition at line 293 of file SubChannel1PhaseProblem.h.

Referenced by externalSolve(), getDuctHTCClosure(), and initialSetup().

_duct_mesh_exist

const bool SubChannel1PhaseProblem::_duct_mesh_exist

protected

Flag that informs if there is a duct mesh or not.

Definition at line 227 of file SubChannel1PhaseProblem.h.

Referenced by computeAddedHeatDuct(), externalSolve(), initialSetup(), and SubChannel1PhaseProblem().

_enthalpy_subcycles

const unsigned int& SubChannel1PhaseProblem::_enthalpy_subcycles

protected

Number of enthalpy, temperature, and property updates performed per flow solve.

Definition at line 251 of file SubChannel1PhaseProblem.h.

Referenced by externalSolve().

_ff_soln

std::unique_ptr<SolutionHandle> SubChannel1PhaseProblem::_ff_soln

protected

Definition at line 312 of file SubChannel1PhaseProblem.h.

Referenced by computeDP(), and initialSetup().

_fp

const SinglePhaseFluidProperties* SubChannel1PhaseProblem::_fp

Non-owning pointer to fluid properties user object.

Definition at line 100 of file SubChannel1PhaseProblem.h.

Referenced by QuadSubChannel1PhaseProblem::computeh(), TriSubChannel1PhaseProblem::computeh(), computeMdot(), computeMu(), computeRho(), computeT(), externalSolve(), getSinglePhaseFluidProperties(), and initialSetup().

_friction_args

struct SubChannel1PhaseProblem::FrictionStruct SubChannel1PhaseProblem::_friction_args

Referenced by computeDP(), and externalSolve().

_friction_closure

const SCMFrictionClosureBase* SubChannel1PhaseProblem::_friction_closure

protected

Friction closure object.

Definition at line 288 of file SubChannel1PhaseProblem.h.

Referenced by computeDP(), getFrictionClosure(), and initialSetup().

_g_grav

const Real SubChannel1PhaseProblem::_g_grav

protected

Definition at line 206 of file SubChannel1PhaseProblem.h.

Referenced by computeDP().

_gravity_direction

const MooseEnum SubChannel1PhaseProblem::_gravity_direction

protected

The direction of gravity.

Definition at line 275 of file SubChannel1PhaseProblem.h.

_h_soln

std::unique_ptr<SolutionHandle> SubChannel1PhaseProblem::_h_soln

protected

Definition at line 300 of file SubChannel1PhaseProblem.h.

Referenced by QuadSubChannel1PhaseProblem::computeh(), TriSubChannel1PhaseProblem::computeh(), computeT(), externalSolve(), initialSetup(), and solveAndPopulateEnthalpy().

_hc_added_heat_rhs

Vec SubChannel1PhaseProblem::_hc_added_heat_rhs

protected

Enthalpy conservation - source and sink.

Definition at line 429 of file SubChannel1PhaseProblem.h.

Referenced by cleanUp(), QuadSubChannel1PhaseProblem::computeh(), TriSubChannel1PhaseProblem::computeh(), and SubChannel1PhaseProblem().

_hc_advective_derivative_mat

Mat SubChannel1PhaseProblem::_hc_advective_derivative_mat

protected

Enthalpy conservation - advective (Eulerian) derivative;.

Definition at line 423 of file SubChannel1PhaseProblem.h.

Referenced by cleanUp(), QuadSubChannel1PhaseProblem::computeh(), TriSubChannel1PhaseProblem::computeh(), and SubChannel1PhaseProblem().

_hc_advective_derivative_rhs

Vec SubChannel1PhaseProblem::_hc_advective_derivative_rhs

protected

Definition at line 424 of file SubChannel1PhaseProblem.h.

Referenced by cleanUp(), QuadSubChannel1PhaseProblem::computeh(), TriSubChannel1PhaseProblem::computeh(), and SubChannel1PhaseProblem().

_hc_cross_derivative_mat

Mat SubChannel1PhaseProblem::_hc_cross_derivative_mat

protected

Enthalpy conservation - cross flux derivative.

Definition at line 426 of file SubChannel1PhaseProblem.h.

Referenced by cleanUp(), QuadSubChannel1PhaseProblem::computeh(), TriSubChannel1PhaseProblem::computeh(), and SubChannel1PhaseProblem().

_hc_cross_derivative_rhs

Vec SubChannel1PhaseProblem::_hc_cross_derivative_rhs

protected

Definition at line 427 of file SubChannel1PhaseProblem.h.

Referenced by cleanUp(), QuadSubChannel1PhaseProblem::computeh(), TriSubChannel1PhaseProblem::computeh(), and SubChannel1PhaseProblem().

_hc_sys_h_mat

Mat SubChannel1PhaseProblem::_hc_sys_h_mat

protected

System matrices.

Definition at line 431 of file SubChannel1PhaseProblem.h.

Referenced by cleanUp(), QuadSubChannel1PhaseProblem::computeh(), TriSubChannel1PhaseProblem::computeh(), and SubChannel1PhaseProblem().

_hc_sys_h_rhs

Vec SubChannel1PhaseProblem::_hc_sys_h_rhs

protected

Definition at line 432 of file SubChannel1PhaseProblem.h.

Referenced by cleanUp(), QuadSubChannel1PhaseProblem::computeh(), TriSubChannel1PhaseProblem::computeh(), and SubChannel1PhaseProblem().

_hc_time_derivative_mat

Mat SubChannel1PhaseProblem::_hc_time_derivative_mat

protected

Enthalpy Enthalpy conservation - time derivative.

Definition at line 420 of file SubChannel1PhaseProblem.h.

Referenced by cleanUp(), QuadSubChannel1PhaseProblem::computeh(), TriSubChannel1PhaseProblem::computeh(), and SubChannel1PhaseProblem().

_hc_time_derivative_rhs

Vec SubChannel1PhaseProblem::_hc_time_derivative_rhs

protected

Definition at line 421 of file SubChannel1PhaseProblem.h.

Referenced by cleanUp(), QuadSubChannel1PhaseProblem::computeh(), TriSubChannel1PhaseProblem::computeh(), and SubChannel1PhaseProblem().

_HTC_soln

std::unique_ptr<SolutionHandle> SubChannel1PhaseProblem::_HTC_soln

protected

Definition at line 313 of file SubChannel1PhaseProblem.h.

Referenced by externalSolve(), and initialSetup().

_implicit_bool

const bool SubChannel1PhaseProblem::_implicit_bool

protected

Flag to define the usage of a implicit or explicit solution.

Definition at line 278 of file SubChannel1PhaseProblem.h.

Referenced by computeDP(), QuadSubChannel1PhaseProblem::computeh(), TriSubChannel1PhaseProblem::computeh(), computeMdot(), computeP(), computeSumWij(), computeWijPrime(), computeWijResidual(), and SubChannel1PhaseProblem().

_interpolation_scheme

const MooseEnum SubChannel1PhaseProblem::_interpolation_scheme

protected

The interpolation method used in constructing the systems.

Definition at line 273 of file SubChannel1PhaseProblem.h.

Referenced by computeDP(), TriSubChannel1PhaseProblem::computeh(), and computeInterpolationCoefficients().

_kij

const Real& SubChannel1PhaseProblem::_kij

protected

Definition at line 207 of file SubChannel1PhaseProblem.h.

Referenced by computeWijResidual().

_mass_flow_equation_relaxation

const Real& SubChannel1PhaseProblem::_mass_flow_equation_relaxation

protected

Equation relaxation factor for mass flow rate in the coupled implicit solve.

Definition at line 253 of file SubChannel1PhaseProblem.h.

Referenced by implicitPetscSolve().

_mass_flow_relaxation

const Real& SubChannel1PhaseProblem::_mass_flow_relaxation

protected

Relaxation factor for mass flow rate updates in the coupled implicit solve.

Definition at line 259 of file SubChannel1PhaseProblem.h.

Referenced by implicitPetscSolve().

_max_sumWij

PetscScalar SubChannel1PhaseProblem::_max_sumWij

protected

Definition at line 437 of file SubChannel1PhaseProblem.h.

Referenced by implicitPetscSolve().

_max_sumWij_new

PetscScalar SubChannel1PhaseProblem::_max_sumWij_new

protected

Definition at line 438 of file SubChannel1PhaseProblem.h.

Referenced by implicitPetscSolve().

_maxit

const PetscInt& SubChannel1PhaseProblem::_maxit

protected

The maximum number of iterations to use for the ksp linear solver.

Definition at line 271 of file SubChannel1PhaseProblem.h.

Referenced by computeMdot(), computeP(), implicitPetscSolve(), petscSnesSolver(), and solveAndPopulateEnthalpy().

_mc_axial_convection_mat

Mat SubChannel1PhaseProblem::_mc_axial_convection_mat

protected

Mass conservation - axial convection.

Definition at line 370 of file SubChannel1PhaseProblem.h.

Referenced by cleanUp(), computeMdot(), implicitPetscSolve(), and SubChannel1PhaseProblem().

_mc_axial_convection_rhs

Vec SubChannel1PhaseProblem::_mc_axial_convection_rhs

protected

Definition at line 371 of file SubChannel1PhaseProblem.h.

Referenced by cleanUp(), computeMdot(), implicitPetscSolve(), and SubChannel1PhaseProblem().

_mc_density_pressure_mat

Mat SubChannel1PhaseProblem::_mc_density_pressure_mat

protected

Mass conservation - pressure derivative of transient density.

Definition at line 373 of file SubChannel1PhaseProblem.h.

Referenced by cleanUp(), computeMdot(), computeSumWij(), implicitPetscSolve(), and SubChannel1PhaseProblem().

_mc_sumWij_mat

Mat SubChannel1PhaseProblem::_mc_sumWij_mat

protected

Matrices and vectors to be used in implicit assembly Mass conservation Mass conservation - sum of cross fluxes.

Definition at line 365 of file SubChannel1PhaseProblem.h.

Referenced by cleanUp(), computeSumWij(), implicitPetscSolve(), and SubChannel1PhaseProblem().

_mdot_soln

std::unique_ptr<SolutionHandle> SubChannel1PhaseProblem::_mdot_soln

protected

Solutions handles and link to TH tables properties.

Definition at line 296 of file SubChannel1PhaseProblem.h.

Referenced by computeDP(), TriSubChannel1PhaseProblem::computeh(), computeMdot(), computeWijPrime(), computeWijResidual(), implicitPetscSolve(), QuadSubChannel1PhaseProblem::initializeSolution(), TriSubChannel1PhaseProblem::initializeSolution(), and initialSetup().

_mixing_closure

const SCMMixingClosureBase* SubChannel1PhaseProblem::_mixing_closure

protected

Turbulent Mixing closure object.

Definition at line 290 of file SubChannel1PhaseProblem.h.

Referenced by computeBulkReynoldsNumber(), computeMixingParameter(), computeSweepFlowMixingParameter(), computeWijPrime(), and initialSetup().

_mu_soln

std::unique_ptr<SolutionHandle> SubChannel1PhaseProblem::_mu_soln

protected

Definition at line 305 of file SubChannel1PhaseProblem.h.

Referenced by computeMu(), and initialSetup().

_n_blocks

unsigned int SubChannel1PhaseProblem::_n_blocks

protected

number of axial blocks

Definition at line 200 of file SubChannel1PhaseProblem.h.

Referenced by externalSolve(), and SubChannel1PhaseProblem().

_n_cells

unsigned int SubChannel1PhaseProblem::_n_cells

protected

Definition at line 208 of file SubChannel1PhaseProblem.h.

Referenced by detectDeformation(), externalSolve(), QuadSubChannel1PhaseProblem::initializeSolution(), TriSubChannel1PhaseProblem::initializeSolution(), and SubChannel1PhaseProblem().

_n_channels

unsigned int SubChannel1PhaseProblem::_n_channels

protected

Definition at line 211 of file SubChannel1PhaseProblem.h.

Referenced by computeBulkReynoldsNumber(), computeDP(), QuadSubChannel1PhaseProblem::computeh(), TriSubChannel1PhaseProblem::computeh(), computeMdot(), computeMu(), computeP(), computeRho(), computeSumWij(), computeT(), computeWijPrime(), computeWijResidual(), detectDeformation(), externalSolve(), implicitPetscSolve(), QuadSubChannel1PhaseProblem::initializeSolution(), TriSubChannel1PhaseProblem::initializeSolution(), solveAndPopulateEnthalpy(), SubChannel1PhaseProblem(), and TriSubChannel1PhaseProblem::TriSubChannel1PhaseProblem().

_n_gaps

unsigned int SubChannel1PhaseProblem::_n_gaps

protected

Definition at line 209 of file SubChannel1PhaseProblem.h.

Referenced by computeSumWij(), computeWijFromSolve(), computeWijPrime(), computeWijResidual(), implicitPetscSolve(), QuadSubChannel1PhaseProblem::initializeSolution(), TriSubChannel1PhaseProblem::initializeSolution(), petscSnesSolver(), residualFunction(), and SubChannel1PhaseProblem().

_n_pins

unsigned int SubChannel1PhaseProblem::_n_pins

protected

Definition at line 210 of file SubChannel1PhaseProblem.h.

Referenced by detectDeformation(), externalSolve(), and SubChannel1PhaseProblem().

_nusselt_args

struct SubChannel1PhaseProblem::NusseltStruct SubChannel1PhaseProblem::_nusselt_args

Referenced by externalSolve().

_one

Real SubChannel1PhaseProblem::_one

protected

Definition at line 215 of file SubChannel1PhaseProblem.h.

Referenced by externalSolve().

_P_maxit

const int& SubChannel1PhaseProblem::_P_maxit

protected

Maximum number of pressure iterations; zero selects the solver's existing automatic limit.

Definition at line 243 of file SubChannel1PhaseProblem.h.

Referenced by externalSolve().

_P_out

const PostprocessorValue& SubChannel1PhaseProblem::_P_out

Outlet pressure postprocessor value.

Definition at line 94 of file SubChannel1PhaseProblem.h.

Referenced by QuadSubChannel1PhaseProblem::computeh(), TriSubChannel1PhaseProblem::computeh(), computeMdot(), computeMu(), computeRho(), computeT(), externalSolve(), getOutletPressure(), and implicitPetscSolve().

_P_soln

std::unique_ptr<SolutionHandle> SubChannel1PhaseProblem::_P_soln

protected

Definition at line 298 of file SubChannel1PhaseProblem.h.

Referenced by QuadSubChannel1PhaseProblem::computeh(), TriSubChannel1PhaseProblem::computeh(), computeMdot(), computeMu(), computeP(), computeRho(), computeT(), computeWijResidual(), externalSolve(), implicitPetscSolve(), and initialSetup().

_P_tol

const Real& SubChannel1PhaseProblem::_P_tol

protected

Convergence tolerance for the pressure loop in external solve.

Definition at line 241 of file SubChannel1PhaseProblem.h.

Referenced by externalSolve().

_pin_HTC_closure

const SCMHTCClosureBase* SubChannel1PhaseProblem::_pin_HTC_closure

protected

HTC closure objects.

Definition at line 292 of file SubChannel1PhaseProblem.h.

Referenced by externalSolve(), getPinHTCClosure(), and initialSetup().

_pin_mesh_exist

const bool SubChannel1PhaseProblem::_pin_mesh_exist

protected

Flag that informs if there is a pin mesh or not.

Definition at line 225 of file SubChannel1PhaseProblem.h.

Referenced by QuadSubChannel1PhaseProblem::computeAddedHeatPin(), TriSubChannel1PhaseProblem::computeAddedHeatPin(), detectDeformation(), externalSolve(), initialSetup(), and SubChannel1PhaseProblem().

_pressure_equation_relaxation

const Real& SubChannel1PhaseProblem::_pressure_equation_relaxation

protected

Equation relaxation factor for pressure in the coupled implicit solve.

Definition at line 255 of file SubChannel1PhaseProblem.h.

Referenced by implicitPetscSolve().

_pressure_fixed_point_error

Real SubChannel1PhaseProblem::_pressure_fixed_point_error = 1.0

protected

Maximum pressure fixed-point update before solution relaxation over the blocks.

Definition at line 441 of file SubChannel1PhaseProblem.h.

Referenced by externalSolve(), and implicitPetscSolve().

_pressure_relaxation

const Real& SubChannel1PhaseProblem::_pressure_relaxation

protected

Relaxation factor for pressure updates in the coupled implicit solve.

Definition at line 261 of file SubChannel1PhaseProblem.h.

Referenced by implicitPetscSolve().

_prod

Vec SubChannel1PhaseProblem::_prod

protected

Definition at line 367 of file SubChannel1PhaseProblem.h.

Referenced by cleanUp(), computeDP(), implicitPetscSolve(), and SubChannel1PhaseProblem().

_prodp

Vec SubChannel1PhaseProblem::_prodp

protected

Definition at line 368 of file SubChannel1PhaseProblem.h.

Referenced by cleanUp(), computeWijResidual(), implicitPetscSolve(), and SubChannel1PhaseProblem().

_q_prime_soln

std::unique_ptr<SolutionHandle> SubChannel1PhaseProblem::_q_prime_soln

protected

Definition at line 308 of file SubChannel1PhaseProblem.h.

Referenced by initialSetup().

_rho_soln

std::unique_ptr<SolutionHandle> SubChannel1PhaseProblem::_rho_soln

protected

Definition at line 304 of file SubChannel1PhaseProblem.h.

Referenced by computeDP(), QuadSubChannel1PhaseProblem::computeh(), TriSubChannel1PhaseProblem::computeh(), computeMdot(), computeRho(), computeWijResidual(), and initialSetup().

_rtol

const PetscReal& SubChannel1PhaseProblem::_rtol

protected

The relative convergence tolerance, (relative decrease) for the ksp linear solver.

Definition at line 265 of file SubChannel1PhaseProblem.h.

Referenced by computeMdot(), computeP(), implicitPetscSolve(), petscSnesSolver(), and solveAndPopulateEnthalpy().

_S_flow_soln

std::unique_ptr<SolutionHandle> SubChannel1PhaseProblem::_S_flow_soln

protected

Definition at line 306 of file SubChannel1PhaseProblem.h.

Referenced by computeDP(), TriSubChannel1PhaseProblem::computeh(), computeWijResidual(), QuadSubChannel1PhaseProblem::initializeSolution(), TriSubChannel1PhaseProblem::initializeSolution(), and initialSetup().

_segregated_bool

const bool SubChannel1PhaseProblem::_segregated_bool

protected

Segregated solve.

Definition at line 282 of file SubChannel1PhaseProblem.h.

Referenced by computeDP(), computeMdot(), computeP(), computeSumWij(), computeWijResidual(), externalSolve(), and SubChannel1PhaseProblem().

_staggered_pressure_bool

const bool SubChannel1PhaseProblem::_staggered_pressure_bool

protected

Flag to define the usage of staggered or collocated pressure.

Definition at line 280 of file SubChannel1PhaseProblem.h.

Referenced by computeP(), and computeWijResidual().

_subchannel_mesh

SubChannelMesh& SubChannel1PhaseProblem::_subchannel_mesh

protected

Definition at line 198 of file SubChannel1PhaseProblem.h.

Referenced by computeAddedHeatDuct(), TriSubChannel1PhaseProblem::computeAddedHeatPin(), computeBulkReynoldsNumber(), computeDP(), TriSubChannel1PhaseProblem::computeh(), computeMdot(), computeMu(), computeP(), computeRho(), computeSumWij(), computeT(), computeWijPrime(), computeWijResidual(), detectDeformation(), externalSolve(), TriSubChannel1PhaseProblem::getSubChannelPeripheralDuctWidth(), implicitPetscSolve(), TriSubChannel1PhaseProblem::initializeSolution(), populateSolutionChan(), populateVectorFromHandle(), solveAndPopulateEnthalpy(), and SubChannel1PhaseProblem().

_SumWij_soln

std::unique_ptr<SolutionHandle> SubChannel1PhaseProblem::_SumWij_soln

protected

Definition at line 297 of file SubChannel1PhaseProblem.h.

Referenced by computeDP(), computeMdot(), computeSumWij(), externalSolve(), implicitPetscSolve(), and initialSetup().

_T_maxit

const int& SubChannel1PhaseProblem::_T_maxit

protected

Maximum iterations for the inner temperature loop.

Definition at line 247 of file SubChannel1PhaseProblem.h.

Referenced by externalSolve().

_T_relaxation

const Real& SubChannel1PhaseProblem::_T_relaxation

protected

Relaxation factor for temperature updates in the inner thermal-hydraulic iteration.

Definition at line 249 of file SubChannel1PhaseProblem.h.

Referenced by computeT().

_T_soln

std::unique_ptr<SolutionHandle> SubChannel1PhaseProblem::_T_soln

protected

Definition at line 301 of file SubChannel1PhaseProblem.h.

Referenced by QuadSubChannel1PhaseProblem::computeh(), TriSubChannel1PhaseProblem::computeh(), computeMdot(), computeMu(), computeRho(), computeT(), externalSolve(), and initialSetup().

_T_tol

const Real& SubChannel1PhaseProblem::_T_tol

protected

Convergence tolerance for the temperature loop in internal solve.

Definition at line 245 of file SubChannel1PhaseProblem.h.

Referenced by externalSolve().

_Tduct_soln

std::unique_ptr<SolutionHandle> SubChannel1PhaseProblem::_Tduct_soln

protected

Definition at line 310 of file SubChannel1PhaseProblem.h.

Referenced by externalSolve(), and initialSetup().

_time_integrator_checked

bool SubChannel1PhaseProblem::_time_integrator_checked = false

protected

Whether the time integrator has been checked for consistency with the implementation.

Definition at line 235 of file SubChannel1PhaseProblem.h.

Referenced by externalSolve().

_Tpin_soln

std::unique_ptr<SolutionHandle> SubChannel1PhaseProblem::_Tpin_soln

protected

Definition at line 302 of file SubChannel1PhaseProblem.h.

Referenced by externalSolve(), and initialSetup().

_TR

Real SubChannel1PhaseProblem::_TR

protected

Flag that activates or deactivates the transient parts of the equations we solve by multiplication.

Definition at line 217 of file SubChannel1PhaseProblem.h.

Referenced by computeDP(), QuadSubChannel1PhaseProblem::computeh(), TriSubChannel1PhaseProblem::computeh(), computeMdot(), computeWijResidual(), and externalSolve().

_verbose_subchannel

const bool SubChannel1PhaseProblem::_verbose_subchannel

protected

Boolean to printout information related to subchannel solve.

Definition at line 284 of file SubChannel1PhaseProblem.h.

Referenced by QuadSubChannel1PhaseProblem::computeh(), TriSubChannel1PhaseProblem::computeh(), computeP(), externalSolve(), and implicitPetscSolve().

_w_perim_soln

std::unique_ptr<SolutionHandle> SubChannel1PhaseProblem::_w_perim_soln

protected

Definition at line 307 of file SubChannel1PhaseProblem.h.

Referenced by QuadSubChannel1PhaseProblem::initializeSolution(), TriSubChannel1PhaseProblem::initializeSolution(), and initialSetup().

_Wij

libMesh::DenseMatrix<Real>& SubChannel1PhaseProblem::_Wij

protected

Definition at line 202 of file SubChannel1PhaseProblem.h.

Referenced by computeDP(), QuadSubChannel1PhaseProblem::computeh(), TriSubChannel1PhaseProblem::computeh(), computeMdot(), computeSumWij(), computeWijFromSolve(), computeWijResidual(), externalSolve(), implicitPetscSolve(), residualFunction(), and SubChannel1PhaseProblem().

_Wij_old

libMesh::DenseMatrix<Real>& SubChannel1PhaseProblem::_Wij_old

protected

Definition at line 203 of file SubChannel1PhaseProblem.h.

Referenced by computeWijResidual(), externalSolve(), implicitPetscSolve(), and SubChannel1PhaseProblem().

_Wij_residual_matrix

libMesh::DenseMatrix<Real> SubChannel1PhaseProblem::_Wij_residual_matrix

protected

Definition at line 205 of file SubChannel1PhaseProblem.h.

Referenced by computeWijResidual(), residualFunction(), and SubChannel1PhaseProblem().

_Wij_vec

Vec SubChannel1PhaseProblem::_Wij_vec

protected

Definition at line 366 of file SubChannel1PhaseProblem.h.

Referenced by cleanUp(), computeSumWij(), computeWijPrime(), computeWijResidual(), implicitPetscSolve(), and SubChannel1PhaseProblem().

_WijPrime

libMesh::DenseMatrix<Real> SubChannel1PhaseProblem::_WijPrime

protected

Definition at line 204 of file SubChannel1PhaseProblem.h.

Referenced by computeDP(), QuadSubChannel1PhaseProblem::computeh(), TriSubChannel1PhaseProblem::computeh(), computeWijPrime(), and SubChannel1PhaseProblem().

_z_grid

std::vector<Real> SubChannel1PhaseProblem::_z_grid

protected

axial location of nodes

Definition at line 214 of file SubChannel1PhaseProblem.h.

Referenced by computeAddedHeatDuct(), QuadSubChannel1PhaseProblem::computeAddedHeatPin(), TriSubChannel1PhaseProblem::computeAddedHeatPin(), computeDP(), QuadSubChannel1PhaseProblem::computeh(), TriSubChannel1PhaseProblem::computeh(), computeMdot(), computeWijPrime(), computeWijResidual(), QuadSubChannel1PhaseProblem::initializeSolution(), TriSubChannel1PhaseProblem::initializeSolution(), and SubChannel1PhaseProblem().

---

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

• subchannel/include/problems/SubChannel1PhaseProblem.h
• subchannel/src/problems/SubChannel1PhaseProblem.C