Specialization of FEProblem to run with component subsystem. More...

#include <THMProblem.h>

Inheritance diagram for THMProblem:

Public Types
enum	CoverageCheckMode

typedef DataFileName	DataFileParameterType

Public Member Functions
	THMProblem (const InputParameters &parameters)

virtual void	advanceState () override

virtual void	copySolutionsBackwards () override

virtual bool	hasPostprocessor (const std::string &name) const
	Check if a postprocessor with a given name exists in the simulation.

virtual bool	getUseNonlinear () const

virtual void	setUseNonlinear (bool use_nonlinear)

virtual void	setInputParametersFEProblem (InputParameters &parameters) override

virtual NonlinearSystem &	getNonlinearSystem (const unsigned int nl_sys_num) override

virtual void	addLineSearch (const InputParameters &parameters) override

virtual void	init () override

bool	initialized () const

virtual libMesh::EquationSystems &	es () override

virtual MooseMesh &	mesh () override

virtual const MooseMesh &	mesh () const override

const MooseMesh &	mesh (bool use_displaced) const override

MooseMesh &	mesh (bool use_displaced)

void	setCoordSystem (const std::vector< SubdomainName > &blocks, const MultiMooseEnum &coord_sys)

void	setAxisymmetricCoordAxis (const MooseEnum &rz_coord_axis)

void	setCoupling (Moose::CouplingType type)

Moose::CouplingType	coupling () const

void	setCouplingMatrix (std::unique_ptr< libMesh::CouplingMatrix > cm, const unsigned int nl_sys_num)

void	setCouplingMatrix (libMesh::CouplingMatrix *cm, const unsigned int nl_sys_num)

const libMesh::CouplingMatrix *	couplingMatrix (const unsigned int nl_sys_num) const override

void	setNonlocalCouplingMatrix ()

bool	areCoupled (const unsigned int ivar, const unsigned int jvar, const unsigned int nl_sys_num) const

bool	hasUOAuxStateCheck () const

bool	checkingUOAuxState () const

virtual bool	checkResidualForNans () const override

void	setCheckResidualForNans (bool check_residual_for_nans)

void	trustUserCouplingMatrix ()

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

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

virtual bool	hasVariable (const std::string &var_name) const override

bool	hasSolverVariable (const std::string &var_name) const

virtual const MooseVariableFieldBase &	getVariable (const THREAD_ID tid, const std::string &var_name, Moose::VarKindType expected_var_type=Moose::VarKindType::VAR_ANY, Moose::VarFieldType expected_var_field_type=Moose::VarFieldType::VAR_FIELD_ANY) const override

virtual const MooseVariableFieldBase &	getVariable (const THREAD_ID tid, const std::string &var_name, Moose::VarKindType expected_var_type=Moose::VarKindType::VAR_ANY, Moose::VarFieldType expected_var_field_type=Moose::VarFieldType::VAR_FIELD_ANY) const =0

virtual MooseVariableFieldBase &	getVariable (const THREAD_ID tid, const std::string &var_name, Moose::VarKindType expected_var_type=Moose::VarKindType::VAR_ANY, Moose::VarFieldType expected_var_field_type=Moose::VarFieldType::VAR_FIELD_ANY)

MooseVariableFieldBase &	getActualFieldVariable (const THREAD_ID tid, const std::string &var_name) override

virtual MooseVariable &	getStandardVariable (const THREAD_ID tid, const std::string &var_name) override

virtual VectorMooseVariable &	getVectorVariable (const THREAD_ID tid, const std::string &var_name) override

virtual ArrayMooseVariable &	getArrayVariable (const THREAD_ID tid, const std::string &var_name) override

virtual bool	hasScalarVariable (const std::string &var_name) const override

virtual MooseVariableScalar &	getScalarVariable (const THREAD_ID tid, const std::string &var_name) override

virtual libMesh::System &	getSystem (const std::string &var_name) override

const RestartableEquationSystems &	getRestartableEquationSystems () const

virtual void	setActiveElementalMooseVariables (const std::set< MooseVariableFEBase * > &moose_vars, const THREAD_ID tid) override

virtual void	clearActiveElementalMooseVariables (const THREAD_ID tid) override

virtual void	clearActiveFEVariableCoupleableMatrixTags (const THREAD_ID tid) override

virtual void	clearActiveFEVariableCoupleableVectorTags (const THREAD_ID tid) override

virtual void	setActiveFEVariableCoupleableVectorTags (std::set< TagID > &vtags, const THREAD_ID tid) override

virtual void	setActiveFEVariableCoupleableMatrixTags (std::set< TagID > &mtags, const THREAD_ID tid) override

virtual void	clearActiveScalarVariableCoupleableMatrixTags (const THREAD_ID tid) override

virtual void	clearActiveScalarVariableCoupleableVectorTags (const THREAD_ID tid) override

virtual void	setActiveScalarVariableCoupleableVectorTags (std::set< TagID > &vtags, const THREAD_ID tid) override

virtual void	setActiveScalarVariableCoupleableMatrixTags (std::set< TagID > &mtags, const THREAD_ID tid) override

virtual void	createQRules (libMesh::QuadratureType type, libMesh::Order order, libMesh::Order volume_order=libMesh::INVALID_ORDER, libMesh::Order face_order=libMesh::INVALID_ORDER, SubdomainID block=Moose::ANY_BLOCK_ID, bool allow_negative_qweights=true)

void	bumpVolumeQRuleOrder (libMesh::Order order, SubdomainID block)

void	bumpAllQRuleOrder (libMesh::Order order, SubdomainID block)

unsigned int	getMaxQps () const

libMesh::Order	getMaxScalarOrder () const

void	checkNonlocalCoupling ()

void	checkUserObjectJacobianRequirement (THREAD_ID tid)

void	setVariableAllDoFMap (const std::vector< const MooseVariableFEBase * > &moose_vars)

const std::vector< const MooseVariableFEBase * > &	getUserObjectJacobianVariables (const THREAD_ID tid) const

virtual Assembly &	assembly (const THREAD_ID tid, const unsigned int sys_num) override

virtual const Assembly &	assembly (const THREAD_ID tid, const unsigned int sys_num) const override

Moose::Kokkos::Assembly &	kokkosAssembly ()

const Moose::Kokkos::Assembly &	kokkosAssembly () const

virtual std::vector< VariableName >	getVariableNames ()

void	initialSetup () override

void	checkDuplicatePostprocessorVariableNames ()

void	timestepSetup () override

void	customSetup (const ExecFlagType &exec_type) override

void	residualSetup () override

void	jacobianSetup () override

virtual void	prepare (const Elem *elem, const THREAD_ID tid) override

virtual void	prepare (const Elem *elem, unsigned int ivar, unsigned int jvar, const std::vector< dof_id_type > &dof_indices, const THREAD_ID tid) override

virtual void	prepareFace (const Elem *elem, const THREAD_ID tid) override

virtual void	setCurrentSubdomainID (const Elem *elem, const THREAD_ID tid) override

virtual void	setNeighborSubdomainID (const Elem *elem, unsigned int side, const THREAD_ID tid) override

virtual void	setNeighborSubdomainID (const Elem *elem, const THREAD_ID tid)

virtual void	prepareAssembly (const THREAD_ID tid) override

virtual void	prepareAssemblyNeighbor (const THREAD_ID tid)

virtual void	addGhostedElem (dof_id_type elem_id) override

virtual void	addGhostedBoundary (BoundaryID boundary_id) override

virtual void	ghostGhostedBoundaries () override

virtual void	sizeZeroes (unsigned int size, const THREAD_ID tid)

virtual bool	reinitDirac (const Elem *elem, const THREAD_ID tid) override

virtual void	reinitElem (const Elem *elem, const THREAD_ID tid) override

virtual void	reinitElemPhys (const Elem *elem, const std::vector< Point > &phys_points_in_elem, const THREAD_ID tid) override

void	reinitElemFace (const Elem *elem, unsigned int side, BoundaryID, const THREAD_ID tid)

virtual void	reinitElemFace (const Elem *elem, unsigned int side, const THREAD_ID tid) override

virtual void	reinitLowerDElem (const Elem lower_d_elem, const THREAD_ID tid, const std::vector< Point > const pts=nullptr, const std::vector< Real > *const weights=nullptr) override

virtual void	reinitNode (const Node *node, const THREAD_ID tid) override

virtual void	reinitNodeFace (const Node *node, BoundaryID bnd_id, const THREAD_ID tid) override

virtual void	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	solve (const unsigned int nl_sys_num)

void	initKokkos ()

virtual void	solveLinearSystem (const unsigned int linear_sys_num, const Moose::PetscSupport::PetscOptions *po=nullptr)

virtual void	setException (const std::string &message)

virtual bool	hasException ()

virtual void	checkExceptionAndStopSolve (bool print_message=true)

virtual bool	solverSystemConverged (const unsigned int solver_sys_num) override

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)

void	skipNextForwardSolutionCopyToOld ()

virtual void	restoreSolutions ()

virtual void	saveOldSolutions ()

virtual void	restoreOldSolutions ()

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

bool	hasSolutionState (unsigned int state, Moose::SolutionIterationType iteration_type) const

virtual void	outputStep (ExecFlagType type)

virtual void	postExecute ()

void	forceOutput ()

virtual void	initPetscOutputAndSomeSolverSettings ()

Moose::PetscSupport::PetscOptions &	getPetscOptions ()

void	logAdd (const std::string &system, const std::string &name, const std::string &type, const InputParameters &params) const

virtual void	addFunction (const std::string &type, const std::string &name, InputParameters &parameters)

virtual bool	hasFunction (const std::string &name, const THREAD_ID tid=0)

virtual Function &	getFunction (const std::string &name, const THREAD_ID tid=0)

virtual void	addKokkosFunction (const std::string &type, const std::string &name, InputParameters &parameters)

virtual bool	hasKokkosFunction (const std::string &name) const

virtual Moose::Kokkos::Function	getKokkosFunction (const std::string &name)

T &	getKokkosFunction (const std::string &name)

virtual void	addMeshDivision (const std::string &type, const std::string &name, InputParameters &params)

MeshDivision &	getMeshDivision (const std::string &name, const THREAD_ID tid=0) const

virtual void	addConvergence (const std::string &type, const std::string &name, InputParameters &parameters)

virtual Convergence &	getConvergence (const std::string &name, const THREAD_ID tid=0) const

virtual const std::vector< std::shared_ptr< Convergence > > &	getConvergenceObjects (const THREAD_ID tid=0) const

virtual bool	hasConvergence (const std::string &name, const THREAD_ID tid=0) const

bool	needToAddDefaultNonlinearConvergence () const

bool	needToAddDefaultMultiAppFixedPointConvergence () const

bool	needToAddDefaultSteadyStateConvergence () const

void	setNeedToAddDefaultNonlinearConvergence ()

void	setNeedToAddDefaultMultiAppFixedPointConvergence ()

void	setNeedToAddDefaultSteadyStateConvergence ()

bool	hasSetMultiAppFixedPointConvergenceName () const

bool	hasSetSteadyStateConvergenceName () const

virtual void	addDefaultNonlinearConvergence (const InputParameters &params)

virtual bool	onlyAllowDefaultNonlinearConvergence () const

void	addDefaultMultiAppFixedPointConvergence (const InputParameters &params)

void	addDefaultSteadyStateConvergence (const InputParameters &params)

virtual void	lineSearch ()

LineSearch *	getLineSearch () override

virtual void	addDistribution (const std::string &type, const std::string &name, InputParameters &parameters)

virtual bool	hasDistribution (const std::string &name) const

virtual Distribution &	getDistribution (const std::string &name)

virtual void	addSampler (const std::string &type, const std::string &name, InputParameters &parameters)

virtual Sampler &	getSampler (const std::string &name, const THREAD_ID tid=0)

NonlinearSystemBase &	getNonlinearSystemBase (const unsigned int sys_num)

const NonlinearSystemBase &	getNonlinearSystemBase (const unsigned int sys_num) const

void	setCurrentNonlinearSystem (const unsigned int nl_sys_num)

NonlinearSystemBase &	currentNonlinearSystem ()

const NonlinearSystemBase &	currentNonlinearSystem () const

virtual const SystemBase &	systemBaseNonlinear (const unsigned int sys_num) const override

virtual SystemBase &	systemBaseNonlinear (const unsigned int sys_num) override

virtual const SystemBase &	systemBaseSolver (const unsigned int sys_num) const override

virtual SystemBase &	systemBaseSolver (const unsigned int sys_num) override

virtual const SystemBase &	systemBaseAuxiliary () const override

virtual SystemBase &	systemBaseAuxiliary () override

virtual const SystemBase &	getSystemBase (const unsigned int sys_num) const

virtual SystemBase &	getSystemBase (const unsigned int sys_num)

SystemBase &	getSystemBase (const std::string &sys_name)

LinearSystem &	getLinearSystem (unsigned int sys_num)

const LinearSystem &	getLinearSystem (unsigned int sys_num) const

SolverSystem &	getSolverSystem (unsigned int sys_num)

const SolverSystem &	getSolverSystem (unsigned int sys_num) const

void	setCurrentLinearSystem (unsigned int sys_num)

LinearSystem &	currentLinearSystem ()

const LinearSystem &	currentLinearSystem () const

virtual const SystemBase &	systemBaseLinear (unsigned int sys_num) const override

virtual SystemBase &	systemBaseLinear (unsigned int sys_num) override

virtual void	addVariable (const std::string &var_type, const std::string &var_name, InputParameters &params)

virtual void	addKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)

virtual void	addHDGKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)

virtual void	addNodalKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)

virtual void	addScalarKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)

virtual void	addBoundaryCondition (const std::string &bc_name, const std::string &name, InputParameters &parameters)

virtual void	addKokkosKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)

virtual void	addKokkosNodalKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)

virtual void	addKokkosBoundaryCondition (const std::string &bc_name, const std::string &name, InputParameters &parameters)

virtual void	addKokkosLinearFVKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)

virtual void	addKokkosLinearFVBC (const std::string &bc_name, const std::string &name, InputParameters &parameters)

virtual void	addConstraint (const std::string &c_name, const std::string &name, InputParameters &parameters)

virtual void	addAuxVariable (const std::string &var_type, const std::string &var_name, InputParameters &params)

virtual void	addAuxVariable (const std::string &var_name, const libMesh::FEType &type, const std::set< SubdomainID > *const active_subdomains=NULL)

virtual void	addElementalFieldVariable (const std::string &var_type, const std::string &var_name, InputParameters &params)

virtual void	addAuxArrayVariable (const std::string &var_name, const libMesh::FEType &type, unsigned int components, const std::set< SubdomainID > *const active_subdomains=NULL)

virtual void	addAuxScalarVariable (const std::string &var_name, libMesh::Order order, Real scale_factor=1., const std::set< SubdomainID > *const active_subdomains=NULL)

virtual void	addAuxKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)

virtual void	addAuxScalarKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)

virtual void	addKokkosAuxKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)

AuxiliarySystem &	getAuxiliarySystem ()

virtual void	addDiracKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)

virtual void	addDGKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)

virtual void	addFVKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)

virtual void	addLinearFVKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)

virtual void	addFVBC (const std::string &fv_bc_name, const std::string &name, InputParameters &parameters)

virtual void	addLinearFVBC (const std::string &fv_bc_name, const std::string &name, InputParameters &parameters)

virtual void	addFVInterfaceKernel (const std::string &fv_ik_name, const std::string &name, InputParameters &parameters)

virtual void	addInterfaceKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)

virtual void	addInitialCondition (const std::string &ic_name, const std::string &name, InputParameters &parameters)

virtual void	addFVInitialCondition (const std::string &ic_name, const std::string &name, InputParameters &parameters)

void	projectSolution ()

unsigned short	getCurrentICState ()

void	projectInitialConditionOnCustomRange (libMesh::ConstElemRange &elem_range, ConstBndNodeRange &bnd_node_range, const std::optional< std::set< VariableName > > &target_vars=std::nullopt)

void	projectFunctionOnCustomRange (ConstElemRange &elem_range, Number(func)(const Point &, const libMesh::Parameters &, const std::string &, const std::string &), Gradient(func_grad)(const Point &, const libMesh::Parameters &, const std::string &, const std::string &), const libMesh::Parameters &params, const std::vector< VariableName > &target_vars)

virtual void	addMaterial (const std::string &material_name, const std::string &name, InputParameters &parameters)

virtual void	addMaterialHelper (std::vector< MaterialWarehouse * > warehouse, const std::string &material_name, const std::string &name, InputParameters &parameters)

virtual void	addInterfaceMaterial (const std::string &material_name, const std::string &name, InputParameters &parameters)

virtual void	addFunctorMaterial (const std::string &functor_material_name, const std::string &name, InputParameters &parameters)

virtual void	addKokkosMaterial (const std::string &material_name, const std::string &name, InputParameters &parameters)

void	prepareMaterials (const std::unordered_set< unsigned int > &consumer_needed_mat_props, const SubdomainID blk_id, const THREAD_ID tid)

void	reinitMaterials (SubdomainID blk_id, const THREAD_ID tid, bool swap_stateful=true)

void	reinitMaterialsFace (SubdomainID blk_id, const THREAD_ID tid, bool swap_stateful=true, const std::deque< MaterialBase * > *reinit_mats=nullptr)

void	reinitMaterialsFaceOnBoundary (const BoundaryID boundary_id, const SubdomainID blk_id, const THREAD_ID tid, const bool swap_stateful=true, const std::deque< MaterialBase * > *const reinit_mats=nullptr)

void	reinitMaterialsNeighborOnBoundary (const BoundaryID boundary_id, const SubdomainID blk_id, const THREAD_ID tid, const bool swap_stateful=true, const std::deque< MaterialBase * > *const reinit_mats=nullptr)

void	reinitMaterialsNeighbor (SubdomainID blk_id, const THREAD_ID tid, bool swap_stateful=true, const std::deque< MaterialBase * > *reinit_mats=nullptr)

void	reinitMaterialsBoundary (BoundaryID boundary_id, const THREAD_ID tid, bool swap_stateful=true, const std::deque< MaterialBase * > *reinit_mats=nullptr)

void	reinitMaterialsInterface (BoundaryID boundary_id, const THREAD_ID tid, bool swap_stateful=true)

void	prepareKokkosMaterials (const std::unordered_set< unsigned int > &consumer_needed_mat_props)

void	reinitKokkosMaterials ()

virtual void	swapBackMaterials (const THREAD_ID tid)

virtual void	swapBackMaterialsFace (const THREAD_ID tid)

virtual void	swapBackMaterialsNeighbor (const THREAD_ID tid)

void	setActiveMaterialProperties (const std::unordered_set< unsigned int > &mat_prop_ids, const THREAD_ID tid)

