Triangular subchannel solver. More...

#include <TriSubChannel1PhaseProblem.h>

Inheritance diagram for TriSubChannel1PhaseProblem:

Public Types
enum	Direction { Direction::TO_EXTERNAL_APP, Direction::FROM_EXTERNAL_APP }

enum	CoverageCheckMode { CoverageCheckMode::FALSE, CoverageCheckMode::TRUE, CoverageCheckMode::OFF, CoverageCheckMode::ON, CoverageCheckMode::SKIP_LIST, CoverageCheckMode::ONLY_LIST }

typedef DataFileName	DataFileParameterType

Public Member Functions
	TriSubChannel1PhaseProblem (const InputParameters &params)

virtual	~TriSubChannel1PhaseProblem ()

virtual void	externalSolve () override

virtual void	syncSolutions (Direction direction) override

virtual bool	solverSystemConverged (const unsigned int) override

virtual void	initialSetup () override

virtual void	solve (unsigned int nl_sys_num=0) override final

virtual void	addExternalVariables ()

virtual libMesh::EquationSystems &	es () override

virtual MooseMesh &	mesh () override

virtual const MooseMesh &	mesh () const override

const MooseMesh &	mesh (bool use_displaced) const override

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

void	trustUserCouplingMatrix ()

std::vector< std::pair< MooseVariableFEBase , MooseVariableFEBase > > &	couplingEntries (const THREAD_ID tid, const unsigned int nl_sys_num)

std::vector< std::pair< MooseVariableFEBase , MooseVariableFEBase > > &	nonlocalCouplingEntries (const THREAD_ID tid, const unsigned int nl_sys_num)

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)

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

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

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	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	reinitNodes (const std::vector< dof_id_type > &nodes, const THREAD_ID tid) override

virtual void	reinitNodesNeighbor (const std::vector< dof_id_type > &nodes, 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

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

virtual void	advanceState ()

virtual void	restoreSolutions ()

virtual void	saveOldSolutions ()

virtual void	restoreOldSolutions ()

void	needSolutionState (unsigned int oldest_needed, Moose::SolutionIterationType iteration_type)

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

void	setNeedToAddDefaultNonlinearConvergence ()

void	setNeedToAddDefaultMultiAppFixedPointConvergence ()

bool	hasSetMultiAppFixedPointConvergenceName () const

virtual void	addDefaultNonlinearConvergence (const InputParameters &params)

virtual bool	onlyAllowDefaultNonlinearConvergence () const

void	addDefaultMultiAppFixedPointConvergence (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 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)

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

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)

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)

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

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)

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)

const ExecuteMooseObjectWarehouse< UserObject > &	getUserObjects () const

T &	getUserObject (const std::string &name, unsigned int tid=0) const

const UserObject &	getUserObjectBase (const std::string &name, const THREAD_ID tid=0) const

const Positions &	getPositionsObject (const std::string &name) const

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

bool	hasPostprocessorValueByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueByName (const PostprocessorName &name, std::size_t t_index=0) const

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

void	setPostprocessorValueByName (const PostprocessorName &name, const PostprocessorValue &value, std::size_t t_index=0)

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

bool	hasPostprocessor (const std::string &param_name, const unsigned int index=0) 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)

bool	execMultiApps (ExecFlagType type, bool auto_advance=true)

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)

void	execTransfers (ExecFlagType type)

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 std::unordered_map< std::pair< BoundaryID, BoundaryID >, AutomaticMortarGeneration > &	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 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)

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 MaterialWarehouse &	getMaterialWarehouse () const

const MaterialWarehouse &	getRegularMaterialsWarehouse () const

const MaterialWarehouse &	getDiscreteMaterialWarehouse () const

const MaterialWarehouse &	getInterfaceMaterialsWarehouse () 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

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

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	haveADObjects () const

bool	shouldSolve () const

const MortarData &	mortarData () const

MortarData &	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)

bool	computingNonlinearResid () const

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

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)

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)

const std::vector< ConvergenceName > &	getNonlinearConvergenceNames () const

const std::vector< ConvergenceName > &	getLinearConvergenceNames () const

const ConvergenceName &	getMultiAppFixedPointConvergenceName () 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

const bool &	currentlyComputingResidual () const

const bool &	currentlyComputingResidual () 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	reinitNeighborLowerDElem (const Elem *elem, const THREAD_ID tid=0)

void	reinitMortarElem (const Elem *elem, const THREAD_ID tid=0)

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	hasScalingVector (const unsigned int nl_sys_num)

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

bool	havePRefinement () 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

MooseApp &	getMooseApp () const

const std::string &	type () const

virtual const std::string &	name () const

std::string	typeAndName () const

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

void	callMooseError (std::string msg, const bool with_prefix) const

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

const InputParameters &	parameters () const

MooseObjectName	uniqueName () 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 &nm) const

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

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

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

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

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

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

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

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

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

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

void	mooseInfo (Args &&... args) 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)

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

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	needSubdomainMaterialOnSide (SubdomainID subdomain_id, const THREAD_ID tid)

bool	needSubdomainMaterialOnSide (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	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

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	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
std::map< std::string, std::vector< dof_id_type > >	_var_dof_map

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

Protected Member Functions
virtual void	initializeSolution () override
	Function to initialize the solution & geometry fields. More...

virtual Real	computeFrictionFactor (FrictionStruct friction_args) override
	Computes the axial friction factor for the sodium coolant and for each subchannel. More...

virtual Real	computeAddedHeatPin (unsigned int i_ch, unsigned int iz) override
	Computes added heat for channel i_ch and cell iz. More...

virtual Real	computeBeta (unsigned int i_gap, unsigned int iz) override
	Computes turbulent mixing coefficient. More...

virtual void	computeh (int iblock) override
	Computes Enthalpy per channel for block iblock. More...

PetscErrorCode	cleanUp ()

void	computeWijFromSolve (int iblock)
	Computes diversion crossflow per gap for block iblock. More...

void	computeSumWij (int iblock)
	Computes net diversion crossflow per channel for block iblock. More...

void	computeMdot (int iblock)
	Computes mass flow per channel for block iblock. More...

void	computeWijPrime (int iblock)
	Computes turbulent crossflow per gap for block iblock. More...

void	computeDP (int iblock)
	Computes Pressure Drop per channel for block iblock. More...

void	computeP (int iblock)
	Computes Pressure per channel for block iblock. More...

void	computeT (int iblock)
	Computes Temperature per channel for block iblock. More...

void	computeRho (int iblock)
	Computes Density per channel for block iblock. More...

void	computeMu (int iblock)
	Computes Viscosity per channel for block iblock. More...

void	computeWijResidual (int iblock)
	Computes Residual Matrix based on the lateral momentum conservation equation for block iblock. More...

Real	computeAddedHeatDuct (unsigned int i_ch, unsigned int iz)
	Function that computes the heat flux added by the duct. More...

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

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

PetscErrorCode	implicitPetscSolve (int iblock)
	Computes implicit solve using PetSc. More...

PetscScalar	computeInterpolationCoefficients (PetscScalar Peclet=0.0)
	Functions that computes the interpolation scheme given the Peclet number. More...

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

PetscErrorCode	createPetscVector (Vec &v, PetscInt n)
	Petsc Functions. More...

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)

template<class T >
PetscErrorCode	populateSolutionGap (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, const Moose::AuxGroup &group, TheWarehouse::Query &query)

void	checkDisplacementOrders ()

void	checkUserObjects ()

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	markFamilyPRefinement (const InputParameters &params)

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
TriSubChannelMesh &	_tri_sch_mesh

Mat	_hc_axial_heat_conduction_mat

Vec	_hc_axial_heat_conduction_rhs

Mat	_hc_radial_heat_conduction_mat

Vec	_hc_radial_heat_conduction_rhs

Mat	_hc_sweep_enthalpy_mat

Vec	_hc_sweep_enthalpy_rhs

struct SubChannel1PhaseProblem::FrictionStruct	_friction_args

SubChannelMesh &	_subchannel_mesh

unsigned int	_n_blocks
	number of axial blocks More...

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

Real	_outer_channels

Real	_dpz_error
	average relative error in pressure drop of channels More...

std::vector< Real >	_z_grid
	axial location of nodes More...

Real	_one

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

const bool	_compute_density
	Flag that activates or deactivates the calculation of density. More...

const bool	_compute_viscosity
	Flag that activates or deactivates the calculation of viscosity. More...

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

const bool	_pin_mesh_exist
	Flag that informs if there is a pin mesh or not. More...

const bool	_duct_mesh_exist
	Flag that informs if there is a pin mesh or not. More...

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

Real	_dt
	Time step. More...

const PostprocessorValue &	_P_out
	Outlet Pressure. More...

const Real &	_CT
	Turbulent modeling parameter used in axial momentum equation. More...

const Real &	_P_tol
	Convergence tolerance for the pressure loop in external solve. More...

const Real &	_T_tol
	Convergence tolerance for the temperature loop in external solve. More...

const int &	_T_maxit
	Maximum iterations for the inner temperature loop. More...

const PetscReal &	_rtol
	The relative convergence tolerance, (relative decrease) for the ksp linear solver. More...

const PetscReal &	_atol
	The absolute convergence tolerance for the ksp linear solver. More...

const PetscReal &	_dtol
	The divergence tolerance for the ksp linear solver. More...

const PetscInt &	_maxit
	The maximum number of iterations to use for the ksp linear solver. More...

const MooseEnum	_interpolation_scheme
	The interpolation method used in constructing the systems. More...

const bool	_implicit_bool
	Flag to define the usage of a implicit or explicit solution. More...

const bool	_staggered_pressure_bool
	Flag to define the usage of staggered or collocated pressure. More...

const bool	_segregated_bool
	Segregated solve. More...

const bool	_monolithic_thermal_bool
	Thermal monolithic bool. More...

const bool	_verbose_subchannel
	Boolean to printout information related to subchannel solve. More...

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

const SinglePhaseFluidProperties *	_fp
	Solutions handles and link to TH tables properties. More...

std::unique_ptr< SolutionHandle >	_mdot_soln

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

std::unique_ptr< SolutionHandle >	_Tduct_soln

std::unique_ptr< SolutionHandle >	_displacement_soln

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

Vec	_Wij_vec

Vec	_prod

Vec	_prodp

Mat	_mc_axial_convection_mat
	Mass conservation - axial convection. More...

Vec	_mc_axial_convection_rhs

Mat	_amc_turbulent_cross_flows_mat
	Mass conservation - density time derivative No implicit matrix. More...

Vec	_amc_turbulent_cross_flows_rhs

Mat	_amc_time_derivative_mat
	Axial momentum conservation - time derivative. More...

Vec	_amc_time_derivative_rhs

Mat	_amc_advective_derivative_mat
	Axial momentum conservation - advective (Eulerian) derivative. More...

Vec	_amc_advective_derivative_rhs

Mat	_amc_cross_derivative_mat
	Axial momentum conservation - cross flux derivative. More...

Vec	_amc_cross_derivative_rhs

Mat	_amc_friction_force_mat
	Axial momentum conservation - friction force. More...

Vec	_amc_friction_force_rhs

Vec	_amc_gravity_rhs
	Axial momentum conservation - buoyancy force No implicit matrix. More...

Mat	_amc_pressure_force_mat
	Axial momentum conservation - pressure force. More...

Vec	_amc_pressure_force_rhs

Mat	_amc_sys_mdot_mat
	Axial momentum system matrix. More...

Vec	_amc_sys_mdot_rhs

Mat	_cmc_time_derivative_mat
	Cross momentum Cross momentum conservation - time derivative. More...

Vec	_cmc_time_derivative_rhs

Mat	_cmc_advective_derivative_mat
	Cross momentum conservation - advective (Eulerian) derivative. More...

Vec	_cmc_advective_derivative_rhs

Mat	_cmc_friction_force_mat
	Cross momentum conservation - friction force. More...

Vec	_cmc_friction_force_rhs

Mat	_cmc_pressure_force_mat
	Cross momentum conservation - pressure force. More...

Vec	_cmc_pressure_force_rhs

Mat	_cmc_sys_Wij_mat
	Lateral momentum system matrix. More...

Vec	_cmc_sys_Wij_rhs

Vec	_cmc_Wij_channel_dummy

Mat	_hc_time_derivative_mat
	Enthalpy Enthalpy conservation - time derivative. More...

Vec	_hc_time_derivative_rhs

Mat	_hc_advective_derivative_mat
	Enthalpy conservation - advective (Eulerian) derivative;. More...

Vec	_hc_advective_derivative_rhs

Mat	_hc_cross_derivative_mat
	Enthalpy conservation - cross flux derivative. More...

Vec	_hc_cross_derivative_rhs

Vec	_hc_added_heat_rhs
	Enthalpy conservation - source and sink. More...

Mat	_hc_sys_h_mat
	System matrices. More...

Vec	_hc_sys_h_rhs

PetscInt	_global_counter = 0
	No implicit matrix. More...

PetscScalar	_added_K = 0.0
	Added resistances for monolithic convergence. More...

PetscScalar	_added_K_old = 1000.0

PetscScalar	_max_sumWij

PetscScalar	_max_sumWij_new

PetscScalar	_correction_factor = 1.0

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

int &	_t_step

Real &	_dt_old

bool	_need_to_add_default_nonlinear_convergence

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

std::map< std::string, unsigned int >	_subspace_dim

std::vector< std::vector< std::unique_ptr< Assembly > > >	_assembly

MooseObjectWarehouse< MeshDivision >	_mesh_divisions

MooseObjectWarehouse< Function >	_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

MooseObjectWarehouse< Marker >	_markers

ReporterData	_reporter_data

ExecuteMooseObjectWarehouse< UserObject >	_all_user_objects

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

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

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

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

CoverageCheckMode	_material_coverage_check

std::vector< SubdomainName >	_material_coverage_blocks

bool	_fv_bcs_integrity_check

const bool	_material_dependency_check

const bool	_uo_aux_state_check

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

const std::string	_type

const std::string	_name

const InputParameters &	_pars

ActionFactory &	_action_factory

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

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

Detailed Description

Triangular subchannel solver.

Definition at line 19 of file TriSubChannel1PhaseProblem.h.

Constructor & Destructor Documentation

◆ TriSubChannel1PhaseProblem()

TriSubChannel1PhaseProblem::TriSubChannel1PhaseProblem ( const InputParameters & params )

Definition at line 26 of file TriSubChannel1PhaseProblem.C.

   : SubChannel1PhaseProblem(params),
     _tri_sch_mesh(SCM::getMesh<TriSubChannelMesh>(_subchannel_mesh))
 {
   // Initializing heat conduction system
   LibmeshPetscCall(createPetscMatrix(
       _hc_axial_heat_conduction_mat, _block_size * _n_channels, _block_size * _n_channels));
   LibmeshPetscCall(createPetscVector(_hc_axial_heat_conduction_rhs, _block_size * _n_channels));
   LibmeshPetscCall(createPetscMatrix(
       _hc_radial_heat_conduction_mat, _block_size * _n_channels, _block_size * _n_channels));
   LibmeshPetscCall(createPetscVector(_hc_radial_heat_conduction_rhs, _block_size * _n_channels));
   LibmeshPetscCall(createPetscMatrix(
       _hc_sweep_enthalpy_mat, _block_size * _n_channels, _block_size * _n_channels));
   LibmeshPetscCall(createPetscVector(_hc_sweep_enthalpy_rhs, _block_size * _n_channels));
 }

◆ ~TriSubChannel1PhaseProblem()

TriSubChannel1PhaseProblem::~TriSubChannel1PhaseProblem ( )

virtual

Definition at line 42 of file TriSubChannel1PhaseProblem.C.

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

Member Function Documentation

◆ cleanUp()

PetscErrorCode TriSubChannel1PhaseProblem::cleanUp ( )

protected

Definition at line 50 of file TriSubChannel1PhaseProblem.C.

Referenced by ~TriSubChannel1PhaseProblem().

 {
   PetscFunctionBegin;
   // Clean up heat conduction system
   LibmeshPetscCall(MatDestroy(&_hc_axial_heat_conduction_mat));
   LibmeshPetscCall(VecDestroy(&_hc_axial_heat_conduction_rhs));
   LibmeshPetscCall(MatDestroy(&_hc_radial_heat_conduction_mat));
   LibmeshPetscCall(VecDestroy(&_hc_radial_heat_conduction_rhs));
   LibmeshPetscCall(MatDestroy(&_hc_sweep_enthalpy_mat));
   LibmeshPetscCall(VecDestroy(&_hc_sweep_enthalpy_rhs));
   PetscFunctionReturn(LIBMESH_PETSC_SUCCESS);
 }

◆ computeAddedHeatDuct()

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

protectedinherited

Function that computes the heat flux added by the duct.

Definition at line 1320 of file SubChannel1PhaseProblem.C.

Referenced by computeh().

 {
   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 = (*_q_prime_duct_soln)(node_in_duct);
       auto heat_rate_out = (*_q_prime_duct_soln)(node_out_duct);
       return 0.5 * (heat_rate_in + heat_rate_out) * dz / _outer_channels;
     }
     else
     {
       return 0.0;
     }
   }
   else
   {
     return 0;
   }
 }

◆ computeAddedHeatPin()

Real TriSubChannel1PhaseProblem::computeAddedHeatPin	(	unsigned int	i_ch,
		unsigned int	iz
	)

overrideprotectedvirtual

Computes added heat for channel i_ch and cell iz.

Implements SubChannel1PhaseProblem.

Definition at line 550 of file TriSubChannel1PhaseProblem.C.

Referenced by computeh().

 {
   auto dz = _z_grid[iz] - _z_grid[iz - 1];
   auto subch_type = _subchannel_mesh.getSubchannelType(i_ch);
 
   if (_pin_mesh_exist)
   {
     double factor;
     switch (subch_type)
     {
       case EChannelType::CENTER:
         factor = 1.0 / 6.0;
         break;
       case EChannelType::EDGE:
         factor = 1.0 / 4.0;
         break;
       case EChannelType::CORNER:
         factor = 1.0 / 6.0;
         break;
       default:
         return 0.0; // handle invalid subch_type if needed
     }
     double heat_rate_in = 0.0;
     double heat_rate_out = 0.0;
     for (auto i_pin : _subchannel_mesh.getChannelPins(i_ch))
     {
       auto * node_in = _subchannel_mesh.getPinNode(i_pin, iz - 1);
       auto * node_out = _subchannel_mesh.getPinNode(i_pin, iz);
       heat_rate_out += factor * (*_q_prime_soln)(node_out);
       heat_rate_in += factor * (*_q_prime_soln)(node_in);
     }
     return (heat_rate_in + heat_rate_out) * dz / 2.0;
   }
   else
   {
     auto * node_in = _subchannel_mesh.getChannelNode(i_ch, iz - 1);
     auto * node_out = _subchannel_mesh.getChannelNode(i_ch, iz);
     return ((*_q_prime_soln)(node_out) + (*_q_prime_soln)(node_in)) * dz / 2.0;
   }
 }

◆ computeBeta()

Real TriSubChannel1PhaseProblem::computeBeta	(	unsigned int	i_gap,
		unsigned int	iz
	)

overrideprotectedvirtual

Computes turbulent mixing coefficient.

Implements SubChannel1PhaseProblem.

