TriInterWrapper1PhaseProblem Class Reference

Triangular interwrapper solver. More...

#include <TriInterWrapper1PhaseProblem.h>

Inheritance diagram for TriInterWrapper1PhaseProblem:

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
	TriInterWrapper1PhaseProblem (const InputParameters &params)
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 ()
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
void	setNeedToAddDefaultNonlinearConvergence ()
virtual void	addDefaultNonlinearConvergence (const InputParameters &params)
virtual bool	onlyAllowDefaultNonlinearConvergence () const
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 &	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	addHDGIntegratedBC (const std::string &kernel_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
void	setPostprocessorValueByName (const PostprocessorName &name, const PostprocessorValue &value, std::size_t t_index=0)
bool	hasPostprocessor (const std::string &name) const
const VectorPostprocessorValue &	getVectorPostprocessorValueByName (const std::string &object_name, const std::string &vector_name, std::size_t t_index=0) const
void	setVectorPostprocessorValueByName (const std::string &object_name, const std::string &vector_name, const VectorPostprocessorValue &value, std::size_t t_index=0)
const VectorPostprocessor &	getVectorPostprocessorObjectByName (const std::string &object_name, const THREAD_ID tid=0) const
virtual void	addDamper (const std::string &damper_name, const std::string &name, InputParameters &parameters)
void	setupDampers ()
bool	hasDampers ()
virtual void	addIndicator (const std::string &indicator_name, const std::string &name, InputParameters &parameters)
virtual void	addMarker (const std::string &marker_name, const std::string &name, InputParameters &parameters)
virtual void	addMultiApp (const std::string &multi_app_name, const std::string &name, InputParameters &parameters)
std::shared_ptr< MultiApp >	getMultiApp (const std::string &multi_app_name) const
std::vector< std::shared_ptr< Transfer > >	getTransfers (ExecFlagType type, Transfer::DIRECTION direction) const
std::vector< std::shared_ptr< Transfer > >	getTransfers (Transfer::DIRECTION direction) const
const ExecuteMooseObjectWarehouse< Transfer > &	getMultiAppTransferWarehouse (Transfer::DIRECTION direction) const
void	execMultiAppTransfers (ExecFlagType type, Transfer::DIRECTION direction)
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)
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, libMesh::SparseMatrix< libMesh::Number > &system_matrix, NumericVector< libMesh::Number > &rhs, 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 () override
void	notifyWhenMeshChanges (MeshChangedInterface *mci)
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)
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
void	setNonlinearConvergenceNames (const std::vector< ConvergenceName > &convergence_names)
std::vector< ConvergenceName >	getNonlinearConvergenceNames () 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
void	setFailNextNonlinearConvergenceCheck ()
void	resetFailNextNonlinearConvergenceCheck ()
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 bool &	currentlyComputingResidual () const
const bool &	currentlyComputingResidual () const
virtual bool	checkNonlocalCouplingRequirement ()
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 libMesh::CouplingMatrix &	nonlocalCouplingMatrix (const unsigned i) const
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 &	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< InternalSideIndicator > &	getInternalSideIndicatorWarehouse ()
const MooseObjectWarehouse< InternalSideIndicator > &	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

Static Public Member Functions
static InputParameters	validParams ()
static std::string	arrayVariableComponent (const std::string &var_name, unsigned int i)
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 Real	computeFrictionFactor (Real Re) override
	Computes the axial friction factor for the sodium coolant and for each subchannel. More...
virtual void	computeDP (int iblock) override
	computeDP(int iz) is defined/overridden in order to use the friction factor for sodium More...
virtual void	computeh (int iblock) override
	computeMassFlowForDPDZ() and enforceUniformDPDZAtInlet() are overriden to define the sodium friction factor More...
virtual void	externalSolve () override
virtual void	computeWijFromSolve (int iblock)
	Computes diversion crossflow per gap for block with index iblock Block is a partition of the whole domain. More...
virtual void	computeSumWij (int iblock)
	Computes net diversion crossflow per channel for block iblock. More...
virtual void	computeMdot (int iblock)
	Computes mass flow per channel for block iblock. More...
virtual void	computeWijPrime (int iblock)
	Computes turbulent crossflow per gap for block iblock. More...
virtual void	computeP (int iblock)
	Computes Pressure per channel for block iblock. More...
virtual void	computeT (int iblock)
	Computes Temperature per channel for block iblock. More...
virtual void	computeRho (int iblock)
	Computes Density per channel for block iblock. More...
virtual void	computeMu (int iblock)
	Computes Viscosity per channel for block iblock. More...
virtual void	computeWij (int iblock)
	Computes cross fluxes for block iblock. More...
virtual Real	computeAddedHeat (unsigned int i_ch, unsigned int iz)
	Computes added heat for channel i_ch and cell iz. More...
virtual libMesh::DenseVector< Real >	residualFunction (int iblock, libMesh::DenseVector< Real > solution)
	Computes Residual per gap for block iblock. More...
virtual PetscErrorCode	petscSnesSolver (int iblock, const libMesh::DenseVector< Real > &solution, libMesh::DenseVector< Real > &root)
	Computes solution of nonlinear equation using snes. More...
virtual PetscErrorCode	implicitPetscSolve (int iblock)
	Computes implicit solve using PetSc. More...
virtual void	initializeSolution ()
	Function to initialize the solution fields. More...
virtual PetscScalar	computeInterpolationCoefficients (PetscScalar Peclet=0.0)
	Functions that computes the interpolation scheme given the Peclet number. More...
virtual PetscScalar	computeInterpolatedValue (PetscScalar topValue, PetscScalar botValue, PetscScalar Peclet=0.0)
PetscErrorCode	cleanUp ()
virtual PetscErrorCode	createPetscVector (Vec &v, PetscInt n)
	Petsc Functions. More...
virtual 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)
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 ()
void	computeSystems (const ExecFlagType &type)
void	meshChangedHelper (bool intermediate_change=false)
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

Protected Attributes
Real	_dpz_error
	average relative error in pressure drop of channels More...
const TriInterWrapperMesh &	_tri_sch_mesh
const InterWrapperMesh &	_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
const unsigned int	_n_cells
const unsigned int	_n_gaps
const unsigned int	_n_assemblies
const unsigned int	_n_channels
const unsigned int	_block_size
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...
bool	_converged
	Variable that informs whether we exited external solve with a converged solution or not. More...
const Real &	_dt
	Time step. More...
const Real &	_P_out
	Outlet Pressure. More...
const Real &	_beta
	Thermal diffusion coefficient used in turbulent crossflow. 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 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 >	_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
Mat	_mc_sumWij_mat
	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::vector< ConvergenceName >	_nonlinear_convergence_names
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	_set_nonlinear_convergence_names
bool	_need_to_add_default_nonlinear_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< std::string >	_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
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
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
std::map< TagName, TagID >	_matrix_tag_name_to_tag_id
std::map< TagID, TagName >	_matrix_tag_id_to_tag_name
Factory &	_factory
std::vector< libMesh::CouplingMatrix >	_nonlocal_cm
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	_requires_nonlocal_coupling
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< InternalSideIndicator >	_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 interwrapper solver.

Definition at line 18 of file TriInterWrapper1PhaseProblem.h.

Constructor & Destructor Documentation

TriInterWrapper1PhaseProblem()

TriInterWrapper1PhaseProblem::TriInterWrapper1PhaseProblem

(

const InputParameters &

params

)

Definition at line 26 of file TriInterWrapper1PhaseProblem.C.

  : InterWrapper1PhaseProblem(params),
    _tri_sch_mesh(SCM::getConstMesh<TriInterWrapperMesh>(_subchannel_mesh))
{
}

Member Function Documentation

cleanUp()