bool	hasActiveMaterialProperties (const THREAD_ID tid) const

void	clearActiveMaterialProperties (const THREAD_ID tid)

std::vector< std::shared_ptr< T > >	addObject (const std::string &type, const std::string &name, InputParameters &parameters, const bool threaded=true, const std::string &var_param_name="variable")

virtual void	addPostprocessor (const std::string &pp_name, const std::string &name, InputParameters &parameters)

virtual void	addVectorPostprocessor (const std::string &pp_name, const std::string &name, InputParameters &parameters)

virtual void	addReporter (const std::string &type, const std::string &name, InputParameters &parameters)

virtual void	addKokkosPostprocessor (const std::string &pp_name, const std::string &name, InputParameters &parameters)

virtual void	addKokkosVectorPostprocessor (const std::string &pp_name, const std::string &name, InputParameters &parameters)

virtual void	addKokkosReporter (const std::string &type, const std::string &name, InputParameters &parameters)

const ReporterData &	getReporterData () const

ReporterData &	getReporterData (ReporterData::WriteKey)

virtual std::vector< std::shared_ptr< UserObject > >	addUserObject (const std::string &user_object_name, const std::string &name, InputParameters &parameters)

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

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

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

virtual void	addKokkosUserObject (const std::string &user_object_name, const std::string &name, InputParameters &parameters)

const T &	getKokkosUserObject (const std::string &name) const

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

void	checkUserObjectNameCollision (const std::string &name, const std::string &type) const

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

virtual void	addFVInterpolationMethod (const std::string &method_type, const std::string &name, InputParameters &parameters)

const FVInterpolationMethod &	getFVInterpolationMethod (const InterpolationMethodName &name, const THREAD_ID tid=0) const

const FVFaceInterpolationMethod &	getFVFaceInterpolationMethod (const InterpolationMethodName &name, const THREAD_ID tid=0) const

const FVAdvectedInterpolationMethod &	getFVAdvectedInterpolationMethod (const InterpolationMethodName &name, const THREAD_ID tid=0) const

bool	hasFVInterpolationMethod (const InterpolationMethodName &name) const

bool	hasPostprocessorValueByName (const PostprocessorName &name) const

const Postprocessor &	getPostprocessorObjectByName (const PostprocessorName &object_name, const THREAD_ID tid=0) const

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

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

const VectorPostprocessorValue &	getVectorPostprocessorValueByName (const std::string &object_name, const std::string &vector_name, std::size_t t_index=0) const

void	setVectorPostprocessorValueByName (const std::string &object_name, const std::string &vector_name, const VectorPostprocessorValue &value, std::size_t t_index=0)

const VectorPostprocessor &	getVectorPostprocessorObjectByName (const std::string &object_name, const THREAD_ID tid=0) const

virtual void	addDamper (const std::string &damper_name, const std::string &name, InputParameters &parameters)

void	setupDampers ()

bool	hasDampers ()

virtual void	addIndicator (const std::string &indicator_name, const std::string &name, InputParameters &parameters)

virtual void	addMarker (const std::string &marker_name, const std::string &name, InputParameters &parameters)

virtual void	addMultiApp (const std::string &multi_app_name, const std::string &name, InputParameters &parameters)

std::shared_ptr< MultiApp >	getMultiApp (const std::string &multi_app_name) const

std::vector< std::shared_ptr< Transfer > >	getTransfers (ExecFlagType type, Transfer::DIRECTION direction) const

std::vector< std::shared_ptr< Transfer > >	getTransfers (Transfer::DIRECTION direction) const

const ExecuteMooseObjectWarehouse< Transfer > &	getMultiAppTransferWarehouse (Transfer::DIRECTION direction) const

void	execMultiAppTransfers (ExecFlagType type, Transfer::DIRECTION direction)

bool	execMultiApps (ExecFlagType type, bool auto_advance=true)

void	finalizeMultiApps ()

void	incrementMultiAppTStep (ExecFlagType type)

void	advanceMultiApps (ExecFlagType type)

void	finishMultiAppStep (ExecFlagType type, bool recurse_through_multiapp_levels=false)

void	backupMultiApps (ExecFlagType type)

void	restoreMultiApps (ExecFlagType type, bool force=false)

Real	computeMultiAppsDT (ExecFlagType type)

virtual void	addTransfer (const std::string &transfer_name, const std::string &name, InputParameters &parameters)

void	execTransfers (ExecFlagType type)

Real	computeResidualL2Norm (NonlinearSystemBase &sys)

Real	computeResidualL2Norm (LinearSystem &sys)

virtual Real	computeResidualL2Norm ()

virtual void	computeResidualSys (libMesh::NonlinearImplicitSystem &sys, const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual)

void	computeResidual (libMesh::NonlinearImplicitSystem &sys, const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual)

virtual void	computeResidual (const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual, const unsigned int nl_sys_num)

void	computeResidualAndJacobian (const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual, libMesh::SparseMatrix< libMesh::Number > &jacobian)

virtual void	computeResidualTag (const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual, TagID tag)

virtual void	computeResidualType (const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual, TagID tag)

virtual void	computeResidualInternal (const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual, const std::set< TagID > &tags)

virtual void	computeResidualTags (const std::set< TagID > &tags)

virtual void	computeJacobianSys (libMesh::NonlinearImplicitSystem &sys, const NumericVector< libMesh::Number > &soln, libMesh::SparseMatrix< libMesh::Number > &jacobian)

virtual void	computeJacobian (const NumericVector< libMesh::Number > &soln, libMesh::SparseMatrix< libMesh::Number > &jacobian, const unsigned int nl_sys_num)

virtual void	computeJacobianTag (const NumericVector< libMesh::Number > &soln, libMesh::SparseMatrix< libMesh::Number > &jacobian, TagID tag)

virtual void	computeJacobianInternal (const NumericVector< libMesh::Number > &soln, libMesh::SparseMatrix< libMesh::Number > &jacobian, const std::set< TagID > &tags)

virtual void	computeJacobianTags (const std::set< TagID > &tags)

virtual void	computeJacobianBlocks (std::vector< JacobianBlock * > &blocks, const unsigned int nl_sys_num)

virtual void	computeJacobianBlock (libMesh::SparseMatrix< libMesh::Number > &jacobian, libMesh::System &precond_system, unsigned int ivar, unsigned int jvar)

virtual void	computeLinearSystemSys (libMesh::LinearImplicitSystem &sys, libMesh::SparseMatrix< libMesh::Number > &system_matrix, NumericVector< libMesh::Number > &rhs, const bool compute_gradients=true)

void	computeLinearSystemTags (const NumericVector< libMesh::Number > &soln, const std::set< TagID > &vector_tags, const std::set< TagID > &matrix_tags, const bool compute_gradients=true)

virtual Real	computeDamping (const NumericVector< libMesh::Number > &soln, const NumericVector< libMesh::Number > &update)

virtual bool	shouldUpdateSolution ()

virtual bool	updateSolution (NumericVector< libMesh::Number > &vec_solution, NumericVector< libMesh::Number > &ghosted_solution)

virtual void	predictorCleanup (NumericVector< libMesh::Number > &ghosted_solution)

virtual void	computeBounds (libMesh::NonlinearImplicitSystem &sys, NumericVector< libMesh::Number > &lower, NumericVector< libMesh::Number > &upper)

virtual void	computeNearNullSpace (libMesh::NonlinearImplicitSystem &sys, std::vector< NumericVector< libMesh::Number > * > &sp)

virtual void	computeNullSpace (libMesh::NonlinearImplicitSystem &sys, std::vector< NumericVector< libMesh::Number > * > &sp)

virtual void	computeTransposeNullSpace (libMesh::NonlinearImplicitSystem &sys, std::vector< NumericVector< libMesh::Number > * > &sp)

virtual void	computePostCheck (libMesh::NonlinearImplicitSystem &sys, const NumericVector< libMesh::Number > &old_soln, NumericVector< libMesh::Number > &search_direction, NumericVector< libMesh::Number > &new_soln, bool &changed_search_direction, bool &changed_new_soln)

virtual void	computeIndicatorsAndMarkers ()

virtual void	computeIndicators ()

virtual void	computeMarkers ()

virtual void	addResidual (const THREAD_ID tid) override

virtual void	addResidualNeighbor (const THREAD_ID tid) override

virtual void	addResidualLower (const THREAD_ID tid) override

virtual void	addResidualScalar (const THREAD_ID tid=0)

virtual void	cacheResidual (const THREAD_ID tid) override

virtual void	cacheResidualNeighbor (const THREAD_ID tid) override

virtual void	addCachedResidual (const THREAD_ID tid) override

virtual void	addCachedResidualDirectly (NumericVector< libMesh::Number > &residual, const THREAD_ID tid)

virtual void	setResidual (NumericVector< libMesh::Number > &residual, const THREAD_ID tid) override

virtual void	setResidual (libMesh::NumericVector< libMesh::Number > &residual, const THREAD_ID tid)=0

virtual void	setResidualNeighbor (NumericVector< libMesh::Number > &residual, const THREAD_ID tid) override

virtual void	setResidualNeighbor (libMesh::NumericVector< libMesh::Number > &residual, const THREAD_ID tid)=0

virtual void	addJacobian (const THREAD_ID tid) override

virtual void	addJacobianNeighbor (const THREAD_ID tid) override

virtual void	addJacobianNeighbor (libMesh::SparseMatrix< libMesh::Number > &jacobian, unsigned int ivar, unsigned int jvar, const DofMap &dof_map, std::vector< dof_id_type > &dof_indices, std::vector< dof_id_type > &neighbor_dof_indices, const std::set< TagID > &tags, const THREAD_ID tid) override

virtual void	addJacobianNeighbor (libMesh::SparseMatrix< libMesh::Number > &jacobian, unsigned int ivar, unsigned int jvar, const libMesh::DofMap &dof_map, std::vector< dof_id_type > &dof_indices, std::vector< dof_id_type > &neighbor_dof_indices, const std::set< TagID > &tags, const THREAD_ID tid)=0

virtual void	addJacobianNeighborLowerD (const THREAD_ID tid) override

virtual void	addJacobianLowerD (const THREAD_ID tid) override

virtual void	addJacobianBlockTags (libMesh::SparseMatrix< libMesh::Number > &jacobian, unsigned int ivar, unsigned int jvar, const DofMap &dof_map, std::vector< dof_id_type > &dof_indices, const std::set< TagID > &tags, const THREAD_ID tid)

virtual void	addJacobianScalar (const THREAD_ID tid=0)

virtual void	addJacobianOffDiagScalar (unsigned int ivar, const THREAD_ID tid=0)

virtual void	cacheJacobian (const THREAD_ID tid) override

virtual void	cacheJacobianNeighbor (const THREAD_ID tid) override

virtual void	addCachedJacobian (const THREAD_ID tid) override

virtual void	prepareShapes (unsigned int var, const THREAD_ID tid) override

virtual void	prepareFaceShapes (unsigned int var, const THREAD_ID tid) override

virtual void	prepareNeighborShapes (unsigned int var, const THREAD_ID tid) override

virtual void	addDisplacedProblem (std::shared_ptr< DisplacedProblem > displaced_problem)

virtual std::shared_ptr< const DisplacedProblem >	getDisplacedProblem () const

virtual std::shared_ptr< DisplacedProblem >	getDisplacedProblem ()

virtual void	updateGeomSearch (GeometricSearchData::GeometricSearchType type=GeometricSearchData::ALL) override

virtual void	updateMortarMesh ()

void	createMortarInterface (const std::pair< BoundaryID, BoundaryID > &primary_secondary_boundary_pair, const std::pair< SubdomainID, SubdomainID > &primary_secondary_subdomain_pair, bool on_displaced, bool periodic, const bool debug, const bool correct_edge_dropping, const Real minimum_projection_angle, const Mortar3DSubpatchPlane mortar_3d_subpatch_plane, const MooseEnum &triangulation, const bool triangulate_triangles, const Mortar3DQuadraturePointMapping mortar_3d_qp_mapping=Mortar3DQuadraturePointMapping::NORMAL_PROJECTION)

const std::unordered_map< std::pair< BoundaryID, BoundaryID >, MortarInterfaceConfig > &	getMortarInterfaces (bool on_displaced) const

virtual void	possiblyRebuildGeomSearchPatches ()

virtual GeometricSearchData &	geomSearchData () override

void	setRestartFile (const std::string &file_name)

const MaterialPropertyRegistry &	getMaterialPropertyRegistry () const

const InitialConditionWarehouse &	getInitialConditionWarehouse () const

const FVInitialConditionWarehouse &	getFVInitialConditionWarehouse () const

SolverParams &	solverParams (unsigned int solver_sys_num=0)

const SolverParams &	solverParams (unsigned int solver_sys_num=0) const

Adaptivity &	adaptivity ()

virtual void	initialAdaptMesh ()

virtual bool	adaptMesh ()

unsigned int	getNumCyclesCompleted ()

bool	hasInitialAdaptivity () const

bool	hasInitialAdaptivity () const

void	initXFEM (std::shared_ptr< XFEMInterface > xfem)

std::shared_ptr< XFEMInterface >	getXFEM ()

bool	haveXFEM ()

virtual bool	updateMeshXFEM ()

virtual void	meshChanged (bool intermediate_change, bool contract_mesh, bool clean_refinement_flags)

void	notifyWhenMeshChanges (MeshChangedInterface *mci)

void	notifyWhenMeshDisplaces (MeshDisplacedInterface *mdi)

void	initElementStatefulProps (const libMesh::ConstElemRange &elem_range, const bool threaded)

void	initKokkosStatefulProps ()

virtual void	checkProblemIntegrity ()

void	registerRandomInterface (RandomInterface &random_interface, const std::string &name)

void	setConstJacobian (bool state)

void	setKernelCoverageCheck (CoverageCheckMode mode)

void	setKernelCoverageCheck (bool flag)

void	setKernelCoverageCheck (CoverageCheckMode mode)

void	setMaterialCoverageCheck (CoverageCheckMode mode)

void	setMaterialCoverageCheck (bool flag)

void	setMaterialCoverageCheck (CoverageCheckMode mode)

void	setParallelBarrierMessaging (bool flag)

void	setVerboseProblem (bool verbose)

bool	verboseMultiApps () const

void	parentOutputPositionChanged ()

unsigned int	subspaceDim (const std::string &prefix) const

const MooseObjectWarehouse< Function > &	getFunctionWarehouse ()

const MaterialWarehouse &	getMaterialWarehouse () const

const MaterialWarehouse &	getRegularMaterialsWarehouse () const

const MaterialWarehouse &	getDiscreteMaterialWarehouse () const

const MaterialWarehouse &	getInterfaceMaterialsWarehouse () const

const MaterialWarehouse &	getKokkosMaterialsWarehouse () const

std::shared_ptr< MaterialBase >	getMaterial (std::string name, Moose::MaterialDataType type, const THREAD_ID tid=0, bool no_warn=false)

MaterialData &	getMaterialData (Moose::MaterialDataType type, const THREAD_ID tid=0, const MooseObject *object=nullptr) const

MaterialData &	getKokkosMaterialData (Moose::MaterialDataType type, const MooseObject *object=nullptr) const

const std::set< const MooseObject * > &	getMaterialPropertyStorageConsumers (Moose::MaterialDataType type) const

const std::set< const MooseObject * > &	getKokkosMaterialPropertyStorageConsumers (Moose::MaterialDataType type) const

bool	restoreOriginalNonzeroPattern () const

bool	errorOnJacobianNonzeroReallocation () const

void	setErrorOnJacobianNonzeroReallocation (bool state)

bool	preserveMatrixSparsityPattern () const

void	setPreserveMatrixSparsityPattern (bool preserve)

bool	ignoreZerosInJacobian () const

void	setIgnoreZerosInJacobian (bool state)

bool	acceptInvalidSolution () const

bool	allowInvalidSolution () const

bool	showInvalidSolutionConsole () const

bool	immediatelyPrintInvalidSolution () const

bool	hasTimeIntegrator () const

virtual void	execute (const ExecFlagType &exec_type)

virtual void	executeAllObjects (const ExecFlagType &exec_type)

virtual Executor &	getExecutor (const std::string &name)

virtual void	computeUserObjects (const ExecFlagType &type, const Moose::AuxGroup &group)

virtual void	computeUserObjectByName (const ExecFlagType &type, const Moose::AuxGroup &group, const std::string &name)

void	needsPreviousNewtonIteration (bool state)

bool	needsPreviousNewtonIteration () const

void	needsPreviousMultiAppFixedPointIterationSolution (bool needed, const unsigned int solver_sys_num)

bool	needsPreviousMultiAppFixedPointIterationSolution (const unsigned int solver_sys_num) const

void	needsPreviousMultiAppFixedPointIterationAuxiliary (bool state)

bool	needsPreviousMultiAppFixedPointIterationAuxiliary () const

void	needsPreviousMultiSystemFixedPointIterationSolution (bool needed, const unsigned int solver_sys_num)

bool	needsPreviousMultiSystemFixedPointIterationSolution (const unsigned int solver_sys_num) const

void	needsPreviousMultiSystemFixedPointIterationAuxiliary (bool state)

bool	needsPreviousMultiSystemFixedPointIterationAuxiliary () const

ExecuteMooseObjectWarehouse< Control > &	getControlWarehouse ()

void	executeControls (const ExecFlagType &exec_type)

void	executeSamplers (const ExecFlagType &exec_type)

virtual void	updateActiveObjects ()

void	reportMooseObjectDependency (MooseObject a, MooseObject b)

ExecuteMooseObjectWarehouse< MultiApp > &	getMultiAppWarehouse ()

bool	hasJacobian () const

bool	constJacobian () const

void	addOutput (const std::string &, const std::string &, InputParameters &)

TheWarehouse &	theWarehouse () const

void	setSNESMFReuseBase (bool reuse, bool set_by_user)

bool	useSNESMFReuseBase ()

void	skipExceptionCheck (bool skip_exception_check)

bool	isSNESMFReuseBaseSetbyUser ()

bool &	petscOptionsInserted ()

PetscOptions &	petscOptionsDatabase ()

virtual void	setUDotRequested (const bool u_dot_requested)

virtual void	setUDotDotRequested (const bool u_dotdot_requested)

virtual void	setUDotOldRequested (const bool u_dot_old_requested)

virtual void	setUDotDotOldRequested (const bool u_dotdot_old_requested)

virtual bool	uDotRequested ()

virtual bool	uDotDotRequested ()

virtual bool	uDotOldRequested ()

virtual bool	uDotDotOldRequested ()

void	haveADObjects (bool have_ad_objects) override

virtual void	haveADObjects (bool have_ad_objects)

bool	haveADObjects () const

bool	shouldSolve () const

const MortarInterfaceWarehouse &	mortarData () const