Definition at line 438 of file TriSubChannel1PhaseProblem.C.

 {
   auto beta = 0.0;
   const Real & pitch = _subchannel_mesh.getPitch();
   const Real & pin_diameter = _subchannel_mesh.getPinDiameter();
   const Real & wire_lead_length = _tri_sch_mesh.getWireLeadLength();
   const Real & wire_diameter = _tri_sch_mesh.getWireDiameter();
   auto chans = _subchannel_mesh.getGapChannels(i_gap);
   unsigned int i_ch = chans.first;
   unsigned int j_ch = chans.second;
   auto subch_type1 = _subchannel_mesh.getSubchannelType(i_ch);
   auto subch_type2 = _subchannel_mesh.getSubchannelType(j_ch);
   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 S_total = Si_in + Sj_in + Si_out + Sj_out;
   auto Si = 0.5 * (Si_in + Si_out);
   auto Sj = 0.5 * (Sj_in + Sj_out);
   auto w_perim_i = 0.5 * ((*_w_perim_soln)(node_in_i) + (*_w_perim_soln)(node_out_i));
   auto w_perim_j = 0.5 * ((*_w_perim_soln)(node_in_j) + (*_w_perim_soln)(node_out_j));
   auto avg_mu = (1 / S_total) * ((*_mu_soln)(node_out_i)*Si_out + (*_mu_soln)(node_in_i)*Si_in +
                                  (*_mu_soln)(node_out_j)*Sj_out + (*_mu_soln)(node_in_j)*Sj_in);
   auto avg_hD = 4.0 * (Si + Sj) / (w_perim_i + w_perim_j);
   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 Re = avg_massflux * avg_hD / avg_mu;
   // crossflow area between channels i,j (dz*gap_width)
   auto gap = _subchannel_mesh.getGapWidth(iz, i_gap);
   // Calculation of flow regime
   auto ReL = 320.0 * std::pow(10.0, pitch / pin_diameter - 1);
   auto ReT = 10000.0 * std::pow(10.0, 0.7 * (pitch / pin_diameter - 1));
   // Calculation of Turbulent Crossflow for wire-wrapped triangular assemblies. Cheng &
   // Todreas (1986)
   if ((subch_type1 == EChannelType::CENTER || subch_type2 == EChannelType::CENTER) &&
       (wire_lead_length != 0) && (wire_diameter != 0))
   {
     // Calculation of geometric parameters
     auto theta = std::acos(wire_lead_length /
                            std::sqrt(std::pow(wire_lead_length, 2) +
                                      std::pow(libMesh::pi * (pin_diameter + wire_diameter), 2)));
     auto Ar1 = libMesh::pi * (pin_diameter + wire_diameter) * wire_diameter / 6.0;
     auto A1prime =
         (std::sqrt(3.0) / 4.0) * std::pow(pitch, 2) - libMesh::pi * std::pow(pin_diameter, 2) / 8.0;
     auto A1 = A1prime - libMesh::pi * std::pow(wire_diameter, 2) / 8.0 / std::cos(theta);
     auto Cm = 0.0;
     if (Re < ReL)
     {
       Cm = 0.077 * std::pow((pitch - pin_diameter) / pin_diameter, -0.5);
     }
     else if (Re > ReT)
     {
       Cm = 0.14 * std::pow((pitch - pin_diameter) / pin_diameter, -0.5);
     }
     else
     {
       auto psi = (std::log(Re) - std::log(ReL)) / (std::log(ReT) - std::log(ReL));
       auto gamma = 2.0 / 3.0;
       Cm = 0.14 * std::pow((pitch - pin_diameter) / pin_diameter, -0.5) +
            (0.14 * std::pow((pitch - pin_diameter) / pin_diameter, -0.5) -
             0.077 * std::pow((pitch - pin_diameter) / pin_diameter, -0.5)) *
                std::pow(psi, gamma);
     }
     // Calculation of turbulent mixing parameter
     beta = Cm * std::pow(Ar1 / A1, 0.5) * std::tan(theta);
   }
   // Calculation of Turbulent Crossflow for bare assemblies, from Kim and Chung (2001).
   else if ((wire_lead_length == 0) && (wire_diameter == 0))
   {
     Real gamma = 20.0;   // empirical constant
     Real sf = 2.0 / 3.0; // shape factor
     Real a = 0.18;
     Real b = 0.2;
     auto f = a * std::pow(Re, -b); // Rehme 1992 circular tube friction factor
     auto k = (1 / S_total) *
              (_fp->k_from_p_T((*_P_soln)(node_out_i) + _P_out, (*_T_soln)(node_out_i)) * Si_out +
               _fp->k_from_p_T((*_P_soln)(node_in_i) + _P_out, (*_T_soln)(node_in_i)) * Si_in +
               _fp->k_from_p_T((*_P_soln)(node_out_j) + _P_out, (*_T_soln)(node_out_j)) * Sj_out +
               _fp->k_from_p_T((*_P_soln)(node_in_j) + _P_out, (*_T_soln)(node_in_j)) * Sj_in);
     auto cp = (1 / S_total) *
               (_fp->cp_from_p_T((*_P_soln)(node_out_i) + _P_out, (*_T_soln)(node_out_i)) * Si_out +
                _fp->cp_from_p_T((*_P_soln)(node_in_i) + _P_out, (*_T_soln)(node_in_i)) * Si_in +
                _fp->cp_from_p_T((*_P_soln)(node_out_j) + _P_out, (*_T_soln)(node_out_j)) * Sj_out +
                _fp->cp_from_p_T((*_P_soln)(node_in_j) + _P_out, (*_T_soln)(node_in_j)) * Sj_in);
     auto Pr = avg_mu * cp / k;                          // Prandtl number
     auto Pr_t = Pr * (Re / gamma) * std::sqrt(f / 8.0); // Turbulent Prandtl number
     auto delta = pitch / std::sqrt(3.0);                // centroid to centroid distance
     auto L_x = sf * delta;  // axial length scale (gap is the lateral length scale)
     auto lamda = gap / L_x; // aspect ratio
     auto a_x = 1.0 - 2.0 * lamda * lamda / libMesh::pi; // velocity coefficient
     auto z_FP_over_D = (2.0 * L_x / pin_diameter) *
                        (1 + (-0.5 * std::log(lamda) + 0.5 * std::log(4.0) - 0.25) * lamda * lamda);
     auto Str = 1.0 / (0.822 * (gap / pin_diameter) + 0.144); // Strouhal number (Wu & Trupp 1994)
     auto freq_factor = 2.0 / std::pow(gamma, 2) * std::sqrt(a / 8.0) * (avg_hD / gap);
     auto rod_mixing = (1 / Pr_t) * lamda;
     auto axial_mixing = a_x * z_FP_over_D * Str;
     // Mixing Stanton number: Stg (eq 25,Kim and Chung (2001), eq 19 (Jeong et. al 2005)
     beta = freq_factor * (rod_mixing + axial_mixing) * std::pow(Re, -b / 2.0);
   }
   mooseAssert(beta >= 0,
               "beta should be positive for the inner gaps, or zero for the edge gaps, because this "
               "case is covered "
               "explicitly in the computeh method.");
   return beta;
 }

◆ computeDP()

void SubChannel1PhaseProblem::computeDP ( int iblock )

protectedinherited

Computes Pressure Drop per channel for block iblock.

Upwind local form loss

Time derivative term

Advective derivative term

Cross derivative term

Friction term

Upwind local form loss

Gravity force

Assembling system

Definition at line 583 of file SubChannel1PhaseProblem.C.

Referenced by SubChannel1PhaseProblem::implicitPetscSolve(), and SubChannel1PhaseProblem::residualFunction().

 {
   unsigned int last_node = (iblock + 1) * _block_size;
   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 =
             std::pow((*_mdot_soln)(node_out), 2.0) * (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.Re = Re;
         _friction_args.i_ch = i_ch;
         _friction_args.S = S;
         _friction_args.w_perim = w_perim;
         auto fi = computeFrictionFactor(_friction_args);
         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 = (fi * dz / Dh_i + ki) * 0.5 *
                              (*_mdot_soln)(node_out)*std::abs((*_mdot_soln)(node_out)) /
                              (S * (*_rho_soln)(node_out));
         auto gravity_term = _g_grav * (*_rho_soln)(node_out)*dz * S;
         auto DP = std::pow(S, -1.0) * (time_term + mass_term1 + mass_term2 + crossflow_term +
                                        turbulent_term + friction_term + gravity_term); // Pa
         _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
           auto Re = ((mdot_loc / S_interp) * Dh_i / mu_interp);
           _friction_args.Re = Re;
           _friction_args.i_ch = i_ch;
           _friction_args.S = S_interp;
           _friction_args.w_perim = w_perim_interp;
           auto fi = computeFrictionFactor(_friction_args);
           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 / ((fi * 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;
 
         if (iz == first_node)
         {
           PetscScalar value_vec_tt = -1.0 * _TR * alpha * (*_mdot_soln)(node_in)*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));
         }
         else
         {
           PetscInt row_tt = i_ch + _n_channels * iz_ind;
           PetscInt col_tt = i_ch + _n_channels * (iz_ind - 1);
           PetscScalar value_tt = _TR * alpha * dz / _dt;
           LibmeshPetscCall(MatSetValues(
               _amc_time_derivative_mat, 1, &row_tt, 1, &col_tt, &value_tt, INSERT_VALUES));
         }
 
         // Adding diagonal elements
         PetscInt row_tt = i_ch + _n_channels * iz_ind;
         PetscInt col_tt = i_ch + _n_channels * iz_ind;
         PetscScalar value_tt = _TR * (1.0 - alpha) * dz / _dt;
         LibmeshPetscCall(MatSetValues(
             _amc_time_derivative_mat, 1, &row_tt, 1, &col_tt, &value_tt, INSERT_VALUES));
 
         // Adding RHS elements
         PetscScalar mdot_old_interp =
             computeInterpolatedValue(_mdot_soln->old(node_out), _mdot_soln->old(node_in), Pe);
         PetscScalar value_vec_tt = _TR * mdot_old_interp * 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 = std::pow((*_mdot_soln)(node_in), 2.0) / (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.Re = Re;
         _friction_args.i_ch = i_ch;
         _friction_args.S = S_interp;
         _friction_args.w_perim = w_perim_interp;
         auto fi = computeFrictionFactor(_friction_args);
         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 = (fi * 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 = -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));
     if (_verbose_subchannel)
       _console << "Block: " << iblock << " - Linear momentum conservation matrix assembled"
                << std::endl;
     // 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 = std::pow(S_interp, -1.0) * xx[iz_ind * _n_channels + i_ch];
             _DP_soln->set(node_out, DP);
           }
           else
           {
             auto DP = 0.0;
             _DP_soln->set(node_out, DP);
           }
         }
       }
       LibmeshPetscCall(VecDestroy(&ls));
     }
   }
 }

◆ computeFrictionFactor()

Real TriSubChannel1PhaseProblem::computeFrictionFactor ( FrictionStruct friction_args )

overrideprotectedvirtual

Computes the axial friction factor for the sodium coolant and for each subchannel.

Upgraded Cheng-Todreas Correlation (2018).

The upgraded Cheng and Todreas correlation for pressure drop in hexagonal wire-wrapped rod bundles

Implements SubChannel1PhaseProblem.

Definition at line 253 of file TriSubChannel1PhaseProblem.C.

 {
   auto Re = friction_args.Re;
   auto i_ch = friction_args.i_ch;
   auto S = friction_args.S;
   auto w_perim = friction_args.w_perim;
   auto Dh_i = 4.0 * S / w_perim;
   Real aL, b1L, b2L, cL;
   Real aT, b1T, b2T, cT;
   const Real & pitch = _subchannel_mesh.getPitch();
   const Real & pin_diameter = _subchannel_mesh.getPinDiameter();
   const Real & wire_lead_length = _tri_sch_mesh.getWireLeadLength();
   const Real & wire_diameter = _tri_sch_mesh.getWireDiameter();
   auto p_over_d = pitch / pin_diameter;
   auto subch_type = _subchannel_mesh.getSubchannelType(i_ch);
   // This gap is a constant value for the whole assembly. Might want to make it
   // subchannel specific in the future if we have duct deformation.
   auto gap = _tri_sch_mesh.getDuctToPinGap();
   auto w_over_d = (pin_diameter + gap) / pin_diameter;
   auto ReL = std::pow(10, (p_over_d - 1)) * 320.0;
   auto ReT = std::pow(10, 0.7 * (p_over_d - 1)) * 1.0E+4;
   auto psi = std::log(Re / ReL) / std::log(ReT / ReL);
   const Real lambda = 7.0;
   auto theta = std::acos(wire_lead_length /
                          std::sqrt(std::pow(wire_lead_length, 2) +
                                    std::pow(libMesh::pi * (pin_diameter + wire_diameter), 2)));
   auto wd_t = (19.56 - 98.71 * (wire_diameter / pin_diameter) +
                303.47 * std::pow((wire_diameter / pin_diameter), 2.0)) *
               std::pow((wire_lead_length / pin_diameter), -0.541);
   auto wd_l = 1.4 * wd_t;
   auto ws_t = -11.0 * std::log(wire_lead_length / pin_diameter) + 19.0;
   auto ws_l = ws_t;
   Real pw_p = 0.0;
   Real ar = 0.0;
   Real a_p = 0.0;
 
   // Find the coefficients of bare Pin bundle friction factor
   // correlations for turbulent and laminar flow regimes. Todreas & Kazimi, Nuclear Systems
   // second edition, Volume 1, Chapter 9.6
   if (subch_type == EChannelType::CENTER)
   {
     if (p_over_d < 1.1)
     {
       aL = 26.0;
       b1L = 888.2;
       b2L = -3334.0;
       aT = 0.09378;
       b1T = 1.398;
       b2T = -8.664;
     }
     else
     {
       aL = 62.97;
       b1L = 216.9;
       b2L = -190.2;
       aT = 0.1458;
       b1T = 0.03632;
       b2T = -0.03333;
     }
     // laminar flow friction factor for bare Pin bundle - Center subchannel
     cL = aL + b1L * (p_over_d - 1) + b2L * std::pow((p_over_d - 1), 2.0);
     // turbulent flow friction factor for bare Pin bundle - Center subchannel
     cT = aT + b1T * (p_over_d - 1) + b2T * std::pow((p_over_d - 1), 2.0);
   }
   else if (subch_type == EChannelType::EDGE)
   {
     if (w_over_d < 1.1)
     {
       aL = 26.18;
       b1L = 554.5;
       b2L = -1480.0;
       aT = 0.09377;
       b1T = 0.8732;
       b2T = -3.341;
     }
     else
     {
       aL = 44.4;
       b1L = 256.7;
       b2L = -267.6;
       aT = 0.1430;
       b1T = 0.04199;
       b2T = -0.04428;
     }
     // laminar flow friction factor for bare Pin bundle - Edge subchannel
     cL = aL + b1L * (w_over_d - 1) + b2L * std::pow((w_over_d - 1), 2.0);
     // turbulent flow friction factor for bare Pin bundle - Edge subchannel
     cT = aT + b1T * (w_over_d - 1) + b2T * std::pow((w_over_d - 1), 2.0);
   }
   else
   {
     if (w_over_d < 1.1)
     {
       aL = 26.98;
       b1L = 1636.0;
       b2L = -10050.0;
       aT = 0.1004;
       b1T = 1.625;
       b2T = -11.85;
     }
     else
     {
       aL = 87.26;
       b1L = 38.59;
       b2L = -55.12;
       aT = 0.1499;
       b1T = 0.006706;
       b2T = -0.009567;
     }
     // laminar flow friction factor for bare Pin bundle - Corner subchannel
     cL = aL + b1L * (w_over_d - 1) + b2L * std::pow((w_over_d - 1), 2.0);
     // turbulent flow friction factor for bare Pin bundle - Corner subchannel
     cT = aT + b1T * (w_over_d - 1) + b2T * std::pow((w_over_d - 1), 2.0);
   }
 
   // Find the coefficients of wire-wrapped Pin bundle friction factor
   // correlations for turbulent and laminar flow regimes. Todreas & Kazimi, Nuclear Systems
   // Volume 1 Chapter 9-6 also Chen and Todreas (2018).
   if ((wire_diameter != 0.0) && (wire_lead_length != 0.0))
   {
     if (subch_type == EChannelType::CENTER)
     {
       // wetted perimeter for center subchannel and bare Pin bundle
       pw_p = libMesh::pi * pin_diameter / 2.0;
       // wire projected area - center subchannel wire-wrapped bundle
       ar = libMesh::pi * (pin_diameter + wire_diameter) * wire_diameter / 6.0;
       // bare Pin bundle center subchannel flow area (normal area + wire area)
       a_p = S + libMesh::pi * std::pow(wire_diameter, 2.0) / 8.0 / std::cos(theta);
       // turbulent friction factor equation constant - Center subchannel
       cT *= (pw_p / w_perim);
       cT += wd_t * (3.0 * ar / a_p) * (Dh_i / wire_lead_length) *
             std::pow((Dh_i / wire_diameter), 0.18);
       // laminar friction factor equation constant - Center subchannel
       cL *= (pw_p / w_perim);
       cL += wd_l * (3.0 * ar / a_p) * (Dh_i / wire_lead_length) * (Dh_i / wire_diameter);
     }
     else if (subch_type == EChannelType::EDGE)
     {
       // wire projected area - edge subchannel wire-wrapped bundle
       ar = libMesh::pi * (pin_diameter + wire_diameter) * wire_diameter / 4.0;
       // bare Pin bundle edge subchannel flow area (normal area + wire area)
       a_p = S + libMesh::pi * std::pow(wire_diameter, 2.0) / 8.0 / std::cos(theta);
       // turbulent friction factor equation constant - Edge subchannel
       cT *= std::pow((1 + ws_t * (ar / a_p) * std::pow(std::tan(theta), 2.0)), 1.41);
       // laminar friction factor equation constant - Edge subchannel
       cL *= (1 + ws_l * (ar / a_p) * std::pow(std::tan(theta), 2.0));
     }
     else
     {
       // wire projected area - corner subchannel wire-wrapped bundle
       ar = libMesh::pi * (pin_diameter + wire_diameter) * wire_diameter / 6.0;
       // bare Pin bundle corner subchannel flow area (normal area + wire area)
       a_p = S + libMesh::pi * std::pow(wire_diameter, 2.0) / 24.0 / std::cos(theta);
       // turbulent friction factor equation constant - Corner subchannel
       cT *= std::pow((1 + ws_t * (ar / a_p) * std::pow(std::tan(theta), 2.0)), 1.41);
       // laminar friction factor equation constant - Corner subchannel
       cL *= (1 + ws_l * (ar / a_p) * std::pow(std::tan(theta), 2.0));
     }
   }
 
   // laminar friction factor
   auto fL = cL / Re;
   // turbulent friction factor
   auto fT = cT / std::pow(Re, 0.18);
 
   if (Re < ReL)
   {
     // laminar flow
     return fL;
   }
   else if (Re > ReT)
   {
     // turbulent flow
     return fT;
   }
   else
   {
     // transient flow: psi definition uses a Bulk ReT/ReL number, same for all channels
     return fL * std::pow((1 - psi), 1.0 / 3.0) * (1 - std::pow(psi, lambda)) +
            fT * std::pow(psi, 1.0 / 3.0);
   }
 }

◆ computeh()

void TriSubChannel1PhaseProblem::computeh ( int iblock )

overrideprotectedvirtual

Computes Enthalpy per channel for block iblock.

Time derivative term

Advective derivative term

Axial heat conduction

TODO: Current axial derivative is zero - check if outflow conditions may make a difference

Radial Terms

Radial heat conduction

Add heat enthalpy from pin

Assembling system

Add all matrices together

Implements SubChannel1PhaseProblem.