PetscErrorCode InterWrapper1PhaseProblem::cleanUp ( )

protectedinherited

Definition at line 253 of file InterWrapper1PhaseProblem.C.

Referenced by InterWrapper1PhaseProblem::~InterWrapper1PhaseProblem().

{
  PetscFunctionBegin;
  // We need to clean up the petsc matrices/vectors
  // Mass conservation components
  LibmeshPetscCall(MatDestroy(&_mc_sumWij_mat));
  LibmeshPetscCall(VecDestroy(&_Wij_vec));
  LibmeshPetscCall(VecDestroy(&_prod));
  LibmeshPetscCall(VecDestroy(&_prodp));
  LibmeshPetscCall(MatDestroy(&_mc_axial_convection_mat));
  LibmeshPetscCall(VecDestroy(&_mc_axial_convection_rhs));

  // Axial momentum conservation components
  LibmeshPetscCall(MatDestroy(&_amc_turbulent_cross_flows_mat));
  LibmeshPetscCall(VecDestroy(&_amc_turbulent_cross_flows_rhs));
  LibmeshPetscCall(MatDestroy(&_amc_time_derivative_mat));
  LibmeshPetscCall(VecDestroy(&_amc_time_derivative_rhs));
  LibmeshPetscCall(MatDestroy(&_amc_advective_derivative_mat));
  LibmeshPetscCall(VecDestroy(&_amc_advective_derivative_rhs));
  LibmeshPetscCall(MatDestroy(&_amc_cross_derivative_mat));
  LibmeshPetscCall(VecDestroy(&_amc_cross_derivative_rhs));
  LibmeshPetscCall(MatDestroy(&_amc_friction_force_mat));
  LibmeshPetscCall(VecDestroy(&_amc_friction_force_rhs));
  LibmeshPetscCall(VecDestroy(&_amc_gravity_rhs));
  LibmeshPetscCall(MatDestroy(&_amc_pressure_force_mat));
  LibmeshPetscCall(VecDestroy(&_amc_pressure_force_rhs));
  LibmeshPetscCall(MatDestroy(&_amc_sys_mdot_mat));
  LibmeshPetscCall(VecDestroy(&_amc_sys_mdot_rhs));

  // Lateral momentum conservation components
  LibmeshPetscCall(MatDestroy(&_cmc_time_derivative_mat));
  LibmeshPetscCall(VecDestroy(&_cmc_time_derivative_rhs));
  LibmeshPetscCall(MatDestroy(&_cmc_advective_derivative_mat));
  LibmeshPetscCall(VecDestroy(&_cmc_advective_derivative_rhs));
  LibmeshPetscCall(MatDestroy(&_cmc_friction_force_mat));
  LibmeshPetscCall(VecDestroy(&_cmc_friction_force_rhs));
  LibmeshPetscCall(MatDestroy(&_cmc_pressure_force_mat));
  LibmeshPetscCall(VecDestroy(&_cmc_pressure_force_rhs));
  LibmeshPetscCall(MatDestroy(&_cmc_sys_Wij_mat));
  LibmeshPetscCall(VecDestroy(&_cmc_sys_Wij_rhs));
  LibmeshPetscCall(VecDestroy(&_cmc_Wij_channel_dummy));

  // Energy conservation components
  LibmeshPetscCall(MatDestroy(&_hc_time_derivative_mat));
  LibmeshPetscCall(VecDestroy(&_hc_time_derivative_rhs));
  LibmeshPetscCall(MatDestroy(&_hc_advective_derivative_mat));
  LibmeshPetscCall(VecDestroy(&_hc_advective_derivative_rhs));
  LibmeshPetscCall(MatDestroy(&_hc_cross_derivative_mat));
  LibmeshPetscCall(VecDestroy(&_hc_cross_derivative_rhs));
  LibmeshPetscCall(VecDestroy(&_hc_added_heat_rhs));
  LibmeshPetscCall(MatDestroy(&_hc_sys_h_mat));
  LibmeshPetscCall(VecDestroy(&_hc_sys_h_rhs));

  PetscFunctionReturn(LIBMESH_PETSC_SUCCESS);
}

computeAddedHeat()

Real InterWrapper1PhaseProblem::computeAddedHeat ( unsigned int  i_ch, unsigned int  iz  )

protectedvirtualinherited

Computes added heat for channel i_ch and cell iz.

Definition at line 1474 of file InterWrapper1PhaseProblem.C.

Referenced by InterWrapper1PhaseProblem::computeh().

{
  auto dz = _z_grid[iz] - _z_grid[iz - 1];
  if (_pin_mesh_exist)
  {
    auto heat_rate_in = 0.0;
    auto 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 += 0.25 * (*_q_prime_soln)(node_out);
      heat_rate_in += 0.25 * (*_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;
  }
}

computeDP()

void TriInterWrapper1PhaseProblem::computeDP ( int  iblock )

overrideprotectedvirtual

computeDP(int iz) is defined/overridden in order to use the friction factor for sodium

Reimplemented from InterWrapper1PhaseProblem.

Definition at line 59 of file TriInterWrapper1PhaseProblem.C.

{
  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 z_grid = _subchannel_mesh.getZGrid();
    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);
        auto 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);
      auto fi = computeFrictionFactor(Re);
      auto ki = k_grid[i_ch][iz - 1];
      auto friction_term = (fi * dz / Dh_i + ki) * 0.5 * (std::pow((*_mdot_soln)(node_out), 2.0)) /
                           (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);
    }
  }
}

computeFrictionFactor()

double TriInterWrapper1PhaseProblem::computeFrictionFactor ( Real  Re )

overrideprotectedvirtual

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

Upgraded Cheng-Todreas Correlation (2018).

Implements InterWrapper1PhaseProblem.

Definition at line 33 of file TriInterWrapper1PhaseProblem.C.

Referenced by computeDP().

{
  Real a, b;
  if (Re < 1)
  {
    return 64.0;
  }
  else if (Re >= 1 and Re < 5000)
  {
    a = 64.0;
    b = -1.0;
  }
  else if (Re >= 5000 and Re < 30000)
  {
    a = 0.316;
    b = -0.25;
  }
  else
  {
    a = 0.184;
    b = -0.20;
  }
  return a * std::pow(Re, b);
}

computeh()

void TriInterWrapper1PhaseProblem::computeh ( int  iblock )

overrideprotectedvirtual

computeMassFlowForDPDZ() and enforceUniformDPDZAtInlet() are overriden to define the sodium friction factor

Reimplemented from InterWrapper1PhaseProblem.

Definition at line 136 of file TriInterWrapper1PhaseProblem.C.