MortarInterfaceWarehouse &	mortarData ()

virtual bool	hasNeighborCoupling () const

virtual bool	hasMortarCoupling () const

void	computingNonlinearResid (bool computing_nonlinear_residual) final

bool	computingNonlinearResid () const

virtual void	computingNonlinearResid (const bool computing_nonlinear_residual)

void	setCurrentlyComputingResidual (bool currently_computing_residual) final

void	numGridSteps (unsigned int num_grid_steps)

void	uniformRefine ()

void	automaticScaling (bool automatic_scaling) override

virtual void	automaticScaling (bool automatic_scaling)

bool	automaticScaling () const

virtual void	reinitElemFaceRef (const Elem elem, unsigned int side, Real tolerance, const std::vector< Point > const pts, const std::vector< Real > *const weights=nullptr, const THREAD_ID tid=0) override

virtual void	reinitNeighborFaceRef (const Elem neighbor_elem, unsigned int neighbor_side, Real tolerance, const std::vector< Point > const pts, const std::vector< Real > *const weights=nullptr, const THREAD_ID tid=0) override

bool	fvBCsIntegrityCheck () const

void	fvBCsIntegrityCheck (bool fv_bcs_integrity_check)

bool	sideUOInterfaceMatPropIntegrityCheck () const

void	getFVMatsAndDependencies (SubdomainID block_id, std::vector< std::shared_ptr< MaterialBase > > &face_materials, std::vector< std::shared_ptr< MaterialBase > > &neighbor_materials, std::set< MooseVariableFieldBase * > &variables, const THREAD_ID tid)

void	resizeMaterialData (Moose::MaterialDataType data_type, unsigned int nqp, const THREAD_ID tid)

bool	haveDisplaced () const override final

bool	hasLinearConvergenceObjects () const

void	setNonlinearConvergenceNames (const std::vector< ConvergenceName > &convergence_names)

void	setLinearConvergenceNames (const std::vector< ConvergenceName > &convergence_names)

void	setMultiAppFixedPointConvergenceName (const ConvergenceName &convergence_name)

void	setSteadyStateConvergenceName (const ConvergenceName &convergence_name)

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

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

const ConvergenceName &	getMultiAppFixedPointConvergenceName () const

const ConvergenceName &	getSteadyStateConvergenceName () const

void	computingScalingJacobian (bool computing_scaling_jacobian)

bool	computingScalingJacobian () const override final

void	computingScalingResidual (bool computing_scaling_residual)

bool	computingScalingResidual () const override final

MooseAppCoordTransform &	coordTransform ()

virtual std::size_t	numNonlinearSystems () const override

virtual std::size_t	numLinearSystems () const override

virtual std::size_t	numSolverSystems () const override

bool	isSolverSystemNonlinear (const unsigned int sys_num)

virtual unsigned int	currentNlSysNum () const override

virtual unsigned int	currentLinearSysNum () const override

virtual unsigned int	nlSysNum (const NonlinearSystemName &nl_sys_name) const override

unsigned int	linearSysNum (const LinearSystemName &linear_sys_name) const override

unsigned int	solverSysNum (const SolverSystemName &solver_sys_name) const override

unsigned int	systemNumForVariable (const VariableName &variable_name) const

bool	getFailNextNonlinearConvergenceCheck () const

bool	getFailNextSystemConvergenceCheck () const

void	setFailNextNonlinearConvergenceCheck ()

void	setFailNextSystemConvergenceCheck ()

void	resetFailNextNonlinearConvergenceCheck ()

void	resetFailNextSystemConvergenceCheck ()

void	setExecutionPrinting (const ExecFlagEnum &print_exec)

bool	shouldPrintExecution (const THREAD_ID tid) const

void	reinitMortarUserObjects (BoundaryID primary_boundary_id, BoundaryID secondary_boundary_id, bool displaced)

virtual const std::vector< VectorTag > &	currentResidualVectorTags () const override

void	setCurrentResidualVectorTags (const std::set< TagID > &vector_tags)

void	clearCurrentResidualVectorTags ()

void	clearCurrentJacobianMatrixTags ()

virtual void	needFV () override

virtual bool	haveFV () const override

virtual bool	hasNonlocalCoupling () const override

bool	identifyVariableGroupsInNL () const

virtual void	setCurrentLowerDElem (const Elem *const lower_d_elem, const THREAD_ID tid) override

virtual void	setCurrentBoundaryID (BoundaryID bid, const THREAD_ID tid) override

const std::vector< NonlinearSystemName > &	getNonlinearSystemNames () const

const std::vector< LinearSystemName > &	getLinearSystemNames () const

const std::vector< SolverSystemName > &	getSolverSystemNames () const

virtual const libMesh::CouplingMatrix &	nonlocalCouplingMatrix (const unsigned i) const override

virtual bool	checkNonlocalCouplingRequirement () const override

virtual Moose::FEBackend	feBackend () const

void	createTagMatrices (CreateTaggedMatrixKey)

bool	useHashTableMatrixAssembly () const

bool	hasKokkosObjects () const

bool	hasKokkosResidualObjects () const

void	addKokkosMeshInitializationHook (std::function< void()> function)

const bool &	currentlyComputingResidual () const

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)

void	reinitGeomSearch ()

virtual void	storeSubdomainMatPropName (SubdomainID block_id, const std::string &name)

virtual void	storeBoundaryMatPropName (BoundaryID boundary_id, const std::string &name)

virtual void	storeSubdomainZeroMatProp (SubdomainID block_id, const MaterialPropertyName &name)

virtual void	storeBoundaryZeroMatProp (BoundaryID boundary_id, const MaterialPropertyName &name)

virtual void	storeSubdomainDelayedCheckMatProp (const std::string &requestor, SubdomainID block_id, const std::string &name)

virtual void	storeBoundaryDelayedCheckMatProp (const std::string &requestor, BoundaryID boundary_id, const std::string &name)

virtual void	checkBlockMatProps ()

virtual void	checkBoundaryMatProps ()

virtual void	markMatPropRequested (const std::string &)

virtual bool	isMatPropRequested (const std::string &prop_name) const

void	addConsumedPropertyName (const MooseObjectName &obj_name, const std::string &prop_name)

const std::map< MooseObjectName, std::set< std::string > > &	getConsumedPropertyMap () const

virtual std::set< SubdomainID >	getMaterialPropertyBlocks (const std::string &prop_name)

virtual std::vector< SubdomainName >	getMaterialPropertyBlockNames (const std::string &prop_name)

virtual bool	hasBlockMaterialProperty (SubdomainID block_id, const std::string &prop_name)

virtual std::set< BoundaryID >	getMaterialPropertyBoundaryIDs (const std::string &prop_name)

virtual std::vector< BoundaryName >	getMaterialPropertyBoundaryNames (const std::string &prop_name)

virtual bool	hasBoundaryMaterialProperty (BoundaryID boundary_id, const std::string &prop_name)

virtual std::set< dof_id_type > &	ghostedElems ()

const bool &	currentlyComputingJacobian () const

void	setCurrentlyComputingJacobian (const bool currently_computing_jacobian)

const bool &	currentlyComputingResidualAndJacobian () const

void	setCurrentlyComputingResidualAndJacobian (bool currently_computing_residual_and_jacobian)

virtual bool	safeAccessTaggedMatrices () const

virtual bool	safeAccessTaggedVectors () const

const std::set< TagID > &	getActiveScalarVariableCoupleableVectorTags (const THREAD_ID tid) const

const std::set< TagID > &	getActiveScalarVariableCoupleableMatrixTags (const THREAD_ID tid) const

const std::set< TagID > &	getActiveFEVariableCoupleableVectorTags (const THREAD_ID tid) const

const std::set< TagID > &	getActiveFEVariableCoupleableMatrixTags (const THREAD_ID tid) const

void	addAlgebraicGhostingFunctor (libMesh::GhostingFunctor &algebraic_gf, bool to_mesh=true)

void	addCouplingGhostingFunctor (libMesh::GhostingFunctor &coupling_gf, bool to_mesh=true)

void	removeAlgebraicGhostingFunctor (libMesh::GhostingFunctor &algebraic_gf)

void	removeCouplingGhostingFunctor (libMesh::GhostingFunctor &coupling_gf)

void	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	setChainControlDataOutput (bool set_output)

void	registerUnfilledFunctorRequest (T *functor_interface, const std::string &functor_name, const THREAD_ID tid)

void	reinitFVFace (const THREAD_ID tid, const FaceInfo &fi)

void	preparePRefinement ()

bool	doingPRefinement () const

bool	havePRefinement () const

void	markFamilyPRefinement (const InputParameters &params)

MooseVariableFEBase &	getVariableHelper (const THREAD_ID tid, const std::string &var_name, Moose::VarKindType expected_var_type, Moose::VarFieldType expected_var_field_type, const std::vector< T > &systems, const SystemBase &aux) const

void	_setCLIOption ()

virtual void	terminateSolve ()

virtual bool	isSolveTerminationRequested () const

const ConsoleStream &	console () const

virtual bool	enabled () const

std::shared_ptr< MooseObject >	getSharedPtr ()

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

bool	isKokkosObject () const

MooseApp &	getMooseApp () const

const std::string &	type () const

const std::string &	name () const

std::string	typeAndName () const

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

MooseObjectName	uniqueName () const

const InputParameters &	parameters () const

const hit::Node *	getHitNode () const

bool	hasBase () const

const std::string &	getBase () const

const T &	getParam (const std::string &name) const

std::vector< std::pair< T1, T2 > >	getParam (const std::string &param1, const std::string &param2) const

const T *	queryParam (const std::string &name) const

const T &	getRenamedParam (const std::string &old_name, const std::string &new_name) const

T	getCheckedPointerParam (const std::string &name, const std::string &error_string="") const

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

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

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

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

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

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

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

std::string	messagePrefix (const bool hit_prefix=true) const

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

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

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

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

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

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

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

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

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

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

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

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

void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) const

std::string	getDataFileName (const std::string &param) const

std::string	getDataFileNameByName (const std::string &relative_path) const

std::string	getDataFilePath (const std::string &relative_path) const

PerfGraph &	perfGraph ()

const libMesh::ConstElemRange &	getEvaluableElementRange ()

const libMesh::ConstElemRange &	getEvaluableElementRange ()

const libMesh::ConstElemRange &	getNonlinearEvaluableElementRange ()

const libMesh::ConstElemRange &	getNonlinearEvaluableElementRange ()

const libMesh::ConstElemRange &	getCurrentAlgebraicElementRange ()

const libMesh::ConstElemRange &	getCurrentAlgebraicElementRange ()

const libMesh::ConstNodeRange &	getCurrentAlgebraicNodeRange ()

const libMesh::ConstNodeRange &	getCurrentAlgebraicNodeRange ()

const ConstBndNodeRange &	getCurrentAlgebraicBndNodeRange ()

const ConstBndNodeRange &	getCurrentAlgebraicBndNodeRange ()

void	setCurrentAlgebraicElementRange (libMesh::ConstElemRange *range)

void	setCurrentAlgebraicElementRange (libMesh::ConstElemRange *range)

void	setCurrentAlgebraicNodeRange (libMesh::ConstNodeRange *range)

void	setCurrentAlgebraicNodeRange (libMesh::ConstNodeRange *range)

void	setCurrentAlgebraicBndNodeRange (ConstBndNodeRange *range)

void	setCurrentAlgebraicBndNodeRange (ConstBndNodeRange *range)

void	allowOutput (bool state)

void	allowOutput (bool state)

void	allowOutput (bool state)

void	allowOutput (bool state)

Moose::Kokkos::Array< Moose::Kokkos::System > &	getKokkosSystems ()

const Moose::Kokkos::Array< Moose::Kokkos::System > &	getKokkosSystems () const

Moose::Kokkos::Array< Moose::Kokkos::System > &	getKokkosSystems ()

const Moose::Kokkos::Array< Moose::Kokkos::System > &	getKokkosSystems () const

Moose::Kokkos::Array< Moose::Kokkos::FESystem > &	getKokkosFESystems ()

const Moose::Kokkos::Array< Moose::Kokkos::FESystem > &	getKokkosFESystems () const

Moose::Kokkos::Array< Moose::Kokkos::FESystem > &	getKokkosFESystems ()

const Moose::Kokkos::Array< Moose::Kokkos::FESystem > &	getKokkosFESystems () const

Moose::Kokkos::System &	getKokkosSystem (const unsigned int sys_num)

const Moose::Kokkos::System &	getKokkosSystem (const unsigned int sys_num) const

Moose::Kokkos::System &	getKokkosSystem (const unsigned int sys_num)

const Moose::Kokkos::System &	getKokkosSystem (const unsigned int sys_num) const

Moose::Kokkos::FESystem &	getKokkosFESystem (const unsigned int sys_num)

const Moose::Kokkos::FESystem &	getKokkosFESystem (const unsigned int sys_num) const

Moose::Kokkos::FESystem &	getKokkosFESystem (const unsigned int sys_num)

const Moose::Kokkos::FESystem &	getKokkosFESystem (const unsigned int sys_num) const

bool	hasMultiApps () const

bool	hasMultiApps (ExecFlagType type) const

bool	hasMultiApps () const

bool	hasMultiApps (ExecFlagType type) const

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

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

const AutomaticMortarGeneration &	getMortarInterface (const std::pair< BoundaryID, BoundaryID > &primary_secondary_boundary_pair, const std::pair< SubdomainID, SubdomainID > &primary_secondary_subdomain_pair, bool on_displaced) const

AutomaticMortarGeneration &	getMortarInterface (const std::pair< BoundaryID, BoundaryID > &primary_secondary_boundary_pair, const std::pair< SubdomainID, SubdomainID > &primary_secondary_subdomain_pair, bool on_displaced)

const AutomaticMortarGeneration &	getMortarInterface (const std::pair< BoundaryID, BoundaryID > &primary_secondary_boundary_pair, const std::pair< SubdomainID, SubdomainID > &primary_secondary_subdomain_pair, bool on_displaced) const

AutomaticMortarGeneration &	getMortarInterface (const std::pair< BoundaryID, BoundaryID > &primary_secondary_boundary_pair, const std::pair< SubdomainID, SubdomainID > &primary_secondary_subdomain_pair, bool on_displaced)

const MaterialPropertyStorage &	getMaterialPropertyStorage ()

const MaterialPropertyStorage &	getMaterialPropertyStorage ()

const MaterialPropertyStorage &	getBndMaterialPropertyStorage ()

const MaterialPropertyStorage &	getBndMaterialPropertyStorage ()

const MaterialPropertyStorage &	getNeighborMaterialPropertyStorage ()

const MaterialPropertyStorage &	getNeighborMaterialPropertyStorage ()

Moose::Kokkos::MaterialPropertyStorage &	getKokkosMaterialPropertyStorage ()

Moose::Kokkos::MaterialPropertyStorage &	getKokkosMaterialPropertyStorage ()

Moose::Kokkos::MaterialPropertyStorage &	getKokkosBndMaterialPropertyStorage ()

Moose::Kokkos::MaterialPropertyStorage &	getKokkosBndMaterialPropertyStorage ()

Moose::Kokkos::MaterialPropertyStorage &	getKokkosNeighborMaterialPropertyStorage ()

Moose::Kokkos::MaterialPropertyStorage &	getKokkosNeighborMaterialPropertyStorage ()

const MooseObjectWarehouse< Indicator > &	getIndicatorWarehouse ()

const MooseObjectWarehouse< Indicator > &	getIndicatorWarehouse ()

const MooseObjectWarehouse< InternalSideIndicatorBase > &	getInternalSideIndicatorWarehouse ()

const MooseObjectWarehouse< InternalSideIndicatorBase > &	getInternalSideIndicatorWarehouse ()

const MooseObjectWarehouse< Marker > &	getMarkerWarehouse ()

const MooseObjectWarehouse< Marker > &	getMarkerWarehouse ()

bool	needBoundaryMaterialOnSide (BoundaryID bnd_id, const THREAD_ID tid)

bool	needBoundaryMaterialOnSide (BoundaryID bnd_id, const THREAD_ID tid)

bool	needInterfaceMaterialOnSide (BoundaryID bnd_id, const THREAD_ID tid)

bool	needInterfaceMaterialOnSide (BoundaryID bnd_id, const THREAD_ID tid)

bool	needInternalNeighborSideMaterial (SubdomainID subdomain_id, const THREAD_ID tid)

bool	needInternalNeighborSideMaterial (SubdomainID subdomain_id, const THREAD_ID tid)

const ExecFlagType &	getCurrentExecuteOnFlag () const

const ExecFlagType &	getCurrentExecuteOnFlag () const

void	setCurrentExecuteOnFlag (const ExecFlagType &)

void	setCurrentExecuteOnFlag (const ExecFlagType &)

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

const libMesh::FEType &	getFlowFEType () const
	Gets the FE type for the flow in this simulation.

virtual void	setupQuadrature ()
	Sets up quadrature rules.

virtual void	initSimulation ()
	Initialize this simulation.

virtual void	initComponents ()
	Initialize this simulation's components.

void	identifyLoops ()
	Identifies the component loops.

void	printComponentLoops () const
	Prints the component loops.

virtual void	run ()
	Run the simulation.

virtual void	addComponent (const std::string &type, const std::string &name, InputParameters params)
	Add a component into this simulation.

bool	hasComponent (const std::string &name) const
	Find out if simulation has a component with the given name.

template<typename T >
bool	hasComponentOfType (const std::string &name) const
	Find out if simulation has a component with the given name and specified type.

template<typename T >
const T &	getComponentByName (const std::string &name) const
	Get component by its name.

const std::vector< std::shared_ptr< Component > > &	getComponents () const
	Return list of components available in the simulation.

virtual void	addClosures (const std::string &type, const std::string &name, InputParameters params)
	Add a closures object into this simulation.

bool	hasClosures (const std::string &name) const
	Return whether the simulation has a closures object.

std::shared_ptr< ClosuresBase >	getClosures (const std::string &name) const
	Get a pointer to a closures object.

void	addSimVariable (bool nl, const VariableName &name, libMesh::FEType fe_type, Real scaling_factor=1.0)
	Queues a variable of type MooseVariableScalar to be added to the nonlinear or aux system.

void	addSimVariable (bool nl, const VariableName &name, libMesh::FEType fe_type, const std::vector< SubdomainName > &subdomain_names, Real scaling_factor=1.0)
	Queues a variable of type MooseVariable to be added to the nonlinear or aux system.

void	addSimVariable (bool nl, const std::string &var_type, const VariableName &name, const InputParameters &params)
	Queues a generic variable to be added to the nonlinear or aux system.

void	checkVariableNameLength (const std::string &name) const
	Reports an error if the variable name is too long.