Definition at line 592 of file TriSubChannel1PhaseProblem.C.

 {
   unsigned int last_node = (iblock + 1) * _block_size;
   unsigned int first_node = iblock * _block_size + 1;
   auto heated_length = _subchannel_mesh.getHeatedLength();
   auto unheated_length_entry = _subchannel_mesh.getHeatedLengthEntry();
   const Real & wire_lead_length = _tri_sch_mesh.getWireLeadLength();
   const Real & wire_diameter = _tri_sch_mesh.getWireDiameter();
   const Real & pitch = _subchannel_mesh.getPitch();
   const Real & pin_diameter = _subchannel_mesh.getPinDiameter();
 
   if (iblock == 0)
   {
     for (unsigned int i_ch = 0; i_ch < _n_channels; i_ch++)
     {
       auto * node = _subchannel_mesh.getChannelNode(i_ch, 0);
       auto h_out = _fp->h_from_p_T((*_P_soln)(node) + _P_out, (*_T_soln)(node));
       if (h_out < 0)
       {
         mooseError(
             name(), " : Calculation of negative Enthalpy h_out = : ", h_out, " Axial Level= : ", 0);
       }
       _h_soln->set(node, h_out);
     }
   }
 
   if (!_implicit_bool)
   {
     for (unsigned int iz = first_node; iz < last_node + 1; iz++)
     {
       auto z_grid = _subchannel_mesh.getZGrid();
       auto dz = z_grid[iz] - z_grid[iz - 1];
       Real gedge_ave = 0.0;
       Real mdot_sum = 0.0;
       Real si_sum = 0.0;
       for (unsigned int i_ch = 0; i_ch < _n_channels; i_ch++)
       {
         auto subch_type = _subchannel_mesh.getSubchannelType(i_ch);
         if (subch_type == EChannelType::EDGE || subch_type == EChannelType::CORNER)
         {
           auto * node_in = _subchannel_mesh.getChannelNode(i_ch, iz - 1);
           auto Si = (*_S_flow_soln)(node_in);
           auto mdot_in = (*_mdot_soln)(node_in);
           mdot_sum = mdot_sum + mdot_in;
           si_sum = si_sum + Si;
         }
       }
       gedge_ave = mdot_sum / si_sum;
 
       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 mdot_in = (*_mdot_soln)(node_in);
         auto h_in = (*_h_soln)(node_in); // J/kg
         auto volume = dz * (*_S_flow_soln)(node_in);
         auto mdot_out = (*_mdot_soln)(node_out);
         auto h_out = 0.0;
         Real sumWijh = 0.0;
         Real sumWijPrimeDhij = 0.0;
         Real e_cond = 0.0;
 
         Real added_enthalpy;
         if (z_grid[iz] > unheated_length_entry &&
             z_grid[iz] <= unheated_length_entry + heated_length)
         {
           added_enthalpy = computeAddedHeatPin(i_ch, iz);
         }
         else
           added_enthalpy = 0.0;
 
         added_enthalpy += computeAddedHeatDuct(i_ch, iz);
 
         // compute the sweep flow enthalpy change
         auto subch_type = _subchannel_mesh.getSubchannelType(i_ch);
         Real sweep_enthalpy = 0.0;
 
         if ((subch_type == EChannelType::EDGE || subch_type == EChannelType::CORNER) &&
             (wire_diameter != 0.0) && (wire_lead_length != 0.0))
         {
           const Real & pitch = _subchannel_mesh.getPitch();
           const Real & pin_diameter = _subchannel_mesh.getPinDiameter();
           const Real & wire_lead_length = _tri_sch_mesh.getWireLeadLength();
           const Real & wire_diameter = _tri_sch_mesh.getWireDiameter();
           auto gap = _tri_sch_mesh.getDuctToPinGap();
           auto w = pin_diameter + gap;
           auto theta =
               std::acos(wire_lead_length /
                         std::sqrt(std::pow(wire_lead_length, 2) +
                                   std::pow(libMesh::pi * (pin_diameter + wire_diameter), 2)));
           auto Sij = dz * gap;
           auto Si = (*_S_flow_soln)(node_in);
           // in/out channels for i_ch
           auto sweep_in = _tri_sch_mesh.getSweepFlowChans(i_ch).first;
           auto * node_sin = _subchannel_mesh.getChannelNode(sweep_in, iz - 1);
 
           // Calculation of flow regime
           auto ReL = 320.0 * std::pow(10.0, pitch / pin_diameter - 1);
           auto ReT = 10000.0 * std::pow(10.0, 0.7 * (pitch / pin_diameter - 1));
           auto massflux = (*_mdot_soln)(node_in) / Si;
           auto w_perim = (*_w_perim_soln)(node_in);
           auto mu = (*_mu_soln)(node_in);
           // hydraulic diameter
           auto hD = 4.0 * Si / w_perim;
           auto Re = massflux * hD / mu;
           // Calculation of geometric parameters
           auto Ar2 = libMesh::pi * (pin_diameter + wire_diameter) * wire_diameter / 4.0;
           auto A2prime =
               pitch * (w - pin_diameter / 2.0) - libMesh::pi * std::pow(pin_diameter, 2) / 8.0;
           auto A2 = A2prime - libMesh::pi * std::pow(wire_diameter, 2) / 8.0 / std::cos(theta);
           auto Cs = 0.0;
           if (Re < ReL)
           {
             Cs = 0.033 * std::pow(wire_lead_length / pin_diameter, 0.3);
           }
           else if (Re > ReT)
           {
             Cs = 0.75 * std::pow(wire_lead_length / pin_diameter, 0.3);
           }
           else
           {
             auto psi = (std::log(Re) - std::log(ReL)) / (std::log(ReT) - std::log(ReL));
             auto gamma = 2.0 / 3.0;
             Cs = 0.75 * std::pow(wire_lead_length / pin_diameter, 0.3) +
                  (0.75 * std::pow(wire_lead_length / pin_diameter, 0.3) -
                   0.033 * std::pow(wire_lead_length / pin_diameter, 0.3)) *
                      std::pow(psi, gamma);
           }
           // Calculation of turbulent mixing parameter
           auto beta = Cs * std::pow(Ar2 / A2, 0.5) * std::tan(theta);
 
           auto wsweep_in = gedge_ave * beta * Sij;
           auto wsweep_out = gedge_ave * beta * Sij;
           auto sweep_hin = (*_h_soln)(node_sin);
           auto sweep_hout = (*_h_soln)(node_in);
           sweep_enthalpy = (wsweep_in * sweep_hin - wsweep_out * sweep_hout);
         }
 
         // 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))
         {
           auto chans = _subchannel_mesh.getGapChannels(i_gap);
           unsigned int ii_ch = chans.first;
           // i is always the smallest and first index in the mapping
           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);
           // Define donor enthalpy
           auto h_star = 0.0;
           if (_Wij(i_gap, iz) > 0.0)
             h_star = (*_h_soln)(node_in_i);
           else if (_Wij(i_gap, iz) < 0.0)
             h_star = (*_h_soln)(node_in_j);
           // take care of the sign by applying the map, use donor cell
           sumWijh += _subchannel_mesh.getCrossflowSign(i_ch, counter) * _Wij(i_gap, iz) * h_star;
           sumWijPrimeDhij += _WijPrime(i_gap, iz) * (2 * (*_h_soln)(node_in) -
                                                      (*_h_soln)(node_in_j) - (*_h_soln)(node_in_i));
           counter++;
 
           // compute the radial heat conduction through the gaps
           auto subch_type_i = _subchannel_mesh.getSubchannelType(ii_ch);
           auto subch_type_j = _subchannel_mesh.getSubchannelType(jj_ch);
           Real dist_ij = pitch;
 
           if (subch_type_i == EChannelType::EDGE && subch_type_j == EChannelType::EDGE)
           {
             dist_ij = pitch;
           }
           else if ((subch_type_i == EChannelType::CORNER && subch_type_j == EChannelType::EDGE) ||
                    (subch_type_i == EChannelType::EDGE && subch_type_j == EChannelType::CORNER))
           {
             dist_ij = pitch;
           }
           else
           {
             dist_ij = pitch / std::sqrt(3);
           }
 
           auto Sij = dz * _subchannel_mesh.getGapWidth(iz, i_gap);
           auto thcon_i = _fp->k_from_p_T((*_P_soln)(node_in_i) + _P_out, (*_T_soln)(node_in_i));
           auto thcon_j = _fp->k_from_p_T((*_P_soln)(node_in_j) + _P_out, (*_T_soln)(node_in_j));
           auto shape_factor =
               0.66 * (pitch / pin_diameter) *
               std::pow((_subchannel_mesh.getGapWidth(iz, i_gap) / pin_diameter), -0.3);
           if (ii_ch == i_ch)
           {
             e_cond += 0.5 * (thcon_i + thcon_j) * Sij * shape_factor *
                       ((*_T_soln)(node_in_j) - (*_T_soln)(node_in_i)) / dist_ij;
           }
           else
           {
             e_cond += -0.5 * (thcon_i + thcon_j) * Sij * shape_factor *
                       ((*_T_soln)(node_in_j) - (*_T_soln)(node_in_i)) / dist_ij;
           }
         }
 
         // compute the axial heat conduction between current and lower axial node
         auto * node_in_i = _subchannel_mesh.getChannelNode(i_ch, iz);
         auto * node_in_j = _subchannel_mesh.getChannelNode(i_ch, iz - 1);
         auto thcon_i = _fp->k_from_p_T((*_P_soln)(node_in_i) + _P_out, (*_T_soln)(node_in_i));
         auto thcon_j = _fp->k_from_p_T((*_P_soln)(node_in_j) + _P_out, (*_T_soln)(node_in_j));
         auto Si = (*_S_flow_soln)(node_in_i);
         auto dist_ij = z_grid[iz] - z_grid[iz - 1];
 
         e_cond += 0.5 * (thcon_i + thcon_j) * Si * ((*_T_soln)(node_in_j) - (*_T_soln)(node_in_i)) /
                   dist_ij;
 
         unsigned int nz = _subchannel_mesh.getNumOfAxialCells();
         // compute the axial heat conduction between current and upper axial node
         if (iz < nz)
         {
           auto * node_in_i = _subchannel_mesh.getChannelNode(i_ch, iz);
           auto * node_in_j = _subchannel_mesh.getChannelNode(i_ch, iz + 1);
           auto thcon_i = _fp->k_from_p_T((*_P_soln)(node_in_i) + _P_out, (*_T_soln)(node_in_i));
           auto thcon_j = _fp->k_from_p_T((*_P_soln)(node_in_j) + _P_out, (*_T_soln)(node_in_j));
           auto Si = (*_S_flow_soln)(node_in_i);
           auto dist_ij = z_grid[iz + 1] - z_grid[iz];
           e_cond += 0.5 * (thcon_i + thcon_j) * Si *
                     ((*_T_soln)(node_in_j) - (*_T_soln)(node_in_i)) / dist_ij;
         }
 
         // end of radial heat conduction calc.
         h_out =
             (mdot_in * h_in - sumWijh - sumWijPrimeDhij + added_enthalpy + e_cond + sweep_enthalpy +
              _TR * _rho_soln->old(node_out) * _h_soln->old(node_out) * volume / _dt) /
             (mdot_out + _TR * (*_rho_soln)(node_out)*volume / _dt);
         if (h_out < 0)
         {
           mooseError(name(),
                      " : Calculation of negative Enthalpy h_out = : ",
                      h_out,
                      " Axial Level= : ",
                      iz);
         }
         _h_soln->set(node_out, h_out); // J/kg
       }
     }
   }
   else
   {
     LibmeshPetscCall(MatZeroEntries(_hc_time_derivative_mat));
     LibmeshPetscCall(MatZeroEntries(_hc_advective_derivative_mat));
     LibmeshPetscCall(MatZeroEntries(_hc_cross_derivative_mat));
     LibmeshPetscCall(MatZeroEntries(_hc_axial_heat_conduction_mat));
     LibmeshPetscCall(MatZeroEntries(_hc_radial_heat_conduction_mat));
     LibmeshPetscCall(MatZeroEntries(_hc_sweep_enthalpy_mat));
 
     LibmeshPetscCall(VecZeroEntries(_hc_time_derivative_rhs));
     LibmeshPetscCall(VecZeroEntries(_hc_advective_derivative_rhs));
     LibmeshPetscCall(VecZeroEntries(_hc_cross_derivative_rhs));
     LibmeshPetscCall(VecZeroEntries(_hc_added_heat_rhs));
     LibmeshPetscCall(VecZeroEntries(_hc_axial_heat_conduction_rhs));
     LibmeshPetscCall(VecZeroEntries(_hc_radial_heat_conduction_rhs));
     LibmeshPetscCall(VecZeroEntries(_hc_sweep_enthalpy_rhs));
 
     LibmeshPetscCall(MatZeroEntries(_hc_sys_h_mat));
     LibmeshPetscCall(VecZeroEntries(_hc_sys_h_rhs));
 
     for (unsigned int iz = first_node; iz < last_node + 1; iz++)
     {
       auto dz = _z_grid[iz] - _z_grid[iz - 1];
       auto heated_length = _subchannel_mesh.getHeatedLength();
       auto unheated_length_entry = _subchannel_mesh.getHeatedLengthEntry();
       auto pitch = _subchannel_mesh.getPitch();
       auto pin_diameter = _subchannel_mesh.getPinDiameter();
       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 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 volume = dz * S_interp;
 
         PetscScalar Pe = 0.5;
         if (_interpolation_scheme == 3)
         {
           // Compute the Peclet number
           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 K_in = _fp->k_from_p_T((*_P_soln)(node_in) + _P_out, (*_T_soln)(node_in));
           auto K_out = _fp->k_from_p_T((*_P_soln)(node_out) + _P_out, (*_T_soln)(node_out));
           auto K = this->computeInterpolatedValue(K_out, K_in, 0.5);
           auto cp_in = _fp->cp_from_p_T((*_P_soln)(node_in) + _P_out, (*_T_soln)(node_in));
           auto cp_out = _fp->cp_from_p_T((*_P_soln)(node_out) + _P_out, (*_T_soln)(node_out));
           auto cp = this->computeInterpolatedValue(cp_out, cp_in, 0.5);
           auto mdot_loc =
               this->computeInterpolatedValue((*_mdot_soln)(node_out), (*_mdot_soln)(node_in), 0.5);
           // hydraulic diameter in the i direction
           auto Dh_i = 4.0 * S_interp / w_perim_interp;
           Pe = mdot_loc * Dh_i * cp / (K * S_interp) * (mdot_loc / std::abs(mdot_loc));
         }
         auto alpha = computeInterpolationCoefficients(Pe);
 
         if (iz == first_node)
         {
           PetscScalar value_vec_tt =
               -1.0 * _TR * alpha * (*_rho_soln)(node_in) * (*_h_soln)(node_in)*volume / _dt;
           PetscInt row_vec_tt = i_ch + _n_channels * iz_ind;
           LibmeshPetscCall(
               VecSetValues(_hc_time_derivative_rhs, 1, &row_vec_tt, &value_vec_tt, ADD_VALUES));
         }
         else
         {
           PetscInt row_tt = i_ch + _n_channels * iz_ind;
           PetscInt col_tt = i_ch + _n_channels * (iz_ind - 1);
           PetscScalar value_tt = _TR * alpha * (*_rho_soln)(node_in)*volume / _dt;
           LibmeshPetscCall(MatSetValues(
               _hc_time_derivative_mat, 1, &row_tt, 1, &col_tt, &value_tt, INSERT_VALUES));
         }
 
         // Adding diagonal elements
         PetscInt row_tt = i_ch + _n_channels * iz_ind;
         PetscInt col_tt = i_ch + _n_channels * iz_ind;
         PetscScalar value_tt = _TR * (1.0 - alpha) * (*_rho_soln)(node_out)*volume / _dt;
         LibmeshPetscCall(MatSetValues(
             _hc_time_derivative_mat, 1, &row_tt, 1, &col_tt, &value_tt, INSERT_VALUES));
 
         // Adding RHS elements
         PetscScalar rho_old_interp =
             computeInterpolatedValue(_rho_soln->old(node_out), _rho_soln->old(node_in), Pe);
         PetscScalar h_old_interp =
             computeInterpolatedValue(_h_soln->old(node_out), _h_soln->old(node_in), Pe);
         PetscScalar value_vec_tt = _TR * rho_old_interp * h_old_interp * volume / _dt;
         PetscInt row_vec_tt = i_ch + _n_channels * iz_ind;
         LibmeshPetscCall(
             VecSetValues(_hc_time_derivative_rhs, 1, &row_vec_tt, &value_vec_tt, ADD_VALUES));
 
         if (iz == first_node)
         {
           PetscInt row_at = i_ch + _n_channels * iz_ind;
           PetscScalar value_at = alpha * (*_mdot_soln)(node_in) * (*_h_soln)(node_in);
           LibmeshPetscCall(
               VecSetValues(_hc_advective_derivative_rhs, 1, &row_at, &value_at, ADD_VALUES));
 
           value_at = alpha * (*_mdot_soln)(node_out) - (1 - alpha) * (*_mdot_soln)(node_in);
           PetscInt col_at = i_ch + _n_channels * iz_ind;
           LibmeshPetscCall(MatSetValues(
               _hc_advective_derivative_mat, 1, &row_at, 1, &col_at, &value_at, ADD_VALUES));
 
           value_at = (1 - alpha) * (*_mdot_soln)(node_out);
           col_at = i_ch + _n_channels * (iz_ind + 1);
           LibmeshPetscCall(MatSetValues(
               _hc_advective_derivative_mat, 1, &row_at, 1, &col_at, &value_at, ADD_VALUES));
         }
         else if (iz == last_node)
         {
           PetscInt row_at = i_ch + _n_channels * iz_ind;
           PetscScalar value_at = 1.0 * (*_mdot_soln)(node_out);
           PetscInt col_at = i_ch + _n_channels * iz_ind;
           LibmeshPetscCall(MatSetValues(
               _hc_advective_derivative_mat, 1, &row_at, 1, &col_at, &value_at, ADD_VALUES));
 
           value_at = -1.0 * (*_mdot_soln)(node_in);
           col_at = i_ch + _n_channels * (iz_ind - 1);
           LibmeshPetscCall(MatSetValues(
               _hc_advective_derivative_mat, 1, &row_at, 1, &col_at, &value_at, ADD_VALUES));
         }
         else
         {
           PetscInt row_at = i_ch + _n_channels * iz_ind;
           PetscInt col_at;
 
           PetscScalar value_at = -alpha * (*_mdot_soln)(node_in);
           col_at = i_ch + _n_channels * (iz_ind - 1);
           LibmeshPetscCall(MatSetValues(
               _hc_advective_derivative_mat, 1, &row_at, 1, &col_at, &value_at, ADD_VALUES));
 
           value_at = alpha * (*_mdot_soln)(node_out) - (1 - alpha) * (*_mdot_soln)(node_in);
           col_at = i_ch + _n_channels * iz_ind;
           LibmeshPetscCall(MatSetValues(
               _hc_advective_derivative_mat, 1, &row_at, 1, &col_at, &value_at, ADD_VALUES));
 
           value_at = (1 - alpha) * (*_mdot_soln)(node_out);
           col_at = i_ch + _n_channels * (iz_ind + 1);
           LibmeshPetscCall(MatSetValues(
               _hc_advective_derivative_mat, 1, &row_at, 1, &col_at, &value_at, ADD_VALUES));
         }
 
         auto * node_center = _subchannel_mesh.getChannelNode(i_ch, iz);
         auto K_center = _fp->k_from_p_T((*_P_soln)(node_center) + _P_out, (*_T_soln)(node_center));
         auto cp_center =
             _fp->cp_from_p_T((*_P_soln)(node_center) + _P_out, (*_T_soln)(node_center));
         auto diff_center = K_center / (cp_center + 1e-15);
 
         if (iz == first_node)
         {
           auto * node_top = _subchannel_mesh.getChannelNode(i_ch, iz + 1);
           auto * node_bottom = _subchannel_mesh.getChannelNode(i_ch, iz - 1);
           auto K_bottom =
               _fp->k_from_p_T((*_P_soln)(node_bottom) + _P_out, (*_T_soln)(node_bottom));
           auto K_top = _fp->k_from_p_T((*_P_soln)(node_top) + _P_out, (*_T_soln)(node_top));
           auto cp_bottom =
               _fp->cp_from_p_T((*_P_soln)(node_bottom) + _P_out, (*_T_soln)(node_bottom));
           auto cp_top = _fp->cp_from_p_T((*_P_soln)(node_top) + _P_out, (*_T_soln)(node_top));
           auto diff_bottom = K_bottom / (cp_bottom + 1e-15);
           auto diff_top = K_top / (cp_top + 1e-15);
 
           auto dz_up = _z_grid[iz + 1] - _z_grid[iz];
           auto dz_down = _z_grid[iz] - _z_grid[iz - 1];
           auto S_up =
               computeInterpolatedValue((*_S_flow_soln)(node_top), (*_S_flow_soln)(node_center));
           auto S_down =
               computeInterpolatedValue((*_S_flow_soln)(node_center), (*_S_flow_soln)(node_bottom));
           auto diff_up = computeInterpolatedValue(diff_top, diff_center);
           auto diff_down = computeInterpolatedValue(diff_center, diff_bottom);
 
           // Diagonal  value
           PetscInt row_at = i_ch + _n_channels * iz_ind;
           PetscInt col_at = i_ch + _n_channels * iz_ind;
           PetscScalar value_at = diff_up * S_up / dz_up + diff_down * S_down / dz_down;
           LibmeshPetscCall(MatSetValues(
               _hc_axial_heat_conduction_mat, 1, &row_at, 1, &col_at, &value_at, INSERT_VALUES));
 
           // Bottom value
           value_at = 1.0 * diff_down * S_down / dz_down * (*_h_soln)(node_bottom);
           LibmeshPetscCall(
               VecSetValues(_hc_axial_heat_conduction_rhs, 1, &row_at, &value_at, ADD_VALUES));
 
           // Top value
           col_at = i_ch + _n_channels * (iz_ind + 1);
           value_at = -diff_up * S_up / dz_up;
           LibmeshPetscCall(MatSetValues(
               _hc_axial_heat_conduction_mat, 1, &row_at, 1, &col_at, &value_at, INSERT_VALUES));
         }
         else if (iz == last_node)
         {
           auto * node_bottom = _subchannel_mesh.getChannelNode(i_ch, iz - 1);
           auto K_bottom =
               _fp->k_from_p_T((*_P_soln)(node_bottom) + _P_out, (*_T_soln)(node_bottom));
           auto cp_bottom =
               _fp->cp_from_p_T((*_P_soln)(node_bottom) + _P_out, (*_T_soln)(node_bottom));
           auto diff_bottom = K_bottom / (cp_bottom + 1e-15);
 
           auto dz_down = _z_grid[iz] - _z_grid[iz - 1];
           auto S_down = 0.5 * ((*_S_flow_soln)(node_center) + (*_S_flow_soln)(node_bottom));
           auto diff_down = 0.5 * (diff_center + diff_bottom);
 
           // Diagonal  value
           PetscInt row_at = i_ch + _n_channels * iz_ind;
           PetscInt col_at = i_ch + _n_channels * iz_ind;
           PetscScalar value_at = diff_down * S_down / dz_down;
           LibmeshPetscCall(MatSetValues(
               _hc_axial_heat_conduction_mat, 1, &row_at, 1, &col_at, &value_at, INSERT_VALUES));
 
           // Bottom value
           col_at = i_ch + _n_channels * (iz_ind - 1);
           value_at = -diff_down * S_down / dz_down;
           LibmeshPetscCall(MatSetValues(
               _hc_axial_heat_conduction_mat, 1, &row_at, 1, &col_at, &value_at, INSERT_VALUES));
 
           // Outflow derivative
           // value_at = -1.0 * (*_mdot_soln)(node_center) * (*_h_soln)(node_center);
           // VecSetValues(_hc_axial_heat_conduction_rhs, 1, &row_at, &value_at, ADD_VALUES);
         }
         else
         {
           auto * node_top = _subchannel_mesh.getChannelNode(i_ch, iz + 1);
           auto * node_bottom = _subchannel_mesh.getChannelNode(i_ch, iz - 1);
           auto K_bottom =
               _fp->k_from_p_T((*_P_soln)(node_bottom) + _P_out, (*_T_soln)(node_bottom));
           auto K_top = _fp->k_from_p_T((*_P_soln)(node_top) + _P_out, (*_T_soln)(node_top));
           auto cp_bottom =
               _fp->cp_from_p_T((*_P_soln)(node_bottom) + _P_out, (*_T_soln)(node_bottom));
           auto cp_top = _fp->cp_from_p_T((*_P_soln)(node_top) + _P_out, (*_T_soln)(node_top));
           auto diff_bottom = K_bottom / (cp_bottom + 1e-15);
           auto diff_top = K_top / (cp_top + 1e-15);
 
           auto dz_up = _z_grid[iz + 1] - _z_grid[iz];
           auto dz_down = _z_grid[iz] - _z_grid[iz - 1];
           auto S_up =
               computeInterpolatedValue((*_S_flow_soln)(node_top), (*_S_flow_soln)(node_center));
           auto S_down =
               computeInterpolatedValue((*_S_flow_soln)(node_center), (*_S_flow_soln)(node_bottom));
           auto diff_up = computeInterpolatedValue(diff_top, diff_center);
           auto diff_down = computeInterpolatedValue(diff_center, diff_bottom);
 
           // Diagonal value
           PetscInt row_at = i_ch + _n_channels * iz_ind;
           PetscInt col_at = i_ch + _n_channels * iz_ind;
           PetscScalar value_at = diff_up * S_up / dz_up + diff_down * S_down / dz_down;
           LibmeshPetscCall(MatSetValues(
               _hc_axial_heat_conduction_mat, 1, &row_at, 1, &col_at, &value_at, INSERT_VALUES));
 
           // Bottom value
           col_at = i_ch + _n_channels * (iz_ind - 1);
           value_at = -diff_down * S_down / dz_down;
           LibmeshPetscCall(MatSetValues(
               _hc_axial_heat_conduction_mat, 1, &row_at, 1, &col_at, &value_at, INSERT_VALUES));
 
           // Top value
           col_at = i_ch + _n_channels * (iz_ind + 1);
           value_at = -diff_up * S_up / dz_up;
           LibmeshPetscCall(MatSetValues(
               _hc_axial_heat_conduction_mat, 1, &row_at, 1, &col_at, &value_at, INSERT_VALUES));
         }
 
         unsigned int counter = 0;
         unsigned int cross_index = iz;
         // Real radial_heat_conduction(0.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);
           PetscScalar h_star;
           // figure out donor axial velocity
           if (_Wij(i_gap, cross_index) > 0.0)
           {
             if (iz == first_node)
             {
               h_star = (*_h_soln)(node_in_i);
               PetscScalar value_vec_ct = -1.0 * alpha *
                                          _subchannel_mesh.getCrossflowSign(i_ch, counter) *
                                          _Wij(i_gap, cross_index) * h_star;
               PetscInt row_vec_ct = i_ch + _n_channels * iz_ind;
               LibmeshPetscCall(VecSetValues(
                   _hc_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);
               PetscInt row_ct = i_ch + _n_channels * iz_ind;
               PetscInt col_ct = ii_ch + _n_channels * (iz_ind - 1);
               LibmeshPetscCall(MatSetValues(
                   _hc_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);
             PetscInt row_ct = i_ch + _n_channels * iz_ind;
             PetscInt col_ct = ii_ch + _n_channels * iz_ind;
             LibmeshPetscCall(MatSetValues(
                 _hc_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)
             {
               h_star = (*_h_soln)(node_in_j);
               PetscScalar value_vec_ct = -1.0 * alpha *
                                          _subchannel_mesh.getCrossflowSign(i_ch, counter) *
                                          _Wij(i_gap, cross_index) * h_star;
               PetscInt row_vec_ct = i_ch + _n_channels * iz_ind;
               LibmeshPetscCall(VecSetValues(
                   _hc_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);
               PetscInt row_ct = i_ch + _n_channels * iz_ind;
               PetscInt col_ct = jj_ch + _n_channels * (iz_ind - 1);
               LibmeshPetscCall(MatSetValues(
                   _hc_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);
             PetscInt row_ct = i_ch + _n_channels * iz_ind;
             PetscInt col_ct = jj_ch + _n_channels * iz_ind;
             LibmeshPetscCall(MatSetValues(
                 _hc_cross_derivative_mat, 1, &row_ct, 1, &col_ct, &value_ct, ADD_VALUES));
           }
 
           // Turbulent cross flows
           if (iz == first_node)
           {
             PetscScalar value_vec_ct =
                 -2.0 * alpha * (*_h_soln)(node_in)*_WijPrime(i_gap, cross_index);
             value_vec_ct += alpha * (*_h_soln)(node_in_j)*_WijPrime(i_gap, cross_index);
             value_vec_ct += alpha * (*_h_soln)(node_in_i)*_WijPrime(i_gap, cross_index);
             PetscInt row_vec_ct = i_ch + _n_channels * iz_ind;
             LibmeshPetscCall(
                 VecSetValues(_hc_cross_derivative_rhs, 1, &row_vec_ct, &value_vec_ct, ADD_VALUES));
           }
           else
           {
             PetscScalar value_center_ct = 2.0 * alpha * _WijPrime(i_gap, cross_index);
             PetscInt row_ct = i_ch + _n_channels * iz_ind;
             PetscInt col_ct = i_ch + _n_channels * (iz_ind - 1);
             LibmeshPetscCall(MatSetValues(
                 _hc_cross_derivative_mat, 1, &row_ct, 1, &col_ct, &value_center_ct, ADD_VALUES));
 
             PetscScalar value_left_ct = -1.0 * alpha * _WijPrime(i_gap, cross_index);
             row_ct = i_ch + _n_channels * iz_ind;
             col_ct = jj_ch + _n_channels * (iz_ind - 1);
             LibmeshPetscCall(MatSetValues(
                 _hc_cross_derivative_mat, 1, &row_ct, 1, &col_ct, &value_left_ct, ADD_VALUES));
 
             PetscScalar value_right_ct = -1.0 * alpha * _WijPrime(i_gap, cross_index);
             row_ct = i_ch + _n_channels * iz_ind;
             col_ct = ii_ch + _n_channels * (iz_ind - 1);
             LibmeshPetscCall(MatSetValues(
                 _hc_cross_derivative_mat, 1, &row_ct, 1, &col_ct, &value_right_ct, ADD_VALUES));
           }
           PetscScalar value_center_ct = 2.0 * (1.0 - alpha) * _WijPrime(i_gap, cross_index);
           PetscInt row_ct = i_ch + _n_channels * iz_ind;
           PetscInt col_ct = i_ch + _n_channels * iz_ind;
           LibmeshPetscCall(MatSetValues(
               _hc_cross_derivative_mat, 1, &row_ct, 1, &col_ct, &value_center_ct, ADD_VALUES));
 
           PetscScalar value_left_ct = -1.0 * (1.0 - alpha) * _WijPrime(i_gap, cross_index);
           row_ct = i_ch + _n_channels * iz_ind;
           col_ct = jj_ch + _n_channels * iz_ind;
           LibmeshPetscCall(MatSetValues(
               _hc_cross_derivative_mat, 1, &row_ct, 1, &col_ct, &value_left_ct, ADD_VALUES));
 
           PetscScalar value_right_ct = -1.0 * (1.0 - alpha) * _WijPrime(i_gap, cross_index);
           row_ct = i_ch + _n_channels * iz_ind;
           col_ct = ii_ch + _n_channels * iz_ind;
           LibmeshPetscCall(MatSetValues(
               _hc_cross_derivative_mat, 1, &row_ct, 1, &col_ct, &value_right_ct, ADD_VALUES));
 
           auto subch_type_i = _subchannel_mesh.getSubchannelType(ii_ch);
           auto subch_type_j = _subchannel_mesh.getSubchannelType(jj_ch);
           Real dist_ij = pitch;
 
           if (subch_type_i == EChannelType::EDGE && subch_type_j == EChannelType::EDGE)
           {
             dist_ij = pitch;
           }
           else if ((subch_type_i == EChannelType::CORNER && subch_type_j == EChannelType::EDGE) ||
                    (subch_type_i == EChannelType::EDGE && subch_type_j == EChannelType::CORNER))
           {
             dist_ij = pitch;
           }
           else
           {
             dist_ij = pitch / std::sqrt(3);
           }
 
           auto Sij = dz * _subchannel_mesh.getGapWidth(iz, i_gap);
           auto K_i = _fp->k_from_p_T((*_P_soln)(node_in_i) + _P_out, (*_T_soln)(node_in_i));
           auto K_j = _fp->k_from_p_T((*_P_soln)(node_in_j) + _P_out, (*_T_soln)(node_in_j));
           auto cp_i = _fp->cp_from_p_T((*_P_soln)(node_in_i) + _P_out, (*_T_soln)(node_in_i));
           auto cp_j = _fp->cp_from_p_T((*_P_soln)(node_in_j) + _P_out, (*_T_soln)(node_in_j));
           auto A_i = K_i / cp_i;
           auto A_j = K_j / cp_j;
           auto harm_A = 2.0 * A_i * A_j / (A_i + A_j);
           auto shape_factor =
               0.66 * (pitch / pin_diameter) *
               std::pow((_subchannel_mesh.getGapWidth(iz, i_gap) / pin_diameter), -0.3);
           // auto base_value =  0.5 * (A_i + A_j) * Sij * shape_factor / dist_ij;
           auto base_value = harm_A * shape_factor * Sij / dist_ij;
           auto neg_base_value = -1.0 * base_value;
 
           row_ct = ii_ch + _n_channels * iz_ind;
           col_ct = ii_ch + _n_channels * iz_ind;
           LibmeshPetscCall(MatSetValues(
               _hc_radial_heat_conduction_mat, 1, &row_ct, 1, &col_ct, &base_value, ADD_VALUES));
 
           row_ct = jj_ch + _n_channels * iz_ind;
           col_ct = jj_ch + _n_channels * iz_ind;
           LibmeshPetscCall(MatSetValues(
               _hc_radial_heat_conduction_mat, 1, &row_ct, 1, &col_ct, &base_value, ADD_VALUES));
 
           row_ct = ii_ch + _n_channels * iz_ind;
           col_ct = jj_ch + _n_channels * iz_ind;
           LibmeshPetscCall(MatSetValues(
               _hc_radial_heat_conduction_mat, 1, &row_ct, 1, &col_ct, &neg_base_value, ADD_VALUES));
 
           row_ct = jj_ch + _n_channels * iz_ind;
           col_ct = ii_ch + _n_channels * iz_ind;
           LibmeshPetscCall(MatSetValues(
               _hc_radial_heat_conduction_mat, 1, &row_ct, 1, &col_ct, &neg_base_value, ADD_VALUES));
           counter++;
         }
 
         // compute the sweep flow enthalpy change
         Real gedge_ave = 0.0;
         Real mdot_sum = 0.0;
         Real si_sum = 0.0;
         for (unsigned int i_ch = 0; i_ch < _n_channels; i_ch++)
         {
           auto subch_type = _subchannel_mesh.getSubchannelType(i_ch);
           if (subch_type == EChannelType::EDGE || subch_type == EChannelType::CORNER)
           {
             auto * node_in = _subchannel_mesh.getChannelNode(i_ch, iz - 1);
             auto Si = (*_S_flow_soln)(node_in);
             auto mdot_in = (*_mdot_soln)(node_in);
             mdot_sum = mdot_sum + mdot_in;
             si_sum = si_sum + Si;
           }
         }
         gedge_ave = mdot_sum / si_sum;
         auto subch_type = _subchannel_mesh.getSubchannelType(i_ch);
         PetscScalar sweep_enthalpy = 0.0;
         if ((subch_type == EChannelType::EDGE || subch_type == EChannelType::CORNER) &&
             (wire_diameter != 0.0) && (wire_lead_length != 0.0))
         {
           const Real & pitch = _subchannel_mesh.getPitch();
           const Real & pin_diameter = _subchannel_mesh.getPinDiameter();
           const Real & wire_lead_length = _tri_sch_mesh.getWireLeadLength();
           const Real & wire_diameter = _tri_sch_mesh.getWireDiameter();
           auto gap = _tri_sch_mesh.getDuctToPinGap();
           auto w = pin_diameter + gap;
           auto theta =
               std::acos(wire_lead_length /
                         std::sqrt(std::pow(wire_lead_length, 2) +
                                   std::pow(libMesh::pi * (pin_diameter + wire_diameter), 2)));
           auto Sij = dz * gap;
           auto Si = (*_S_flow_soln)(node_in);
           // in/out channels for i_ch
           auto sweep_in = _tri_sch_mesh.getSweepFlowChans(i_ch).first;
           auto * node_sin = _subchannel_mesh.getChannelNode(sweep_in, iz - 1);
 
           // Calculation of flow regime
           auto ReL = 320.0 * std::pow(10.0, pitch / pin_diameter - 1);
           auto ReT = 10000.0 * std::pow(10.0, 0.7 * (pitch / pin_diameter - 1));
           auto massflux = (*_mdot_soln)(node_in) / Si;
           auto w_perim = (*_w_perim_soln)(node_in);
           auto mu = (*_mu_soln)(node_in);
           // hydraulic diameter
           auto hD = 4.0 * Si / w_perim;
           auto Re = massflux * hD / mu;
           // Calculation of geometric parameters
           auto Ar2 = libMesh::pi * (pin_diameter + wire_diameter) * wire_diameter / 4.0;
           auto A2prime =
               pitch * (w - pin_diameter / 2.0) - libMesh::pi * std::pow(pin_diameter, 2) / 8.0;
           auto A2 = A2prime - libMesh::pi * std::pow(wire_diameter, 2) / 8.0 / std::cos(theta);
           auto Cs = 0.0;
           if (Re < ReL)
           {
             Cs = 0.033 * std::pow(wire_lead_length / pin_diameter, 0.3);
           }
           else if (Re > ReT)
           {
             Cs = 0.75 * std::pow(wire_lead_length / pin_diameter, 0.3);
           }
           else
           {
             auto psi = (std::log(Re) - std::log(ReL)) / (std::log(ReT) - std::log(ReL));
             auto gamma = 2.0 / 3.0;
             Cs = 0.75 * std::pow(wire_lead_length / pin_diameter, 0.3) +
                  (0.75 * std::pow(wire_lead_length / pin_diameter, 0.3) -
                   0.033 * std::pow(wire_lead_length / pin_diameter, 0.3)) *
                      std::pow(psi, gamma);
           }
           // Calculation of turbulent mixing parameter
           auto beta = Cs * std::pow(Ar2 / A2, 0.5) * std::tan(theta);
 
           auto wsweep_in = gedge_ave * beta * Sij;
           auto wsweep_out = gedge_ave * beta * Sij;
           auto sweep_hin = (*_h_soln)(node_sin);
           auto sweep_hout = (*_h_soln)(node_in);
           sweep_enthalpy = (wsweep_in * sweep_hin - wsweep_out * sweep_hout);
 
           if (iz == first_node)
           {
             PetscInt row_sh = i_ch + _n_channels * iz_ind;
             PetscScalar value_hs = -sweep_enthalpy;
             LibmeshPetscCall(
                 VecSetValues(_hc_sweep_enthalpy_rhs, 1, &row_sh, &value_hs, ADD_VALUES));
           }
           else
           {
             PetscInt row_sh = i_ch + _n_channels * (iz_ind - 1);
             PetscInt col_sh = i_ch + _n_channels * (iz_ind - 1);
             LibmeshPetscCall(MatSetValues(
                 _hc_sweep_enthalpy_mat, 1, &row_sh, 1, &col_sh, &wsweep_out, ADD_VALUES));
             PetscInt col_sh_l = sweep_in + _n_channels * (iz_ind - 1);
             PetscScalar neg_sweep_in = -1.0 * wsweep_in;
             LibmeshPetscCall(MatSetValues(
                 _hc_sweep_enthalpy_mat, 1, &row_sh, 1, &col_sh_l, &(neg_sweep_in), ADD_VALUES));
           }
         }
 
         PetscScalar added_enthalpy;
         if (_z_grid[iz] > unheated_length_entry &&
             _z_grid[iz] <= unheated_length_entry + heated_length)
           added_enthalpy = computeAddedHeatPin(i_ch, iz);
         else
           added_enthalpy = 0.0;
         added_enthalpy += computeAddedHeatDuct(i_ch, iz);
         PetscInt row_vec_ht = i_ch + _n_channels * iz_ind;
         LibmeshPetscCall(
             VecSetValues(_hc_added_heat_rhs, 1, &row_vec_ht, &added_enthalpy, ADD_VALUES));
       }
     }
     LibmeshPetscCall(MatAssemblyBegin(_hc_time_derivative_mat, MAT_FINAL_ASSEMBLY));
     LibmeshPetscCall(MatAssemblyEnd(_hc_time_derivative_mat, MAT_FINAL_ASSEMBLY));
     LibmeshPetscCall(MatAssemblyBegin(_hc_advective_derivative_mat, MAT_FINAL_ASSEMBLY));
     LibmeshPetscCall(MatAssemblyEnd(_hc_advective_derivative_mat, MAT_FINAL_ASSEMBLY));
     LibmeshPetscCall(MatAssemblyBegin(_hc_cross_derivative_mat, MAT_FINAL_ASSEMBLY));
     LibmeshPetscCall(MatAssemblyEnd(_hc_cross_derivative_mat, MAT_FINAL_ASSEMBLY));
     LibmeshPetscCall(MatAssemblyBegin(_hc_axial_heat_conduction_mat, MAT_FINAL_ASSEMBLY));
     LibmeshPetscCall(MatAssemblyEnd(_hc_axial_heat_conduction_mat, MAT_FINAL_ASSEMBLY));
     LibmeshPetscCall(MatAssemblyBegin(_hc_radial_heat_conduction_mat, MAT_FINAL_ASSEMBLY));
     LibmeshPetscCall(MatAssemblyEnd(_hc_radial_heat_conduction_mat, MAT_FINAL_ASSEMBLY));
     LibmeshPetscCall(MatAssemblyBegin(_hc_sweep_enthalpy_mat, MAT_FINAL_ASSEMBLY));
     LibmeshPetscCall(MatAssemblyEnd(_hc_sweep_enthalpy_mat, MAT_FINAL_ASSEMBLY));
     LibmeshPetscCall(MatAssemblyBegin(_hc_sys_h_mat, MAT_FINAL_ASSEMBLY));
     LibmeshPetscCall(MatAssemblyEnd(_hc_sys_h_mat, MAT_FINAL_ASSEMBLY));
     LibmeshPetscCall(
         MatAXPY(_hc_sys_h_mat, 1.0, _hc_time_derivative_mat, DIFFERENT_NONZERO_PATTERN));
     LibmeshPetscCall(MatAssemblyBegin(_hc_sys_h_mat, MAT_FINAL_ASSEMBLY));
     LibmeshPetscCall(MatAssemblyEnd(_hc_sys_h_mat, MAT_FINAL_ASSEMBLY));
     LibmeshPetscCall(
         MatAXPY(_hc_sys_h_mat, 1.0, _hc_advective_derivative_mat, DIFFERENT_NONZERO_PATTERN));
     LibmeshPetscCall(MatAssemblyBegin(_hc_sys_h_mat, MAT_FINAL_ASSEMBLY));
     LibmeshPetscCall(MatAssemblyEnd(_hc_sys_h_mat, MAT_FINAL_ASSEMBLY));
     LibmeshPetscCall(
         MatAXPY(_hc_sys_h_mat, 1.0, _hc_cross_derivative_mat, DIFFERENT_NONZERO_PATTERN));
     LibmeshPetscCall(MatAssemblyBegin(_hc_sys_h_mat, MAT_FINAL_ASSEMBLY));
     LibmeshPetscCall(MatAssemblyEnd(_hc_sys_h_mat, MAT_FINAL_ASSEMBLY));
     LibmeshPetscCall(
         MatAXPY(_hc_sys_h_mat, 1.0, _hc_axial_heat_conduction_mat, DIFFERENT_NONZERO_PATTERN));
     LibmeshPetscCall(MatAssemblyBegin(_hc_sys_h_mat, MAT_FINAL_ASSEMBLY));
     LibmeshPetscCall(MatAssemblyEnd(_hc_sys_h_mat, MAT_FINAL_ASSEMBLY));
     LibmeshPetscCall(
         MatAXPY(_hc_sys_h_mat, 1.0, _hc_radial_heat_conduction_mat, DIFFERENT_NONZERO_PATTERN));
     LibmeshPetscCall(MatAssemblyBegin(_hc_sys_h_mat, MAT_FINAL_ASSEMBLY));
     LibmeshPetscCall(MatAssemblyEnd(_hc_sys_h_mat, MAT_FINAL_ASSEMBLY));
     LibmeshPetscCall(
         MatAXPY(_hc_sys_h_mat, 1.0, _hc_sweep_enthalpy_mat, DIFFERENT_NONZERO_PATTERN));
     LibmeshPetscCall(MatAssemblyBegin(_hc_sys_h_mat, MAT_FINAL_ASSEMBLY));
     LibmeshPetscCall(MatAssemblyEnd(_hc_sys_h_mat, MAT_FINAL_ASSEMBLY));
     if (_verbose_subchannel)
       _console << "Block: " << iblock << " - Enthalpy conservation matrix assembled" << std::endl;
     // RHS
     LibmeshPetscCall(VecAXPY(_hc_sys_h_rhs, 1.0, _hc_time_derivative_rhs));
     LibmeshPetscCall(VecAXPY(_hc_sys_h_rhs, 1.0, _hc_advective_derivative_rhs));
     LibmeshPetscCall(VecAXPY(_hc_sys_h_rhs, 1.0, _hc_cross_derivative_rhs));
     LibmeshPetscCall(VecAXPY(_hc_sys_h_rhs, 1.0, _hc_added_heat_rhs));
     LibmeshPetscCall(VecAXPY(_hc_sys_h_rhs, 1.0, _hc_axial_heat_conduction_rhs));
     LibmeshPetscCall(VecAXPY(_hc_sys_h_rhs, 1.0, _hc_radial_heat_conduction_rhs));
     LibmeshPetscCall(VecAXPY(_hc_sys_h_rhs, 1.0, _hc_sweep_enthalpy_rhs));
 
     if (_segregated_bool || (!_monolithic_thermal_bool))
     {
       // Assembly the matrix system
       KSP ksploc;
       PC pc;
       Vec sol;
       LibmeshPetscCall(VecDuplicate(_hc_sys_h_rhs, &sol));
       LibmeshPetscCall(KSPCreate(PETSC_COMM_WORLD, &ksploc));
       LibmeshPetscCall(KSPSetOperators(ksploc, _hc_sys_h_mat, _hc_sys_h_mat));
       LibmeshPetscCall(KSPGetPC(ksploc, &pc));
       LibmeshPetscCall(PCSetType(pc, PCJACOBI));
       LibmeshPetscCall(KSPSetTolerances(ksploc, _rtol, _atol, _dtol, _maxit));
       LibmeshPetscCall(KSPSetOptionsPrefix(ksploc, "h_sys_"));
       LibmeshPetscCall(KSPSetFromOptions(ksploc));
       LibmeshPetscCall(KSPSolve(ksploc, _hc_sys_h_rhs, sol));
       // VecView(sol, PETSC_VIEWER_STDOUT_WORLD);
       PetscScalar * xx;
       LibmeshPetscCall(VecGetArray(sol, &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++)
         {
           auto * node_out = _subchannel_mesh.getChannelNode(i_ch, iz);
           auto h_out = xx[iz_ind * _n_channels + i_ch];
           if (h_out < 0)
           {
             mooseError(name(),
                        " : Calculation of negative Enthalpy h_out = : ",
                        h_out,
                        " Axial Level= : ",
                        iz);
           }
           _h_soln->set(node_out, h_out);
         }
       }
       LibmeshPetscCall(KSPDestroy(&ksploc));
       LibmeshPetscCall(VecDestroy(&sol));
     }
   }
 }

◆ computeInterpolatedValue()

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

protectedinherited

Definition at line 364 of file SubChannel1PhaseProblem.C.

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

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

◆ computeInterpolationCoefficients()

PetscScalar SubChannel1PhaseProblem::computeInterpolationCoefficients ( PetscScalar Peclet = 0.0 )

protectedinherited

Functions that computes the interpolation scheme given the Peclet number.

Definition at line 344 of file SubChannel1PhaseProblem.C.

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

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

◆ computeMdot()

void SubChannel1PhaseProblem::computeMdot ( int iblock )

protectedinherited

Computes mass flow per channel for block iblock.

Definition at line 471 of file SubChannel1PhaseProblem.C.

Referenced by SubChannel1PhaseProblem::implicitPetscSolve(), and SubChannel1PhaseProblem::residualFunction().

 {
   unsigned int last_node = (iblock + 1) * _block_size;
   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));
 
         // 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));
     if (_verbose_subchannel)
       _console << "Block: " << iblock << " - Mass conservation matrix assembled" << std::endl;
 
     if (_segregated_bool)
     {
       KSP ksploc;
       PC pc;
       Vec sol;
       LibmeshPetscCall(VecDuplicate(_mc_axial_convection_rhs, &sol));
       LibmeshPetscCall(KSPCreate(PETSC_COMM_WORLD, &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));
     }
   }
 }

◆ computeMu()

void SubChannel1PhaseProblem::computeMu ( int iblock )

protectedinherited

Computes Viscosity per channel for block iblock.

Definition at line 1386 of file SubChannel1PhaseProblem.C.

Referenced by SubChannel1PhaseProblem::externalSolve().

 {
   unsigned int last_node = (iblock + 1) * _block_size;
   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)));
     }
   }
 }