Referenced by 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);
      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);
    }
  }

  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];
    auto heated_length = _subchannel_mesh.getHeatedLength();
    auto unheated_length_entry = _subchannel_mesh.getHeatedLengthEntry();

    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++)
    {
      const Real & pitch = _subchannel_mesh.getPitch();
      const Real & assembly_diameter = _subchannel_mesh.getSideX();
      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 = ((*_q_prime_soln)(node_out) + (*_q_prime_soln)(node_in)) * dz / 2.0;
      else
        added_enthalpy = 0.0;

      // 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)
      {
        const Real & pitch = _subchannel_mesh.getPitch();
        const Real & assembly_diameter = _subchannel_mesh.getSideX();
        const Real & wire_lead_length = 0.0;
        const Real & wire_diameter = 0.0;
        auto gap = _tri_sch_mesh.getDuctToPinGap();
        auto w = assembly_diameter + gap;
        auto theta =
            std::acos(wire_lead_length /
                      std::sqrt(std::pow(wire_lead_length, 2) +
                                std::pow(libMesh::pi * (assembly_diameter + wire_diameter), 2)));
        // 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);
        auto cs_t = 0.75 * std::pow(wire_lead_length / assembly_diameter, 0.3);
        auto ar2 = libMesh::pi * (assembly_diameter + wire_diameter) * wire_diameter / 4.0;
        auto a2p = pitch * (w - assembly_diameter / 2.0) -
                   libMesh::pi * std::pow(assembly_diameter, 2) / 8.0;
        auto Sij_in = dz * gap;
        auto Sij_out = dz * gap;
        auto wsweep_in = gedge_ave * cs_t * std::pow((ar2 / a2p), 0.5) * std::tan(theta) * Sij_in;
        auto wsweep_out = gedge_ave * cs_t * std::pow((ar2 / a2p), 0.5) * std::tan(theta) * Sij_out;
        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 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(i_gap);
        auto thcon_i = _fp->k_from_p_T((*_P_soln)(node_in_i), (*_T_soln)(node_in_i));
        auto thcon_j = _fp->k_from_p_T((*_P_soln)(node_in_j), (*_T_soln)(node_in_j));
        auto shape_factor =
            0.66 * (pitch / assembly_diameter) *
            std::pow((_subchannel_mesh.getGapWidth(i_gap) / assembly_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), (*_T_soln)(node_in_i));
      auto thcon_j = _fp->k_from_p_T((*_P_soln)(node_in_j), (*_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), (*_T_soln)(node_in_i));
        auto thcon_j = _fp->k_from_p_T((*_P_soln)(node_in_j), (*_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)
      {
        mooseWarning(name(),
                     " : Calculation of negative Enthalpy h_out = : ",
                     h_out,
                     " Axial Level= : ",
                     iz);
      }
      _h_soln->set(node_out, h_out); // J/kg
    }
  }
}

computeInterpolatedValue()

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

protectedvirtualinherited

Definition at line 343 of file InterWrapper1PhaseProblem.C.

Referenced by InterWrapper1PhaseProblem::computeDP(), InterWrapper1PhaseProblem::computeh(), InterWrapper1PhaseProblem::computeP(), and InterWrapper1PhaseProblem::computeWij().

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

computeInterpolationCoefficients()

PetscScalar InterWrapper1PhaseProblem::computeInterpolationCoefficients ( PetscScalar  Peclet = 0.0 )

protectedvirtualinherited

Functions that computes the interpolation scheme given the Peclet number.

Definition at line 316 of file InterWrapper1PhaseProblem.C.

Referenced by InterWrapper1PhaseProblem::computeDP(), InterWrapper1PhaseProblem::computeh(), InterWrapper1PhaseProblem::computeInterpolatedValue(), InterWrapper1PhaseProblem::computeP(), and InterWrapper1PhaseProblem::computeWij().

{
  if (_interpolation_scheme == "upwind")
  {
    return 1.0;
  }
  else if (_interpolation_scheme == "downwind")
  {
    return 0.0;
  }
  else if (_interpolation_scheme == "central_difference")
  {
    return 0.5;
  }
  else if (_interpolation_scheme == "exponential")
  {
    return ((Peclet - 1.0) * std::exp(Peclet) + 1) / (Peclet * (std::exp(Peclet) - 1.) + 1e-10);
  }
  else
  {
    mooseError(name(),
               ": Interpolation scheme should be a string: upwind, downwind, central_difference, "
               "exponential");
  }
}

computeMdot()

void InterWrapper1PhaseProblem::computeMdot ( int  iblock )

protectedvirtualinherited

Computes mass flow per channel for block iblock.

Definition at line 566 of file InterWrapper1PhaseProblem.C.

Referenced by InterWrapper1PhaseProblem::implicitPetscSolve(), and InterWrapper1PhaseProblem::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));
    _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 InterWrapper1PhaseProblem::computeMu ( int  iblock )

protectedvirtualinherited

Computes Viscosity per channel for block iblock.

Definition at line 1937 of file InterWrapper1PhaseProblem.C.

Referenced by InterWrapper1PhaseProblem::externalSolve(), and 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 InterWrapper1PhaseProblem::computeP ( int  iblock )

protectedvirtualinherited

Computes Pressure per channel for block iblock.

Definition at line 1242 of file InterWrapper1PhaseProblem.C.

Referenced by InterWrapper1PhaseProblem::implicitPetscSolve(), and InterWrapper1PhaseProblem::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);

          // Creating matrix of coefficients and RHS vector
          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);

          // 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);
              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));
      _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 InterWrapper1PhaseProblem::computeRho ( int  iblock )

protectedvirtualinherited

Computes Density per channel for block iblock.

Definition at line 1912 of file InterWrapper1PhaseProblem.C.

Referenced by InterWrapper1PhaseProblem::externalSolve(), and 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 InterWrapper1PhaseProblem::computeSumWij ( int  iblock )

protectedvirtualinherited

Computes net diversion crossflow per channel for block iblock.

Definition at line 501 of file InterWrapper1PhaseProblem.C.

Referenced by InterWrapper1PhaseProblem::implicitPetscSolve(), and InterWrapper1PhaseProblem::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 implicit
  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 InterWrapper1PhaseProblem::computeT ( int  iblock )

protectedvirtualinherited

Computes Temperature per channel for block iblock.

Definition at line 1896 of file InterWrapper1PhaseProblem.C.

Referenced by InterWrapper1PhaseProblem::externalSolve(), and 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)));
    }
  }
}

computeWij()

void InterWrapper1PhaseProblem::computeWij ( int  iblock )

protectedvirtualinherited

Computes cross fluxes for block iblock.

Assembling system

Definition at line 1962 of file InterWrapper1PhaseProblem.C.

Referenced by InterWrapper1PhaseProblem::implicitPetscSolve(), and InterWrapper1PhaseProblem::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(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);
        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);

        // 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(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
        auto alpha = 0.0; // hard code downwind;
        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(0.5);

        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));
    _console << "Block: " << iblock << " - Cross flow system matrix assembled" << std::endl;
    _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));
    }
  }
}

computeWijFromSolve()

void InterWrapper1PhaseProblem::computeWijFromSolve ( int  iblock )

protectedvirtualinherited

Computes diversion crossflow per gap for block with index iblock Block is a partition of the whole domain.

Definition at line 468 of file InterWrapper1PhaseProblem.C.

Referenced by InterWrapper1PhaseProblem::externalSolve(), and 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 InterWrapper1PhaseProblem::computeWijPrime ( int  iblock )

protectedvirtualinherited

Computes turbulent crossflow per gap for block iblock.

Update turbulent crossflow

Definition at line 677 of file InterWrapper1PhaseProblem.C.

Referenced by InterWrapper1PhaseProblem::externalSolve(), InterWrapper1PhaseProblem::implicitPetscSolve(), and InterWrapper1PhaseProblem::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_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);
        // crossflow area between channels i,j (dz*gap_width)
        auto Sij = dz * _subchannel_mesh.getGapWidth(i_gap);
        // Calculation of Turbulent Crossflow
        _WijPrime(i_gap, iz) =
            _beta * 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)) *
            Sij;
      }
    }
  }
  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_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);
        // crossflow area between channels i,j (dz*gap_width)
        auto Sij = dz * _subchannel_mesh.getGapWidth(i_gap);

        // Base value - I don't want to write it every time
        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));
      }
    }
    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));
  }
}

createPetscMatrix()

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

protectedvirtualinherited

Definition at line 364 of file InterWrapper1PhaseProblem.C.

Referenced by InterWrapper1PhaseProblem::InterWrapper1PhaseProblem().