void	addConstantIC (const VariableName &var_name, Real value, const std::vector< SubdomainName > &block_names)

void	addFunctionIC (const VariableName &var_name, const std::string &func_name, const std::vector< SubdomainName > &block_names)

void	addConstantScalarIC (const VariableName &var_name, Real value)

void	addComponentScalarIC (const VariableName &var_name, const std::vector< Real > &value)

void	addSimInitialCondition (const std::string &type, const std::string &name, InputParameters params)

void	addControl (const std::string &type, const std::string &name, InputParameters params)
	Add a control.

void	addFileOutputter (const std::string &name)

void	addScreenOutputter (const std::string &name)

std::vector< OutputName >	getOutputsVector (const std::string &key) const
	Gets the vector of output names corresponding to a 1-word key string.

virtual void	buildMesh ()
	Create mesh for this simulation.

virtual void	addVariables ()
	Add variables involved in this simulation.

virtual void	addMooseObjects ()
	Add component MOOSE objects.

virtual void	setupMesh ()
	Perform mesh setup actions such as setting up the coordinate system(s) and creating ghosted elements.

ThermalHydraulicsApp &	getApp ()
	Get the ThermalHydraulicsApp.

virtual void	integrityCheck () const
	Check the integrity of the simulation.

virtual void	controlDataIntegrityCheck ()
	Check the integrity of the control data.

virtual void	couplingMatrixIntegrityCheck () const
	Check integrity of coupling matrix used by the preconditioner.

template<typename T >
bool	hasControlData (const std::string &name)
	Query if control data with name 'name' exists.

template<typename T >
ControlData< T > *	getControlData (const std::string &name)
	Get control data of type T and name 'name', if it does not exist it will be created.

template<typename T >
ControlData< T > *	declareControlData (const std::string &name, THMControl *ctrl)
	Declare control data of type T and name 'name', if it does not exist it will be created.

const bool &	getImplicitTimeIntegrationFlag ()
	Gets the flag indicating whether an implicit time integration scheme is being used.

bool	hasInitialConditionsFromFile () const
	Are initial conditions specified from a file.

Logger &	log ()

void	setCheckJacobian (bool state)
	Enable Jacobian checking.

virtual void	augmentSparsity (const dof_id_type &elem_id1, const dof_id_type &elem_id2)
	Hint how to augment sparsity pattern between two elements.

bool	getVectorValuedVelocity ()
	Is velocity output as vector-valued field.

void	setVectorValuedVelocity (bool vector_velocity)
	Set if velocity is being output as a vector-valued field.

void	addRelationshipManagers ()
	Add additional relationship managers to run the simulation.

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

template<typename... Args>
void	logError (Args &&... args) const
	Logs an error.

template<typename... Args>
void	logComponentError (const std::string &component_name, Args &&... args) const
	Logs an error for a component.

template<typename... Args>
void	logWarning (Args &&... args) const
	Logs a warning.

template<typename... Args>
void	logComponentWarning (const std::string &component_name, Args &&... args) const
	Logs a warning for a component.

std::string	genName (const std::string &prefix, unsigned int id, const std::string &suffix="") const
	Build a name from a prefix, number and possible suffix.

std::string	genName (const std::string &prefix, unsigned int i, unsigned int j, const std::string &suffix="") const
	Build a name from a prefix, 2 numbers and possible suffix.

std::string	genName (const std::string &prefix, const std::string &name, unsigned int i) const
	Build a name from 2 strings and a number.

std::string	genName (const std::string &prefix, const std::string &middle, const std::string &suffix="") const
	Build a name from strings.

std::string	genSafeName (const std::string &prefix, const std::string &middle, const std::string &suffix="") const
	Build a name from strings that is safe to use in input files (i.e.

Static Public Member Functions
static InputParameters	validParams ()

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

static void	selectVectorTagsFromSystem (const SystemBase &system, const std::vector< VectorTag > &input_vector_tags, std::set< TagID > &selected_tags)

static void	selectMatrixTagsFromSystem (const SystemBase &system, const std::map< TagName, TagID > &input_matrix_tags, std::set< TagID > &selected_tags)

static void	objectSetupHelper (const std::vector< T * > &objects, const ExecFlagType &exec_flag)

static void	objectSetupHelper (const std::vector< T * > &objects, const ExecFlagType &exec_flag)

static void	objectExecuteHelper (const std::vector< T * > &objects)

static void	objectExecuteHelper (const std::vector< T * > &objects)

static void	setComponentVariableOrder (const VariableName &var, int index)
	Sets a component variable order index.

Public Attributes
std::map< std::string, std::vector< dof_id_type > >	_var_dof_map

	usingCombinedWarningSolutionWarnings

const ConsoleStream	_console

std::vector< Real >	_real_zero

std::vector< VariableValue >	_scalar_zero

std::vector< VariableValue >	_zero

std::vector< VariablePhiValue >	_phi_zero

std::vector< MooseArray< ADReal > >	_ad_zero

std::vector< VariableGradient >	_grad_zero

std::vector< MooseArray< ADRealVectorValue > >	_ad_grad_zero

std::vector< VariablePhiGradient >	_grad_phi_zero

std::vector< VariableSecond >	_second_zero

std::vector< MooseArray< ADRealTensorValue > >	_ad_second_zero

std::vector< VariablePhiSecond >	_second_phi_zero

std::vector< Point >	_point_zero

std::vector< VectorVariableValue >	_vector_zero

std::vector< VectorVariableCurl >	_vector_curl_zero

Real	_zero

Static Public Attributes
static const std::string	type_param

static const std::string	name_param

static const std::string	unique_name_param

static const std::string	app_param

static const std::string	moose_base_param

static const std::string	kokkos_object_param

Protected Member Functions
virtual void	meshChanged ()

MooseVariableFieldBase &	getVariableHelper (const THREAD_ID tid, const std::string &var_name, Moose::VarKindType expected_var_type, Moose::VarFieldType expected_var_field_type, const std::vector< T > &nls, const SystemBase &aux) const

void	createTagVectors ()

void	createTagSolutions ()

virtual void	meshDisplaced ()

void	computeSystems (const ExecFlagType &type)

bool	duplicateVariableCheck (const std::string &var_name, const libMesh::FEType &type, bool is_aux, const std::set< SubdomainID > *const active_subdomains)

void	computeUserObjectsInternal (const ExecFlagType &type, TheWarehouse::Query &query)

void	computeKokkosUserObjectsInternal (const ExecFlagType &type, TheWarehouse::Query &query)

void	checkDisplacementOrders ()

void	checkUserObjects ()

void	checkDependMaterialsHelper (const std::map< SubdomainID, std::vector< std::shared_ptr< MaterialBase > > > &materials_map)

void	checkCoordinateSystems ()

void	reinitBecauseOfGhostingOrNewGeomObjects (bool mortar_changed=false)

void	addObjectParamsHelper (InputParameters &params, const std::string &object_name, const std::string &var_param_name="variable")

bool	verifyVectorTags () const

void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const

InvalidSolutionID	registerInvalidSolutionInternal (const std::string &message, const bool warning) const

PerfID	registerTimedSection (const std::string &section_name, const unsigned int level) const

PerfID	registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const

std::string	timedSectionName (const std::string &section_name) const

T &	declareRestartableData (const std::string &data_name, Args &&... args)

ManagedValue< T >	declareManagedRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)

const T &	getRestartableData (const std::string &data_name) const

T &	declareRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)

T &	declareRecoverableData (const std::string &data_name, Args &&... args)

T &	declareRestartableDataWithObjectName (const std::string &data_name, const std::string &object_name, Args &&... args)

T &	declareRestartableDataWithObjectNameWithContext (const std::string &data_name, const std::string &object_name, void *context, Args &&... args)

std::string	restartableName (const std::string &data_name) const

void	setupEquations ()
	Setup equations to be solved in this simulation.

void	setupInitialConditionsFromFile ()
	Setup reading initial conditions from a specified file, see 'initial_from_file' and 'initial_from_file_timestep' parameters.

void	setupInitialConditionObjects ()

void	setupCoordinateSystem ()
	Sets the coordinate system for each subdomain.

void	setupCriticalHeatFluxTable ()
	Setup ctirical heat flux table user object.

Protected Attributes
bool	_use_nonlinear

std::vector< std::shared_ptr< NonlinearSystem > >	_nl_sys

MooseMesh &	_mesh

bool	_initialized

std::optional< std::vector< ConvergenceName > >	_nonlinear_convergence_names

std::optional< std::vector< ConvergenceName > >	_linear_convergence_names

std::optional< ConvergenceName >	_multiapp_fixed_point_convergence_name

std::optional< ConvergenceName >	_steady_state_convergence_name

std::set< TagID >	_fe_vector_tags

std::set< TagID >	_fe_matrix_tags

std::set< TagID >	_linear_vector_tags

std::set< TagID >	_linear_matrix_tags

const bool &	_solve

bool	_transient

Real &	_time

Real &	_time_old

int &	_t_step

Real &	_dt

Real &	_dt_old

bool	_need_to_add_default_nonlinear_convergence

bool	_need_to_add_default_multiapp_fixed_point_convergence

bool	_need_to_add_default_steady_state_convergence

const std::vector< LinearSystemName >	_linear_sys_names

const std::size_t	_num_linear_sys

std::vector< std::shared_ptr< LinearSystem > >	_linear_systems

std::map< LinearSystemName, unsigned int >	_linear_sys_name_to_num

LinearSystem *	_current_linear_sys

const bool	_using_default_nl

const std::vector< NonlinearSystemName >	_nl_sys_names

const std::size_t	_num_nl_sys

std::map< NonlinearSystemName, unsigned int >	_nl_sys_name_to_num

NonlinearSystemBase *	_current_nl_sys

SolverSystem *	_current_solver_sys

std::vector< std::shared_ptr< SolverSystem > >	_solver_systems

std::map< SolverVariableName, unsigned int >	_solver_var_to_sys_num

std::map< SolverSystemName, unsigned int >	_solver_sys_name_to_num

std::vector< SolverSystemName >	_solver_sys_names

std::shared_ptr< AuxiliarySystem >	_aux

Moose::CouplingType	_coupling

std::vector< std::unique_ptr< libMesh::CouplingMatrix > >	_cm

Moose::Kokkos::Array< Moose::Kokkos::System >	_kokkos_systems

Moose::Kokkos::Array< Moose::Kokkos::FESystem >	_kokkos_fe_systems

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

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

Moose::Kokkos::Assembly	_kokkos_assembly

MooseObjectWarehouse< MeshDivision >	_mesh_divisions

MooseObjectWarehouse< Function >	_functions

MooseObjectWarehouse< Moose::FunctionBase >	_kokkos_functions

MooseObjectWarehouse< Convergence >	_convergences

MooseObjectWarehouse< KernelBase >	_nonlocal_kernels

MooseObjectWarehouse< IntegratedBCBase >	_nonlocal_integrated_bcs

MaterialPropertyRegistry	_material_prop_registry

MaterialPropertyStorage &	_material_props

MaterialPropertyStorage &	_bnd_material_props

MaterialPropertyStorage &	_neighbor_material_props

Moose::Kokkos::MaterialPropertyStorage &	_kokkos_material_props

Moose::Kokkos::MaterialPropertyStorage &	_kokkos_bnd_material_props

Moose::Kokkos::MaterialPropertyStorage &	_kokkos_neighbor_material_props

MooseObjectWarehouse< Marker >	_markers

ReporterData	_reporter_data

ExecuteMooseObjectWarehouse< MultiApp >	_multi_apps

ExecuteMooseObjectWarehouse< TransientMultiApp >	_transient_multi_apps

ExecuteMooseObjectWarehouse< Transfer >	_transfers

ExecuteMooseObjectWarehouse< Transfer >	_to_multi_app_transfers

ExecuteMooseObjectWarehouse< Transfer >	_from_multi_app_transfers

ExecuteMooseObjectWarehouse< Transfer >	_between_multi_app_transfers

std::map< std::string, std::unique_ptr< RandomData > >	_random_data_objects

std::vector< std::unordered_map< SubdomainID, bool > >	_block_mat_side_cache

std::vector< std::unordered_map< BoundaryID, bool > >	_bnd_mat_side_cache

std::vector< std::unordered_map< BoundaryID, bool > >	_interface_mat_side_cache

std::vector< MeshChangedInterface * >	_notify_when_mesh_changes

std::vector< MeshDisplacedInterface * >	_notify_when_mesh_displaces

Adaptivity	_adaptivity

unsigned int	_cycles_completed

std::shared_ptr< XFEMInterface >	_xfem

MooseMesh *	_displaced_mesh

std::shared_ptr< DisplacedProblem >	_displaced_problem

GeometricSearchData	_geometric_search_data

std::unique_ptr< MortarInterfaceWarehouse >	_mortar_data

bool	_reinit_displaced_elem

bool	_reinit_displaced_face

bool	_reinit_displaced_neighbor

bool	_input_file_saved

bool	_has_dampers

bool	_has_constraints

bool	_snesmf_reuse_base

bool	_skip_exception_check

bool	_snesmf_reuse_base_set_by_user

bool	_has_initialized_stateful

bool	_const_jacobian

bool	_has_jacobian

bool	_needs_old_newton_iter

bool	_previous_nl_solution_required

std::vector< bool >	_previous_multiapp_fp_nl_solution_required

bool	_previous_multiapp_fp_aux_solution_required

std::vector< bool >	_previous_multisystem_fp_nl_solution_required

bool	_previous_multisystem_fp_aux_solution_required

bool	_has_nonlocal_coupling

bool	_calculate_jacobian_in_uo

std::vector< std::vector< const MooseVariableFEBase * > >	_uo_jacobian_moose_vars

std::vector< unsigned char >	_has_active_material_properties

std::vector< SolverParams >	_solver_params

CoverageCheckMode	_kernel_coverage_check

std::vector< SubdomainName >	_kernel_coverage_blocks

const bool	_boundary_restricted_node_integrity_check

const bool	_boundary_restricted_elem_integrity_check

const bool	_side_uo_interface_mat_prop_integrity_check

CoverageCheckMode	_material_coverage_check

std::vector< SubdomainName >	_material_coverage_blocks

bool	_fv_bcs_integrity_check

const bool	_material_dependency_check

const bool	_uo_aux_state_check

bool	_check_residual_for_nans

unsigned int	_max_qps

libMesh::Order	_max_scalar_order

bool	_has_time_integrator

bool	_has_exception

bool	_parallel_barrier_messaging

MooseEnum	_verbose_setup

bool	_verbose_multiapps

bool	_verbose_restore

std::string	_exception_message

ExecFlagType	_current_execute_on_flag

ExecuteMooseObjectWarehouse< Control >	_control_warehouse

Moose::PetscSupport::PetscOptions	_petsc_options

PetscOptions	_petsc_option_data_base

bool	_is_petsc_options_inserted

std::shared_ptr< LineSearch >	_line_search

std::unique_ptr< libMesh::ConstElemRange >	_evaluable_local_elem_range

std::unique_ptr< libMesh::ConstElemRange >	_nl_evaluable_local_elem_range

std::unique_ptr< libMesh::ConstElemRange >	_aux_evaluable_local_elem_range

std::unique_ptr< libMesh::ConstElemRange >	_current_algebraic_elem_range

std::unique_ptr< libMesh::ConstNodeRange >	_current_algebraic_node_range

std::unique_ptr< ConstBndNodeRange >	_current_algebraic_bnd_node_range

bool	_using_ad_mat_props

unsigned short	_current_ic_state

const bool	_use_hash_table_matrix_assembly

std::map< TagName, TagID >	_matrix_tag_name_to_tag_id

std::map< TagID, TagName >	_matrix_tag_id_to_tag_name

Factory &	_factory

DiracKernelInfo	_dirac_kernel_info

std::map< SubdomainID, std::set< std::string > >	_map_block_material_props

std::map< BoundaryID, std::set< std::string > >	_map_boundary_material_props

std::map< SubdomainID, std::set< MaterialPropertyName > >	_zero_block_material_props

std::map< BoundaryID, std::set< MaterialPropertyName > >	_zero_boundary_material_props

std::set< std::string >	_material_property_requested

std::vector< std::set< MooseVariableFieldBase * > >	_active_elemental_moose_variables

std::vector< unsigned int >	_has_active_elemental_moose_variables

std::vector< std::set< TagID > >	_active_fe_var_coupleable_matrix_tags

std::vector< std::set< TagID > >	_active_fe_var_coupleable_vector_tags

std::vector< std::set< TagID > >	_active_sc_var_coupleable_matrix_tags

std::vector< std::set< TagID > >	_active_sc_var_coupleable_vector_tags

bool	_default_ghosting

std::set< dof_id_type >	_ghosted_elems

bool	_currently_computing_jacobian

bool	_currently_computing_residual_and_jacobian

bool	_computing_nonlinear_residual

bool	_currently_computing_residual

bool	_safe_access_tagged_matrices

bool	_safe_access_tagged_vectors

bool	_have_ad_objects

std::unordered_set< TagID >	_not_zeroed_tagged_vectors

bool	_cli_option_found

bool	_color_output

bool	_termination_requested

const bool &	_enabled

MooseApp &	_app

ActionFactory &	_action_factory

const std::string &	_type

const std::string &	_name

const InputParameters &	_pars

MooseApp &	_pg_moose_app

const std::string	_prefix

MooseApp &	_restartable_app

const std::string	_restartable_system_name

const THREAD_ID	_restartable_tid

const bool	_restartable_read_only

InitialConditionWarehouse	_ics

FVInitialConditionWarehouse	_fv_ics

ScalarInitialConditionWarehouse	_scalar_ics

MaterialWarehouse	_materials

MaterialWarehouse	_interface_materials

MaterialWarehouse	_discrete_materials

MaterialWarehouse	_all_materials

MaterialWarehouse	_kokkos_materials

MooseObjectWarehouse< Indicator >	_indicators

MooseObjectWarehouse< InternalSideIndicatorBase >	_internal_side_indicators

std::map< SubdomainID, std::multimap< std::string, std::string > >	_map_block_material_props_check

std::map< BoundaryID, std::multimap< std::string, std::string > >	_map_boundary_material_props_check

const Parallel::Communicator &	_communicator

THMMesh &	_thm_mesh
	THM mesh.

FEProblemBase &	_fe_problem
	Pointer to FEProblem representing this simulation.

ThermalHydraulicsApp &	_thm_app
	The application this is associated with.

Factory &	_thm_factory
	The Factory associated with the MooseApp.

std::vector< std::shared_ptr< Component > >	_components
	List of components in this simulation.

std::map< std::string, std::shared_ptr< Component > >	_comp_by_name
	Map of components by their names.

std::map< std::string, std::string >	_component_name_to_loop_name
	Map of component name to component loop name.