◆ computeP()

void SubChannel1PhaseProblem::computeP ( int iblock )

protectedinherited

Computes Pressure per channel for block iblock.

Definition at line 1087 of file SubChannel1PhaseProblem.C.

Referenced by SubChannel1PhaseProblem::implicitPetscSolve(), and SubChannel1PhaseProblem::residualFunction().

 {
   unsigned int last_node = (iblock + 1) * _block_size;
   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_soln)(node_out));
         }
       }
     }
     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_soln)(node_out) / 2.0);
           }
           else
           {
             _P_soln->set(node_in,
                          (*_P_soln)(node_out) + (1.0 - alpha) * (*_DP_soln)(node_out) +
                              alpha * (*_DP_soln)(node_in));
           }
         }
       }
     }
   }
   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_soln)(node_out);
             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_WORLD, &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_soln)(node_out);
             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_soln)(node_in);
               auto dp_out = (*_DP_soln)(node_out);
               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_WORLD, &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));
       }
     }
   }
 }

◆ computeRho()

void SubChannel1PhaseProblem::computeRho ( int iblock )

protectedinherited

Computes Density per channel for block iblock.

Definition at line 1363 of file SubChannel1PhaseProblem.C.

Referenced by SubChannel1PhaseProblem::externalSolve().

 {
   unsigned int last_node = (iblock + 1) * _block_size;
   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)));
     }
   }
 }