{
  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 InterWrapper1PhaseProblem::createPetscVector ( Vec &  v, PetscInt  n  )

protectedvirtualinherited

Petsc Functions.

Definition at line 352 of file InterWrapper1PhaseProblem.C.

Referenced by InterWrapper1PhaseProblem::computeWij(), InterWrapper1PhaseProblem::implicitPetscSolve(), and InterWrapper1PhaseProblem::InterWrapper1PhaseProblem().

{
  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 TriInterWrapper1PhaseProblem::externalSolve ( )

overrideprotectedvirtual

TODO: add a verbose print flag

Reimplemented from InterWrapper1PhaseProblem.

Definition at line 339 of file TriInterWrapper1PhaseProblem.C.

{
  initializeSolution();
  _console << "Executing subchannel solver\n";
  auto P_error = 1.0;
  unsigned int P_it = 0;
  unsigned int P_it_max = 2 * _n_blocks;
  if (_n_blocks == 1)
    P_it_max = 1;
  while (P_error > _P_tol && P_it < P_it_max)
  {
    P_it += 1;
    if (P_it == P_it_max and _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;
      auto 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();

        // computeWij(iblock);
        computeWijFromSolve(iblock);

        if (_compute_power)
        {
          computeh(iblock);

          computeT(iblock);
        }

        if (_compute_density)
          computeRho(iblock);

        if (_compute_viscosity)
          computeMu(iblock);

        // 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;
  }
  // update old crossflow matrix
  _Wij_old = _Wij;
  _console << "Finished executing subchannel solver\n";
  _aux->solution().close();

  auto power_in = 0.0;
  auto power_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);
    power_in += (*_mdot_soln)(node_in) * (*_h_soln)(node_in);
    power_out += (*_mdot_soln)(node_out) * (*_h_soln)(node_out);
  }

  auto Total_surface_area = 0.0;
  auto mass_flow_in = 0.0;
  auto 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);
    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);

  _console << " ======================================= " << std::endl;
  _console << " ======== Subchannel Print Outs ======== " << std::endl;
  _console << " ======================================= " << std::endl;
  _console << "Total Surface Area :" << Total_surface_area << " m^2" << 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 in: " << mass_flow_in << " kg/sec" << std::endl;
  _console << "Mass out: " << mass_flow_out << " kg/sec" << std::endl;
  _console << " ======================================= " << std::endl;
}

implicitPetscSolve()

PetscErrorCode InterWrapper1PhaseProblem::implicitPetscSolve ( int  iblock )

protectedvirtualinherited

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 2389 of file InterWrapper1PhaseProblem.C.

Referenced by InterWrapper1PhaseProblem::externalSolve().

{
  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
  computeWij(iblock);
  // If monolithic solve - Assembling enthalpy matrix
  if (_monolithic_thermal_bool)
    computeh(iblock);

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

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

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

  _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]));
    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]));
  }
  _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));
    _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);
    _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
    LibmeshPetscCall(VecSum(_Wij_loc_vec, &relax_factor));
    relax_factor /= _block_size * _n_gaps;
#endif
    relax_factor = relax_factor / _max_sumWij + 0.5;
    _console << "Relax base value: " << relax_factor << std::endl;

    PetscScalar resistance_relaxation = 0.9;
    _added_K = _max_sumWij / min_mdot;
    _console << "New cross resistance: " << _added_K << std::endl;
    _added_K = (_added_K * resistance_relaxation + (1.0 - resistance_relaxation) * _added_K_old) *
               relax_factor;
    _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;
    _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;

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

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

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

    _console << "Wij relaxed" << std::endl;
  }
  _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));
  _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));
  }
  _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]));
  }

  Vec sol_mdot, sol_p, sol_Wij;
  _console << "Vectors created." << std::endl;
  PetscInt num_vecs;
  Vec * loc_vecs;
  LibmeshPetscCall(VecNestGetSubVecs(x_nest, &num_vecs, &loc_vecs));
  _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));
  _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)
  {
    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));
  _console << "Maximum estimated Wij new: " << _max_sumWij_new << std::endl;
  _correction_factor = _max_sumWij_new / _max_sumWij;
  _console << "Correction factor: " << _correction_factor << std::endl;
  _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));
  _console << "Solutions destroyed." << std::endl;

  PetscFunctionReturn(LIBMESH_PETSC_SUCCESS);
}

initializeSolution()

void InterWrapper1PhaseProblem::initializeSolution ( )

protectedvirtualinherited

Function to initialize the solution fields.

Definition at line 2906 of file InterWrapper1PhaseProblem.C.

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

{
  unsigned int last_node = _n_cells;
  unsigned int first_node = 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_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));
    }
  }
  _mdot_soln->close();
}

initialSetup()

void InterWrapper1PhaseProblem::initialSetup ( )

overridevirtualinherited

Reimplemented from ExternalProblem.

Definition at line 226 of file InterWrapper1PhaseProblem.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));
  _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));
}

petscSnesSolver()

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

protectedvirtualinherited

Computes solution of nonlinear equation using snes.

Definition at line 2333 of file InterWrapper1PhaseProblem.C.

Referenced by InterWrapper1PhaseProblem::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
  problemInfo info;
  info.iblock = iblock;
  info.schp = this;
  LibmeshPetscCall(SNESSetFunction(snes, r, formFunctionIW, &info));

  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 InterWrapper1PhaseProblem::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 294 of file InterWrapper1PhaseProblem.h.

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

{
  PetscErrorCode ierr;
  PetscScalar * xx;

  PetscFunctionBegin;
  ierr = VecGetArray(x, &xx);
  CHKERRQ(ierr);
  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];
    }
  }
  ierr = VecRestoreArray(x, &xx);
  CHKERRQ(ierr);
  PetscFunctionReturn(LIBMESH_PETSC_SUCCESS);
}

populateSolutionChan()

template<class T >

PetscErrorCode InterWrapper1PhaseProblem::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 423 of file InterWrapper1PhaseProblem.C.