std::map< std::string, THM::FlowModelID >	_loop_name_to_model_id
	Map of loop name to model type.

std::map< std::string, std::shared_ptr< ClosuresBase > >	_closures_by_name
	Map of closures by their names.

std::map< VariableName, VariableInfo >	_vars
	variables for this simulation (name and info about the var)

std::map< std::string, ICInfo >	_ics

const InputParameters &	_thm_pars
	"Global" of this simulation

libMesh::FEType	_flow_fe_type
	finite element type for the flow in the simulation

std::vector< OutputName >	_outputters_all

std::vector< OutputName >	_outputters_file

std::vector< OutputName >	_outputters_screen

std::map< std::string, ControlDataValue * >	_control_data
	Control data created in the control logic system.

bool	_implicit_time_integration
	true if using implicit time integration scheme

Logger	_log

bool	_check_jacobian
	True if checking jacobian.

std::map< dof_id_type, std::vector< dof_id_type > >	_sparsity_elem_augmentation
	Additional sparsity pattern that needs to be added into the Jacobian matrix.

bool	_output_vector_velocity
	Flag indicating if velocity is output as vector-valued field.

const Parallel::Communicator &	_communicator

Private Types
enum	TrueFunctorIs

Private Member Functions
void	setResidualObjectParamsAndLog (const std::string &ro_name, const std::string &name, InputParameters &parameters, const unsigned int nl_sys_num, const std::string &base_name, bool &reinit_displaced)

void	setAuxKernelParamsAndLog (const std::string &ak_name, const std::string &name, InputParameters &parameters, const std::string &base_name)

TheWarehouse::Query	getUOQuery (const std::string &system, const ExecFlagType &type, const Moose::AuxGroup &group) const

void	getUOExecutionGroups (TheWarehouse::Query &query, std::set< int > &execution_groups) const

void	handleException (const std::string &calling_method)

std::vector< MortarUserObject * >	getMortarUserObjects (BoundaryID primary_boundary_id, BoundaryID secondary_boundary_id, bool displaced, const std::vector< MortarUserObject * > &mortar_uo_superset)

std::vector< MortarUserObject * >	getMortarUserObjects (BoundaryID primary_boundary_id, BoundaryID secondary_boundary_id, bool displaced)

virtual std::pair< bool, unsigned int >	determineSolverSystem (const std::string &var_name, bool error_if_not_found=false) const override

void	checkICRestartError (const std::string &ic_name, const std::string &name, const VariableName &var_name)

void	addAnyRedistributers ()

void	updateMaxQps ()

void	joinAndFinalize (TheWarehouse::Query query, bool isgen=false)

void	kokkosJoinAndFinalize (const std::vector< Moose::Kokkos::UserObject * > &userobjs)

virtual void	resetState ()

void	cloneAlgebraicGhostingFunctor (libMesh::GhostingFunctor &algebraic_gf, bool to_mesh=true)

void	cloneCouplingGhostingFunctor (libMesh::GhostingFunctor &coupling_gf, bool to_mesh=true)

void	showFunctors () const

void	showFunctorRequestors () const

RestartableDataValue &	registerRestartableDataOnApp (std::unique_ptr< RestartableDataValue > data, THREAD_ID tid) const

void	registerRestartableNameWithFilterOnApp (const std::string &name, Moose::RESTARTABLE_FILTER filter)

RestartableData< T > &	declareRestartableDataHelper (const std::string &data_name, void *context, Args &&... args) const

std::string	restrictionSubdomainCheckName (SubdomainID check_id)

std::string	restrictionSubdomainCheckName (SubdomainID check_id)

std::string	restrictionBoundaryCheckName (BoundaryID check_id)

std::string	restrictionBoundaryCheckName (BoundaryID check_id)

std::vector< VariableName >	sortAddedComponentVariables () const
	Returns a sorted list of the variables added by components.

Static Private Member Functions
static const hit::Node *	getHitNode (const InputParameters &params)

static std::string	messagePrefix (const InputParameters &params, const bool hit_prefix)

static SolverParams	makeLinearSolverParams ()

Private Attributes
std::vector< std::shared_ptr< NonlinearSystemBase > >	_nl

Restartable::ManagedValue< RestartableEquationSystems >	_req

bool	_error_on_jacobian_nonzero_reallocation

const bool	_restore_original_nonzero_pattern

bool	_ignore_zeros_in_jacobian

bool	_preserve_matrix_sparsity_pattern

const bool	_force_restart

const bool	_allow_ics_during_restart

const bool	_skip_nl_system_check

bool	_fail_next_system_convergence_check

const bool	_allow_invalid_solution

const bool	_show_invalid_solution_console

const bool &	_immediately_print_invalid_solution

bool	_started_initial_setup

bool	_has_internal_edge_residual_objects

bool	_u_dot_requested

bool	_u_dotdot_requested

bool	_u_dot_old_requested

bool	_u_dotdot_old_requested

bool	_has_mortar

unsigned int	_num_grid_steps

bool	_trust_user_coupling_matrix

bool	_computing_scaling_jacobian

bool	_computing_scaling_residual

bool	_checking_uo_aux_state

ExecFlagEnum	_print_execution_on

const bool	_identify_variable_groups_in_nl

std::vector< VectorTag >	_current_residual_vector_tags

bool	_have_fv

const bool	_regard_general_exceptions_as_errors

std::vector< libMesh::CouplingMatrix >	_nonlocal_cm

bool	_requires_nonlocal_coupling

bool	_has_kokkos_objects

bool	_has_kokkos_residual_objects

std::vector< std::function< void()> >	_kokkos_mesh_initialization_hooks

std::vector< std::multimap< std::string, std::tuple< TrueFunctorIs, std::unique_ptr< Moose::FunctorEnvelopeBase >, std::unique_ptr< Moose::FunctorEnvelopeBase > > > >	_functors

std::vector< std::map< std::string, std::unique_ptr< Moose::FunctorAbstract > > >	_pbblf_functors

std::map< std::string, std::set< std::string > >	_functor_to_requestors

std::vector< std::multimap< std::string, std::pair< bool, bool > > >	_functor_to_request_info

bool	_show_functors

bool	_show_chain_control_data

std::vector< VectorTag >	_vector_tags

std::vector< std::vector< VectorTag > >	_typed_vector_tags

std::map< TagName, TagID >	_vector_tags_name_map

std::map< MooseObjectName, std::set< std::string > >	_consumed_material_properties

std::unordered_map< libMesh::GhostingFunctor *, std::vector< std::shared_ptr< libMesh::GhostingFunctor > > >	_root_alg_gf_to_sys_clones

std::unordered_map< libMesh::GhostingFunctor *, std::vector< std::shared_ptr< libMesh::GhostingFunctor > > >	_root_coupling_gf_to_sys_clones

bool	_have_p_refinement

std::unordered_map< FEFamily, bool >	_family_for_p_refinement

const ParallelParamObject &	_parent

const MooseBase &	_si_moose_base

const FEProblemBase *	_si_problem

const RestartableDataMapName	_metaname

std::string	_restartable_name

Static Private Attributes
static const std::unordered_set< FEFamily >	_default_families_without_p_refinement

static std::map< VariableName, int >	_component_variable_order_map
	Component variable order map; see setComponentVariableOrder for more info.

Detailed Description

Specialization of FEProblem to run with component subsystem.

Definition at line 18 of file THMProblem.h.

Constructor & Destructor Documentation

◆ THMProblem()

THMProblem::THMProblem ( const InputParameters & parameters )

Definition at line 37 of file THMProblem.C.

  : FEProblem(parameters), Simulation(*this, parameters)
{
}

Member Function Documentation

◆ addClosures()

void Simulation::addClosures	(	const std::string &	type,
		const std::string &	name,
		InputParameters	params
	)

virtualinherited

Add a closures object into this simulation.

Parameters

[in]	type	Closures class name
[in]	name	Closures object name
[in]	params	Input parameters

Definition at line 1009 of file Simulation.C.

{
  std::shared_ptr<ClosuresBase> obj_ptr = _thm_factory.create<ClosuresBase>(type, name, params);
  if (_closures_by_name.find(name) == _closures_by_name.end())
    _closures_by_name[name] = obj_ptr;
  else
    logError("A closures object with the name '", name, "' already exists.");
}

Referenced by AddClosuresAction::act().

◆ addComponent()

void Simulation::addComponent	(	const std::string &	type,
		const std::string &	name,
		InputParameters	params
	)

virtualinherited

Add a component into this simulation.

Parameters

type	Type (the registered class name) of the component
name	Name of the component
params	Input parameters

Definition at line 991 of file Simulation.C.

{
  std::shared_ptr<Component> comp = _thm_factory.create<Component>(type, name, params);
  if (_comp_by_name.find(name) == _comp_by_name.end())
    _comp_by_name[name] = comp;
  else
    logError("Component with name '", name, "' already exists");
  _components.push_back(comp);
}

Referenced by AddComponentAction::act(), and THMActionComponent::addTHMComponent().

◆ addComponentScalarIC()

void Simulation::addComponentScalarIC	(	const VariableName &	var_name,
		const std::vector< Real > &	value
	)

inherited

Definition at line 565 of file Simulation.C.

{
  if (hasInitialConditionsFromFile())
    return;
 
  std::string class_name = "ScalarComponentIC";
  InputParameters params = _thm_factory.getValidParams(class_name);
  params.set<VariableName>("variable") = var_name;
  params.set<std::vector<Real>>("values") = value;
  addSimInitialCondition(class_name, genName(var_name, "ic"), params);
}

◆ addConstantIC()

void Simulation::addConstantIC	(	const VariableName &	var_name,
		Real	value,
		const std::vector< SubdomainName > &	block_names
	)

inherited

Definition at line 512 of file Simulation.C.

{
  if (hasInitialConditionsFromFile())
    return;
 
  std::string blk_str = block_names[0];
  for (unsigned int i = 1; i < block_names.size(); i++)
    blk_str += ":" + block_names[i];
 
  std::string class_name = "ConstantIC";
  InputParameters params = _thm_factory.getValidParams(class_name);
  params.set<VariableName>("variable") = var_name;
  params.set<Real>("value") = value;
  params.set<std::vector<SubdomainName>>("block") = block_names;
  addSimInitialCondition(class_name, genName(var_name, blk_str, "ic"), params);
}

Referenced by FlowModel::addCommonInitialConditions(), VolumeJunction1Phase::addJunctionIC(), and HeatTransferFromExternalAppHeatFlux1Phase::addVariables().

◆ addConstantScalarIC()

void Simulation::addConstantScalarIC	(	const VariableName &	var_name,
		Real	value
	)

inherited

Definition at line 552 of file Simulation.C.

{
  if (hasInitialConditionsFromFile())
    return;
 
  std::string class_name = "ScalarConstantIC";
  InputParameters params = _thm_factory.getValidParams(class_name);
  params.set<VariableName>("variable") = var_name;
  params.set<Real>("value") = value;
  addSimInitialCondition(class_name, genName(var_name, "ic"), params);
}

Referenced by Shaft::addVariables(), and TotalPower::addVariables().

◆ addControl()

void Simulation::addControl	(	const std::string &	type,
		const std::string &	name,
		InputParameters	params
	)

inherited

Add a control.

Parameters

type	Type (registered name) of the control
name	Name of the control
params	Input parameters

Definition at line 487 of file Simulation.C.

{
  params.addPrivateParam<FEProblemBase *>("_fe_problem_base", &_fe_problem);
  std::shared_ptr<Control> control = _thm_factory.create<Control>(type, name, params);
  _fe_problem.getControlWarehouse().addObject(control);
}

◆ addFileOutputter()

void Simulation::addFileOutputter ( const std::string & name )

inherited

Definition at line 1035 of file Simulation.C.

{
  _outputters_all.push_back(name);
  _outputters_file.push_back(name);
}

Referenced by THMSetupOutputAction::act().

◆ addFunctionIC()

void Simulation::addFunctionIC	(	const VariableName &	var_name,
		const std::string &	func_name,
		const std::vector< SubdomainName > &	block_names
	)

inherited

Definition at line 532 of file Simulation.C.

{
  if (hasInitialConditionsFromFile())
    return;
 
  std::string blk_str = block_names[0];
  for (unsigned int i = 1; i < block_names.size(); i++)
    blk_str += ":" + block_names[i];
 
  std::string class_name = "FunctionIC";
  InputParameters params = _thm_factory.getValidParams(class_name);
  params.set<VariableName>("variable") = var_name;
  params.set<std::vector<SubdomainName>>("block") = block_names;
  params.set<FunctionName>("function") = func_name;
  addSimInitialCondition(class_name, genName(var_name, blk_str, "ic"), params);
}

Referenced by FlowModel::addCommonInitialConditions(), HeatTransferBase::addHeatedPerimeter(), HeatConductionModel::addInitialConditions(), HeatTransferFromExternalAppTemperature1Phase::addVariables(), HeatTransferFromHeatStructure1Phase::addVariables(), HeatTransferFromHeatStructure3D1Phase::addVariables(), and HeatTransferFromSpecifiedTemperature1Phase::addVariables().

◆ addMooseObjects()

void Simulation::addMooseObjects ( )

virtualinherited

Add component MOOSE objects.

Definition at line 738 of file Simulation.C.

{
  for (auto && comp : _components)
    comp->addMooseObjects();
}

Referenced by AddComponentMooseObjectsAction::act().

◆ addRelationshipManagers()

void Simulation::addRelationshipManagers ( )

inherited

Add additional relationship managers to run the simulation.

Definition at line 745 of file Simulation.C.

{
  {
    const std::string class_name = "AugmentSparsityBetweenElements";
    auto params = _thm_factory.getValidParams(class_name);
    params.set<Moose::RelationshipManagerType>("rm_type") =
        Moose::RelationshipManagerType::COUPLING | Moose::RelationshipManagerType::ALGEBRAIC |
        Moose::RelationshipManagerType::GEOMETRIC;
    params.set<std::string>("for_whom") = _fe_problem.name();
    params.set<MooseMesh *>("mesh") = &_thm_mesh;
    params.set<std::map<dof_id_type, std::vector<dof_id_type>> *>("_elem_map") =
        &_sparsity_elem_augmentation;
    auto rm =
        _thm_factory.create<RelationshipManager>(class_name, "thm:sparsity_btw_elems", params);
    if (!_thm_app.addRelationshipManager(rm))
      _thm_factory.releaseSharedObjects(*rm);
  }
 
  for (auto && comp : _components)
    comp->addRelationshipManagers(Moose::RelationshipManagerType::COUPLING |
                                  Moose::RelationshipManagerType::ALGEBRAIC |
                                  Moose::RelationshipManagerType::GEOMETRIC);
}

Referenced by THMAddRelationshipManagersAction::act().

◆ addScreenOutputter()

void Simulation::addScreenOutputter ( const std::string & name )

inherited

Definition at line 1042 of file Simulation.C.

{
  _outputters_all.push_back(name);
  _outputters_screen.push_back(name);
}

Referenced by THMSetupOutputAction::act().

◆ addSimInitialCondition()

void Simulation::addSimInitialCondition	(	const std::string &	type,
		const std::string &	name,
		InputParameters	params
	)

inherited

Definition at line 495 of file Simulation.C.

{
  if (hasInitialConditionsFromFile())
    return;
 
  if (_ics.find(name) == _ics.end())
  {
    ICInfo ic(type, params);
    _ics[name] = ic;
  }
  else
    mooseError("Initial condition with name '", name, "' already exists.");
}

Referenced by FlowModel::addCommonInitialConditions(), Simulation::addComponentScalarIC(), Simulation::addConstantIC(), Simulation::addConstantScalarIC(), FlowModelGasMix::addDensityIC(), FlowModelSinglePhase::addDensityIC(), FlowModel1PhaseBase::addFunctionIC(), Simulation::addFunctionIC(), FlowModelSinglePhase::addPassiveTransportIC(), FlowModel1PhaseBase::addRhoAIC(), FlowModelGasMix::addRhoEAIC(), FlowModelSinglePhase::addRhoEAIC(), FlowModel1PhaseBase::addRhoUAIC(), FlowModel1PhaseBase::addSpecificInternalEnergyIC(), FlowModel1PhaseBase::addSpecificTotalEnthalpyIC(), FlowModel1PhaseBase::addSpecificVolumeIC(), FlowChannelBase::addVariables(), FlowModel1PhaseBase::addVelocityIC(), VolumeJunction1Phase::addVolumeJunctionIC(), and FlowModelGasMix::addXiRhoAIC().

◆ addSimVariable() [1/3]

void Simulation::addSimVariable	(	bool	nl,
		const std::string &	var_type,
		const VariableName &	name,
		const InputParameters &	params
	)

inherited

Queues a generic variable to be added to the nonlinear or aux system.

Parameters

[in]	nl	True if this is a nonlinear (solution) variable
[in]	var_type	Type (class) of the variable
[in]	name	Name of the variable
[in]	params	Input parameters for the variable

Definition at line 405 of file Simulation.C.

{
  checkVariableNameLength(name);
 
  if (_vars.find(name) == _vars.end()) // variable is new
  {
    VariableInfo vi;
    vi._nl = nl;
    vi._var_type = var_type;
    vi._params = params;
 
    _vars[name] = vi;
  }
  else // variable was previously added
  {
    VariableInfo & vi = _vars[name];
    InputParameters & vi_params = vi._params;
 
    if (vi._nl != nl)
      mooseError("The variable '",
                 name,
                 "' has already been added in a different system (nonlinear or aux).");
 
    if (vi._var_type != var_type)
      mooseError("The variable '",
                 name,
                 "' has already been added with a different type than '",
                 var_type,
                 "'.");
 
    // Check that all valid parameters (other than 'block') are consistent
    for (auto it = params.begin(); it != params.end(); it++)
    {
      const std::string param_name = it->first;
      if (param_name == "block")
      {
        if (vi_params.isParamValid("block"))
        {
          auto blocks = vi_params.get<std::vector<SubdomainName>>("block");
          const auto new_blocks = params.get<std::vector<SubdomainName>>("block");
          for (const auto & subdomain_name : new_blocks)
            if (std::find(blocks.begin(), blocks.end(), subdomain_name) == blocks.end())
              blocks.push_back(subdomain_name);
          vi_params.set<std::vector<SubdomainName>>("block") = blocks;
        }
        else
          mooseError("The variable '", name, "' was added previously without block restriction.");
      }
      else if (params.isParamValid(param_name))
      {
        if (vi_params.isParamValid(param_name))
        {
          if (params.rawParamVal(param_name) != vi_params.rawParamVal(param_name))
            mooseError("The variable '",
                       name,
                       "' was added previously with a different value for the parameter '",
                       param_name,
                       "'.");
        }
        else
          mooseError("The variable '",
                     name,
                     "' was added previously without the parameter '",
                     param_name,
                     "'.");
      }
    }
  }
}