◆ computeSumWij()

void SubChannel1PhaseProblem::computeSumWij ( int iblock )

protectedinherited

Computes net diversion crossflow per channel for block iblock.

Definition at line 406 of file SubChannel1PhaseProblem.C.

Referenced by SubChannel1PhaseProblem::implicitPetscSolve(), and SubChannel1PhaseProblem::residualFunction().

 {
   unsigned int last_node = (iblock + 1) * _block_size;
   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 explicit
   else
   {
     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 + 1, _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));
     }
   }
 }

◆ computeT()

void SubChannel1PhaseProblem::computeT ( int iblock )

protectedinherited

Computes Temperature per channel for block iblock.

Definition at line 1348 of file SubChannel1PhaseProblem.C.

Referenced by SubChannel1PhaseProblem::externalSolve().

 {
   unsigned int last_node = (iblock + 1) * _block_size;
   unsigned int first_node = iblock * _block_size + 1;
   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, _fp->T_from_p_h((*_P_soln)(node) + _P_out, (*_h_soln)(node)));
     }
   }
 }

◆ computeWijFromSolve()

void SubChannel1PhaseProblem::computeWijFromSolve ( int iblock )

protectedinherited

Computes diversion crossflow per gap for block iblock.

Definition at line 373 of file SubChannel1PhaseProblem.C.

Referenced by SubChannel1PhaseProblem::externalSolve().

 {
   unsigned int last_node = (iblock + 1) * _block_size;
   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++;
     }
   }
 }

◆ computeWijPrime()

void SubChannel1PhaseProblem::computeWijPrime ( int iblock )

protectedinherited

Computes turbulent crossflow per gap for block iblock.

Update turbulent crossflow

Definition at line 1737 of file SubChannel1PhaseProblem.C.

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

 {
   unsigned int last_node = (iblock + 1) * _block_size;
   unsigned int first_node = iblock * _block_size + 1;
   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;
       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 = computeBeta(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));
   }
 }

◆ computeWijResidual()

void SubChannel1PhaseProblem::computeWijResidual ( int iblock )

protectedinherited

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

Assembling system

Definition at line 1409 of file SubChannel1PhaseProblem.C.

Referenced by SubChannel1PhaseProblem::implicitPetscSolve(), and SubChannel1PhaseProblem::residualFunction().

 {
   // Cross flow residual
   if (!_implicit_bool)
   {
     unsigned int last_node = (iblock + 1) * _block_size;
     unsigned int first_node = iblock * _block_size;
     const Real & pitch = _subchannel_mesh.getPitch();
     for (unsigned int iz = first_node + 1; 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) / Si / rho_i + (*_mdot_soln)(node_out_j) / Sj / rho_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 * std::pow(Sij, 2.0) * 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));
     unsigned int last_node = (iblock + 1) * _block_size;
     unsigned int first_node = iblock * _block_size;
     const Real & pitch = _subchannel_mesh.getPitch();
     for (unsigned int iz = first_node + 1; iz < last_node + 1; iz++)
     {
       auto dz = _z_grid[iz] - _z_grid[iz - 1];
       auto iz_ind = iz - first_node - 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);
 
         // 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 + 1)
         {
           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 = std::pow(Sij, 2.0) * 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 = std::pow(Sij, 2.0) * 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));
     if (_verbose_subchannel)
       _console << "Block: " << iblock << " - Cross flow system matrix assembled" << std::endl;
     if (_verbose_subchannel)
       _console << "Block: " << iblock << " - Cross flow pressure force matrix assembled"
                << std::endl;
     // 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));
       Vec loc_holder_Wij;
       LibmeshPetscCall(createPetscVector(loc_holder_Wij, _block_size * _n_gaps));
       LibmeshPetscCall(populateVectorFromHandle<SolutionHandle>(
           _prodp, *_P_soln, iblock * _block_size, (iblock + 1) * _block_size - 1, _n_channels));
       LibmeshPetscCall(populateVectorFromDense<libMesh::DenseMatrix<Real>>(
           loc_holder_Wij, _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 + 1; iz < last_node + 1; iz++)
       {
         auto iz_ind = iz - first_node - 1;
         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));
       LibmeshPetscCall(VecDestroy(&loc_holder_Wij));
     }
   }
 }

◆ createPetscMatrix()

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

inlineprotectedinherited

Definition at line 203 of file SubChannel1PhaseProblem.h.

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

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

◆ createPetscVector()

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

inlineprotectedinherited

Petsc Functions.

Definition at line 192 of file SubChannel1PhaseProblem.h.

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

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

◆ externalSolve()

void SubChannel1PhaseProblem::externalSolve ( )

overridevirtualinherited

Assigning temperature to the fuel pins

Assigning temperatures to duct

Implements ExternalProblem.

Definition at line 2530 of file SubChannel1PhaseProblem.C.

 {
   _console << "Executing subchannel solver\n";
   _dt = (isTransient() ? dt() : _one);
   _TR = isTransient();
   initializeSolution();
   if (_verbose_subchannel)
     _console << "Solution initialized" << std::endl;
   Real P_error = 1.0;
   unsigned int P_it = 0;
   unsigned int P_it_max;
 
   if (_segregated_bool)
     P_it_max = 20 * _n_blocks;
   else
     P_it_max = 100;
 
   if ((_n_blocks == 1) && (_segregated_bool))
     P_it_max = 5;
 
   while ((P_error > _P_tol && P_it < P_it_max))
   {
     P_it += 1;
     if (P_it == P_it_max && _n_blocks != 1)
     {
       _console << "Reached maximum number of axial pressure iterations" << std::endl;
       _converged = false;
     }
     _console << "Solving Outer Iteration : " << P_it << std::endl;
     auto P_L2norm_old_axial = _P_soln->L2norm();
     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)
       {
         T_it += 1;
         if (T_it == _T_maxit)
         {
           _console << "Reached maximum number of temperature iterations for block: " << iblock
                    << std::endl;
           _converged = false;
         }
         auto T_L2norm_old_block = _T_soln->L2norm();
 
         if (_segregated_bool)
         {
           computeWijFromSolve(iblock);
 
           if (_compute_power)
           {
             computeh(iblock);
             computeT(iblock);
           }
         }
         else
         {
           LibmeshPetscCall(implicitPetscSolve(iblock));
           computeWijPrime(iblock);
           if (_verbose_subchannel)
             _console << "Done with main solve." << std::endl;
           if (_monolithic_thermal_bool)
           {
             // Enthalpy is already solved from the monolithic solve
             computeT(iblock);
           }
           else
           {
             if (_verbose_subchannel)
               _console << "Starting thermal solve." << std::endl;
             if (_compute_power)
             {
               computeh(iblock);
               computeT(iblock);
             }
             if (_verbose_subchannel)
               _console << "Done with thermal solve." << std::endl;
           }
         }
 
         if (_verbose_subchannel)
           _console << "Start updating thermophysical properties." << std::endl;
 
         if (_compute_density)
           computeRho(iblock);
 
         if (_compute_viscosity)
           computeMu(iblock);
 
         if (_verbose_subchannel)
           _console << "Done updating thermophysical properties." << std::endl;
 
         // We must do a global assembly to make sure data is parallel consistent before we do things
         // like compute L2 norms
         _aux->solution().close();
 
         auto T_L2norm_new = _T_soln->L2norm();
         T_block_error =
             std::abs((T_L2norm_new - T_L2norm_old_block) / (T_L2norm_old_block + 1E-14));
         _console << "T_block_error: " << T_block_error << std::endl;
       }
     }
     auto P_L2norm_new_axial = _P_soln->L2norm();
     P_error =
         std::abs((P_L2norm_new_axial - P_L2norm_old_axial) / (P_L2norm_old_axial + _P_out + 1E-14));
     _console << "P_error :" << P_error << std::endl;
     if (_verbose_subchannel)
     {
       _console << "Iteration:  " << P_it << std::endl;
       _console << "Maximum iterations: " << P_it_max << std::endl;
     }
   }
   // update old crossflow matrix
   _Wij_old = _Wij;
   _console << "Finished executing subchannel solver\n";
 
   if (_pin_mesh_exist)
   {
     _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;
         Real rod_counter = 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;
           auto Nu = 0.023 * std::pow(Re, 0.8) * std::pow(Pr, 0.4);
           auto hw = Nu * k / Dh_i;
           if ((*_Dpin_soln)(pin_node) <= 0)
             mooseError("Dpin should not be null or negative when computing pin powers: ",
                        (*_Dpin_soln)(pin_node));
           sumTemp +=
               (*_q_prime_soln)(pin_node) / ((*_Dpin_soln)(pin_node)*M_PI * hw) + (*_T_soln)(node);
           rod_counter += 1.0;
         }
         if (rod_counter > 0)
           _Tpin_soln->set(pin_node, sumTemp / rod_counter);
         else
           mooseError("Pin was not found for pin index:  " + std::to_string(i_pin));
       }
     }
   }
 
   if (_duct_mesh_exist)
   {
     _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;
       auto Nu = 0.023 * std::pow(Re, 0.8) * std::pow(Pr, 0.4);
       auto hw = Nu * k / Dh_i;
       auto T_chan = (*_q_prime_duct_soln)(dn) / (_subchannel_mesh.getPinDiameter() * M_PI * hw) +
                     (*_T_soln)(node_chan);
       _Tduct_soln->set(dn, T_chan);
     }
   }
   _aux->solution().close();
   _aux->update();
 
   Real power_in = 0.0;
   Real power_out = 0.0;
   Real Total_surface_area = 0.0;
   Real Total_wetted_perimeter = 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);
     Total_surface_area += (*_S_flow_soln)(node_in);
     Total_wetted_perimeter += (*_w_perim_soln)(node_in);
     power_in += (*_mdot_soln)(node_in) * (*_h_soln)(node_in);
     power_out += (*_mdot_soln)(node_out) * (*_h_soln)(node_out);
     mass_flow_in += (*_mdot_soln)(node_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);
 
   Real bulk_Dh = 4.0 * Total_surface_area / Total_wetted_perimeter;
   Real inlet_mu = (*_mu_soln)(_subchannel_mesh.getChannelNode(0, 0));
   Real bulk_Re = mass_flow_in * bulk_Dh / (inlet_mu * Total_surface_area);
   if (_verbose_subchannel)
   {
     _console << " ======================================= " << std::endl;
     _console << " ======== Subchannel Print Outs ======== " << std::endl;
     _console << " ======================================= " << std::endl;
     _console << "Total flow area :" << Total_surface_area << " 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;
   }
 }

◆ implicitPetscSolve()

PetscErrorCode SubChannel1PhaseProblem::implicitPetscSolve ( int iblock )

protectedinherited

Computes implicit solve using PetSc.

Initializing flags

Assembling matrices

Setting up linear solver

Solving

Destroying solver elements

Recovering the solutions

Assigning the solutions to arrays

Populating Mass flow

Populating Pressure

Populating Crossflow

Populating Enthalpy

Populating sum_Wij

Destroying arrays

Definition at line 1930 of file SubChannel1PhaseProblem.C.