{
  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 InterWrapper1PhaseProblem::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 447 of file InterWrapper1PhaseProblem.C.

{
  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 InterWrapper1PhaseProblem::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 376 of file InterWrapper1PhaseProblem.C.

Referenced by InterWrapper1PhaseProblem::computeSumWij(), InterWrapper1PhaseProblem::computeWij(), and InterWrapper1PhaseProblem::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 InterWrapper1PhaseProblem::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 399 of file InterWrapper1PhaseProblem.C.

{
  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 > InterWrapper1PhaseProblem::residualFunction ( int  iblock, libMesh::DenseVector< Real >  solution  )

protectedvirtualinherited

Computes Residual per gap for block iblock.

Definition at line 2291 of file InterWrapper1PhaseProblem.C.

Referenced by formFunctionIW().

{
  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);
  // Solving cross fluxes
  computeWij(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 InterWrapper1PhaseProblem::solverSystemConverged ( const unsigned int  )

overridevirtualinherited

Reimplemented from ExternalProblem.

Definition at line 310 of file InterWrapper1PhaseProblem.C.

{
  return _converged;
}

syncSolutions()

void InterWrapper1PhaseProblem::syncSolutions ( Direction  direction )

overridevirtualinherited

Implements ExternalProblem.

Definition at line 3078 of file InterWrapper1PhaseProblem.C.

{
}

validParams()

InputParameters TriInterWrapper1PhaseProblem::validParams ( )

static

Definition at line 18 of file TriInterWrapper1PhaseProblem.C.

{
  InputParameters params = InterWrapper1PhaseProblem::validParams();
  params.addClassDescription(
      "Solver class for interwrapper of assemblies in a triangular-lattice arrangement");
  return params;
}

Member Data Documentation

_added_K

PetscScalar InterWrapper1PhaseProblem::_added_K = 0.0

protectedinherited

Added resistances for monolithic convergence.

Definition at line 282 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::implicitPetscSolve().

_added_K_old

PetscScalar InterWrapper1PhaseProblem::_added_K_old = 1000.0

protectedinherited

Definition at line 283 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::implicitPetscSolve().

_amc_advective_derivative_mat

Mat InterWrapper1PhaseProblem::_amc_advective_derivative_mat

protectedinherited

Axial momentum conservation - advective (Eulerian) derivative.

Definition at line 227 of file InterWrapper1PhaseProblem.h.

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

_amc_advective_derivative_rhs

Vec InterWrapper1PhaseProblem::_amc_advective_derivative_rhs

protectedinherited

Definition at line 228 of file InterWrapper1PhaseProblem.h.

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

_amc_cross_derivative_mat

Mat InterWrapper1PhaseProblem::_amc_cross_derivative_mat

protectedinherited

Axial momentum conservation - cross flux derivative.

Definition at line 230 of file InterWrapper1PhaseProblem.h.

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

_amc_cross_derivative_rhs

Vec InterWrapper1PhaseProblem::_amc_cross_derivative_rhs

protectedinherited

Definition at line 231 of file InterWrapper1PhaseProblem.h.

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

_amc_friction_force_mat

Mat InterWrapper1PhaseProblem::_amc_friction_force_mat

protectedinherited

Axial momentum conservation - friction force.

Definition at line 233 of file InterWrapper1PhaseProblem.h.

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

_amc_friction_force_rhs

Vec InterWrapper1PhaseProblem::_amc_friction_force_rhs

protectedinherited

Definition at line 234 of file InterWrapper1PhaseProblem.h.

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

_amc_gravity_rhs

Vec InterWrapper1PhaseProblem::_amc_gravity_rhs

protectedinherited

Axial momentum conservation - buoyancy force No implicit matrix.

Definition at line 237 of file InterWrapper1PhaseProblem.h.

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

_amc_pressure_force_mat

Mat InterWrapper1PhaseProblem::_amc_pressure_force_mat

protectedinherited

Axial momentum conservation - pressure force.

Definition at line 239 of file InterWrapper1PhaseProblem.h.

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

_amc_pressure_force_rhs

Vec InterWrapper1PhaseProblem::_amc_pressure_force_rhs

protectedinherited

Definition at line 240 of file InterWrapper1PhaseProblem.h.

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

_amc_sys_mdot_mat

Mat InterWrapper1PhaseProblem::_amc_sys_mdot_mat

protectedinherited

Axial momentum system matrix.

Definition at line 242 of file InterWrapper1PhaseProblem.h.

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

_amc_sys_mdot_rhs

Vec InterWrapper1PhaseProblem::_amc_sys_mdot_rhs

protectedinherited

Definition at line 243 of file InterWrapper1PhaseProblem.h.

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

_amc_time_derivative_mat

Mat InterWrapper1PhaseProblem::_amc_time_derivative_mat

protectedinherited

Axial momentum conservation - time derivative.

Definition at line 224 of file InterWrapper1PhaseProblem.h.

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

_amc_time_derivative_rhs

Vec InterWrapper1PhaseProblem::_amc_time_derivative_rhs

protectedinherited

Definition at line 225 of file InterWrapper1PhaseProblem.h.

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

_amc_turbulent_cross_flows_mat

Mat InterWrapper1PhaseProblem::_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 221 of file InterWrapper1PhaseProblem.h.

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

_amc_turbulent_cross_flows_rhs

Vec InterWrapper1PhaseProblem::_amc_turbulent_cross_flows_rhs

protectedinherited

Definition at line 222 of file InterWrapper1PhaseProblem.h.

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

_atol

const PetscReal& InterWrapper1PhaseProblem::_atol

protectedinherited

The absolute convergence tolerance for the ksp linear solver.

Definition at line 139 of file InterWrapper1PhaseProblem.h.

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

_beta

const Real& InterWrapper1PhaseProblem::_beta

protectedinherited

Thermal diffusion coefficient used in turbulent crossflow.

Definition at line 127 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::computeWijPrime().

_block_size

const unsigned int InterWrapper1PhaseProblem::_block_size

protectedinherited

Definition at line 106 of file InterWrapper1PhaseProblem.h.

Referenced by computeDP(), InterWrapper1PhaseProblem::computeDP(), computeh(), InterWrapper1PhaseProblem::computeh(), InterWrapper1PhaseProblem::computeMdot(), InterWrapper1PhaseProblem::computeMu(), InterWrapper1PhaseProblem::computeP(), InterWrapper1PhaseProblem::computeRho(), InterWrapper1PhaseProblem::computeSumWij(), InterWrapper1PhaseProblem::computeT(), InterWrapper1PhaseProblem::computeWij(), InterWrapper1PhaseProblem::computeWijFromSolve(), InterWrapper1PhaseProblem::computeWijPrime(), InterWrapper1PhaseProblem::externalSolve(), externalSolve(), InterWrapper1PhaseProblem::implicitPetscSolve(), InterWrapper1PhaseProblem::InterWrapper1PhaseProblem(), InterWrapper1PhaseProblem::petscSnesSolver(), and InterWrapper1PhaseProblem::residualFunction().

_cmc_advective_derivative_mat

Mat InterWrapper1PhaseProblem::_cmc_advective_derivative_mat

protectedinherited

Cross momentum conservation - advective (Eulerian) derivative.

Definition at line 250 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::cleanUp(), InterWrapper1PhaseProblem::computeWij(), and InterWrapper1PhaseProblem::InterWrapper1PhaseProblem().

_cmc_advective_derivative_rhs

Vec InterWrapper1PhaseProblem::_cmc_advective_derivative_rhs

protectedinherited

Definition at line 251 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::cleanUp(), InterWrapper1PhaseProblem::computeWij(), and InterWrapper1PhaseProblem::InterWrapper1PhaseProblem().

_cmc_friction_force_mat

Mat InterWrapper1PhaseProblem::_cmc_friction_force_mat

protectedinherited

Cross momentum conservation - friction force.

Definition at line 253 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::cleanUp(), InterWrapper1PhaseProblem::computeWij(), and InterWrapper1PhaseProblem::InterWrapper1PhaseProblem().

_cmc_friction_force_rhs

Vec InterWrapper1PhaseProblem::_cmc_friction_force_rhs

protectedinherited

Definition at line 254 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::cleanUp(), InterWrapper1PhaseProblem::computeWij(), and InterWrapper1PhaseProblem::InterWrapper1PhaseProblem().

_cmc_pressure_force_mat

Mat InterWrapper1PhaseProblem::_cmc_pressure_force_mat

protectedinherited

Cross momentum conservation - pressure force.

Definition at line 256 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::cleanUp(), InterWrapper1PhaseProblem::computeWij(), InterWrapper1PhaseProblem::implicitPetscSolve(), and InterWrapper1PhaseProblem::InterWrapper1PhaseProblem().

_cmc_pressure_force_rhs

Vec InterWrapper1PhaseProblem::_cmc_pressure_force_rhs

protectedinherited

Definition at line 257 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::cleanUp(), InterWrapper1PhaseProblem::computeWij(), InterWrapper1PhaseProblem::implicitPetscSolve(), and InterWrapper1PhaseProblem::InterWrapper1PhaseProblem().

_cmc_sys_Wij_mat

Mat InterWrapper1PhaseProblem::_cmc_sys_Wij_mat

protectedinherited

Lateral momentum system matrix.

Definition at line 259 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::cleanUp(), InterWrapper1PhaseProblem::computeWij(), InterWrapper1PhaseProblem::implicitPetscSolve(), and InterWrapper1PhaseProblem::InterWrapper1PhaseProblem().

_cmc_sys_Wij_rhs

Vec InterWrapper1PhaseProblem::_cmc_sys_Wij_rhs

protectedinherited

Definition at line 260 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::cleanUp(), InterWrapper1PhaseProblem::computeWij(), InterWrapper1PhaseProblem::implicitPetscSolve(), and InterWrapper1PhaseProblem::InterWrapper1PhaseProblem().

_cmc_time_derivative_mat

Mat InterWrapper1PhaseProblem::_cmc_time_derivative_mat

protectedinherited

Cross momentum Cross momentum conservation - time derivative.

Definition at line 247 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::cleanUp(), InterWrapper1PhaseProblem::computeWij(), and InterWrapper1PhaseProblem::InterWrapper1PhaseProblem().

_cmc_time_derivative_rhs

Vec InterWrapper1PhaseProblem::_cmc_time_derivative_rhs

protectedinherited

Definition at line 248 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::cleanUp(), InterWrapper1PhaseProblem::computeWij(), and InterWrapper1PhaseProblem::InterWrapper1PhaseProblem().

_cmc_Wij_channel_dummy

Vec InterWrapper1PhaseProblem::_cmc_Wij_channel_dummy

protectedinherited

Definition at line 261 of file InterWrapper1PhaseProblem.h.

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

_compute_density

const bool InterWrapper1PhaseProblem::_compute_density

protectedinherited

Flag that activates or deactivates the calculation of density.

Definition at line 113 of file InterWrapper1PhaseProblem.h.

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

_compute_power

const bool InterWrapper1PhaseProblem::_compute_power

protectedinherited

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

Definition at line 117 of file InterWrapper1PhaseProblem.h.

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

_compute_viscosity

const bool InterWrapper1PhaseProblem::_compute_viscosity

protectedinherited

Flag that activates or deactivates the calculation of viscosity.

Definition at line 115 of file InterWrapper1PhaseProblem.h.

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

_converged

bool InterWrapper1PhaseProblem::_converged

protectedinherited

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

Definition at line 121 of file InterWrapper1PhaseProblem.h.

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

_correction_factor

PetscScalar InterWrapper1PhaseProblem::_correction_factor = 1.0

protectedinherited

Definition at line 286 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::implicitPetscSolve().

_CT

const Real& InterWrapper1PhaseProblem::_CT

protectedinherited

Turbulent modeling parameter used in axial momentum equation.

Definition at line 129 of file InterWrapper1PhaseProblem.h.

Referenced by computeDP(), and InterWrapper1PhaseProblem::computeDP().

_DP_soln

std::unique_ptr<SolutionHandle> InterWrapper1PhaseProblem::_DP_soln

protectedinherited

Definition at line 160 of file InterWrapper1PhaseProblem.h.

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

_dpz_error

Real TriInterWrapper1PhaseProblem::_dpz_error

protected

average relative error in pressure drop of channels

Definition at line 37 of file TriInterWrapper1PhaseProblem.h.

_dt

const Real& InterWrapper1PhaseProblem::_dt

protectedinherited

Time step.

Definition at line 123 of file InterWrapper1PhaseProblem.h.

Referenced by computeDP(), InterWrapper1PhaseProblem::computeDP(), computeh(), InterWrapper1PhaseProblem::computeh(), InterWrapper1PhaseProblem::computeMdot(), and InterWrapper1PhaseProblem::computeWij().

_dtol

const PetscReal& InterWrapper1PhaseProblem::_dtol

protectedinherited

The divergence tolerance for the ksp linear solver.

Definition at line 141 of file InterWrapper1PhaseProblem.h.

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

_fp

const SinglePhaseFluidProperties* InterWrapper1PhaseProblem::_fp

protectedinherited

Solutions handles and link to TH tables properties.

Definition at line 156 of file InterWrapper1PhaseProblem.h.

Referenced by computeh(), InterWrapper1PhaseProblem::computeh(), InterWrapper1PhaseProblem::computeMu(), InterWrapper1PhaseProblem::computeRho(), InterWrapper1PhaseProblem::computeT(), InterWrapper1PhaseProblem::externalSolve(), externalSolve(), and InterWrapper1PhaseProblem::initialSetup().

_g_grav

const Real InterWrapper1PhaseProblem::_g_grav

protectedinherited

Definition at line 100 of file InterWrapper1PhaseProblem.h.

Referenced by computeDP(), and InterWrapper1PhaseProblem::computeDP().

_global_counter

PetscInt InterWrapper1PhaseProblem::_global_counter = 0

protectedinherited

No implicit matrix.

Definition at line 279 of file InterWrapper1PhaseProblem.h.

_h_soln

std::unique_ptr<SolutionHandle> InterWrapper1PhaseProblem::_h_soln

protectedinherited

Definition at line 161 of file InterWrapper1PhaseProblem.h.

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

_hc_added_heat_rhs

Vec InterWrapper1PhaseProblem::_hc_added_heat_rhs

protectedinherited

Enthalpy conservation - source and sink.

Definition at line 274 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::cleanUp(), InterWrapper1PhaseProblem::computeh(), and InterWrapper1PhaseProblem::InterWrapper1PhaseProblem().

_hc_advective_derivative_mat

Mat InterWrapper1PhaseProblem::_hc_advective_derivative_mat

protectedinherited

Enthalpy conservation - advective (Eulerian) derivative;.

Definition at line 268 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::cleanUp(), InterWrapper1PhaseProblem::computeh(), and InterWrapper1PhaseProblem::InterWrapper1PhaseProblem().

_hc_advective_derivative_rhs

Vec InterWrapper1PhaseProblem::_hc_advective_derivative_rhs

protectedinherited

Definition at line 269 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::cleanUp(), InterWrapper1PhaseProblem::computeh(), and InterWrapper1PhaseProblem::InterWrapper1PhaseProblem().

_hc_cross_derivative_mat

Mat InterWrapper1PhaseProblem::_hc_cross_derivative_mat

protectedinherited

Enthalpy conservation - cross flux derivative.

Definition at line 271 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::cleanUp(), InterWrapper1PhaseProblem::computeh(), and InterWrapper1PhaseProblem::InterWrapper1PhaseProblem().

_hc_cross_derivative_rhs

Vec InterWrapper1PhaseProblem::_hc_cross_derivative_rhs

protectedinherited

Definition at line 272 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::cleanUp(), InterWrapper1PhaseProblem::computeh(), and InterWrapper1PhaseProblem::InterWrapper1PhaseProblem().

_hc_sys_h_mat

Mat InterWrapper1PhaseProblem::_hc_sys_h_mat

protectedinherited

System matrices.

Definition at line 276 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::cleanUp(), InterWrapper1PhaseProblem::computeh(), InterWrapper1PhaseProblem::implicitPetscSolve(), and InterWrapper1PhaseProblem::InterWrapper1PhaseProblem().

_hc_sys_h_rhs

Vec InterWrapper1PhaseProblem::_hc_sys_h_rhs

protectedinherited

Definition at line 277 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::cleanUp(), InterWrapper1PhaseProblem::computeh(), InterWrapper1PhaseProblem::implicitPetscSolve(), and InterWrapper1PhaseProblem::InterWrapper1PhaseProblem().

_hc_time_derivative_mat

Mat InterWrapper1PhaseProblem::_hc_time_derivative_mat

protectedinherited

Enthalpy Enthalpy conservation - time derivative.

Definition at line 265 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::cleanUp(), InterWrapper1PhaseProblem::computeh(), and InterWrapper1PhaseProblem::InterWrapper1PhaseProblem().

_hc_time_derivative_rhs

Vec InterWrapper1PhaseProblem::_hc_time_derivative_rhs

protectedinherited

Definition at line 266 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::cleanUp(), InterWrapper1PhaseProblem::computeh(), and InterWrapper1PhaseProblem::InterWrapper1PhaseProblem().

_implicit_bool

const bool InterWrapper1PhaseProblem::_implicit_bool

protectedinherited

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

Definition at line 147 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::computeDP(), InterWrapper1PhaseProblem::computeh(), InterWrapper1PhaseProblem::computeMdot(), InterWrapper1PhaseProblem::computeP(), InterWrapper1PhaseProblem::computeSumWij(), InterWrapper1PhaseProblem::computeWij(), InterWrapper1PhaseProblem::computeWijPrime(), and InterWrapper1PhaseProblem::InterWrapper1PhaseProblem().

_interpolation_scheme

const MooseEnum InterWrapper1PhaseProblem::_interpolation_scheme

protectedinherited

The interpolation method used in constructing the systems.

Definition at line 145 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::computeInterpolationCoefficients().

_kij

const Real& InterWrapper1PhaseProblem::_kij

protectedinherited

Definition at line 101 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::computeWij().

_max_sumWij

PetscScalar InterWrapper1PhaseProblem::_max_sumWij

protectedinherited

Definition at line 284 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::implicitPetscSolve().

_max_sumWij_new

PetscScalar InterWrapper1PhaseProblem::_max_sumWij_new

protectedinherited

Definition at line 285 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::implicitPetscSolve().

_maxit

const PetscInt& InterWrapper1PhaseProblem::_maxit

protectedinherited

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

Definition at line 143 of file InterWrapper1PhaseProblem.h.

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

_mc_axial_convection_mat

Mat InterWrapper1PhaseProblem::_mc_axial_convection_mat

protectedinherited

Mass conservation - axial convection.

Definition at line 214 of file InterWrapper1PhaseProblem.h.

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

_mc_axial_convection_rhs

Vec InterWrapper1PhaseProblem::_mc_axial_convection_rhs

protectedinherited

Definition at line 215 of file InterWrapper1PhaseProblem.h.

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

_mc_sumWij_mat

Mat InterWrapper1PhaseProblem::_mc_sumWij_mat

protectedinherited

Mass conservation Mass conservation - sum of cross fluxes.

Definition at line 209 of file InterWrapper1PhaseProblem.h.

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

_mdot_soln

std::unique_ptr<SolutionHandle> InterWrapper1PhaseProblem::_mdot_soln

protectedinherited

Definition at line 157 of file InterWrapper1PhaseProblem.h.

Referenced by computeDP(), InterWrapper1PhaseProblem::computeDP(), InterWrapper1PhaseProblem::computeMdot(), InterWrapper1PhaseProblem::computeWij(), InterWrapper1PhaseProblem::computeWijPrime(), InterWrapper1PhaseProblem::implicitPetscSolve(), InterWrapper1PhaseProblem::initializeSolution(), and InterWrapper1PhaseProblem::initialSetup().

_monolithic_thermal_bool

const bool InterWrapper1PhaseProblem::_monolithic_thermal_bool

protectedinherited

Thermal monolithic bool.

Definition at line 153 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::externalSolve(), and InterWrapper1PhaseProblem::implicitPetscSolve().

_mu_soln

std::unique_ptr<SolutionHandle> InterWrapper1PhaseProblem::_mu_soln

protectedinherited

Definition at line 165 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::computeMu(), and InterWrapper1PhaseProblem::initialSetup().

_n_assemblies

const unsigned int InterWrapper1PhaseProblem::_n_assemblies

protectedinherited

Definition at line 104 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::externalSolve().

_n_blocks

unsigned int InterWrapper1PhaseProblem::_n_blocks

protectedinherited

number of axial blocks

Definition at line 95 of file InterWrapper1PhaseProblem.h.

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

_n_cells

const unsigned int InterWrapper1PhaseProblem::_n_cells

protectedinherited

Definition at line 102 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::externalSolve(), externalSolve(), InterWrapper1PhaseProblem::initializeSolution(), and InterWrapper1PhaseProblem::InterWrapper1PhaseProblem().

_n_channels

const unsigned int InterWrapper1PhaseProblem::_n_channels

protectedinherited

Definition at line 105 of file InterWrapper1PhaseProblem.h.

Referenced by computeDP(), InterWrapper1PhaseProblem::computeDP(), computeh(), InterWrapper1PhaseProblem::computeh(), InterWrapper1PhaseProblem::computeMdot(), InterWrapper1PhaseProblem::computeMu(), InterWrapper1PhaseProblem::computeP(), InterWrapper1PhaseProblem::computeRho(), InterWrapper1PhaseProblem::computeSumWij(), InterWrapper1PhaseProblem::computeT(), InterWrapper1PhaseProblem::computeWij(), InterWrapper1PhaseProblem::computeWijPrime(), InterWrapper1PhaseProblem::externalSolve(), externalSolve(), InterWrapper1PhaseProblem::implicitPetscSolve(), InterWrapper1PhaseProblem::initializeSolution(), and InterWrapper1PhaseProblem::InterWrapper1PhaseProblem().

_n_gaps

const unsigned int InterWrapper1PhaseProblem::_n_gaps

protectedinherited

Definition at line 103 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::computeSumWij(), InterWrapper1PhaseProblem::computeWij(), InterWrapper1PhaseProblem::computeWijFromSolve(), InterWrapper1PhaseProblem::computeWijPrime(), InterWrapper1PhaseProblem::implicitPetscSolve(), InterWrapper1PhaseProblem::InterWrapper1PhaseProblem(), InterWrapper1PhaseProblem::petscSnesSolver(), and InterWrapper1PhaseProblem::residualFunction().

_one

Real InterWrapper1PhaseProblem::_one

protectedinherited

Definition at line 109 of file InterWrapper1PhaseProblem.h.

_P_out

const Real& InterWrapper1PhaseProblem::_P_out

protectedinherited

Outlet Pressure.

Definition at line 125 of file InterWrapper1PhaseProblem.h.

Referenced by computeh(), InterWrapper1PhaseProblem::computeh(), InterWrapper1PhaseProblem::computeMu(), InterWrapper1PhaseProblem::computeRho(), InterWrapper1PhaseProblem::computeT(), InterWrapper1PhaseProblem::externalSolve(), and externalSolve().

_P_soln

std::unique_ptr<SolutionHandle> InterWrapper1PhaseProblem::_P_soln

protectedinherited

Definition at line 159 of file InterWrapper1PhaseProblem.h.

Referenced by computeh(), InterWrapper1PhaseProblem::computeh(), InterWrapper1PhaseProblem::computeMu(), InterWrapper1PhaseProblem::computeP(), InterWrapper1PhaseProblem::computeRho(), InterWrapper1PhaseProblem::computeT(), InterWrapper1PhaseProblem::computeWij(), InterWrapper1PhaseProblem::externalSolve(), externalSolve(), InterWrapper1PhaseProblem::implicitPetscSolve(), and InterWrapper1PhaseProblem::initialSetup().

_P_tol

const Real& InterWrapper1PhaseProblem::_P_tol

protectedinherited

Convergence tolerance for the pressure loop in external solve.

Definition at line 131 of file InterWrapper1PhaseProblem.h.

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

_pin_mesh_exist

const bool InterWrapper1PhaseProblem::_pin_mesh_exist

protectedinherited

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

Definition at line 119 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::computeAddedHeat(), InterWrapper1PhaseProblem::externalSolve(), and InterWrapper1PhaseProblem::initialSetup().

_prod

Vec InterWrapper1PhaseProblem::_prod

protectedinherited

Definition at line 211 of file InterWrapper1PhaseProblem.h.

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

_prodp

Vec InterWrapper1PhaseProblem::_prodp

protectedinherited

Definition at line 212 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::cleanUp(), InterWrapper1PhaseProblem::computeWij(), InterWrapper1PhaseProblem::implicitPetscSolve(), and InterWrapper1PhaseProblem::InterWrapper1PhaseProblem().

_q_prime_soln

std::unique_ptr<SolutionHandle> InterWrapper1PhaseProblem::_q_prime_soln

protectedinherited

Definition at line 168 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::computeAddedHeat(), computeh(), and InterWrapper1PhaseProblem::initialSetup().

_rho_soln

std::unique_ptr<SolutionHandle> InterWrapper1PhaseProblem::_rho_soln

protectedinherited

Definition at line 164 of file InterWrapper1PhaseProblem.h.

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

_rtol

const PetscReal& InterWrapper1PhaseProblem::_rtol

protectedinherited

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

Definition at line 137 of file InterWrapper1PhaseProblem.h.

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

_S_flow_soln

std::unique_ptr<SolutionHandle> InterWrapper1PhaseProblem::_S_flow_soln

protectedinherited

Definition at line 166 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::computeDP(), and InterWrapper1PhaseProblem::initialSetup().

_segregated_bool

const bool InterWrapper1PhaseProblem::_segregated_bool

protectedinherited

Segregated solve.

Definition at line 151 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::computeDP(), InterWrapper1PhaseProblem::computeh(), InterWrapper1PhaseProblem::computeMdot(), InterWrapper1PhaseProblem::computeP(), InterWrapper1PhaseProblem::computeSumWij(), InterWrapper1PhaseProblem::computeWij(), and InterWrapper1PhaseProblem::externalSolve().

_staggered_pressure_bool

const bool InterWrapper1PhaseProblem::_staggered_pressure_bool

protectedinherited

Flag to define the usage of staggered or collocated pressure.

Definition at line 149 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::computeP(), and InterWrapper1PhaseProblem::computeWij().

_subchannel_mesh

const InterWrapperMesh& InterWrapper1PhaseProblem::_subchannel_mesh

protectedinherited

Definition at line 93 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::computeAddedHeat(), computeDP(), InterWrapper1PhaseProblem::computeDP(), computeh(), InterWrapper1PhaseProblem::computeh(), InterWrapper1PhaseProblem::computeMdot(), InterWrapper1PhaseProblem::computeMu(), InterWrapper1PhaseProblem::computeP(), InterWrapper1PhaseProblem::computeRho(), InterWrapper1PhaseProblem::computeSumWij(), InterWrapper1PhaseProblem::computeT(), InterWrapper1PhaseProblem::computeWij(), InterWrapper1PhaseProblem::computeWijPrime(), InterWrapper1PhaseProblem::externalSolve(), externalSolve(), InterWrapper1PhaseProblem::implicitPetscSolve(), InterWrapper1PhaseProblem::initializeSolution(), InterWrapper1PhaseProblem::populateSolutionChan(), and InterWrapper1PhaseProblem::populateVectorFromHandle().

_SumWij_soln

std::unique_ptr<SolutionHandle> InterWrapper1PhaseProblem::_SumWij_soln

protectedinherited

Definition at line 158 of file InterWrapper1PhaseProblem.h.

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

_T_maxit

const int& InterWrapper1PhaseProblem::_T_maxit

protectedinherited

Maximum iterations for the inner temperature loop.

Definition at line 135 of file InterWrapper1PhaseProblem.h.

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

_T_soln

std::unique_ptr<SolutionHandle> InterWrapper1PhaseProblem::_T_soln

protectedinherited

Definition at line 162 of file InterWrapper1PhaseProblem.h.

Referenced by computeh(), InterWrapper1PhaseProblem::computeh(), InterWrapper1PhaseProblem::computeMu(), InterWrapper1PhaseProblem::computeRho(), InterWrapper1PhaseProblem::computeT(), InterWrapper1PhaseProblem::externalSolve(), externalSolve(), and InterWrapper1PhaseProblem::initialSetup().

_T_tol

const Real& InterWrapper1PhaseProblem::_T_tol

protectedinherited

Convergence tolerance for the temperature loop in external solve.

Definition at line 133 of file InterWrapper1PhaseProblem.h.

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

_Tpin_soln

std::unique_ptr<SolutionHandle> InterWrapper1PhaseProblem::_Tpin_soln

protectedinherited

Definition at line 163 of file InterWrapper1PhaseProblem.h.

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

_TR

Real InterWrapper1PhaseProblem::_TR

protectedinherited

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

Definition at line 111 of file InterWrapper1PhaseProblem.h.

Referenced by computeDP(), InterWrapper1PhaseProblem::computeDP(), computeh(), InterWrapper1PhaseProblem::computeh(), InterWrapper1PhaseProblem::computeMdot(), and InterWrapper1PhaseProblem::computeWij().

_tri_sch_mesh

const TriInterWrapperMesh& TriInterWrapper1PhaseProblem::_tri_sch_mesh

protected

Definition at line 38 of file TriInterWrapper1PhaseProblem.h.

Referenced by computeh().

_w_perim_soln

std::unique_ptr<SolutionHandle> InterWrapper1PhaseProblem::_w_perim_soln

protectedinherited

Definition at line 167 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::initialSetup().

_Wij

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

protectedinherited

Definition at line 96 of file InterWrapper1PhaseProblem.h.

Referenced by computeDP(), InterWrapper1PhaseProblem::computeDP(), computeh(), InterWrapper1PhaseProblem::computeh(), InterWrapper1PhaseProblem::computeMdot(), InterWrapper1PhaseProblem::computeSumWij(), InterWrapper1PhaseProblem::computeWij(), InterWrapper1PhaseProblem::computeWijFromSolve(), InterWrapper1PhaseProblem::externalSolve(), externalSolve(), InterWrapper1PhaseProblem::implicitPetscSolve(), InterWrapper1PhaseProblem::InterWrapper1PhaseProblem(), and InterWrapper1PhaseProblem::residualFunction().

_Wij_old

libMesh::DenseMatrix<Real> InterWrapper1PhaseProblem::_Wij_old

protectedinherited

Definition at line 97 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::computeWij(), InterWrapper1PhaseProblem::externalSolve(), externalSolve(), InterWrapper1PhaseProblem::implicitPetscSolve(), and InterWrapper1PhaseProblem::InterWrapper1PhaseProblem().

_Wij_residual_matrix

libMesh::DenseMatrix<Real> InterWrapper1PhaseProblem::_Wij_residual_matrix

protectedinherited

Definition at line 99 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::computeWij(), InterWrapper1PhaseProblem::InterWrapper1PhaseProblem(), and InterWrapper1PhaseProblem::residualFunction().

_Wij_vec

Vec InterWrapper1PhaseProblem::_Wij_vec

protectedinherited

Definition at line 210 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::cleanUp(), InterWrapper1PhaseProblem::computeSumWij(), InterWrapper1PhaseProblem::computeWij(), InterWrapper1PhaseProblem::computeWijPrime(), InterWrapper1PhaseProblem::implicitPetscSolve(), and InterWrapper1PhaseProblem::InterWrapper1PhaseProblem().

_WijPrime

libMesh::DenseMatrix<Real> InterWrapper1PhaseProblem::_WijPrime

protectedinherited

Definition at line 98 of file InterWrapper1PhaseProblem.h.

Referenced by computeDP(), InterWrapper1PhaseProblem::computeDP(), computeh(), InterWrapper1PhaseProblem::computeh(), InterWrapper1PhaseProblem::computeWijPrime(), and InterWrapper1PhaseProblem::InterWrapper1PhaseProblem().

_z_grid

std::vector<Real> InterWrapper1PhaseProblem::_z_grid

protectedinherited

axial location of nodes

Definition at line 108 of file InterWrapper1PhaseProblem.h.

Referenced by InterWrapper1PhaseProblem::computeAddedHeat(), InterWrapper1PhaseProblem::computeDP(), InterWrapper1PhaseProblem::computeh(), InterWrapper1PhaseProblem::computeMdot(), InterWrapper1PhaseProblem::computeWij(), and InterWrapper1PhaseProblem::computeWijPrime().

---

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

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