◆ addSimVariable() [2/3]

void Simulation::addSimVariable	(	bool	nl,
		const VariableName &	name,
		libMesh::FEType	fe_type,
		const std::vector< SubdomainName > &	subdomain_names,
		Real	scaling_factor = `1.0`
	)

inherited

Queues a variable of type MooseVariable to be added to the nonlinear or aux system.

Parameters

[in]	nl	True if this is a nonlinear (solution) variable
[in]	name	Name of the variable
[in]	fe_type	FEType of the variable
[in]	subdomain_names	List of subdomain names to add the variable to
[in]	scaling_factor	Scaling factor for the variable

Definition at line 314 of file Simulation.C.

{
  checkVariableNameLength(name);
 
  if (fe_type.family == SCALAR)
    mooseDeprecated(
        "The version of Simulation::addSimVariable() with subdomain names can no longer be used "
        "with scalar variables since scalar variables cannot be block-restricted. Use the version "
        "of Simulation::addSimVariable() without subdomain names instead.");
 
#ifdef DEBUG
  for (const auto & subdomain_name : subdomain_names)
    mooseAssert(subdomain_name != "ANY_BLOCK_ID",
                "'ANY_BLOCK_ID' cannot be used for adding field variables in components.");
#endif
 
  if (_vars.find(name) == _vars.end()) // variable is new
  {
    VariableInfo vi;
    InputParameters & params = vi._params;
 
    vi._nl = nl;
    vi._var_type = "MooseVariable";
    params = _thm_factory.getValidParams(vi._var_type);
    params.set<std::vector<SubdomainName>>("block") = subdomain_names;
 
    auto family = AddVariableAction::getNonlinearVariableFamilies();
    family = Utility::enum_to_string(fe_type.family);
    params.set<MooseEnum>("family") = family;
 
    auto order = AddVariableAction::getNonlinearVariableOrders();
    order = Utility::enum_to_string<Order>(fe_type.order);
    params.set<MooseEnum>("order") = order;
 
    if (nl)
      params.set<std::vector<Real>>("scaling") = {scaling_factor};
    else if (!MooseUtils::absoluteFuzzyEqual(scaling_factor, 1.0))
      mooseError("Aux variables cannot be provided a residual scaling factor.");
 
    _vars[name] = vi;
  }
  else // variable was previously added
  {
    VariableInfo & vi = _vars[name];
    InputParameters & params = vi._params;
 
    if (vi._nl != nl)
      mooseError("The variable '",
                 name,
                 "' has already been added in a different system (nonlinear or aux).");
 
    if (vi._var_type != "MooseVariable")
      mooseError("The variable '",
                 name,
                 "' has already been added with a different type than 'MooseVariable'.");
 
    auto family = AddVariableAction::getNonlinearVariableFamilies();
    family = Utility::enum_to_string(fe_type.family);
    if (!params.get<MooseEnum>("family").compareCurrent(family))
      mooseError("The variable '", name, "' has already been added with a different FE family.");
 
    auto order = AddVariableAction::getNonlinearVariableOrders();
    order = Utility::enum_to_string<Order>(fe_type.order);
    if (!params.get<MooseEnum>("order").compareCurrent(order))
      mooseError("The variable '", name, "' has already been added with a different FE order.");
 
    // If already block-restricted, extend the block restriction
    if (params.isParamValid("block"))
    {
      auto blocks = params.get<std::vector<SubdomainName>>("block");
      for (const auto & subdomain_name : subdomain_names)
        if (std::find(blocks.begin(), blocks.end(), subdomain_name) == blocks.end())
          blocks.push_back(subdomain_name);
      params.set<std::vector<SubdomainName>>("block") = blocks;
    }
    else
      params.set<std::vector<SubdomainName>>("block") = subdomain_names;
 
    if (params.isParamValid("scaling"))
      if (!MooseUtils::absoluteFuzzyEqual(params.get<std::vector<Real>>("scaling")[0],
                                          scaling_factor))
        mooseError(
            "The variable '", name, "' has already been added with a different scaling factor.");
  }
}

◆ addSimVariable() [3/3]

void Simulation::addSimVariable	(	bool	nl,
		const VariableName &	name,
		libMesh::FEType	fe_type,
		Real	scaling_factor = `1.0`
	)

inherited

Queues a variable of type MooseVariableScalar to be added to the nonlinear or aux system.

Parameters

[in]	nl	True if this is a nonlinear (solution) variable
[in]	name	Name of the variable
[in]	fe_type	FEType of the variable
[in]	scaling_factor	Scaling factor for the variable

Definition at line 271 of file Simulation.C.

{
  checkVariableNameLength(name);
 
  if (fe_type.family != SCALAR)
    mooseError("This method should only be used for scalar variables.");
 
  if (_vars.find(name) == _vars.end()) // variable is new
  {
    VariableInfo vi;
    InputParameters & params = vi._params;
 
    vi._nl = nl;
    vi._var_type = "MooseVariableScalar";
    params = _thm_factory.getValidParams(vi._var_type);
 
    auto family = AddVariableAction::getNonlinearVariableFamilies();
    family = Utility::enum_to_string(fe_type.family);
    params.set<MooseEnum>("family") = family;
 
    auto order = AddVariableAction::getNonlinearVariableOrders();
    order = Utility::enum_to_string<Order>(fe_type.order);
    params.set<MooseEnum>("order") = order;
 
    if (nl)
      params.set<std::vector<Real>>("scaling") = {scaling_factor};
    else if (!MooseUtils::absoluteFuzzyEqual(scaling_factor, 1.0))
      mooseError("Aux variables cannot be provided a residual scaling factor.");
 
    _vars[name] = vi;
  }
  else
    // One of the two cases is true:
    // - This variable was previously added as a scalar variable, and scalar
    //   variables should not be added more than once, since there is no block
    //   restriction to extend, as there is in the field variable version of this
    //   method.
    // - This variable was previously added as a field variable, and a variable
    //   may have only one type (this method is used for scalar variables only).
    mooseError("The variable '", name, "' was already added.");
}

Referenced by FlowModel::addCommonVariables(), HeatTransferBase::addHeatedPerimeter(), HeatConductionModel::addVariables(), FlowModel1PhaseBase::addVariables(), FlowModelGasMix::addVariables(), FlowModelSinglePhase::addVariables(), FormLossFromExternalApp1Phase::addVariables(), HeatTransferFromExternalAppHeatFlux1Phase::addVariables(), HeatTransferFromHeatStructure3D1Phase::addVariables(), HeatTransferFromTemperature1Phase::addVariables(), HSBoundaryExternalAppConvection::addVariables(), HSBoundaryExternalAppHeatFlux::addVariables(), HSBoundaryExternalAppTemperature::addVariables(), Shaft::addVariables(), and TotalPowerBase::addVariables().

◆ addVariables()

void Simulation::addVariables ( )

virtualinherited

Add variables involved in this simulation.

Definition at line 634 of file Simulation.C.

{
  TransientBase * trex = dynamic_cast<TransientBase *>(getApp().getExecutioner());
  if (trex)
  {
    Moose::TimeIntegratorType ti_type = trex->getTimeScheme();
    // This is only needed for the listed time integrators that are using the original approach to
    // explicit integration in MOOSE.  Currently, the new time integrators like
    // ActuallyExplicitEuler do not need the implicit flag to be set.
    if (ti_type == Moose::TI_EXPLICIT_TVD_RK_2 || ti_type == Moose::TI_EXPLICIT_MIDPOINT ||
        ti_type == Moose::TI_EXPLICIT_EULER)
      _implicit_time_integration = false;
  }
 
  if (_components.size() == 0)
    return;
 
  // Cache the variables that components request to add
  for (auto && comp : _components)
    comp->addVariables();
 
  // Sort the variables for a consistent ordering
  const auto var_names = sortAddedComponentVariables();
 
  // Report the ordering if the executioner is verbose
  if (_fe_problem.getParam<MooseEnum>("verbose_setup") != "false")
  {
    std::stringstream ss;
    ss << "The system ordering of variables added by Components is as follows:\n";
    for (const auto & var : var_names)
      ss << "  " << var << "\n";
    mooseInfo(ss.str());
  }
 
  // Add the variables to the problem
  for (const auto & name : var_names)
  {
    VariableInfo & vi = _vars[name];
 
    if (vi._nl)
      _fe_problem.addVariable(vi._var_type, name, vi._params);
    else
      _fe_problem.addAuxVariable(vi._var_type, name, vi._params);
  }
 
  if (hasInitialConditionsFromFile())
    setupInitialConditionsFromFile();
  else
    setupInitialConditionObjects();
}

Referenced by THMAddVariablesAction::act().

◆ advanceState()

void THMProblem::advanceState ( )

overridevirtual

Reimplemented from FEProblem.

Definition at line 43 of file THMProblem.C.

{
  FEProblem::advanceState();
  Simulation::advanceState();
}

◆ augmentSparsity()

void Simulation::augmentSparsity	(	const dof_id_type &	elem_id1,
		const dof_id_type &	elem_id2
	)

virtualinherited

Hint how to augment sparsity pattern between two elements.

The augmentation will be symmetric

Definition at line 71 of file Simulation.C.

{
  auto it = _sparsity_elem_augmentation.find(elem_id1);
  if (it == _sparsity_elem_augmentation.end())
    it = _sparsity_elem_augmentation.insert(_sparsity_elem_augmentation.begin(),
                                            {elem_id1, std::vector<dof_id_type>()});
  it->second.push_back(elem_id2);
 
  it = _sparsity_elem_augmentation.find(elem_id2);
  if (it == _sparsity_elem_augmentation.end())
    it = _sparsity_elem_augmentation.insert(_sparsity_elem_augmentation.begin(),
                                            {elem_id2, std::vector<dof_id_type>()});
  it->second.push_back(elem_id1);
}

Referenced by GateValve1Phase::setupMesh(), HeatStructure2DCouplerBase::setupMesh(), HeatTransferFromHeatStructure1Phase::setupMesh(), HeatTransferFromHeatStructure3D1Phase::setupMesh(), HSCoupler2D2DRadiation::setupMesh(), HSCoupler2D3D::setupMesh(), JunctionOneToOne1Phase::setupMesh(), and VolumeJunction1Phase::setupMesh().

◆ buildMesh()

void Simulation::buildMesh ( )

virtualinherited

Create mesh for this simulation.

Definition at line 87 of file Simulation.C.

{
  if (_components.size() == 0)
    return;
 
  // build mesh
  for (auto && comp : _components)
    comp->executeSetupMesh();
}

Referenced by THMBuildMeshAction::act().

◆ checkVariableNameLength()

void Simulation::checkVariableNameLength ( const std::string & name ) const

inherited

Reports an error if the variable name is too long.

Definition at line 479 of file Simulation.C.

{
  if (name.size() > THM::MAX_VARIABLE_LENGTH)
    mooseError(
        "Variable name '", name, "' is too long. The limit is ", THM::MAX_VARIABLE_LENGTH, ".");
}

Referenced by Simulation::addSimVariable(), Simulation::addSimVariable(), and Simulation::addSimVariable().

◆ controlDataIntegrityCheck()

void Simulation::controlDataIntegrityCheck ( )

virtualinherited

Check the integrity of the control data.

Definition at line 911 of file Simulation.C.

{
  if (_check_jacobian)
    return;
 
  // check that control data are consistent
  for (auto && i : _control_data)
  {
    if (!i.second->getDeclared())
      logError("Control data '",
               i.first,
               "' was requested, but was not declared by any active control object.");
  }
 
  _log.emitLoggedErrors();
 
  auto & ctrl_wh = _fe_problem.getControlWarehouse()[EXEC_TIMESTEP_BEGIN];
 
  // initialize THM control objects
  for (auto && i : ctrl_wh.getObjects())
  {
    THMControl * ctrl = dynamic_cast<THMControl *>(i.get());
    if (ctrl != nullptr)
      ctrl->init();
  }
 
  for (auto && i : ctrl_wh.getObjects())
  {
    THMControl * ctrl = dynamic_cast<THMControl *>(i.get());
    // if it is a THM control
    if (ctrl != nullptr)
    {
      // get its dependencies on control data
      auto & cd_deps = ctrl->getControlDataDependencies();
      for (auto && cd_name : cd_deps)
      {
        ControlDataValue * cdv = _control_data[cd_name];
        // find out which control object built the control data
        std::string dep_name = cdv->getControl()->name();
        auto & deps = ctrl->getDependencies();
        // and if it is not in its dependency list, add it
        auto it = std::find(deps.begin(), deps.end(), dep_name);
        if (it == deps.end())
          deps.push_back(dep_name);
      }
    }
  }
 
  // Find all `TerminateControl`s and all their dependencies. Then add those
  // objects into TIMESTEP_END control warehouse
  MooseObjectWarehouse<Control> & ctrl_wh_tse =
      _fe_problem.getControlWarehouse()[EXEC_TIMESTEP_END];
  for (auto && i : ctrl_wh.getObjects())
  {
    if (TerminateControl * ctrl = dynamic_cast<TerminateControl *>(i.get()))
    {
      std::list<const THMControl *> l;
      l.push_back(ctrl);
      while (l.size() > 0)
      {
        const THMControl * ctrl = l.front();
        auto & cd_deps = ctrl->getControlDataDependencies();
        for (auto && cd_name : cd_deps)
        {
          ControlDataValue * cdv = _control_data[cd_name];
          l.push_back(cdv->getControl());
        }
        ctrl_wh_tse.addObject(ctrl_wh.getObject(ctrl->name()));
        l.pop_front();
      }
    }
  }
}

Referenced by ControlDataIntegrityCheckAction::act().

◆ copySolutionsBackwards()

void THMProblem::copySolutionsBackwards ( )

overridevirtual

Reimplemented from FEProblem.

Definition at line 50 of file THMProblem.C.

{
  FEProblem::copySolutionsBackwards();
  Simulation::advanceState();
}

◆ couplingMatrixIntegrityCheck()

void Simulation::couplingMatrixIntegrityCheck ( ) const

virtualinherited

Check integrity of coupling matrix used by the preconditioner.

Definition at line 807 of file Simulation.C.

{
  if (!_fe_problem.shouldSolve())
    return;
 
  const TimeIntegrator * ti = nullptr;
  const auto & time_integrators =
      _fe_problem.getNonlinearSystemBase(/*nl_sys_num=*/0).getTimeIntegrators();
  if (!time_integrators.empty())
    ti = time_integrators.front().get();
  // Yes, this is horrible. Don't ask why...
  if ((dynamic_cast<const ExplicitTimeIntegrator *>(ti) != nullptr) ||
      (dynamic_cast<const ExplicitEuler *>(ti) != nullptr) ||
      (dynamic_cast<const ExplicitRK2 *>(ti) != nullptr) ||
      (dynamic_cast<const ExplicitTVDRK2 *>(ti) != nullptr))
    return;
 
  const CouplingMatrix * cm = _fe_problem.couplingMatrix(/*nl_sys_num=*/0);
  if (cm == nullptr)
    mooseError("Coupling matrix does not exists. Something really bad happened.");
 
  bool full = true;
  for (unsigned int i = 0; i < cm->size(); i++)
    for (unsigned int j = 0; j < cm->size(); j++)
      full &= (*cm)(i, j);
 
  if (!full)
    mooseError(
        "Single matrix preconditioning with full coupling is required to run. Please, check that "
        "your input file has the following preconditioning block:\n\n"
        "[Preconditioning]\n"
        "  [pc]\n"
        "    type = SMP\n"
        "    full = true\n"
        "  []\n"
        "[].\n");
}

Referenced by THMPreconditioningIntegrityCheckAction::act().

◆ declareControlData()

template<typename T >

ControlData< T > * Simulation::declareControlData	(	const std::string &	name,
		THMControl *	ctrl
	)

inlineinherited

Declare control data of type T and name 'name', if it does not exist it will be created.

Parameters

name	The unique name of the control data

Returns: Pointer to the control data of type T

Definition at line 311 of file Simulation.h.

  {
    ControlData<T> * data = getControlData<T>(name);
    if (!data->getDeclared())
    {
      // Mark the data for error checking
      data->setDeclared();
      data->setControl(ctrl);
    }
    else
      logError("Trying to declare '", name, "', but it was already declared.");
 
    return data;
  }

Referenced by THMControl::declareComponentControlData(), and THMControl::declareControlData().

◆ genName() [1/4]

std::string NamingInterface::genName	(	const std::string &	prefix,
		const std::string &	middle,
		const std::string &	suffix = `""`
	)		const

inlineinherited

Build a name from strings.

Definition at line 66 of file NamingInterface.h.

  {
    std::stringstream ss;
    ss << prefix << ":" << middle;
    if (!suffix.empty())
      ss << ":" << suffix;
    return ss.str();
  }

◆ genName() [2/4]

std::string NamingInterface::genName	(	const std::string &	prefix,
		const std::string &	name,
		unsigned int	i
	)		const

inlineinherited

Build a name from 2 strings and a number.

Definition at line 56 of file NamingInterface.h.

  {
    std::stringstream ss;
    ss << prefix << ":" << name << ":" << i;
    return ss.str();
  }

◆ genName() [3/4]

std::string NamingInterface::genName	(	const std::string &	prefix,
		unsigned int	i,
		unsigned int	j,
		const std::string &	suffix = `""`
	)		const

inlineinherited

Build a name from a prefix, 2 numbers and possible suffix.

Definition at line 41 of file NamingInterface.h.

  {
    std::stringstream ss;
    ss << prefix << ":" << i << ":" << j;
    if (!suffix.empty())
      ss << ":" << suffix;
    return ss.str();
  }

◆ genName() [4/4]

std::string NamingInterface::genName	(	const std::string &	prefix,
		unsigned int	id,
		const std::string &	suffix = `""`
	)		const

inlineinherited

Build a name from a prefix, number and possible suffix.

Definition at line 29 of file NamingInterface.h.

  {
    std::stringstream ss;
    ss << prefix << ":" << id;
    if (!suffix.empty())
      ss << ":" << suffix;
    return ss.str();
  }

◆ genSafeName()

std::string NamingInterface::genSafeName	(	const std::string &	prefix,
		const std::string &	middle,
		const std::string &	suffix = `""`
	)		const

inlineinherited

Build a name from strings that is safe to use in input files (i.e.

can be exposed to users)

Definition at line 80 of file NamingInterface.h.

  {
    std::stringstream ss;
    ss << prefix << "_" << middle;
    if (!suffix.empty())
      ss << "_" << suffix;
    return ss.str();
  }

Referenced by HSBoundaryAmbientConvection::addMooseObjects(), HSBoundaryExternalAppConvection::addMooseObjects(), HSBoundaryExternalAppHeatFlux::addMooseObjects(), HSBoundaryHeatFlux::addMooseObjects(), and HSBoundaryRadiation::addMooseObjects().