Referenced by SubChannel1PhaseProblem::externalSolve().

 {
   bool lag_block_thermal_solve = true;
   Vec b_nest, x_nest; /* approx solution, RHS, exact solution */
   Mat A_nest;         /* linear system matrix */
   KSP ksp;            /* linear solver context */
   PC pc;              /* preconditioner context */
 
   PetscFunctionBegin;
   PetscInt Q = _monolithic_thermal_bool ? 4 : 3;
   std::vector<Mat> mat_array(Q * Q);
   std::vector<Vec> vec_array(Q);
 
   bool _axial_mass_flow_tight_coupling = true;
   bool _pressure_axial_momentum_tight_coupling = true;
   bool _pressure_cross_momentum_tight_coupling = true;
   unsigned int first_node = iblock * _block_size + 1;
   unsigned int last_node = (iblock + 1) * _block_size;
 
   // Computing sum of crossflows with previous iteration
   computeSumWij(iblock);
   // Assembling axial flux matrix
   computeMdot(iblock);
   // Computing turbulent crossflow with previous step axial mass flows
   computeWijPrime(iblock);
   // Assembling for Pressure Drop matrix
   computeDP(iblock);
   // Assembling pressure matrix
   computeP(iblock);
   // Assembling cross fluxes matrix
   computeWijResidual(iblock);
   // If monolithic solve - Assembling enthalpy matrix
   if (_monolithic_thermal_bool)
     computeh(iblock);
 
   if (_verbose_subchannel)
   {
     _console << "Starting nested system." << std::endl;
     _console << "Number of simultaneous variables: " << Q << std::endl;
   }
   // Mass conservation
   PetscInt field_num = 0;
   LibmeshPetscCall(
       MatDuplicate(_mc_axial_convection_mat, MAT_COPY_VALUES, &mat_array[Q * field_num + 0]));
   LibmeshPetscCall(MatAssemblyBegin(mat_array[Q * field_num + 0], MAT_FINAL_ASSEMBLY));
   LibmeshPetscCall(MatAssemblyEnd(mat_array[Q * field_num + 0], MAT_FINAL_ASSEMBLY));
   mat_array[Q * field_num + 1] = NULL;
   if (_axial_mass_flow_tight_coupling)
   {
     LibmeshPetscCall(MatDuplicate(_mc_sumWij_mat, MAT_COPY_VALUES, &mat_array[Q * field_num + 2]));
     LibmeshPetscCall(MatAssemblyBegin(mat_array[Q * field_num + 2], MAT_FINAL_ASSEMBLY));
     LibmeshPetscCall(MatAssemblyEnd(mat_array[Q * field_num + 2], MAT_FINAL_ASSEMBLY));
   }
   else
   {
     mat_array[Q * field_num + 2] = NULL;
   }
   if (_monolithic_thermal_bool)
   {
     mat_array[Q * field_num + 3] = NULL;
   }
   LibmeshPetscCall(VecDuplicate(_mc_axial_convection_rhs, &vec_array[field_num]));
   LibmeshPetscCall(VecCopy(_mc_axial_convection_rhs, vec_array[field_num]));
   if (!_axial_mass_flow_tight_coupling)
   {
     Vec sumWij_loc;
     LibmeshPetscCall(VecDuplicate(_mc_axial_convection_rhs, &sumWij_loc));
     LibmeshPetscCall(VecSet(sumWij_loc, 0.0));
     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++)
       {
         auto * node_out = _subchannel_mesh.getChannelNode(i_ch, iz);
 
         PetscScalar value_vec_2 = -1.0 * (*_SumWij_soln)(node_out);
         PetscInt row_vec_2 = i_ch + _n_channels * iz_ind;
         LibmeshPetscCall(VecSetValues(sumWij_loc, 1, &row_vec_2, &value_vec_2, ADD_VALUES));
       }
     }
     LibmeshPetscCall(VecAXPY(vec_array[field_num], 1.0, sumWij_loc));
     LibmeshPetscCall(VecDestroy(&sumWij_loc));
   }
 
   if (_verbose_subchannel)
     _console << "Mass ok." << std::endl;
   // Axial momentum conservation
   field_num = 1;
   if (_pressure_axial_momentum_tight_coupling)
   {
     LibmeshPetscCall(
         MatDuplicate(_amc_sys_mdot_mat, MAT_COPY_VALUES, &mat_array[Q * field_num + 0]));
     LibmeshPetscCall(MatAssemblyBegin(mat_array[Q * field_num + 0], MAT_FINAL_ASSEMBLY));
     LibmeshPetscCall(MatAssemblyEnd(mat_array[Q * field_num + 0], MAT_FINAL_ASSEMBLY));
   }
   else
   {
     mat_array[Q * field_num + 0] = NULL;
   }
   LibmeshPetscCall(
       MatDuplicate(_amc_pressure_force_mat, MAT_COPY_VALUES, &mat_array[Q * field_num + 1]));
   LibmeshPetscCall(MatAssemblyBegin(mat_array[Q * field_num + 1], MAT_FINAL_ASSEMBLY));
   LibmeshPetscCall(MatAssemblyEnd(mat_array[Q * field_num + 1], MAT_FINAL_ASSEMBLY));
   mat_array[Q * field_num + 2] = NULL;
   if (_monolithic_thermal_bool)
   {
     mat_array[Q * field_num + 3] = NULL;
   }
   LibmeshPetscCall(VecDuplicate(_amc_pressure_force_rhs, &vec_array[field_num]));
   LibmeshPetscCall(VecCopy(_amc_pressure_force_rhs, vec_array[field_num]));
   if (_pressure_axial_momentum_tight_coupling)
   {
     LibmeshPetscCall(VecAXPY(vec_array[field_num], 1.0, _amc_sys_mdot_rhs));
   }
   else
   {
     unsigned int last_node = (iblock + 1) * _block_size;
     unsigned int first_node = iblock * _block_size + 1;
     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));
     LibmeshPetscCall(VecAXPY(vec_array[field_num], -1.0, ls));
     LibmeshPetscCall(VecDestroy(&ls));
   }
 
   if (_verbose_subchannel)
     _console << "Lin mom OK." << std::endl;
 
   // Cross momentum conservation
   field_num = 2;
   mat_array[Q * field_num + 0] = NULL;
   if (_pressure_cross_momentum_tight_coupling)
   {
     LibmeshPetscCall(
         MatDuplicate(_cmc_pressure_force_mat, MAT_COPY_VALUES, &mat_array[Q * field_num + 1]));
     LibmeshPetscCall(MatAssemblyBegin(mat_array[Q * field_num + 1], MAT_FINAL_ASSEMBLY));
     LibmeshPetscCall(MatAssemblyEnd(mat_array[Q * field_num + 1], MAT_FINAL_ASSEMBLY));
   }
   else
   {
     mat_array[Q * field_num + 1] = NULL;
   }
 
   LibmeshPetscCall(MatDuplicate(_cmc_sys_Wij_mat, MAT_COPY_VALUES, &mat_array[Q * field_num + 2]));
   LibmeshPetscCall(MatAssemblyBegin(mat_array[Q * field_num + 2], MAT_FINAL_ASSEMBLY));
   LibmeshPetscCall(MatAssemblyEnd(mat_array[Q * field_num + 2], MAT_FINAL_ASSEMBLY));
   if (_monolithic_thermal_bool)
   {
     mat_array[Q * field_num + 3] = NULL;
   }
 
   LibmeshPetscCall(VecDuplicate(_cmc_sys_Wij_rhs, &vec_array[field_num]));
   LibmeshPetscCall(VecCopy(_cmc_sys_Wij_rhs, vec_array[field_num]));
   if (_pressure_cross_momentum_tight_coupling)
   {
     LibmeshPetscCall(VecAXPY(vec_array[field_num], 1.0, _cmc_pressure_force_rhs));
   }
   else
   {
     Vec sol_holder_P;
     LibmeshPetscCall(createPetscVector(sol_holder_P, _block_size * _n_gaps));
     LibmeshPetscCall(populateVectorFromHandle<SolutionHandle>(
         _prodp, *_P_soln, iblock * _block_size, (iblock + 1) * _block_size - 1, _n_channels));
 
     LibmeshPetscCall(MatMult(_cmc_pressure_force_mat, _prodp, sol_holder_P));
     LibmeshPetscCall(VecAXPY(sol_holder_P, -1.0, _cmc_pressure_force_rhs));
     LibmeshPetscCall(VecScale(sol_holder_P, 1.0));
     LibmeshPetscCall(VecAXPY(vec_array[field_num], 1.0, sol_holder_P));
     LibmeshPetscCall(VecDestroy(&sol_holder_P));
   }
 
   if (_verbose_subchannel)
     _console << "Cross mom ok." << std::endl;
 
   // Energy conservation
   if (_monolithic_thermal_bool)
   {
     field_num = 3;
     mat_array[Q * field_num + 0] = NULL;
     mat_array[Q * field_num + 1] = NULL;
     mat_array[Q * field_num + 2] = NULL;
     LibmeshPetscCall(MatDuplicate(_hc_sys_h_mat, MAT_COPY_VALUES, &mat_array[Q * field_num + 3]));
     if (lag_block_thermal_solve)
     {
       LibmeshPetscCall(MatZeroEntries(mat_array[Q * field_num + 3]));
       LibmeshPetscCall(MatShift(mat_array[Q * field_num + 3], 1.0));
     }
     LibmeshPetscCall(MatAssemblyBegin(mat_array[Q * field_num + 3], MAT_FINAL_ASSEMBLY));
     LibmeshPetscCall(MatAssemblyEnd(mat_array[Q * field_num + 3], MAT_FINAL_ASSEMBLY));
     LibmeshPetscCall(VecDuplicate(_hc_sys_h_rhs, &vec_array[field_num]));
     LibmeshPetscCall(VecCopy(_hc_sys_h_rhs, vec_array[field_num]));
     if (lag_block_thermal_solve)
     {
       LibmeshPetscCall(VecZeroEntries(vec_array[field_num]));
       LibmeshPetscCall(VecShift(vec_array[field_num], 1.0));
     }
 
     if (_verbose_subchannel)
       _console << "Energy ok." << std::endl;
   }
 
   // Relaxing linear system
   // Weaker relaxation
   if (true)
   {
     // Estimating cross-flow resistances to achieve realizable solves
     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 diag_Wij_loc;
     LibmeshPetscCall(createPetscVector(diag_Wij_loc, _block_size * _n_gaps));
     Vec Wij_estimate;
     LibmeshPetscCall(createPetscVector(Wij_estimate, _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));
     LibmeshPetscCall(MatMult(mat_array[Q], _prod, mdot_estimate));
     LibmeshPetscCall(MatGetDiagonal(mat_array[Q + 1], pmat_diag));
     LibmeshPetscCall(VecAXPY(pmat_diag, 1e-10, unity_vec));
     LibmeshPetscCall(VecPointwiseDivide(p_estimate, mdot_estimate, pmat_diag));
     LibmeshPetscCall(MatMult(mat_array[2 * Q + 1], p_estimate, sol_holder_P));
     LibmeshPetscCall(VecAXPY(sol_holder_P, -1.0, _cmc_pressure_force_rhs));
     LibmeshPetscCall(MatGetDiagonal(mat_array[2 * Q + 2], diag_Wij_loc));
     LibmeshPetscCall(VecAXPY(diag_Wij_loc, 1e-10, unity_vec_Wij));
     LibmeshPetscCall(VecPointwiseDivide(Wij_estimate, sol_holder_P, diag_Wij_loc));
     Vec sumWij_loc;
     LibmeshPetscCall(createPetscVector(sumWij_loc, _block_size * _n_channels));
     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++)
       {
         PetscScalar sumWij = 0.0;
         unsigned int counter = 0;
         for (auto i_gap : _subchannel_mesh.getChannelGaps(i_ch))
         {
           auto chans = _subchannel_mesh.getGapChannels(i_gap);
           unsigned int i_ch_loc = chans.first;
           PetscInt row_vec = i_ch_loc + _n_channels * 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));
       }
     }
 
     PetscScalar min_mdot;
     LibmeshPetscCall(VecAbs(_prod));
     LibmeshPetscCall(VecMin(_prod, NULL, &min_mdot));
     if (_verbose_subchannel)
       _console << "Minimum estimated mdot: " << min_mdot << std::endl;
 
     LibmeshPetscCall(VecAbs(sumWij_loc));
     LibmeshPetscCall(VecMax(sumWij_loc, NULL, &_max_sumWij));
     _max_sumWij = std::max(1e-10, _max_sumWij);
     if (_verbose_subchannel)
       _console << "Maximum estimated Wij: " << _max_sumWij << std::endl;
 
     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;
     if (_verbose_subchannel)
       _console << "Relax base value: " << relax_factor << std::endl;
 
     PetscScalar resistance_relaxation = 0.9;
     _added_K = _max_sumWij / min_mdot;
     if (_verbose_subchannel)
       _console << "New cross resistance: " << _added_K << std::endl;
     _added_K = (_added_K * resistance_relaxation + (1.0 - resistance_relaxation) * _added_K_old) *
                relax_factor;
     if (_verbose_subchannel)
       _console << "Relaxed cross resistance: " << _added_K << std::endl;
     if (_added_K < 10 && _added_K >= 1.0)
       _added_K = 1.0; //(1.0 - resistance_relaxation);
     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;
     if (_added_K < 1e-3)
       _added_K = 1.0 * _added_K;
     if (_verbose_subchannel)
       _console << "Actual added cross resistance: " << _added_K << std::endl;
     LibmeshPetscCall(VecScale(unity_vec_Wij, _added_K));
     _added_K_old = _added_K;
 
     // Adding cross resistances
     LibmeshPetscCall(MatDiagonalSet(mat_array[2 * Q + 2], unity_vec_Wij, ADD_VALUES));
     LibmeshPetscCall(VecDestroy(&mdot_estimate));
     LibmeshPetscCall(VecDestroy(&pmat_diag));
     LibmeshPetscCall(VecDestroy(&unity_vec));
     LibmeshPetscCall(VecDestroy(&p_estimate));
     LibmeshPetscCall(VecDestroy(&sol_holder_P));
     LibmeshPetscCall(VecDestroy(&diag_Wij_loc));
     LibmeshPetscCall(VecDestroy(&unity_vec_Wij));
     LibmeshPetscCall(VecDestroy(&Wij_estimate));
     LibmeshPetscCall(VecDestroy(&sumWij_loc));
     LibmeshPetscCall(VecDestroy(&_Wij_loc_vec));
     LibmeshPetscCall(VecDestroy(&_Wij_old_loc_vec));
 
     // Auto-computing relaxation factors
     PetscScalar relaxation_factor_mdot, relaxation_factor_P, relaxation_factor_Wij;
     relaxation_factor_mdot = 1.0;
     relaxation_factor_P = 1.0; // std::exp(-5.0);
     relaxation_factor_Wij = 0.1;
 
     if (_verbose_subchannel)
     {
       _console << "Relax mdot: " << relaxation_factor_mdot << std::endl;
       _console << "Relax P: " << relaxation_factor_P << std::endl;
       _console << "Relax Wij: " << relaxation_factor_Wij << std::endl;
     }
 
     PetscInt field_num = 0;
     Vec diag_mdot;
     LibmeshPetscCall(VecDuplicate(vec_array[field_num], &diag_mdot));
     LibmeshPetscCall(MatGetDiagonal(mat_array[Q * field_num + field_num], diag_mdot));
     LibmeshPetscCall(VecScale(diag_mdot, 1.0 / relaxation_factor_mdot));
     LibmeshPetscCall(
         MatDiagonalSet(mat_array[Q * field_num + field_num], diag_mdot, INSERT_VALUES));
     LibmeshPetscCall(populateVectorFromHandle<SolutionHandle>(
         _prod, *_mdot_soln, first_node, last_node, _n_channels));
     LibmeshPetscCall(VecScale(diag_mdot, (1.0 - relaxation_factor_mdot)));
     LibmeshPetscCall(VecPointwiseMult(_prod, _prod, diag_mdot));
     LibmeshPetscCall(VecAXPY(vec_array[field_num], 1.0, _prod));
     LibmeshPetscCall(VecDestroy(&diag_mdot));
 
     if (_verbose_subchannel)
       _console << "mdot relaxed" << std::endl;
 
     field_num = 1;
     Vec diag_P;
     LibmeshPetscCall(VecDuplicate(vec_array[field_num], &diag_P));
     LibmeshPetscCall(MatGetDiagonal(mat_array[Q * field_num + field_num], diag_P));
     LibmeshPetscCall(VecScale(diag_P, 1.0 / relaxation_factor_P));
     LibmeshPetscCall(MatDiagonalSet(mat_array[Q * field_num + field_num], diag_P, INSERT_VALUES));
     if (_verbose_subchannel)
       _console << "Mat assembled" << std::endl;
     LibmeshPetscCall(populateVectorFromHandle<SolutionHandle>(
         _prod, *_P_soln, first_node, last_node, _n_channels));
     LibmeshPetscCall(VecScale(diag_P, (1.0 - relaxation_factor_P)));
     LibmeshPetscCall(VecPointwiseMult(_prod, _prod, diag_P));
     LibmeshPetscCall(VecAXPY(vec_array[field_num], 1.0, _prod));
     LibmeshPetscCall(VecDestroy(&diag_P));
 
     if (_verbose_subchannel)
       _console << "P relaxed" << std::endl;
 
     field_num = 2;
     Vec diag_Wij;
     LibmeshPetscCall(VecDuplicate(vec_array[field_num], &diag_Wij));
     LibmeshPetscCall(MatGetDiagonal(mat_array[Q * field_num + field_num], diag_Wij));
     LibmeshPetscCall(VecScale(diag_Wij, 1.0 / relaxation_factor_Wij));
     LibmeshPetscCall(MatDiagonalSet(mat_array[Q * field_num + field_num], diag_Wij, INSERT_VALUES));
     LibmeshPetscCall(populateVectorFromDense<libMesh::DenseMatrix<Real>>(
         _Wij_vec, _Wij, first_node, last_node, _n_gaps));
     LibmeshPetscCall(VecScale(diag_Wij, (1.0 - relaxation_factor_Wij)));
     LibmeshPetscCall(VecPointwiseMult(_Wij_vec, _Wij_vec, diag_Wij));
     LibmeshPetscCall(VecAXPY(vec_array[field_num], 1.0, _Wij_vec));
     LibmeshPetscCall(VecDestroy(&diag_Wij));
 
     if (_verbose_subchannel)
       _console << "Wij relaxed" << std::endl;
   }
   if (_verbose_subchannel)
     _console << "Linear solver relaxed." << std::endl;
 
   // Creating nested matrices
   LibmeshPetscCall(MatCreateNest(PETSC_COMM_WORLD, Q, NULL, Q, NULL, mat_array.data(), &A_nest));
   LibmeshPetscCall(VecCreateNest(PETSC_COMM_WORLD, Q, NULL, vec_array.data(), &b_nest));
   if (_verbose_subchannel)
     _console << "Nested system created." << std::endl;
 
   // Creating linear solver
   LibmeshPetscCall(KSPCreate(PETSC_COMM_WORLD, &ksp));
   LibmeshPetscCall(KSPSetType(ksp, KSPFGMRES));
   // Setting KSP operators
   LibmeshPetscCall(KSPSetOperators(ksp, A_nest, A_nest));
   // Set KSP and PC options
   LibmeshPetscCall(KSPGetPC(ksp, &pc));
   LibmeshPetscCall(PCSetType(pc, PCFIELDSPLIT));
   LibmeshPetscCall(KSPSetTolerances(ksp, _rtol, _atol, _dtol, _maxit));
   // Splitting fields
   std::vector<IS> rows(Q);
   // IS rows[Q];
   PetscInt M = 0;
   LibmeshPetscCall(MatNestGetISs(A_nest, rows.data(), NULL));
   for (PetscInt j = 0; j < Q; ++j)
   {
     IS expand1;
     LibmeshPetscCall(ISDuplicate(rows[M], &expand1));
     M += 1;
     LibmeshPetscCall(PCFieldSplitSetIS(pc, NULL, expand1));
     LibmeshPetscCall(ISDestroy(&expand1));
   }
   if (_verbose_subchannel)
     _console << "Linear solver assembled." << std::endl;
 
   LibmeshPetscCall(VecDuplicate(b_nest, &x_nest));
   LibmeshPetscCall(VecSet(x_nest, 0.0));
   LibmeshPetscCall(KSPSolve(ksp, b_nest, x_nest));
 
   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]));
   }
   if (_verbose_subchannel)
     _console << "Solver elements destroyed." << std::endl;
 
   Vec sol_mdot, sol_p, sol_Wij;
   if (_verbose_subchannel)
     _console << "Vectors created." << std::endl;
   PetscInt num_vecs;
   Vec * loc_vecs;
   LibmeshPetscCall(VecNestGetSubVecs(x_nest, &num_vecs, &loc_vecs));
   if (_verbose_subchannel)
     _console << "Starting extraction." << std::endl;
   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));
   if (_verbose_subchannel)
     _console << "Getting individual field solutions from coupled solver." << std::endl;
 
   PetscScalar * sol_p_array;
   LibmeshPetscCall(VecGetArray(sol_p, &sol_p_array));
   PetscScalar * sol_Wij_array;
   LibmeshPetscCall(VecGetArray(sol_Wij, &sol_Wij_array));
 
   LibmeshPetscCall(populateSolutionChan<SolutionHandle>(
       sol_mdot, *_mdot_soln, first_node, last_node, _n_channels));
 
   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 = sol_p_array[iz_ind * _n_channels + i_ch];
       _P_soln->set(node_in, value);
     }
   }
 
   LibmeshPetscCall(populateDenseFromVector<libMesh::DenseMatrix<Real>>(
       sol_Wij, _Wij, first_node, last_node - 1, _n_gaps));
 
   if (_monolithic_thermal_bool)
   {
     if (lag_block_thermal_solve)
     {
       KSP ksploc;
       PC pc;
       Vec sol;
       LibmeshPetscCall(VecDuplicate(_hc_sys_h_rhs, &sol));
       LibmeshPetscCall(KSPCreate(PETSC_COMM_WORLD, &ksploc));
       LibmeshPetscCall(KSPSetOperators(ksploc, _hc_sys_h_mat, _hc_sys_h_mat));
       LibmeshPetscCall(KSPGetPC(ksploc, &pc));
       LibmeshPetscCall(PCSetType(pc, PCJACOBI));
       LibmeshPetscCall(KSPSetTolerances(ksploc, _rtol, _atol, _dtol, _maxit));
       LibmeshPetscCall(KSPSetFromOptions(ksploc));
       LibmeshPetscCall(KSPSolve(ksploc, _hc_sys_h_rhs, sol));
       PetscScalar * xx;
       LibmeshPetscCall(VecGetArray(sol, &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++)
         {
           auto * node_out = _subchannel_mesh.getChannelNode(i_ch, iz);
           auto h_out = xx[iz_ind * _n_channels + i_ch];
           if (h_out < 0)
           {
             mooseError(name(),
                        " : Calculation of negative Enthalpy h_out = : ",
                        h_out,
                        " Axial Level= : ",
                        iz);
           }
           _h_soln->set(node_out, h_out);
         }
       }
       LibmeshPetscCall(KSPDestroy(&ksploc));
       LibmeshPetscCall(VecDestroy(&sol));
     }
     else
     {
       Vec sol_h;
       LibmeshPetscCall(VecDuplicate(_hc_sys_h_rhs, &sol_h));
       LibmeshPetscCall(VecCopy(loc_vecs[3], sol_h));
       PetscScalar * sol_h_array;
       LibmeshPetscCall(VecGetArray(sol_h, &sol_h_array));
       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++)
         {
           auto * node_out = _subchannel_mesh.getChannelNode(i_ch, iz);
           auto h_out = sol_h_array[iz_ind * _n_channels + i_ch];
           if (h_out < 0)
           {
             mooseError(name(),
                        " : Calculation of negative Enthalpy h_out = : ",
                        h_out,
                        " Axial Level= : ",
                        iz);
           }
           _h_soln->set(node_out, h_out);
         }
       }
       LibmeshPetscCall(VecDestroy(&sol_h));
     }
   }
 
   LibmeshPetscCall(MatMult(_mc_sumWij_mat, sol_Wij, _prod));
   LibmeshPetscCall(populateSolutionChan<SolutionHandle>(
       _prod, *_SumWij_soln, first_node, last_node, _n_channels));
 
   Vec sumWij_loc;
   LibmeshPetscCall(createPetscVector(sumWij_loc, _block_size * _n_channels));
   LibmeshPetscCall(populateVectorFromHandle<SolutionHandle>(
       _prod, *_SumWij_soln, first_node, last_node, _n_channels));
 
   LibmeshPetscCall(VecAbs(_prod));
   LibmeshPetscCall(VecMax(_prod, NULL, &_max_sumWij_new));
   if (_verbose_subchannel)
     _console << "Maximum estimated Wij new: " << _max_sumWij_new << std::endl;
   _correction_factor = _max_sumWij_new / _max_sumWij;
   if (_verbose_subchannel)
     _console << "Correction factor: " << _correction_factor << std::endl;
   if (_verbose_subchannel)
     _console << "Solutions assigned to MOOSE variables." << std::endl;
 
   LibmeshPetscCall(VecDestroy(&x_nest));
   LibmeshPetscCall(VecDestroy(&sol_mdot));
   LibmeshPetscCall(VecDestroy(&sol_p));
   LibmeshPetscCall(VecDestroy(&sol_Wij));
   LibmeshPetscCall(VecDestroy(&sumWij_loc));
   if (_verbose_subchannel)
     _console << "Solutions destroyed." << std::endl;
 
   PetscFunctionReturn(LIBMESH_PETSC_SUCCESS);
 }

◆ initializeSolution()

void TriSubChannel1PhaseProblem::initializeSolution ( )

overrideprotectedvirtual

Function to initialize the solution & geometry fields.

update surface area, wetted perimeter based on: Dpin, displacement

Calculate subchannel area

Correct subchannel area and wetted perimeter in case of overlapping pins

Apply area reduction on subchannels affected by blockage

update map of gap between pins (gij) based on: Dpin, displacement

Implements SubChannel1PhaseProblem.