◆ getApp()

ThermalHydraulicsApp & Simulation::getApp ( )

inlineinherited

Get the ThermalHydraulicsApp.

Definition at line 245 of file Simulation.h.

245{ return _thm_app; }

Referenced by Simulation::addVariables().

◆ getClosures()

std::shared_ptr< ClosuresBase > Simulation::getClosures ( const std::string & name ) const

inherited

Get a pointer to a closures object.

Parameters

[in] name Closures object name

Definition at line 1025 of file Simulation.C.

{
  auto it = _closures_by_name.find(name);
  if (it != _closures_by_name.end())
    return it->second;
  else
    mooseError("The requested closures object '", name, "' does not exist.");
}

Referenced by FlowChannelBase::init().

◆ getComponentByName()

template<typename T >

const T & Simulation::getComponentByName ( const std::string & name ) const

inherited

Get component by its name.

Template Parameters

T	the type of the component we are requesting

Parameters

name	The name of the component

Returns: Pointer to the component if found, otherwise throws and error

Definition at line 504 of file Simulation.h.

{
  auto it = _comp_by_name.find(name);
  if (it != _comp_by_name.end())
    return *dynamic_cast<T *>((it->second).get());
  else
    mooseError("Component '",
               name,
               "' does not exist in the simulation. Use hasComponent or "
               "checkComponnetByName before calling getComponent.");
}

Referenced by VolumeJunctionCoupledFlux1Phase::addFluxPostprocessor(), VolumeJunctionCoupledFlux1Phase::addVolumeJunctionKernel(), Component::getComponentByName(), Component1DConnection::init(), FlowBoundary::init(), FlowBoundary1PhaseBase::init(), FlowJunction::init(), and FlowJunction1Phase::init().

◆ getComponents()

const std::vector< std::shared_ptr< Component > > & Simulation::getComponents ( ) const

inlineinherited

Return list of components available in the simulation.

Definition at line 117 of file Simulation.h.

117{ return _components; }

Referenced by ComponentsConvergence::initialSetup(), and ParaviewComponentAnnotationMap::output().

◆ getControlData()

template<typename T >

ControlData< T > * Simulation::getControlData ( const std::string & name )

inlineinherited

Get control data of type T and name 'name', if it does not exist it will be created.

Parameters

name	The unique name of the control data

Returns: Pointer to the control data of type T

Definition at line 290 of file Simulation.h.

  {
    ControlData<T> * data = nullptr;
    if (_control_data.find(name) == _control_data.end())
    {
      data = new ControlData<T>(_thm_app, name);
      _control_data[name] = data;
    }
    else
      data = dynamic_cast<ControlData<T> *>(_control_data[name]);
 
    return data;
  }

Referenced by BoolControlDataValuePostprocessor::BoolControlDataValuePostprocessor(), THMControl::getControlDataByName(), THMControl::getControlDataOldByName(), THMParsedFunctionWrapper::initialize(), and RealControlDataValuePostprocessor::RealControlDataValuePostprocessor().

◆ getFlowFEType()

const libMesh::FEType & Simulation::getFlowFEType ( ) const

inlineinherited

Gets the FE type for the flow in this simulation.

Definition at line 48 of file Simulation.h.

48{ return _flow_fe_type; }

Simulation::_flow_fe_type

libMesh::FEType _flow_fe_type

finite element type for the flow in the simulation

Definition Simulation.h:430

Referenced by Simulation::setupQuadrature().

◆ getImplicitTimeIntegrationFlag()

const bool & Simulation::getImplicitTimeIntegrationFlag ( )

inlineinherited

Gets the flag indicating whether an implicit time integration scheme is being used.

Definition at line 329 of file Simulation.h.

329{ return _implicit_time_integration; }

Referenced by FlowModelGasMix::addMassDiffusionEnergyDGKernel(), FlowModelGasMix::addMassDiffusionSpeciesDGKernel(), GateValve1Phase::addMooseObjects(), JunctionOneToOne1Phase::addMooseObjects(), VolumeJunction1Phase::addMooseObjects(), FlowModelGasMix::addRDGAdvectionDGKernels(), FlowModelSinglePhase::addRDGAdvectionDGKernels(), FlowModelGasMix::addSlopeReconstructionMaterial(), FlowModelSinglePhase::addSlopeReconstructionMaterial(), FlowBoundary1Phase::addWeakBCs(), and FlowBoundaryGasMix::addWeakBCs().

◆ getOutputsVector()

std::vector< OutputName > Simulation::getOutputsVector ( const std::string & key ) const

inherited

Gets the vector of output names corresponding to a 1-word key string.

Parameters

[in] key string key that corresponds to an output names vector

Returns: output names vector corresponding to key

Definition at line 1049 of file Simulation.C.

{
  std::string key_lowercase = key;
  std::transform(key_lowercase.begin(), key_lowercase.end(), key_lowercase.begin(), ::tolower);
 
  std::vector<OutputName> outputs;
  if (key_lowercase == "none")
    outputs.push_back("none"); // provide non-existent name, so it does not get printed out
  else if (key_lowercase == "screen")
    outputs = _outputters_screen;
  else if (key_lowercase == "file")
    outputs = _outputters_file;
  else if (key_lowercase == "both")
    outputs = _outputters_all;
  else
    mooseError("The outputs vector key '" + key_lowercase + "' is invalid");
 
  return outputs;
}

◆ getVectorValuedVelocity()

bool Simulation::getVectorValuedVelocity ( )

inlineinherited

Is velocity output as vector-valued field.

Returns: true for vector-valued field, false for scalar

Definition at line 359 of file Simulation.h.

359{ return _output_vector_velocity; }

Simulation::_output_vector_velocity

bool _output_vector_velocity

Flag indicating if velocity is output as vector-valued field.

Definition Simulation.h:474

Referenced by FlowChannel1PhaseBase::buildFlowModel().

◆ hasClosures()

bool Simulation::hasClosures ( const std::string & name ) const

inherited

Return whether the simulation has a closures object.

Parameters

[in] name Closures object name

Definition at line 1019 of file Simulation.C.

{
  return _closures_by_name.find(name) != _closures_by_name.end();
}

◆ hasComponent()

bool Simulation::hasComponent ( const std::string & name ) const

inherited

Find out if simulation has a component with the given name.

Parameters

name	The name of the component

Returns: true if the components exists, otherwise false

Definition at line 1002 of file Simulation.C.

{
  auto it = _comp_by_name.find(name);
  return (it != _comp_by_name.end());
}

Referenced by Component::checkComponentExistsByName(), Component::checkComponentOfTypeExistsByName(), and Simulation::initSimulation().

◆ hasComponentOfType()

template<typename T >

bool Simulation::hasComponentOfType ( const std::string & name ) const

inherited

Find out if simulation has a component with the given name and specified type.

Template Parameters

T	the type of the component we are requesting

Parameters

name	The name of the component

Returns: true if the component exists and has specified type, otherwise false

Definition at line 493 of file Simulation.h.

{
  auto it = _comp_by_name.find(name);
  if (it != _comp_by_name.end())
    return dynamic_cast<T *>((it->second).get()) != nullptr;
  else
    return false;
}

Referenced by Component::checkComponentOfTypeExistsByName(), and Component::hasComponentByName().

◆ hasControlData()

template<typename T >

bool Simulation::hasControlData ( const std::string & name )

inlineinherited

Query if control data with name 'name' exists.

Parameters

name	The unique name of the control data

Returns: true if control data 'name' exists, false otherwise

Definition at line 275 of file Simulation.h.

  {
    if (_control_data.find(name) == _control_data.end())
      return false;
    else
      return dynamic_cast<ControlData<T> *>(_control_data[name]) != NULL;
  }

Referenced by THMParsedFunctionWrapper::initialize().

◆ hasInitialConditionsFromFile()

bool Simulation::hasInitialConditionsFromFile ( ) const

inherited

Are initial conditions specified from a file.

Returns: true if initial conditions are specified from a file

Definition at line 1070 of file Simulation.C.

{
  return _thm_pars.isParamValid("initial_from_file");
}

Referenced by Simulation::addComponentScalarIC(), Simulation::addConstantIC(), Simulation::addConstantScalarIC(), Simulation::addFunctionIC(), Simulation::addSimInitialCondition(), Simulation::addVariables(), HeatStructureInterface::check(), FlowChannel1PhaseBase::check(), Shaft::check(), and VolumeJunction1Phase::check().

◆ hasPostprocessor()

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

virtual

Check if a postprocessor with a given name exists in the simulation.

Returns: true if postprocessor with the given name exists in the simulation, false otherwise

Parameters

name	The name of the postprocessor

Definition at line 57 of file THMProblem.C.

{
  if (_reporter_data.hasReporterValue(ReporterName(name, "value")))
    return true;
 
  // Sometimes we want to know if a Postprocessor exists well before Postprocessor objects
  // are actually constructed (within check() in Components) in order to provide a better
  // error than MOOSE (which checks for Postprocessor existence well after objects are added).
  // Therefore, if we can't find that we have a Reporter value that represents the PP,
  // this method might have been called before the add_postprocessor task that sets up the
  // Reporter values for the postprocessors. Therefore, let's also see which Postprocessors
  // are slated to be constructed in the future (via the AddPostprocessorAction actions,
  // in which the names are the PP names themselves)
  for (const auto & action : getMooseApp().actionWarehouse().getActions<AddPostprocessorAction>())
    if (action->name() == name)
      return true;
 
  return false;
}

◆ identifyLoops()

void Simulation::identifyLoops ( )

inherited

Identifies the component loops.

Definition at line 164 of file Simulation.C.

{
  // loop over junctions and boundaries (non-geometrical components)
  for (const auto & component : _components)
  {
    const auto flow_connection =
        MooseSharedNamespace::dynamic_pointer_cast<Component1DConnection>(component);
    if (flow_connection)
    {
      // create vector of names of this component and its connected flow channels, and then sort
      // them
      std::vector<std::string> names = flow_connection->getConnectedComponentNames();
      names.push_back(component->name());
      std::sort(names.begin(), names.end());
 
      // pick first name alphabetically to be the proposed loop name
      std::string proposed_loop_name = names[0];
 
      for (const std::string & name : names)
      {
        // if the name is not yet in the map
        if (_component_name_to_loop_name.find(name) == _component_name_to_loop_name.end())
          // just add the new map key; nothing else needs updating
          _component_name_to_loop_name[name] = proposed_loop_name;
        else
        {
          // compare to the existing loop name for this component to make sure the
          // proposed loop name is first alphabetically
          const std::string current_loop_name = _component_name_to_loop_name[name];
          // if proposed loop name comes later, change map values of the current
          // loop name to be the proposed name, and then update the proposed name
          // to be the current name
          if (proposed_loop_name > current_loop_name)
          {
            for (auto && entry : _component_name_to_loop_name)
              if (entry.second == proposed_loop_name)
                entry.second = current_loop_name;
            proposed_loop_name = current_loop_name;
          }
          // if proposed loop name comes earlier, change map values of the current
          // loop name to be the proposed name
          else if (proposed_loop_name < current_loop_name)
          {
            for (auto && entry : _component_name_to_loop_name)
              if (entry.second == current_loop_name)
                entry.second = proposed_loop_name;
          }
        }
      }
    }
  }
 
  // get the list of loops
  std::vector<std::string> loops;
  for (const auto & entry : _component_name_to_loop_name)
    if (std::find(loops.begin(), loops.end(), entry.second) == loops.end())
      loops.push_back(entry.second);
 
  // fill the map of loop name to model ID
  for (const auto & loop : loops)
  {
    // find a flow channel in this loop and get its model ID
    THM::FlowModelID model_id;
    bool found_model_id = false;
    for (const auto & component : _components)
    {
      const auto flow_chan_base_component =
          MooseSharedNamespace::dynamic_pointer_cast<FlowChannelBase>(component);
      if (flow_chan_base_component && (_component_name_to_loop_name[component->name()] == loop))
      {
        model_id = flow_chan_base_component->getFlowModelID();
        found_model_id = true;
        break;
      }
    }
    // set the value in the map or throw an error
    if (found_model_id)
      _loop_name_to_model_id[loop] = model_id;
    else
      logError("No FlowChannelBase-derived components were found in loop '", loop, "'");
  }
}

Referenced by IdentifyLoopsAction::act().

◆ initComponents()

void Simulation::initComponents ( )

virtualinherited

Initialize this simulation's components.

Definition at line 151 of file Simulation.C.

{
  // initialize components
  for (auto && comp : _components)
    comp->executeInit();
 
  // perform secondary initialization, which relies on init() being called
  // already for all components
  for (auto && comp : _components)
    comp->executeInitSecondary();
}

Referenced by THMInitComponentsAction::act().

◆ initSimulation()

void Simulation::initSimulation ( )

virtualinherited

Initialize this simulation.

Definition at line 135 of file Simulation.C.

{
  // sort the components using dependency resolver
  DependencyResolver<std::shared_ptr<Component>> dependency_resolver;
  for (const auto & comp : _components)
  {
    dependency_resolver.addNode(comp);
    for (const auto & dep : comp->getDependencies())
      if (hasComponent(dep))
        dependency_resolver.addEdge(_comp_by_name[dep], comp);
  }
 
  _components = dependency_resolver.dfs();
}

Referenced by THMInitSimulationAction::act().

◆ integrityCheck()

void Simulation::integrityCheck ( ) const

virtualinherited

Check the integrity of the simulation.

Definition at line 846 of file Simulation.C.

{
  if (_components.size() == 0)
    return;
 
  if (_check_jacobian)
    return;
 
  // go over components and put flow channels into one "bucket"
  std::vector<Component *> flow_channels;
  for (auto && comp : _components)
  {
    auto flow_channel = dynamic_cast<FlowChannelBase *>(comp.get());
    if (flow_channel != nullptr)
      flow_channels.push_back(flow_channel);
  }
 
  // initialize number of connected flow channel inlets and outlets to zero
  std::map<std::string, unsigned int> flow_channel_inlets;
  std::map<std::string, unsigned int> flow_channel_outlets;
  for (auto && comp : flow_channels)
  {
    flow_channel_inlets[comp->name()] = 0;
    flow_channel_outlets[comp->name()] = 0;
  }
 
  // mark connections of any Component1DConnection components
  for (const auto & comp : _components)
  {
    auto pc_comp = dynamic_cast<Component1DConnection *>(comp.get());
    if (pc_comp != nullptr)
    {
      for (const auto & connection : pc_comp->getConnections())
      {
        if (connection._end_type == Component1DConnection::IN)
          flow_channel_inlets[connection._component_name]++;
        else if (connection._end_type == Component1DConnection::OUT)
          flow_channel_outlets[connection._component_name]++;
      }
    }
  }
 
  // finally, check that each flow channel has exactly one input and one output
  for (auto && comp : flow_channels)
  {
    if (flow_channel_inlets[comp->name()] == 0)
      logError("Component '", comp->name(), "' does not have connected inlet.");
    else if (flow_channel_inlets[comp->name()] > 1)
      logError("Multiple inlets specified for component '", comp->name(), "'.");
 
    if (flow_channel_outlets[comp->name()] == 0)
      logError("Component '", comp->name(), "' does not have connected outlet.");
    else if (flow_channel_outlets[comp->name()] > 1)
      logError("Multiple outlets specified for component '", comp->name(), "'.");
  }
 
  // let components check themselves
  for (auto && comp : _components)
    comp->executeCheck();
 
  _log.emitLoggedWarnings();
  _log.emitLoggedErrors();
}

Referenced by IntegrityCheckAction::act().

◆ log()

Logger & Simulation::log ( )

inlineinherited

Definition at line 338 of file Simulation.h.

338{ return _log; }

Referenced by AddClosuresAction::act().

◆ logComponentError()

template<typename... Args>

void LoggingInterface::logComponentError	(	const std::string &	component_name,
		Args &&...	args
	)		const

inlineinherited

Logs an error for a component.

Parameters

[in] component_name Name of the component

Definition at line 47 of file LoggingInterface.h.

  {
    _log.add(Logger::ERROR, component_name, ": ", std::forward<Args>(args)...);
  }

Referenced by Closures1PhaseSimple::checkFlowChannel(), Closures1PhaseSimple::checkHeatTransfer(), and Component::logError().

◆ logComponentWarning()

template<typename... Args>

void LoggingInterface::logComponentWarning	(	const std::string &	component_name,
		Args &&...	args
	)		const

inlineinherited

Logs a warning for a component.

Parameters

[in] component_name Name of the component

Definition at line 67 of file LoggingInterface.h.

  {
    _log.add(Logger::WARNING, component_name, ": ", std::forward<Args>(args)...);
  }

Referenced by Component::logWarning().

◆ logError()

template<typename... Args>

void LoggingInterface::logError ( Args &&... args ) const

inlineinherited

Logs an error.

Definition at line 36 of file LoggingInterface.h.

  {
    _log.add(Logger::ERROR, std::forward<Args>(args)...);
  }

Referenced by Simulation::addClosures(), Simulation::addComponent(), Simulation::controlDataIntegrityCheck(), Simulation::declareControlData(), Simulation::identifyLoops(), and Simulation::integrityCheck().

◆ logWarning()

template<typename... Args>

void LoggingInterface::logWarning ( Args &&... args ) const

inlineinherited

Logs a warning.

Definition at line 56 of file LoggingInterface.h.

  {
    _log.add(Logger::WARNING, std::forward<Args>(args)...);
  }

◆ printComponentLoops()

void Simulation::printComponentLoops ( ) const

inherited

Prints the component loops.

Definition at line 248 of file Simulation.C.

{
  // get the list of loops
  std::vector<std::string> loops;
  for (auto && entry : _component_name_to_loop_name)
    if (std::find(loops.begin(), loops.end(), entry.second) == loops.end())
      loops.push_back(entry.second);
 
  // for each loop
  Moose::out << "\nListing of component loops:" << std::endl;
  for (unsigned int i = 0; i < loops.size(); i++)
  {
    Moose::out << "\n  Loop " << i + 1 << ":" << std::endl;
 
    // print out each component in the loop
    for (auto && entry : _component_name_to_loop_name)
      if (entry.second == loops[i])
        Moose::out << "    " << entry.first << std::endl;
  }
  Moose::out << std::endl;
}

Referenced by THMPrintComponentLoopsAction::act().

◆ run()

void Simulation::run ( )

virtualinherited

Run the simulation.

Definition at line 986 of file Simulation.C.

987{

988}

◆ setCheckJacobian()

void Simulation::setCheckJacobian ( bool state )

inlineinherited

Enable Jacobian checking.

Parameters

state True for Jacobian checking, otherwise false

Definition at line 345 of file Simulation.h.

345{ _check_jacobian = state; }

Referenced by THMDebugAction::act().

◆ setComponentVariableOrder()

void Simulation::setComponentVariableOrder	(	const VariableName &	var,
		int	index
	)

staticinherited

Sets a component variable order index.

See Component system documentation for more information.

Parameters

[in]	var	Variable to order
[in]	index	Order index

Definition at line 40 of file Simulation.C.

{
  _component_variable_order_map[var] = index;
}

Referenced by ThermalHydraulicsApp::registerAll().

◆ setupCoordinateSystem()

void Simulation::setupCoordinateSystem ( )

protectedinherited

Sets the coordinate system for each subdomain.

Definition at line 770 of file Simulation.C.

{
  MultiMooseEnum coord_types("XYZ RZ RSPHERICAL");
  std::vector<SubdomainName> blocks;
 
  for (auto && comp : _components)
  {
    if (comp->parent() == nullptr)
    {
      const auto & subdomains = comp->getSubdomainNames();
      const auto & coord_sys = comp->getCoordSysTypes();
 
      for (unsigned int i = 0; i < subdomains.size(); i++)
      {
        blocks.push_back(subdomains[i]);
        // coord_types.push_back("XYZ");
        coord_types.setAdditionalValue(coord_sys[i] == Moose::COORD_RZ ? "RZ" : "XYZ");
      }
    }
  }
  _fe_problem.setCoordSystem(blocks, coord_types);
 
  // RZ geometries are always aligned with x-axis
  MooseEnum rz_coord_axis("X=0 Y=1", "X");
  _fe_problem.setAxisymmetricCoordAxis(rz_coord_axis);
}

Referenced by Simulation::setupMesh().

◆ setupCriticalHeatFluxTable()

void Simulation::setupCriticalHeatFluxTable ( )

protectedinherited

Setup ctirical heat flux table user object.

◆ setupEquations()

void Simulation::setupEquations ( )

protectedinherited

Setup equations to be solved in this simulation.

◆ setupInitialConditionObjects()

void Simulation::setupInitialConditionObjects ( )

protectedinherited

Definition at line 727 of file Simulation.C.

{
  for (auto && i : _ics)
  {
    const std::string & name = i.first;
    ICInfo & ic = i.second;
    _fe_problem.addInitialCondition(ic._type, name, ic._params);
  }
}

Referenced by Simulation::addVariables().

◆ setupInitialConditionsFromFile()

void Simulation::setupInitialConditionsFromFile ( )

protectedinherited

Setup reading initial conditions from a specified file, see 'initial_from_file' and 'initial_from_file_timestep' parameters.

Definition at line 686 of file Simulation.C.

{
  const UserObjectName suo_name = genName("thm", "suo");
  {
    const std::string class_name = "SolutionUserObject";
    InputParameters params = _thm_factory.getValidParams(class_name);
    params.set<MeshFileName>("mesh") = _thm_pars.get<FileName>("initial_from_file");
    params.set<std::string>("timestep") = _thm_pars.get<std::string>("initial_from_file_timestep");
    _fe_problem.addUserObject(class_name, suo_name, params);
  }
 
  for (auto && v : _vars)
  {
    const VariableName & var_name = v.first;
    const VariableInfo & vi = v.second;
 
    if (vi._var_type == "MooseVariableScalar")
    {
      std::string class_name = "ScalarSolutionIC";
      InputParameters params = _thm_factory.getValidParams(class_name);
      params.set<VariableName>("variable") = var_name;
      params.set<VariableName>("from_variable") = var_name;
      params.set<UserObjectName>("solution_uo") = suo_name;
      _fe_problem.addInitialCondition(class_name, genName(var_name, "ic"), params);
    }
    else
    {
      std::string class_name = "SolutionIC";
      InputParameters params = _thm_factory.getValidParams(class_name);
      params.set<VariableName>("variable") = var_name;
      params.set<VariableName>("from_variable") = var_name;
      params.set<UserObjectName>("solution_uo") = suo_name;
      if (vi._params.isParamValid("block"))
        params.set<std::vector<SubdomainName>>("block") =
            vi._params.get<std::vector<SubdomainName>>("block");
      _fe_problem.addInitialCondition(class_name, genName(var_name, "ic"), params);
    }
  }
}

Referenced by Simulation::addVariables().

◆ setupMesh()

void Simulation::setupMesh ( )

virtualinherited

Perform mesh setup actions such as setting up the coordinate system(s) and creating ghosted elements.

Definition at line 798 of file Simulation.C.

{
  if (_components.size() == 0)
    return;
 
  setupCoordinateSystem();
}

Referenced by THMSetupMeshAction::act().

◆ setupQuadrature()

void Simulation::setupQuadrature ( )

virtualinherited

Sets up quadrature rules.

Definition at line 98 of file Simulation.C.

{
  if (_components.size() == 0)
    return;
 
  Order order = CONSTANT;
  unsigned int n_flow_channels = 0;
  unsigned int n_heat_structures = 0;
 
  for (auto && comp : _components)
  {
    auto flow_channel = dynamic_cast<FlowChannelBase *>(comp.get());
    if (flow_channel != nullptr)
      n_flow_channels++;
 
    auto hs_interface = dynamic_cast<HeatStructureInterface *>(comp.get());
    if (hs_interface)
      n_heat_structures++;
  }
 
  if (n_flow_channels > 0)
  {
    const FEType & fe_type = getFlowFEType();
    if (fe_type.default_quadrature_order() > order)
      order = fe_type.default_quadrature_order();
  }
  if (n_heat_structures > 0)
  {
    const FEType & fe_type = HeatConductionModel::feType();
    if (fe_type.default_quadrature_order() > order)
      order = fe_type.default_quadrature_order();
  }
 
  _fe_problem.createQRules(QGAUSS, order, order, order);
}

Referenced by THMSetupQuadratureAction::act().

◆ setVectorValuedVelocity()

void Simulation::setVectorValuedVelocity ( bool vector_velocity )

inlineinherited

Set if velocity is being output as a vector-valued field.

Definition at line 364 of file Simulation.h.

364{ _output_vector_velocity = vector_velocity; }

Referenced by THMOutputVectorVelocityAction::act().

◆ sortAddedComponentVariables()

std::vector< VariableName > Simulation::sortAddedComponentVariables ( ) const

privateinherited

Returns a sorted list of the variables added by components.

See Component system documentation for more information.

Definition at line 578 of file Simulation.C.

{
  // Check that no index in order map is used more than once.
  // Also, convert the map to a vector of pairs to be sorted.
  std::set<int> indices;
  std::vector<std::pair<VariableName, int>> registered_var_index_pairs;
  for (const auto & var_and_index : _component_variable_order_map)
  {
    registered_var_index_pairs.push_back(var_and_index);
 
    const auto ind = var_and_index.second;
    auto insert_return = indices.insert(ind);
    if (!insert_return.second)
      mooseError("The index ", ind, " was used for multiple component variables.");
  }
 
  // Collect all of the added variable names into an unsorted vector.
  std::vector<VariableName> vars_unsorted;
  for (const auto & var_and_data : _vars)
    vars_unsorted.push_back(var_and_data.first);
 
  // The sorting works as follows. For those variables that are listed in
  // _component_variable_order_map, these are ordered before those that are not,
  // in the order of their indices in the map. Those not in the map are sorted
  // alphabetically.
 
  // Sort registered_var_index_pairs by value (index)
  std::sort(registered_var_index_pairs.begin(),
            registered_var_index_pairs.end(),
            [](const std::pair<VariableName, int> & a, const std::pair<VariableName, int> & b)
            { return a.second < b.second; });
 
  // Loop over the ordered, registered variable names and add a variable to the
  // sorted list if in vars_unsorted. When this happens, delete the element from
  // vars_unsorted, leaving only unregistered variable names after the loop.
  std::vector<VariableName> vars_sorted;
  for (const auto & var_index_pair : registered_var_index_pairs)
  {
    const auto & var = var_index_pair.first;
    if (std::find(vars_unsorted.begin(), vars_unsorted.end(), var) != vars_unsorted.end())
    {
      vars_sorted.push_back(var);
      vars_unsorted.erase(std::remove(vars_unsorted.begin(), vars_unsorted.end(), var),
                          vars_unsorted.end());
    }
  }
 
  // Sort the remaining (unregistered) variables alphabetically and then add
  // them to the end of the full list.
  std::sort(vars_unsorted.begin(), vars_unsorted.end());
  vars_sorted.insert(vars_sorted.end(), vars_unsorted.begin(), vars_unsorted.end());
 
  return vars_sorted;
}

Referenced by Simulation::addVariables().

◆ validParams()

InputParameters THMProblem::validParams ( )

static

Definition at line 16 of file THMProblem.C.

{
  InputParameters params = FEProblem::validParams();
 
  params.addParam<bool>("2nd_order_mesh", false, "Use 2nd order elements in the mesh");
 
  params.addParam<FileName>("initial_from_file",
                            "The name of an exodus file with initial conditions");
  params.addParam<std::string>(
      "initial_from_file_timestep",
      "LATEST",
      "Gives the timestep (or \"LATEST\") for which to read a solution from a file "
      "for a given variable. (Default: LATEST)");
 
  params.set<bool>("boundary_restricted_elem_integrity_check") = false;
 
  params.addClassDescription("Specialization of FEProblem to run with component subsystem");
 
  return params;
}

Member Data Documentation

◆ _check_jacobian

bool Simulation::_check_jacobian

protectedinherited

True if checking jacobian.

Definition at line 468 of file Simulation.h.

Referenced by Simulation::controlDataIntegrityCheck(), Simulation::integrityCheck(), and Simulation::setCheckJacobian().

◆ _closures_by_name

std::map<std::string, std::shared_ptr<ClosuresBase> > Simulation::_closures_by_name

protectedinherited

Map of closures by their names.

Definition at line 409 of file Simulation.h.

Referenced by Simulation::addClosures(), Simulation::getClosures(), and Simulation::hasClosures().

◆ _comp_by_name

std::map<std::string, std::shared_ptr<Component> > Simulation::_comp_by_name

protectedinherited

Map of components by their names.

Definition at line 402 of file Simulation.h.

Referenced by Simulation::addComponent(), Simulation::getComponentByName(), Simulation::hasComponent(), Simulation::hasComponentOfType(), and Simulation::initSimulation().

◆ _component_name_to_loop_name

std::map<std::string, std::string> Simulation::_component_name_to_loop_name

protectedinherited

Map of component name to component loop name.

Definition at line 404 of file Simulation.h.

Referenced by Simulation::identifyLoops(), and Simulation::printComponentLoops().

◆ _component_variable_order_map

std::map< VariableName, int > Simulation::_component_variable_order_map

staticprivateinherited

Component variable order map; see setComponentVariableOrder for more info.

Definition at line 488 of file Simulation.h.

Referenced by Simulation::setComponentVariableOrder(), and Simulation::sortAddedComponentVariables().

◆ _components

std::vector<std::shared_ptr<Component> > Simulation::_components

protectedinherited

List of components in this simulation.

Definition at line 400 of file Simulation.h.

Referenced by Simulation::addComponent(), Simulation::addMooseObjects(), Simulation::addRelationshipManagers(), Simulation::addVariables(), Simulation::buildMesh(), Simulation::getComponents(), Simulation::identifyLoops(), Simulation::initComponents(), Simulation::initSimulation(), Simulation::integrityCheck(), Simulation::setupCoordinateSystem(), Simulation::setupMesh(), and Simulation::setupQuadrature().

◆ _control_data

std::map<std::string, ControlDataValue *> Simulation::_control_data

protectedinherited

Control data created in the control logic system.

Definition at line 460 of file Simulation.h.

Referenced by Simulation::advanceState(), Simulation::controlDataIntegrityCheck(), Simulation::getControlData(), Simulation::hasControlData(), and Simulation::~Simulation().

◆ _fe_problem

FEProblemBase& Simulation::_fe_problem

protectedinherited

Pointer to FEProblem representing this simulation.

Definition at line 391 of file Simulation.h.

Referenced by Simulation::addControl(), Simulation::addRelationshipManagers(), Simulation::addVariables(), Simulation::controlDataIntegrityCheck(), Simulation::couplingMatrixIntegrityCheck(), Simulation::setupCoordinateSystem(), Simulation::setupInitialConditionObjects(), Simulation::setupInitialConditionsFromFile(), and Simulation::setupQuadrature().

◆ _flow_fe_type

libMesh::FEType Simulation::_flow_fe_type

protectedinherited

finite element type for the flow in the simulation

Definition at line 430 of file Simulation.h.

Referenced by Simulation::getFlowFEType().

◆ _ics

std::map<std::string, ICInfo> Simulation::_ics

protectedinherited

Definition at line 424 of file Simulation.h.

Referenced by Simulation::addSimInitialCondition(), and Simulation::setupInitialConditionObjects().

◆ _implicit_time_integration

bool Simulation::_implicit_time_integration

protectedinherited

true if using implicit time integration scheme

Definition at line 463 of file Simulation.h.

Referenced by Simulation::addVariables(), and Simulation::getImplicitTimeIntegrationFlag().

◆ _log

Logger Simulation::_log

protectedinherited

Definition at line 465 of file Simulation.h.

Referenced by Simulation::controlDataIntegrityCheck(), Simulation::integrityCheck(), and Simulation::log().

◆ _loop_name_to_model_id

std::map<std::string, THM::FlowModelID> Simulation::_loop_name_to_model_id

protectedinherited

Map of loop name to model type.

Definition at line 406 of file Simulation.h.

Referenced by Simulation::identifyLoops().

◆ _output_vector_velocity

bool Simulation::_output_vector_velocity

protectedinherited

Flag indicating if velocity is output as vector-valued field.

Definition at line 474 of file Simulation.h.

Referenced by Simulation::getVectorValuedVelocity(), and Simulation::setVectorValuedVelocity().

◆ _outputters_all

std::vector<OutputName> Simulation::_outputters_all

protectedinherited

Definition at line 455 of file Simulation.h.

Referenced by Simulation::addFileOutputter(), Simulation::addScreenOutputter(), and Simulation::getOutputsVector().

◆ _outputters_file

std::vector<OutputName> Simulation::_outputters_file

protectedinherited

Definition at line 456 of file Simulation.h.

Referenced by Simulation::addFileOutputter(), and Simulation::getOutputsVector().

◆ _outputters_screen

std::vector<OutputName> Simulation::_outputters_screen

protectedinherited

Definition at line 457 of file Simulation.h.

Referenced by Simulation::addScreenOutputter(), and Simulation::getOutputsVector().

◆ _sparsity_elem_augmentation

std::map<dof_id_type, std::vector<dof_id_type> > Simulation::_sparsity_elem_augmentation

protectedinherited

Additional sparsity pattern that needs to be added into the Jacobian matrix.

Definition at line 471 of file Simulation.h.

Referenced by Simulation::addRelationshipManagers(), and Simulation::augmentSparsity().

◆ _thm_app

ThermalHydraulicsApp& Simulation::_thm_app

protectedinherited

The application this is associated with.

Definition at line 394 of file Simulation.h.

Referenced by Simulation::addRelationshipManagers(), Simulation::getApp(), and Simulation::getControlData().

◆ _thm_factory

Factory& Simulation::_thm_factory

protectedinherited

The Factory associated with the MooseApp.

Definition at line 397 of file Simulation.h.

Referenced by Simulation::addClosures(), Simulation::addComponent(), Simulation::addComponentScalarIC(), Simulation::addConstantIC(), Simulation::addConstantScalarIC(), Simulation::addControl(), Simulation::addFunctionIC(), Simulation::addRelationshipManagers(), Simulation::addSimVariable(), Simulation::addSimVariable(), and Simulation::setupInitialConditionsFromFile().

◆ _thm_mesh

THMMesh& Simulation::_thm_mesh

protectedinherited

THM mesh.

Definition at line 388 of file Simulation.h.

Referenced by Simulation::addRelationshipManagers().

◆ _thm_pars

const InputParameters& Simulation::_thm_pars

protectedinherited

"Global" of this simulation

Definition at line 427 of file Simulation.h.

Referenced by Simulation::hasInitialConditionsFromFile(), and Simulation::setupInitialConditionsFromFile().

◆ _vars

std::map<VariableName, VariableInfo> Simulation::_vars

protectedinherited

variables for this simulation (name and info about the var)

Definition at line 412 of file Simulation.h.

Referenced by Simulation::addSimVariable(), Simulation::addSimVariable(), Simulation::addSimVariable(), Simulation::addVariables(), Simulation::setupInitialConditionsFromFile(), and Simulation::sortAddedComponentVariables().

◆ _zero

Real Simulation::_zero

inherited

Definition at line 477 of file Simulation.h.

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

thermal_hydraulics/include/problems/THMProblem.h
thermal_hydraulics/src/problems/THMProblem.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ THMProblem()

Member Function Documentation

◆ addClosures()

◆ addComponent()

◆ addComponentScalarIC()

◆ addConstantIC()

◆ addConstantScalarIC()

◆ addControl()

◆ addFileOutputter()

◆ addFunctionIC()

◆ addMooseObjects()

◆ addRelationshipManagers()

◆ addScreenOutputter()

◆ addSimInitialCondition()

◆ addSimVariable() [1/3]

◆ addSimVariable() [2/3]

◆ addSimVariable() [3/3]

◆ addVariables()

◆ advanceState()

◆ augmentSparsity()

◆ buildMesh()

◆ checkVariableNameLength()

◆ controlDataIntegrityCheck()

◆ copySolutionsBackwards()

◆ couplingMatrixIntegrityCheck()

◆ declareControlData()

◆ genName() [1/4]

◆ genName() [2/4]

◆ genName() [3/4]

◆ genName() [4/4]

◆ genSafeName()

◆ getApp()

◆ getClosures()

◆ getComponentByName()

◆ getComponents()

◆ getControlData()

◆ getFlowFEType()

◆ getImplicitTimeIntegrationFlag()

◆ getOutputsVector()

◆ getVectorValuedVelocity()

◆ hasClosures()

◆ hasComponent()

◆ hasComponentOfType()

◆ hasControlData()

◆ hasInitialConditionsFromFile()

◆ hasPostprocessor()

◆ identifyLoops()

◆ initComponents()

◆ initSimulation()

◆ integrityCheck()

◆ log()

◆ logComponentError()

◆ logComponentWarning()

◆ logError()

◆ logWarning()

◆ printComponentLoops()

◆ run()

◆ setCheckJacobian()

◆ setComponentVariableOrder()

◆ setupCoordinateSystem()

◆ setupCriticalHeatFluxTable()

◆ setupEquations()

◆ setupInitialConditionObjects()

◆ setupInitialConditionsFromFile()

◆ setupMesh()

◆ setupQuadrature()