Definition at line 64 of file TriSubChannel1PhaseProblem.C.

 {
   if (_deformation)
   {
     Real standard_area, wire_area, additional_area, wetted_perimeter, displaced_area;
     auto flat_to_flat = _tri_sch_mesh.getFlatToFlat();
     auto n_rings = _tri_sch_mesh.getNumOfRings();
     auto pitch = _subchannel_mesh.getPitch();
     auto pin_diameter = _subchannel_mesh.getPinDiameter();
     auto wire_diameter = _tri_sch_mesh.getWireDiameter();
     auto wire_lead_length = _tri_sch_mesh.getWireLeadLength();
     auto gap = _tri_sch_mesh.getDuctToPinGap();
     auto z_blockage = _subchannel_mesh.getZBlockage();
     auto index_blockage = _subchannel_mesh.getIndexBlockage();
     auto reduction_blockage = _subchannel_mesh.getReductionBlockage();
     auto theta = std::acos(wire_lead_length /
                            std::sqrt(std::pow(wire_lead_length, 2) +
                                      std::pow(libMesh::pi * (pin_diameter + wire_diameter), 2)));
     for (unsigned int iz = 0; iz < _n_cells + 1; iz++)
     {
       for (unsigned int i_ch = 0; i_ch < _n_channels; i_ch++)
       {
         auto subch_type = _subchannel_mesh.getSubchannelType(i_ch);
         auto * node = _subchannel_mesh.getChannelNode(i_ch, iz);
         auto Z = _z_grid[iz];
         Real rod_area = 0.0;
         Real rod_perimeter = 0.0;
         for (auto i_pin : _subchannel_mesh.getChannelPins(i_ch))
         {
           auto * pin_node = _subchannel_mesh.getPinNode(i_pin, iz);
           if (subch_type == EChannelType::CENTER || subch_type == EChannelType::CORNER)
           {
             rod_area +=
                 (1.0 / 6.0) * 0.25 * M_PI * (*_Dpin_soln)(pin_node) * (*_Dpin_soln)(pin_node);
             rod_perimeter += (1.0 / 6.0) * M_PI * (*_Dpin_soln)(pin_node);
           }
           else
           {
             rod_area +=
                 (1.0 / 4.0) * 0.25 * M_PI * (*_Dpin_soln)(pin_node) * (*_Dpin_soln)(pin_node);
             rod_perimeter += (1.0 / 4.0) * M_PI * (*_Dpin_soln)(pin_node);
           }
         }
 
         if (subch_type == EChannelType::CENTER)
         {
           standard_area = std::pow(pitch, 2.0) * std::sqrt(3.0) / 4.0;
           additional_area = 0.0;
           displaced_area = 0.0;
           wire_area = libMesh::pi * std::pow(wire_diameter, 2.0) / 8.0 / std::cos(theta);
           wetted_perimeter = rod_perimeter + 0.5 * libMesh::pi * wire_diameter / std::cos(theta);
         }
         else if (subch_type == EChannelType::EDGE)
         {
           standard_area = pitch * (pin_diameter / 2.0 + gap);
           additional_area = 0.0;
           displaced_area = (*_displacement_soln)(node)*pitch;
           wire_area = libMesh::pi * std::pow(wire_diameter, 2.0) / 8.0 / std::cos(theta);
           wetted_perimeter =
               rod_perimeter + 0.5 * libMesh::pi * wire_diameter / std::cos(theta) + pitch;
         }
         else
         {
           standard_area = 1.0 / std::sqrt(3.0) * std::pow((pin_diameter / 2.0 + gap), 2.0);
           additional_area = 0.0;
           displaced_area = 1.0 / std::sqrt(3.0) *
                            (pin_diameter + 2.0 * gap + (*_displacement_soln)(node)) *
                            (*_displacement_soln)(node);
           wire_area = libMesh::pi / 24.0 * std::pow(wire_diameter, 2.0) / std::cos(theta);
           wetted_perimeter =
               rod_perimeter + libMesh::pi * wire_diameter / std::cos(theta) / 6.0 +
               2.0 / std::sqrt(3.0) * (pin_diameter / 2.0 + gap + (*_displacement_soln)(node));
         }
 
         auto subchannel_area =
             standard_area + additional_area + displaced_area - rod_area - wire_area;
 
         auto overlapping_pin_area = 0.0;
         auto overlapping_wetted_perimeter = 0.0;
         for (auto i_gap : _subchannel_mesh.getChannelGaps(i_ch))
         {
           auto gap_pins = _subchannel_mesh.getGapPins(i_gap);
           auto pin_1 = gap_pins.first;
           auto pin_2 = gap_pins.second;
           auto * pin_node_1 = _subchannel_mesh.getPinNode(pin_1, iz);
           auto * pin_node_2 = _subchannel_mesh.getPinNode(pin_2, iz);
           auto Diameter1 = (*_Dpin_soln)(pin_node_1);
           auto Radius1 = Diameter1 / 2.0;
           auto Diameter2 = (*_Dpin_soln)(pin_node_2);
           auto Radius2 = Diameter2 / 2.0;
           auto pitch = _subchannel_mesh.getPitch();
 
           if (pitch < (Radius1 + Radius2)) // overlapping pins
           {
             mooseWarning(" The gap of index : '", i_gap, " at axial cell ", iz, " ' is blocked.");
             auto cos1 =
                 (pitch * pitch + Radius1 * Radius1 - Radius2 * Radius2) / (2 * pitch * Radius1);
             auto cos2 =
                 (pitch * pitch + Radius2 * Radius2 - Radius1 * Radius1) / (2 * pitch * Radius2);
             auto angle1 = 2.0 * acos(cos1);
             auto angle2 = 2.0 * acos(cos2);
             // half of the intersecting arc-length
             overlapping_wetted_perimeter += 0.5 * angle1 * Radius1 + 0.5 * angle2 * Radius2;
             // Half of the overlapping area
             overlapping_pin_area +=
                 0.5 * Radius1 * Radius1 * acos(cos1) + 0.5 * Radius2 * Radius2 * acos(cos2) -
                 0.25 * sqrt((-pitch + Radius1 + Radius2) * (pitch + Radius1 - Radius2) *
                             (pitch - Radius1 + Radius2) * (pitch + Radius1 + Radius2));
           }
         }
         subchannel_area += overlapping_pin_area;           // correct surface area
         wetted_perimeter += -overlapping_wetted_perimeter; // correct wetted perimeter
 
         auto index = 0;
         for (const auto & i_blockage : index_blockage)
         {
           if (i_ch == i_blockage && (Z >= z_blockage.front() && Z <= z_blockage.back()))
           {
             subchannel_area *= reduction_blockage[index];
           }
           index++;
         }
         _S_flow_soln->set(node, subchannel_area);
         _w_perim_soln->set(node, wetted_perimeter);
       }
     }
     for (unsigned int iz = 0; iz < _n_cells + 1; iz++)
     {
       for (unsigned int i_gap = 0; i_gap < _n_gaps; i_gap++)
       {
         auto gap_pins = _subchannel_mesh.getGapPins(i_gap);
         auto pin_1 = gap_pins.first;
         auto pin_2 = gap_pins.second;
         auto * pin_node_1 = _subchannel_mesh.getPinNode(pin_1, iz);
         auto * pin_node_2 = _subchannel_mesh.getPinNode(pin_2, iz);
 
         if (pin_1 == pin_2) // Corner or edge gap
         {
           auto displacement = 0.0;
           auto counter = 0.0;
           for (auto i_ch : _subchannel_mesh.getPinChannels(pin_1))
           {
             auto subch_type = _subchannel_mesh.getSubchannelType(i_ch);
             auto * node = _subchannel_mesh.getChannelNode(i_ch, iz);
             if (subch_type == EChannelType::EDGE || subch_type == EChannelType::CORNER)
             {
               displacement += (*_displacement_soln)(node);
               counter += 1.0;
             }
           }
           displacement = displacement / counter;
           _tri_sch_mesh._gij_map[iz][i_gap] =
               0.5 * (flat_to_flat - (n_rings - 1) * pitch * std::sqrt(3.0) -
                      (*_Dpin_soln)(pin_node_1)) +
               displacement;
         }
         else // center gap
         {
           _tri_sch_mesh._gij_map[iz][i_gap] =
               pitch - (*_Dpin_soln)(pin_node_1) / 2.0 - (*_Dpin_soln)(pin_node_2) / 2.0;
         }
         // if pins come in contact, the gap is zero
         if (_tri_sch_mesh._gij_map[iz][i_gap] <= 0.0)
           _tri_sch_mesh._gij_map[iz][i_gap] = 0.0;
       }
     }
   }
 
   for (unsigned int iz = 1; iz < _n_cells + 1; iz++)
   {
     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);
       _mdot_soln->set(node_out, (*_mdot_soln)(node_in));
     }
   }
 
   // We must do a global assembly to make sure data is parallel consistent before we do things
   // like compute L2 norms
   _aux->solution().close();
 }

◆ initialSetup()

void SubChannel1PhaseProblem::initialSetup ( )

overridevirtualinherited

Reimplemented from ExternalProblem.

Definition at line 243 of file SubChannel1PhaseProblem.C.

 {
   ExternalProblem::initialSetup();
   _fp = &getUserObject<SinglePhaseFluidProperties>(getParam<UserObjectName>("fp"));
   _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));
   _DP_soln = std::make_unique<SolutionHandle>(getVariable(0, SubChannelApp::PRESSURE_DROP));
   _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));
   }
   _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)
   {
     _q_prime_duct_soln =
         std::make_unique<SolutionHandle>(getVariable(0, SubChannelApp::DUCT_LINEAR_HEAT_RATE));
     _Tduct_soln = std::make_unique<SolutionHandle>(getVariable(0, SubChannelApp::DUCT_TEMPERATURE));
   }
 }

◆ petscSnesSolver()

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

protectedinherited

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

Definition at line 1875 of file SubChannel1PhaseProblem.C.

Referenced by SubChannel1PhaseProblem::computeWijFromSolve().

 {
   SNES snes;
   KSP ksp;
   PC pc;
   Vec x, r;
   PetscMPIInt size;
   PetscScalar * xx;
 
   PetscFunctionBegin;
   PetscCallMPI(MPI_Comm_size(PETSC_COMM_WORLD, &size));
   if (size > 1)
     SETERRQ(PETSC_COMM_WORLD, PETSC_ERR_SUP, "Example is only for sequential runs");
   LibmeshPetscCall(SNESCreate(PETSC_COMM_WORLD, &snes));
   LibmeshPetscCall(VecCreate(PETSC_COMM_WORLD, &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);
 }

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

protectedinherited

Definition at line 333 of file SubChannel1PhaseProblem.h.

Referenced by SubChannel1PhaseProblem::computeWijPrime(), and SubChannel1PhaseProblem::implicitPetscSolve().

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

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

protectedinherited

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

◆ populateSolutionGap()

template<class T >

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

protectedinherited

Definition at line 431 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(iz * cross_dimension + i_l) = 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
	)

protectedinherited

Definition at line 384 of file SubChannel1PhaseProblem.h.

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

 {
   PetscScalar * xx;
   PetscFunctionBegin;
   LibmeshPetscCall(VecGetArray(x, &xx));
   for (unsigned int iz = first_axial_level; iz < last_axial_level; 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);
 }

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

protectedinherited

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

protectedinherited

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

Definition at line 1833 of file SubChannel1PhaseProblem.C.

Referenced by formFunction().

 {
   unsigned int last_node = (iblock + 1) * _block_size;
   unsigned int first_node = iblock * _block_size;
   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 + 1; 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;
 }

◆ solverSystemConverged()

bool SubChannel1PhaseProblem::solverSystemConverged ( const unsigned int )

overridevirtualinherited

Reimplemented from ExternalProblem.

Definition at line 338 of file SubChannel1PhaseProblem.C.

 {
   return _converged;
 }

◆ syncSolutions()

void SubChannel1PhaseProblem::syncSolutions ( Direction direction )

overridevirtualinherited

Implements ExternalProblem.

Definition at line 2757 of file SubChannel1PhaseProblem.C.

2758 {

2759 }

◆ validParams()

InputParameters TriSubChannel1PhaseProblem::validParams ( )

static

Definition at line 18 of file TriSubChannel1PhaseProblem.C.

 {
   InputParameters params = SubChannel1PhaseProblem::validParams();
   params.addClassDescription("Solver class for subchannels in a triangular lattice assembly and "
                              "bare/wire-wrapped fuel pins");
   return params;
 }

Member Data Documentation

◆ _added_K

PetscScalar SubChannel1PhaseProblem::_added_K = 0.0

protectedinherited

Added resistances for monolithic convergence.

Definition at line 321 of file SubChannel1PhaseProblem.h.

Referenced by SubChannel1PhaseProblem::implicitPetscSolve().

◆ _added_K_old

PetscScalar SubChannel1PhaseProblem::_added_K_old = 1000.0

protectedinherited

Definition at line 322 of file SubChannel1PhaseProblem.h.

Referenced by SubChannel1PhaseProblem::implicitPetscSolve().

◆ _amc_advective_derivative_mat

Mat SubChannel1PhaseProblem::_amc_advective_derivative_mat

protectedinherited

Axial momentum conservation - advective (Eulerian) derivative.

Definition at line 266 of file SubChannel1PhaseProblem.h.

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

◆ _amc_advective_derivative_rhs

Vec SubChannel1PhaseProblem::_amc_advective_derivative_rhs

protectedinherited

Definition at line 267 of file SubChannel1PhaseProblem.h.

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

◆ _amc_cross_derivative_mat

Mat SubChannel1PhaseProblem::_amc_cross_derivative_mat

protectedinherited

Axial momentum conservation - cross flux derivative.

Definition at line 269 of file SubChannel1PhaseProblem.h.

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

◆ _amc_cross_derivative_rhs

Vec SubChannel1PhaseProblem::_amc_cross_derivative_rhs

protectedinherited

Definition at line 270 of file SubChannel1PhaseProblem.h.

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

◆ _amc_friction_force_mat

Mat SubChannel1PhaseProblem::_amc_friction_force_mat

protectedinherited

Axial momentum conservation - friction force.

Definition at line 272 of file SubChannel1PhaseProblem.h.

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

◆ _amc_friction_force_rhs

Vec SubChannel1PhaseProblem::_amc_friction_force_rhs

protectedinherited

Definition at line 273 of file SubChannel1PhaseProblem.h.

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

◆ _amc_gravity_rhs

Vec SubChannel1PhaseProblem::_amc_gravity_rhs

protectedinherited

Axial momentum conservation - buoyancy force No implicit matrix.

Definition at line 276 of file SubChannel1PhaseProblem.h.

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

◆ _amc_pressure_force_mat

Mat SubChannel1PhaseProblem::_amc_pressure_force_mat

protectedinherited

Axial momentum conservation - pressure force.

Definition at line 278 of file SubChannel1PhaseProblem.h.

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

◆ _amc_pressure_force_rhs

Vec SubChannel1PhaseProblem::_amc_pressure_force_rhs

protectedinherited

Definition at line 279 of file SubChannel1PhaseProblem.h.

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

◆ _amc_sys_mdot_mat

Mat SubChannel1PhaseProblem::_amc_sys_mdot_mat

protectedinherited

Axial momentum system matrix.

Definition at line 281 of file SubChannel1PhaseProblem.h.

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

◆ _amc_sys_mdot_rhs

Vec SubChannel1PhaseProblem::_amc_sys_mdot_rhs

protectedinherited

Definition at line 282 of file SubChannel1PhaseProblem.h.

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

◆ _amc_time_derivative_mat

Mat SubChannel1PhaseProblem::_amc_time_derivative_mat

protectedinherited

Axial momentum conservation - time derivative.

Definition at line 263 of file SubChannel1PhaseProblem.h.

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

◆ _amc_time_derivative_rhs

Vec SubChannel1PhaseProblem::_amc_time_derivative_rhs

protectedinherited

Definition at line 264 of file SubChannel1PhaseProblem.h.

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

◆ _amc_turbulent_cross_flows_mat

Mat SubChannel1PhaseProblem::_amc_turbulent_cross_flows_mat

protectedinherited

Mass conservation - density time derivative No implicit matrix.

Axial momentum Axial momentum conservation - compute turbulent cross fluxes

Definition at line 260 of file SubChannel1PhaseProblem.h.

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

◆ _amc_turbulent_cross_flows_rhs

Vec SubChannel1PhaseProblem::_amc_turbulent_cross_flows_rhs

protectedinherited

Definition at line 261 of file SubChannel1PhaseProblem.h.

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

◆ _atol

const PetscReal& SubChannel1PhaseProblem::_atol

protectedinherited

The absolute convergence tolerance for the ksp linear solver.

Definition at line 152 of file SubChannel1PhaseProblem.h.

Referenced by QuadSubChannel1PhaseProblem::computeh(), computeh(), SubChannel1PhaseProblem::computeMdot(), SubChannel1PhaseProblem::computeP(), SubChannel1PhaseProblem::implicitPetscSolve(), and SubChannel1PhaseProblem::petscSnesSolver().

◆ _block_size

unsigned int SubChannel1PhaseProblem::_block_size

protectedinherited

Definition at line 116 of file SubChannel1PhaseProblem.h.

◆ _cmc_advective_derivative_mat

Mat SubChannel1PhaseProblem::_cmc_advective_derivative_mat

protectedinherited

Cross momentum conservation - advective (Eulerian) derivative.

Definition at line 289 of file SubChannel1PhaseProblem.h.

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

◆ _cmc_advective_derivative_rhs

Vec SubChannel1PhaseProblem::_cmc_advective_derivative_rhs

protectedinherited

Definition at line 290 of file SubChannel1PhaseProblem.h.

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

◆ _cmc_friction_force_mat

Mat SubChannel1PhaseProblem::_cmc_friction_force_mat

protectedinherited

Cross momentum conservation - friction force.

Definition at line 292 of file SubChannel1PhaseProblem.h.

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

◆ _cmc_friction_force_rhs

Vec SubChannel1PhaseProblem::_cmc_friction_force_rhs

protectedinherited

Definition at line 293 of file SubChannel1PhaseProblem.h.

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

◆ _cmc_pressure_force_mat

Mat SubChannel1PhaseProblem::_cmc_pressure_force_mat

protectedinherited

Cross momentum conservation - pressure force.

Definition at line 295 of file SubChannel1PhaseProblem.h.

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

◆ _cmc_pressure_force_rhs

Vec SubChannel1PhaseProblem::_cmc_pressure_force_rhs

protectedinherited

Definition at line 296 of file SubChannel1PhaseProblem.h.

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

◆ _cmc_sys_Wij_mat

Mat SubChannel1PhaseProblem::_cmc_sys_Wij_mat

protectedinherited

Lateral momentum system matrix.

Definition at line 298 of file SubChannel1PhaseProblem.h.

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

◆ _cmc_sys_Wij_rhs

Vec SubChannel1PhaseProblem::_cmc_sys_Wij_rhs

protectedinherited

Definition at line 299 of file SubChannel1PhaseProblem.h.

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

◆ _cmc_time_derivative_mat

Mat SubChannel1PhaseProblem::_cmc_time_derivative_mat

protectedinherited

Cross momentum Cross momentum conservation - time derivative.

Definition at line 286 of file SubChannel1PhaseProblem.h.

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

◆ _cmc_time_derivative_rhs

Vec SubChannel1PhaseProblem::_cmc_time_derivative_rhs

protectedinherited

Definition at line 287 of file SubChannel1PhaseProblem.h.

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

◆ _cmc_Wij_channel_dummy

Vec SubChannel1PhaseProblem::_cmc_Wij_channel_dummy

protectedinherited

Definition at line 300 of file SubChannel1PhaseProblem.h.

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

◆ _compute_density

const bool SubChannel1PhaseProblem::_compute_density

protectedinherited

Flag that activates or deactivates the calculation of density.

Definition at line 126 of file SubChannel1PhaseProblem.h.

Referenced by SubChannel1PhaseProblem::externalSolve().

◆ _compute_power

const bool SubChannel1PhaseProblem::_compute_power

protectedinherited

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

Definition at line 130 of file SubChannel1PhaseProblem.h.

Referenced by SubChannel1PhaseProblem::externalSolve().

◆ _compute_viscosity

const bool SubChannel1PhaseProblem::_compute_viscosity

protectedinherited

Flag that activates or deactivates the calculation of viscosity.

Definition at line 128 of file SubChannel1PhaseProblem.h.

Referenced by SubChannel1PhaseProblem::externalSolve().

◆ _converged

bool SubChannel1PhaseProblem::_converged

protectedinherited

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

Definition at line 136 of file SubChannel1PhaseProblem.h.

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

◆ _correction_factor

PetscScalar SubChannel1PhaseProblem::_correction_factor = 1.0

protectedinherited

Definition at line 325 of file SubChannel1PhaseProblem.h.

Referenced by SubChannel1PhaseProblem::implicitPetscSolve().

◆ _CT

const Real& SubChannel1PhaseProblem::_CT

protectedinherited

Turbulent modeling parameter used in axial momentum equation.

Definition at line 142 of file SubChannel1PhaseProblem.h.

Referenced by SubChannel1PhaseProblem::computeDP().

◆ _deformation

const bool SubChannel1PhaseProblem::_deformation

protectedinherited

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

Definition at line 170 of file SubChannel1PhaseProblem.h.

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

◆ _displacement_soln

std::unique_ptr<SolutionHandle> SubChannel1PhaseProblem::_displacement_soln

protectedinherited

Definition at line 189 of file SubChannel1PhaseProblem.h.

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

◆ _DP_soln

std::unique_ptr<SolutionHandle> SubChannel1PhaseProblem::_DP_soln

protectedinherited

Definition at line 177 of file SubChannel1PhaseProblem.h.

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

◆ _Dpin_soln

std::unique_ptr<SolutionHandle> SubChannel1PhaseProblem::_Dpin_soln

protectedinherited

Definition at line 181 of file SubChannel1PhaseProblem.h.

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

◆ _dpz_error

Real SubChannel1PhaseProblem::_dpz_error

protectedinherited

average relative error in pressure drop of channels

Definition at line 119 of file SubChannel1PhaseProblem.h.

◆ _dt

Real SubChannel1PhaseProblem::_dt

protectedinherited

Time step.

Definition at line 138 of file SubChannel1PhaseProblem.h.

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

◆ _dtol

const PetscReal& SubChannel1PhaseProblem::_dtol

protectedinherited

The divergence tolerance for the ksp linear solver.

Definition at line 154 of file SubChannel1PhaseProblem.h.

Referenced by QuadSubChannel1PhaseProblem::computeh(), computeh(), SubChannel1PhaseProblem::computeMdot(), SubChannel1PhaseProblem::computeP(), SubChannel1PhaseProblem::implicitPetscSolve(), and SubChannel1PhaseProblem::petscSnesSolver().

◆ _duct_mesh_exist

const bool SubChannel1PhaseProblem::_duct_mesh_exist

protectedinherited

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

Definition at line 134 of file SubChannel1PhaseProblem.h.

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

◆ _fp

const SinglePhaseFluidProperties* SubChannel1PhaseProblem::_fp

protectedinherited

Solutions handles and link to TH tables properties.

Definition at line 173 of file SubChannel1PhaseProblem.h.

Referenced by QuadSubChannel1PhaseProblem::computeBeta(), computeBeta(), QuadSubChannel1PhaseProblem::computeh(), computeh(), SubChannel1PhaseProblem::computeMu(), SubChannel1PhaseProblem::computeRho(), SubChannel1PhaseProblem::computeT(), SubChannel1PhaseProblem::externalSolve(), and SubChannel1PhaseProblem::initialSetup().

◆ _friction_args

struct SubChannel1PhaseProblem::FrictionStruct SubChannel1PhaseProblem::_friction_args

protectedinherited

Referenced by SubChannel1PhaseProblem::computeDP().

◆ _g_grav

const Real SubChannel1PhaseProblem::_g_grav

protectedinherited

Definition at line 110 of file SubChannel1PhaseProblem.h.

Referenced by SubChannel1PhaseProblem::computeDP().

◆ _global_counter

PetscInt SubChannel1PhaseProblem::_global_counter = 0

protectedinherited

No implicit matrix.

Definition at line 318 of file SubChannel1PhaseProblem.h.

◆ _h_soln

std::unique_ptr<SolutionHandle> SubChannel1PhaseProblem::_h_soln

protectedinherited

Definition at line 178 of file SubChannel1PhaseProblem.h.

Referenced by QuadSubChannel1PhaseProblem::computeh(), computeh(), SubChannel1PhaseProblem::computeT(), SubChannel1PhaseProblem::externalSolve(), SubChannel1PhaseProblem::implicitPetscSolve(), and SubChannel1PhaseProblem::initialSetup().

◆ _hc_added_heat_rhs

Vec SubChannel1PhaseProblem::_hc_added_heat_rhs

protectedinherited

Enthalpy conservation - source and sink.

Definition at line 313 of file SubChannel1PhaseProblem.h.

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

◆ _hc_advective_derivative_mat

Mat SubChannel1PhaseProblem::_hc_advective_derivative_mat

protectedinherited

Enthalpy conservation - advective (Eulerian) derivative;.

Definition at line 307 of file SubChannel1PhaseProblem.h.

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

◆ _hc_advective_derivative_rhs

Vec SubChannel1PhaseProblem::_hc_advective_derivative_rhs

protectedinherited

Definition at line 308 of file SubChannel1PhaseProblem.h.

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

◆ _hc_axial_heat_conduction_mat

Mat TriSubChannel1PhaseProblem::_hc_axial_heat_conduction_mat

protected

Definition at line 40 of file TriSubChannel1PhaseProblem.h.

Referenced by cleanUp(), computeh(), and TriSubChannel1PhaseProblem().

◆ _hc_axial_heat_conduction_rhs

Vec TriSubChannel1PhaseProblem::_hc_axial_heat_conduction_rhs

protected

Definition at line 41 of file TriSubChannel1PhaseProblem.h.

Referenced by cleanUp(), computeh(), and TriSubChannel1PhaseProblem().

◆ _hc_cross_derivative_mat

Mat SubChannel1PhaseProblem::_hc_cross_derivative_mat

protectedinherited

Enthalpy conservation - cross flux derivative.

Definition at line 310 of file SubChannel1PhaseProblem.h.

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

◆ _hc_cross_derivative_rhs

Vec SubChannel1PhaseProblem::_hc_cross_derivative_rhs

protectedinherited

Definition at line 311 of file SubChannel1PhaseProblem.h.

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

◆ _hc_radial_heat_conduction_mat

Mat TriSubChannel1PhaseProblem::_hc_radial_heat_conduction_mat

protected

Definition at line 42 of file TriSubChannel1PhaseProblem.h.

Referenced by cleanUp(), computeh(), and TriSubChannel1PhaseProblem().

◆ _hc_radial_heat_conduction_rhs

Vec TriSubChannel1PhaseProblem::_hc_radial_heat_conduction_rhs

protected

Definition at line 43 of file TriSubChannel1PhaseProblem.h.

Referenced by cleanUp(), computeh(), and TriSubChannel1PhaseProblem().

◆ _hc_sweep_enthalpy_mat

Mat TriSubChannel1PhaseProblem::_hc_sweep_enthalpy_mat

protected

Definition at line 44 of file TriSubChannel1PhaseProblem.h.

Referenced by cleanUp(), computeh(), and TriSubChannel1PhaseProblem().

◆ _hc_sweep_enthalpy_rhs

Vec TriSubChannel1PhaseProblem::_hc_sweep_enthalpy_rhs

protected

Definition at line 45 of file TriSubChannel1PhaseProblem.h.

Referenced by cleanUp(), computeh(), and TriSubChannel1PhaseProblem().

◆ _hc_sys_h_mat

Mat SubChannel1PhaseProblem::_hc_sys_h_mat

protectedinherited

System matrices.

Definition at line 315 of file SubChannel1PhaseProblem.h.

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

◆ _hc_sys_h_rhs

Vec SubChannel1PhaseProblem::_hc_sys_h_rhs

protectedinherited

Definition at line 316 of file SubChannel1PhaseProblem.h.

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

◆ _hc_time_derivative_mat

Mat SubChannel1PhaseProblem::_hc_time_derivative_mat

protectedinherited

Enthalpy Enthalpy conservation - time derivative.

Definition at line 304 of file SubChannel1PhaseProblem.h.

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

◆ _hc_time_derivative_rhs

Vec SubChannel1PhaseProblem::_hc_time_derivative_rhs

protectedinherited

Definition at line 305 of file SubChannel1PhaseProblem.h.

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

◆ _implicit_bool

const bool SubChannel1PhaseProblem::_implicit_bool

protectedinherited

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

Definition at line 160 of file SubChannel1PhaseProblem.h.

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

◆ _interpolation_scheme

const MooseEnum SubChannel1PhaseProblem::_interpolation_scheme

protectedinherited

The interpolation method used in constructing the systems.

Definition at line 158 of file SubChannel1PhaseProblem.h.

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

◆ _kij

const Real& SubChannel1PhaseProblem::_kij

protectedinherited

Definition at line 111 of file SubChannel1PhaseProblem.h.

Referenced by SubChannel1PhaseProblem::computeWijResidual().

◆ _max_sumWij

PetscScalar SubChannel1PhaseProblem::_max_sumWij

protectedinherited

Definition at line 323 of file SubChannel1PhaseProblem.h.

Referenced by SubChannel1PhaseProblem::implicitPetscSolve().

◆ _max_sumWij_new

PetscScalar SubChannel1PhaseProblem::_max_sumWij_new

protectedinherited

Definition at line 324 of file SubChannel1PhaseProblem.h.

Referenced by SubChannel1PhaseProblem::implicitPetscSolve().

◆ _maxit

const PetscInt& SubChannel1PhaseProblem::_maxit

protectedinherited

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

Definition at line 156 of file SubChannel1PhaseProblem.h.

Referenced by QuadSubChannel1PhaseProblem::computeh(), computeh(), SubChannel1PhaseProblem::computeMdot(), SubChannel1PhaseProblem::computeP(), SubChannel1PhaseProblem::implicitPetscSolve(), and SubChannel1PhaseProblem::petscSnesSolver().

◆ _mc_axial_convection_mat

Mat SubChannel1PhaseProblem::_mc_axial_convection_mat

protectedinherited

Mass conservation - axial convection.

Definition at line 253 of file SubChannel1PhaseProblem.h.

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

◆ _mc_axial_convection_rhs

Vec SubChannel1PhaseProblem::_mc_axial_convection_rhs

protectedinherited

Definition at line 254 of file SubChannel1PhaseProblem.h.

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

◆ _mc_sumWij_mat

Mat SubChannel1PhaseProblem::_mc_sumWij_mat

protectedinherited

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

Definition at line 248 of file SubChannel1PhaseProblem.h.

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

◆ _mdot_soln

std::unique_ptr<SolutionHandle> SubChannel1PhaseProblem::_mdot_soln

protectedinherited

Definition at line 174 of file SubChannel1PhaseProblem.h.

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

◆ _monolithic_thermal_bool

const bool SubChannel1PhaseProblem::_monolithic_thermal_bool

protectedinherited

Thermal monolithic bool.

Definition at line 166 of file SubChannel1PhaseProblem.h.

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

◆ _mu_soln

std::unique_ptr<SolutionHandle> SubChannel1PhaseProblem::_mu_soln

protectedinherited

Definition at line 183 of file SubChannel1PhaseProblem.h.

Referenced by QuadSubChannel1PhaseProblem::computeBeta(), computeBeta(), SubChannel1PhaseProblem::computeMu(), and SubChannel1PhaseProblem::initialSetup().

◆ _n_blocks

unsigned int SubChannel1PhaseProblem::_n_blocks

protectedinherited

number of axial blocks

Definition at line 105 of file SubChannel1PhaseProblem.h.

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

◆ _n_cells

unsigned int SubChannel1PhaseProblem::_n_cells

protectedinherited

Definition at line 112 of file SubChannel1PhaseProblem.h.

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

◆ _n_channels

unsigned int SubChannel1PhaseProblem::_n_channels

protectedinherited

Definition at line 115 of file SubChannel1PhaseProblem.h.

◆ _n_gaps

unsigned int SubChannel1PhaseProblem::_n_gaps

protectedinherited

Definition at line 113 of file SubChannel1PhaseProblem.h.

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

◆ _n_pins

unsigned int SubChannel1PhaseProblem::_n_pins

protectedinherited

Definition at line 114 of file SubChannel1PhaseProblem.h.

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

◆ _one

Real SubChannel1PhaseProblem::_one

protectedinherited

Definition at line 122 of file SubChannel1PhaseProblem.h.

Referenced by SubChannel1PhaseProblem::externalSolve().

◆ _outer_channels

Real SubChannel1PhaseProblem::_outer_channels

protectedinherited

Definition at line 117 of file SubChannel1PhaseProblem.h.

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

◆ _P_out

const PostprocessorValue& SubChannel1PhaseProblem::_P_out

protectedinherited

Outlet Pressure.

Definition at line 140 of file SubChannel1PhaseProblem.h.

Referenced by QuadSubChannel1PhaseProblem::computeBeta(), computeBeta(), QuadSubChannel1PhaseProblem::computeh(), computeh(), SubChannel1PhaseProblem::computeMu(), SubChannel1PhaseProblem::computeRho(), SubChannel1PhaseProblem::computeT(), and SubChannel1PhaseProblem::externalSolve().

◆ _P_soln

std::unique_ptr<SolutionHandle> SubChannel1PhaseProblem::_P_soln

protectedinherited

Definition at line 176 of file SubChannel1PhaseProblem.h.

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

◆ _P_tol

const Real& SubChannel1PhaseProblem::_P_tol

protectedinherited

Convergence tolerance for the pressure loop in external solve.

Definition at line 144 of file SubChannel1PhaseProblem.h.

Referenced by SubChannel1PhaseProblem::externalSolve().

◆ _pin_mesh_exist

const bool SubChannel1PhaseProblem::_pin_mesh_exist

protectedinherited

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

Definition at line 132 of file SubChannel1PhaseProblem.h.

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

◆ _prod

Vec SubChannel1PhaseProblem::_prod

protectedinherited

Definition at line 250 of file SubChannel1PhaseProblem.h.

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

◆ _prodp

Vec SubChannel1PhaseProblem::_prodp

protectedinherited

Definition at line 251 of file SubChannel1PhaseProblem.h.

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

◆ _q_prime_duct_soln

std::unique_ptr<SolutionHandle> SubChannel1PhaseProblem::_q_prime_duct_soln

protectedinherited

Definition at line 187 of file SubChannel1PhaseProblem.h.

Referenced by SubChannel1PhaseProblem::initialSetup().

◆ _q_prime_soln

std::unique_ptr<SolutionHandle> SubChannel1PhaseProblem::_q_prime_soln

protectedinherited

Definition at line 186 of file SubChannel1PhaseProblem.h.

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

◆ _rho_soln

std::unique_ptr<SolutionHandle> SubChannel1PhaseProblem::_rho_soln

protectedinherited

Definition at line 182 of file SubChannel1PhaseProblem.h.

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

◆ _rtol

const PetscReal& SubChannel1PhaseProblem::_rtol

protectedinherited

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

Definition at line 150 of file SubChannel1PhaseProblem.h.

Referenced by QuadSubChannel1PhaseProblem::computeh(), computeh(), SubChannel1PhaseProblem::computeMdot(), SubChannel1PhaseProblem::computeP(), SubChannel1PhaseProblem::implicitPetscSolve(), and SubChannel1PhaseProblem::petscSnesSolver().

◆ _S_flow_soln

std::unique_ptr<SolutionHandle> SubChannel1PhaseProblem::_S_flow_soln

protectedinherited

Definition at line 184 of file SubChannel1PhaseProblem.h.

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

◆ _segregated_bool

const bool SubChannel1PhaseProblem::_segregated_bool

protectedinherited

Segregated solve.

Definition at line 164 of file SubChannel1PhaseProblem.h.

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

◆ _staggered_pressure_bool

const bool SubChannel1PhaseProblem::_staggered_pressure_bool

protectedinherited

Flag to define the usage of staggered or collocated pressure.

Definition at line 162 of file SubChannel1PhaseProblem.h.

Referenced by SubChannel1PhaseProblem::computeP(), and SubChannel1PhaseProblem::computeWijResidual().

◆ _subchannel_mesh

SubChannelMesh& SubChannel1PhaseProblem::_subchannel_mesh

protectedinherited

◆ _SumWij_soln

std::unique_ptr<SolutionHandle> SubChannel1PhaseProblem::_SumWij_soln

protectedinherited

Definition at line 175 of file SubChannel1PhaseProblem.h.

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

◆ _T_maxit

const int& SubChannel1PhaseProblem::_T_maxit

protectedinherited

Maximum iterations for the inner temperature loop.

Definition at line 148 of file SubChannel1PhaseProblem.h.

Referenced by SubChannel1PhaseProblem::externalSolve().

◆ _T_soln

std::unique_ptr<SolutionHandle> SubChannel1PhaseProblem::_T_soln

protectedinherited

Definition at line 179 of file SubChannel1PhaseProblem.h.

Referenced by QuadSubChannel1PhaseProblem::computeBeta(), computeBeta(), QuadSubChannel1PhaseProblem::computeh(), computeh(), SubChannel1PhaseProblem::computeMu(), SubChannel1PhaseProblem::computeRho(), SubChannel1PhaseProblem::computeT(), SubChannel1PhaseProblem::externalSolve(), and SubChannel1PhaseProblem::initialSetup().

◆ _T_tol

const Real& SubChannel1PhaseProblem::_T_tol

protectedinherited

Convergence tolerance for the temperature loop in external solve.

Definition at line 146 of file SubChannel1PhaseProblem.h.

Referenced by SubChannel1PhaseProblem::externalSolve().

◆ _Tduct_soln

std::unique_ptr<SolutionHandle> SubChannel1PhaseProblem::_Tduct_soln

protectedinherited

Definition at line 188 of file SubChannel1PhaseProblem.h.

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

◆ _Tpin_soln

std::unique_ptr<SolutionHandle> SubChannel1PhaseProblem::_Tpin_soln

protectedinherited

Definition at line 180 of file SubChannel1PhaseProblem.h.

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

◆ _TR

Real SubChannel1PhaseProblem::_TR

protectedinherited

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

Definition at line 124 of file SubChannel1PhaseProblem.h.

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

◆ _tri_sch_mesh

TriSubChannelMesh& TriSubChannel1PhaseProblem::_tri_sch_mesh

protected

Definition at line 38 of file TriSubChannel1PhaseProblem.h.

Referenced by computeBeta(), computeFrictionFactor(), computeh(), and initializeSolution().

◆ _verbose_subchannel

const bool SubChannel1PhaseProblem::_verbose_subchannel

protectedinherited

Boolean to printout information related to subchannel solve.

Definition at line 168 of file SubChannel1PhaseProblem.h.

Referenced by SubChannel1PhaseProblem::computeDP(), QuadSubChannel1PhaseProblem::computeh(), computeh(), SubChannel1PhaseProblem::computeMdot(), SubChannel1PhaseProblem::computeP(), SubChannel1PhaseProblem::computeWijResidual(), SubChannel1PhaseProblem::externalSolve(), and SubChannel1PhaseProblem::implicitPetscSolve().

◆ _w_perim_soln

std::unique_ptr<SolutionHandle> SubChannel1PhaseProblem::_w_perim_soln

protectedinherited

Definition at line 185 of file SubChannel1PhaseProblem.h.

Referenced by QuadSubChannel1PhaseProblem::computeBeta(), computeBeta(), QuadSubChannel1PhaseProblem::initializeSolution(), initializeSolution(), and SubChannel1PhaseProblem::initialSetup().

◆ _Wij

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

protectedinherited

Definition at line 106 of file SubChannel1PhaseProblem.h.

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

◆ _Wij_old

libMesh::DenseMatrix<Real> SubChannel1PhaseProblem::_Wij_old

protectedinherited

Definition at line 107 of file SubChannel1PhaseProblem.h.

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

◆ _Wij_residual_matrix

libMesh::DenseMatrix<Real> SubChannel1PhaseProblem::_Wij_residual_matrix

protectedinherited

Definition at line 109 of file SubChannel1PhaseProblem.h.

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

◆ _Wij_vec

Vec SubChannel1PhaseProblem::_Wij_vec

protectedinherited

Definition at line 249 of file SubChannel1PhaseProblem.h.

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

◆ _WijPrime

libMesh::DenseMatrix<Real> SubChannel1PhaseProblem::_WijPrime

protectedinherited

Definition at line 108 of file SubChannel1PhaseProblem.h.

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

◆ _z_grid

std::vector<Real> SubChannel1PhaseProblem::_z_grid

protectedinherited

axial location of nodes

Definition at line 121 of file SubChannel1PhaseProblem.h.

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

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

subchannel/include/problems/TriSubChannel1PhaseProblem.h
subchannel/src/problems/TriSubChannel1PhaseProblem.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ TriSubChannel1PhaseProblem()

◆ ~TriSubChannel1PhaseProblem()

Member Function Documentation

◆ cleanUp()

◆ computeAddedHeatDuct()

◆ computeAddedHeatPin()

◆ computeBeta()

◆ computeDP()

◆ computeFrictionFactor()

◆ computeh()

◆ computeInterpolatedValue()

◆ computeInterpolationCoefficients()

◆ computeMdot()

◆ computeMu()

◆ computeP()

◆ computeRho()

◆ computeSumWij()

◆ computeT()

◆ computeWijFromSolve()

◆ computeWijPrime()

◆ computeWijResidual()

◆ createPetscMatrix()

◆ createPetscVector()

◆ externalSolve()

◆ implicitPetscSolve()

◆ initializeSolution()

◆ initialSetup()

◆ petscSnesSolver()

◆ populateDenseFromVector()

◆ populateSolutionChan()

◆ populateSolutionGap()

◆ populateVectorFromDense()

◆ populateVectorFromHandle()

◆ residualFunction()

◆ solverSystemConverged()

◆ syncSolutions()

◆ validParams()

Member Data Documentation

◆ _added_K

◆ _added_K_old

◆ _amc_advective_derivative_mat

◆ _amc_advective_derivative_rhs

◆ _amc_cross_derivative_mat

◆ _amc_cross_derivative_rhs

◆ _amc_friction_force_mat

◆ _amc_friction_force_rhs

◆ _amc_gravity_rhs

◆ _amc_pressure_force_mat

◆ _amc_pressure_force_rhs

◆ _amc_sys_mdot_mat

◆ _amc_sys_mdot_rhs

◆ _amc_time_derivative_mat

◆ _amc_time_derivative_rhs

◆ _amc_turbulent_cross_flows_mat

◆ _amc_turbulent_cross_flows_rhs

◆ _atol

◆ _block_size

◆ _cmc_advective_derivative_mat

◆ _cmc_advective_derivative_rhs

◆ _cmc_friction_force_mat

◆ _cmc_friction_force_rhs

◆ _cmc_pressure_force_mat

◆ _cmc_pressure_force_rhs

◆ _cmc_sys_Wij_mat

◆ _cmc_sys_Wij_rhs

◆ _cmc_time_derivative_mat

◆ _cmc_time_derivative_rhs

◆ _cmc_Wij_channel_dummy

◆ _compute_density

◆ _compute_power

◆ _compute_viscosity

◆ _converged