DumpObjectsLinearSystem Class Reference

Linear system for dumping objects TODO: consider creating a base class for LinearSystems to be able to create a more minimal linear system. More...

#include <DumpObjectsLinearSystem.h>

Inheritance diagram for DumpObjectsLinearSystem:

Public Member Functions
	DumpObjectsLinearSystem (FEProblemBase &problem, const std::string &name)
virtual void	solve () override
	Solve the system (using libMesh magic)
virtual void	stopSolve (const ExecFlagType &, const std::set< TagID > &) override
	Quit the current solve as soon as possible.
virtual bool	converged () override
	At the moment, this is only used for the multi-system fixed point iteration.
virtual void	preInit () override
	This is called prior to the libMesh system has been init'd.
virtual void	initSolutionState () override
	Initializes the solution state.
virtual void	initialSetup () override
	Setup Functions.
virtual void	reinit () override
	Reinitialize the system when the degrees of freedom in this system have changed.
void	addKokkosKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
	Add a Kokkos linear finite volume kernel to this system.
void	addKokkosBoundaryCondition (const std::string &bc_name, const std::string &name, InputParameters &parameters)
	Add a Kokkos linear finite volume boundary condition to this system.
virtual void	residualSetup () override
virtual void	jacobianSetup () override
virtual bool	containsTimeKernel () override
	If the system has a kernel that corresponds to a time derivative.
virtual std::vector< std::string >	timeKernelVariableNames () override
	Returns the names of the variables that have time derivative kernels in the system.
void	computeLinearSystemTags (const std::set< TagID > &vector_tags, const std::set< TagID > &matrix_tags, const bool compute_gradients=true)
	Compute the right hand side and the system matrix of the system for given tags.
libMesh::LinearImplicitSystem &	linearImplicitSystem ()
	Return a reference to the stored linear implicit system.
NumericVector< Number > &	getRightHandSideTimeVector ()
	Return a numeric vector that is associated with the time tag.
NumericVector< Number > &	getRightHandSideNonTimeVector ()
	Return a numeric vector that is associated with the nontime tag.
virtual void	augmentSparsity (SparsityPattern::Graph &sparsity, std::vector< dof_id_type > &n_nz, std::vector< dof_id_type > &n_oz) override
	Will modify the sparsity pattern to add logical geometric connections.
unsigned int	nLinearIterations () const
	Return the number of linear iterations.
virtual System &	system () override
	Get the reference to the libMesh system.
virtual const System &	system () const override
NumericVector< Number > &	getRightHandSideVector ()
	Fetching the right hand side vector from the libmesh system.
const NumericVector< Number > &	getRightHandSideVector () const
SparseMatrix< Number > &	getSystemMatrix ()
	Fetching the system matrix from the libmesh system.
const SparseMatrix< Number > &	getSystemMatrix () const
virtual void	compute (ExecFlagType type) override
	Compute time derivatives, auxiliary variables, etc.
void	computeGradients ()
	Compute and finalize all registered linear FV gradient fields.
LinearFVGradientReader	registerFVGradient (unsigned int variable_number, const FVGradientMethod &method, unsigned int oldest_state=0)
	Register a variable for gradient values produced by a method object.
void	updateFVGradient (const LinearFVGradientReader &reader)
	Update a registered gradient reader explicitly.
virtual void	restoreSolutions () override final
	Restore current solutions (call after your solve failed)
void	serializeSolution ()
void	setSolution (const NumericVector< Number > &soln)
	Set the solution to a given vector.
void	applyFixedPointRelaxation (const Real relaxation_factor, const Moose::SolutionIterationType iteration_type)
	Apply solution under/over-relaxation for fixed point iterations.
void	setPCSide (MooseEnum pcs)
	Set the side on which the preconditioner is applied to.
Moose::PCSideType	getPCSide ()
	Get the current preconditioner side.
void	setMooseKSPNormType (MooseEnum kspnorm)
	Set the norm in which the linear convergence will be measured.
Moose::MooseKSPNormType	getMooseKSPNormType ()
	Get the norm in which the linear convergence is measured.
virtual const NumericVector< Number > *const &	currentSolution () const override final
	The solution vector that is currently being operated on.
unsigned int	number () const
	Gets the number of this system.
MooseMesh &	mesh ()
const MooseMesh &	mesh () const
SubProblem &	subproblem ()
const SubProblem &	subproblem () const
FEProblemBase &	feProblem ()
const FEProblemBase &	feProblem () const
void	applyScalingFactors (const std::vector< Real > &inverse_scaling_factors)
	Applies scaling factors to the system's variables.
bool	computingScalingJacobian () const
	Whether we are computing an initial Jacobian for automatic variable scaling.
bool	automaticScaling () const
	Getter for whether we are performing automatic scaling.
void	automaticScaling (bool automatic_scaling)
	Setter for whether we are performing automatic scaling.
void	setVerboseFlag (const bool &verbose)
	Sets the verbose flag.
virtual libMesh::DofMap &	dofMap ()
	Gets writeable reference to the dof map.
virtual const libMesh::DofMap &	dofMap () const
	Gets const reference to the dof map.
virtual void	postInit ()
virtual void	initializeObjects ()
	Called only once, just before the solve begins so objects can do some precalculations.
void	update ()
	Update the system (doing libMesh magic)
void	copyOldSolutions ()
	Copy the solution back in time (older -> old, etc).
void	advanceStateHistory (Moose::SolutionIterationType iteration_type)
	Advance solution vectors and additional system-owned state together.
void	copyPreviousSolutions (const Moose::SolutionIterationType iteration_type)
	Copy a specific type of solution back in time (current -> old -> older, etc).
void	restoreStateHistory ()
	Restore solution vectors and additional system-owned state together.
NumericVector< Number > &	solution ()
const NumericVector< Number > &	solution () const
NumericVector< Number > &	solutionOld ()
const NumericVector< Number > &	solutionOld () const
NumericVector< Number > &	solutionOlder ()
const NumericVector< Number > &	solutionOlder () const
virtual const NumericVector< Number > *	solutionPreviousNewton () const
virtual NumericVector< Number > *	solutionPreviousNewton ()
const std::vector< NumericVector< Number > * > &	getSolutionStates (const Moose::SolutionIterationType iteration_type) const
	Get all of the solution states (current, old, ...) for the given iteration type.
std::size_t	getNumSolutionStates (const Moose::SolutionIterationType iteration_type) const
	Get the number of solution states (0 = current, 1 = current + old, ...) for the given iteration type.
virtual NumericVector< Number > &	solutionState (const unsigned int state, Moose::SolutionIterationType iteration_type=Moose::SolutionIterationType::Time)
	Get a state of the solution (0 = current, 1 = old, 2 = older, etc).
virtual const NumericVector< Number > &	solutionState (const unsigned int state, Moose::SolutionIterationType iteration_type=Moose::SolutionIterationType::Time) const
	Get a state of the solution (0 = current, 1 = old, 2 = older, etc).
libMesh::ParallelType	solutionStateParallelType (const unsigned int state, const Moose::SolutionIterationType iteration_type) const
	Returns the parallel type of the given solution state.
virtual void	needSolutionState (const unsigned int state, Moose::SolutionIterationType iteration_type=Moose::SolutionIterationType::Time, libMesh::ParallelType parallel_type=GHOSTED)
	Registers that the solution state state is needed.
virtual bool	hasSolutionState (const unsigned int state, Moose::SolutionIterationType iteration_type=Moose::SolutionIterationType::Time) const
	Whether or not the system has the solution state (0 = current, 1 = old, 2 = older, etc).
virtual void	addDotVectors ()
	Add u_dot, u_dotdot, u_dot_old and u_dotdot_old vectors if requested by the time integrator.
virtual std::vector< Number > &	duDotDus ()
virtual Number &	duDotDotDu ()
virtual const Number &	duDotDotDu () const
virtual const Number &	duDotDu (unsigned int var_num=0) const
virtual NumericVector< Number > *	solutionUDot ()
virtual const NumericVector< Number > *	solutionUDot () const
virtual NumericVector< Number > *	solutionUDotDot ()
virtual const NumericVector< Number > *	solutionUDotDot () const
virtual NumericVector< Number > *	solutionUDotOld ()
virtual const NumericVector< Number > *	solutionUDotOld () const
virtual NumericVector< Number > *	solutionUDotDotOld ()
virtual const NumericVector< Number > *	solutionUDotDotOld () const
virtual void	saveOldSolutions ()
	Save the old and older solutions.
virtual void	restoreOldSolutions ()
	Restore the old and older solutions when the saved solutions present.
bool	hasVector (const std::string &tag_name) const
	Check if the named vector exists in the system.
virtual bool	hasVector (TagID tag_id) const
	Check if the tagged vector exists in the system.
virtual TagID	timeVectorTag () const
	Ideally, we should not need this API.
virtual TagID	nonTimeVectorTag () const
virtual TagID	residualVectorTag () const
virtual std::set< TagID >	defaultVectorTags () const
	Get the default vector tags associated with this system.
virtual std::set< TagID >	defaultMatrixTags () const
	Get the default matrix tags associted with this system.
virtual void	associateVectorToTag (NumericVector< Number > &vec, TagID tag)
	Associate a vector for a given tag.
virtual void	disassociateVectorFromTag (NumericVector< Number > &vec, TagID tag)
	Disassociate a given vector from a given tag.
virtual void	disassociateVectorFromTag (TagID tag)
	Disassociate any vector that is associated with a given tag.
virtual void	disassociateDefaultVectorTags ()
	Disassociate the vectors associated with the default vector tags of this system.
virtual bool	hasMatrix (TagID tag) const
	Check if the tagged matrix exists in the system.
virtual libMesh::SparseMatrix< Number > &	getMatrix (TagID tag)
	Get a raw SparseMatrix.
virtual const libMesh::SparseMatrix< Number > &	getMatrix (TagID tag) const
	Get a raw SparseMatrix.
virtual void	activateAllMatrixTags ()
	Make all existing matrices active.
virtual bool	matrixTagActive (TagID tag) const
	If or not a matrix tag is active.
virtual void	deactivateAllMatrixTags ()
	Make matrices inactive.
void	closeTaggedMatrices (const std::set< TagID > &tags)
	Close all matrices associated the tags.
void	flushTaggedMatrices (const std::set< TagID > &tags)
	flushes all matrices associated to tags.
virtual void	associateMatrixToTag (libMesh::SparseMatrix< Number > &matrix, TagID tag)
	Associate a matrix to a tag.
virtual void	disassociateMatrixFromTag (libMesh::SparseMatrix< Number > &matrix, TagID tag)
	Disassociate a matrix from a tag.
virtual void	disassociateMatrixFromTag (TagID tag)
	Disassociate any matrix that is associated with a given tag.
virtual void	disassociateDefaultMatrixTags ()
	Disassociate the matrices associated with the default matrix tags of this system.
virtual NumericVector< Number > &	serializedSolution ()
	Returns a reference to a serialized version of the solution vector for this subproblem.
virtual NumericVector< Number > &	residualCopy ()
virtual NumericVector< Number > &	residualGhosted ()
virtual void	augmentSendList (std::vector< dof_id_type > &send_list)
	Will modify the send_list to add all of the extra ghosted dofs for this system.
virtual void	addVariable (const std::string &var_type, const std::string &var_name, InputParameters &parameters)
	Canonical method for adding a variable.
virtual bool	isArrayVariable (const std::string &var_name) const
	If a variable is an array variable.
virtual bool	isScalarVariable (unsigned int var_name) const
MooseVariableFieldBase &	getVariable (THREAD_ID tid, const std::string &var_name) const
	Gets a reference to a variable of with specified name.
MooseVariableFieldBase &	getVariable (THREAD_ID tid, unsigned int var_number) const
	Gets a reference to a variable with specified number.
template<typename T >
MooseVariableFE< T > &	getFieldVariable (THREAD_ID tid, const std::string &var_name)
	Gets a reference to a variable of with specified name.
template<typename T >
MooseVariableFE< T > &	getFieldVariable (THREAD_ID tid, unsigned int var_number)
	Gets a reference to a variable with specified number.
template<typename T >
MooseVariableField< T > &	getActualFieldVariable (THREAD_ID tid, const std::string &var_name)
	Returns a field variable pointer - this includes finite volume variables.
template<typename T >
MooseVariableField< T > &	getActualFieldVariable (THREAD_ID tid, unsigned int var_number)
	Returns a field variable pointer - this includes finite volume variables.
template<typename T >
MooseVariableFV< T > &	getFVVariable (THREAD_ID tid, const std::string &var_name)
	Return a finite volume variable.
virtual MooseVariableScalar &	getScalarVariable (THREAD_ID tid, const std::string &var_name) const
	Gets a reference to a scalar variable with specified number.
virtual MooseVariableScalar &	getScalarVariable (THREAD_ID tid, unsigned int var_number) const
	Gets a reference to a variable with specified number.
virtual const std::set< SubdomainID > *	getVariableBlocks (unsigned int var_number)
	Get the block where a variable of this system is defined.
virtual unsigned int	nVariables () const
	Get the number of variables in this system.
unsigned int	nFieldVariables () const
	Get the number of field variables in this system.
unsigned int	nFVVariables () const
	Get the number of finite volume variables in this system.
std::size_t	getMaxVarNDofsPerElem () const
	Gets the maximum number of dofs used by any one variable on any one element.
std::size_t	getMaxVarNDofsPerNode () const
	Gets the maximum number of dofs used by any one variable on any one node.
void	assignMaxVarNDofsPerElem (std::size_t max_dofs)
	assign the maximum element dofs
void	assignMaxVarNDofsPerNode (std::size_t max_dofs)
	assign the maximum node dofs
virtual void	addVariableToZeroOnResidual (std::string var_name)
	Adds this variable to the list of variables to be zeroed during each residual evaluation.
virtual void	addVariableToZeroOnJacobian (std::string var_name)
	Adds this variable to the list of variables to be zeroed during each Jacobian evaluation.
virtual void	zeroVariables (std::vector< std::string > &vars_to_be_zeroed)
	Zero out the solution for the list of variables passed in.
virtual void	zeroVariablesForResidual ()
	Zero out the solution for the variables that were registered as needing to have their solutions zeroed on out on residual evaluation by a call to addVariableToZeroOnResidual()
virtual void	zeroVariablesForJacobian ()
	Zero out the solution for the variables that were registered as needing to have their solutions zeroed on out on Jacobian evaluation by a call to addVariableToZeroOnResidual()
virtual libMesh::Order	getMinQuadratureOrder ()
	Get minimal quadrature order needed for integrating variables in this system.
virtual void	prepare (THREAD_ID tid)
	Prepare the system for use.
virtual void	prepareFace (THREAD_ID tid, bool resize_data)
	Prepare the system for use on sides.
virtual void	prepareNeighbor (THREAD_ID tid)
	Prepare the system for use.
virtual void	prepareLowerD (THREAD_ID tid)
	Prepare the system for use for lower dimensional elements.
virtual void	reinitElem (const Elem *elem, THREAD_ID tid)
	Reinit an element assembly info.
virtual void	reinitElemFace (const Elem *elem, unsigned int side, THREAD_ID tid)
	Reinit assembly info for a side of an element.
virtual void	reinitNeighborFace (const Elem *elem, unsigned int side, THREAD_ID tid)
	Compute the values of the variables at all the current points.
virtual void	reinitNeighbor (const Elem *elem, THREAD_ID tid)
	Compute the values of the variables at all the current points.
virtual void	reinitLowerD (THREAD_ID tid)
	Compute the values of the variables on the lower dimensional element.
virtual void	reinitNode (const Node *node, THREAD_ID tid)
	Reinit nodal assembly info.
virtual void	reinitNodeFace (const Node *node, BoundaryID bnd_id, THREAD_ID tid)
	Reinit nodal assembly info on a face.
virtual void	reinitNodes (const std::vector< dof_id_type > &nodes, THREAD_ID tid)
	Reinit variables at a set of nodes.
virtual void	reinitNodesNeighbor (const std::vector< dof_id_type > &nodes, THREAD_ID tid)
	Reinit variables at a set of neighbor nodes.
virtual void	reinitScalars (THREAD_ID tid, bool reinit_for_derivative_reordering=false)
	Reinit scalar varaibles.
virtual void	addVariableToCopy (const std::string &dest_name, const std::string &source_name, const std::string &timestep)
	Add info about variable that will be copied.
const std::vector< MooseVariableFieldBase * > &	getVariables (THREAD_ID tid)
const VariableWarehouse &	variableWarehouse (THREAD_ID tid=0) const
const std::vector< MooseVariableScalar * > &	getScalarVariables (THREAD_ID tid)
const std::set< SubdomainID > &	getSubdomainsForVar (unsigned int var_number) const
const std::set< SubdomainID > &	getSubdomainsForVar (const std::string &var_name) const
	Get the block where a variable of this system is defined.
void	removeVector (const std::string &name)
	Remove a vector from the system with the given name.
void	removeVector (TagID tag_id)
	Remove a solution length vector from the system with the specified TagID.
NumericVector< Number > &	addVector (const std::string &vector_name, const bool project, const libMesh::ParallelType type)
	Adds a solution length vector to the system.
NumericVector< Number > &	addVector (TagID tag, const bool project, const libMesh::ParallelType type)
	Adds a solution length vector to the system with the specified TagID.
void	closeTaggedVector (const TagID tag)
	Close vector with the given tag.
void	closeTaggedVectors (const std::set< TagID > &tags)
	Close all vectors for given tags.
void	zeroTaggedVector (const TagID tag)
	Zero vector with the given tag.
void	zeroTaggedVectors (const std::set< TagID > &tags)
	Zero all vectors for given tags.
void	setVariableGlobalDoFs (const std::string &var_name)
	set all the global dof indices for a variable
const std::vector< dof_id_type > &	getVariableGlobalDoFs ()
	Get the global dof indices of a variable, this needs to be called after the indices have been set by setVariableGlobalDoFs
libMesh::SparseMatrix< Number > &	addMatrix (TagID tag)
	Adds a matrix with a given tag.
void	removeMatrix (TagID tag)
	Removes a matrix with a given tag.
virtual const std::string &	name () const
const std::vector< VariableName > &	getVariableNames () const
void	getStandardFieldVariableNames (std::vector< VariableName > &std_field_variables) const
unsigned int	getMaxVariableNumber () const
	Returns the maximum number of all variables on the system.
virtual void	computeVariables (const NumericVector< Number > &)
void	copyVars (libMesh::ExodusII_IO &io)
virtual void	copySolutionsBackwards ()
	Copy current solution into old and older.
void	copyStateHistoryBackwards ()
	Copy solution vectors and additional system-owned state into older states.
void	addTimeIntegrator (const std::string &type, const std::string &name, InputParameters &parameters)
bool	hasVarCopy () const
	Whether or not there are variables to be restarted from an Exodus mesh file.
void	addScalingVector ()
	Add the scaling factor vector to the system.
bool	solutionStatesInitialized () const
	Whether or not the solution states have been initialized via initSolutionState()
virtual void	timestepSetup ()
virtual void	customSetup (const ExecFlagType &exec_type)
virtual void	subdomainSetup ()
void	clearAllDofIndices ()
	Clear all dof indices from moose variables.
void	setActiveVariableCoupleableVectorTags (const std::set< TagID > &vtags, THREAD_ID tid)
	Set the active vector tags for the variables.
void	setActiveScalarVariableCoupleableVectorTags (const std::set< TagID > &vtags, THREAD_ID tid)
	Set the active vector tags for the scalar variables.
Moose::VarKindType	varKind () const
void	copyTimeIntegrators (const SystemBase &other_sys)
	Copy time integrators from another system.
const TimeIntegrator &	getTimeIntegrator (const unsigned int var_num) const
	Retrieve the time integrator that integrates the given variable's equation.
const TimeIntegrator *	queryTimeIntegrator (const unsigned int var_num) const
	Retrieve the time integrator that integrates the given variable's equation.
const std::vector< std::shared_ptr< TimeIntegrator > > &	getTimeIntegrators ()
std::string	prefix () const
void	sizeVariableMatrixData ()
	size the matrix data for each variable for the number of matrix tags we have
void	skipNextSolutionToOldCopy ()
	Skip the next copy from the solution vector to the old solution vector old -> older is still performed.
const Parallel::Communicator &	comm () const
processor_id_type	n_processors () const
processor_id_type	processor_id () const
PerfGraph &	perfGraph ()
	Get the PerfGraph.
const FVGradientMethod &	resolveFVGradientMethod (const GradientMethodName &method_name)
	Resolve a named gradient method, constructing a built-in method when needed.
TagID	rightHandSideTimeVectorTag () const
TagID	rightHandSideNonTimeVectorTag () const
TagID	rightHandSideVectorTag () const
virtual TagID	systemMatrixTag () const override
	Return the Matrix Tag ID for System.
virtual NumericVector< Number > &	getVector (const std::string &name)
	Get a raw NumericVector by name.
virtual const NumericVector< Number > &	getVector (const std::string &name) const
virtual NumericVector< Number > &	getVector (TagID tag)
	Get a raw NumericVector by tag.
virtual const NumericVector< Number > &	getVector (TagID tag) const
virtual bool	hasVariable (const std::string &var_name) const
	Query a system for a variable.
virtual bool	hasScalarVariable (const std::string &var_name) const

Static Public Member Functions
static InputParameters	validParams ()

Public Attributes
const ConsoleStream	_console
	An instance of helper class to write streams to the Console objects.

Protected Types
using	GradientContainer = LinearFVGradientReader::GradientContainer
	Non-owning view with one vector per spatial component of a cell-centered gradient field.
using	GradientStateContainer = LinearFVGradientReader::GradientStateContainer
	Gradient fields indexed by solution time state.
using	OwnedGradientContainer = std::vector< std::unique_ptr< libMesh::NumericVector< libMesh::Number > > >
	Owned vectors used for the current gradient and its replacement.

Protected Member Functions
virtual void	copyAdditionalStateBackwards (Moose::SolutionIterationType iteration_type, bool skip_current_to_old) override
	Copy system-owned state not represented by solution vectors.
virtual void	restoreAdditionalStates () override
	Restore system-owned state not represented by solution vectors.
void	computeLinearSystemInternal (const std::set< TagID > &vector_tags, const std::set< TagID > &matrix_tags, const bool compute_gradients=true)
	Compute the right hand side and system matrix for given tags.
void	initialSetupKokkosLinearFV ()
	Perform the initial setup of the Kokkos linear finite volume kernels and boundary conditions.
void	computeKokkosLinearSystem (const std::set< TagID > &vector_tags, const std::set< TagID > &matrix_tags)
	Assemble the Kokkos contributions to the linear system for the given tags.
void	checkInvalidSolution ()
virtual NumericVector< Number > &	solutionInternal () const override final
	Internal getter for solution owned by libMesh.
virtual bool	matrixFromColoring () const
	Whether a system matrix is formed from coloring.
PerfID	registerTimedSection (const std::string &section_name, const unsigned int level) const
	Call to register a named section for timing.
PerfID	registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const
	Call to register a named section for timing.
std::string	timedSectionName (const std::string &section_name) const
void	initializeLinearFVGradientStorage ()
	Initialize private current and replacement gradient storage.
void	initializeLinearFVGradientHistoryStorage ()
	Register named system vectors for requested historical gradient states.
void	rebuildLinearFVGradientStorage ()
	Rebuild cached gradient values and reusable scratch storage after mesh/DOF changes.
void	copyPreviousGradientStates (Moose::SolutionIterationType iteration_type, bool skip_current_to_old)
	Copy published gradient values into requested older states.
void	restoreGradientStates ()
	Restore current gradients from state one after a failed timestep.
bool	hasLinearFVGradients () const
	Whether any linear finite-volume gradient fields have been registered to this object.
void	initializeContainer (OwnedGradientContainer &container) const
	Allocate one zeroed vector per spatial component for gradient storage.
void	resizeGradientStateStorage (LinearFVGradientContainer &container, unsigned int oldest_state)
	Ensure that a method container stores every requested time state.
void	setCurrentGradientState (LinearFVGradientContainer &container) const
	Set solution state zero to the current gradient.
void	checkRestartedGradientHistory (const FVGradientMethod &method, LinearFVGradientContainer &container)
	Validate and mark gradient history loaded during restart or recovery.
void	initializeGradientStatesForTimeAdvance ()
	Compute and publish uninitialized gradients before their first time-state advancement.
LinearFVGradientContainer &	computeLinearFVGradientContainer (const FVGradientMethod &method)
	Compute replacement field values for a registered gradient method.
void	finalizeLinearFVGradientContainer (LinearFVGradientContainer &container)
	Replace the current gradient storage with the freshly computed new gradients.

Static Protected Member Functions
static std::string	gradientStateVectorName (const FVGradientMethod &method, unsigned int state, unsigned int component)
	Return the stable system-vector name for one old gradient component.

Protected Attributes
NumericVector< Number > *	_dummy
System &	_sys
	Base class reference to the libmesh system.
unsigned int	_current_l_its
	The linear iterations needed for convergence.
std::set< TagID >	_vector_tags
	Vector tags to temporarily store all tags associated with the current system.
std::set< TagID >	_matrix_tags
	Matrix tags to temporarily store all tags associated with the current system.
TagID	_rhs_time_tag
	Tag for time contribution rhs.
NumericVector< Number > *	_rhs_time
	right hand side vector for time contributions
TagID	_rhs_non_time_tag
	Tag for non-time contribution rhs.
NumericVector< Number > *	_rhs_non_time
	right hand side vector for non-time contributions
TagID	_rhs_tag
	Used for the right hand side vector from PETSc.
TagID	_system_matrix_non_time_tag
	Tag for non-time contribution to the system matrix.
TagID	_system_matrix_tag
	Tag for every contribution to system matrix.
unsigned int	_n_linear_iters
	Number of linear iterations.
Real	_initial_linear_residual
	The initial linear residual.
Real	_final_linear_residual
	The final linear residual.
bool	_converged
	If the solve on the linear system converged.
libMesh::LinearImplicitSystem &	_linear_implicit_system
	Base class reference to the linear implicit system in libmesh.
const NumericVector< Number > *	_current_solution
	solution vector from solver
Moose::PCSideType	_pc_side
	Preconditioning side.
Moose::MooseKSPNormType	_ksp_norm
	KSP norm type.
bool	_solution_is_invalid
	Boolean to see if solution is invalid.
SubProblem &	_subproblem
	The subproblem for whom this class holds variable data, etc; this can either be the governing finite element/volume problem or a subjugate displaced problem.
FEProblemBase &	_fe_problem
	the governing finite element/volume problem
MooseApp &	_app
Factory &	_factory
MooseMesh &	_mesh
std::string	_name
	The name of this system.
std::vector< VariableWarehouse >	_vars
	Variable warehouses (one for each thread)
std::map< unsigned int, std::set< SubdomainID > >	_var_map
	Map of variables (variable id -> array of subdomains where it lives)
unsigned int	_max_var_number
	Maximum variable number.
std::vector< std::string >	_vars_to_be_zeroed_on_residual
std::vector< std::string >	_vars_to_be_zeroed_on_jacobian
NumericVector< Number > *	_u_dot
	solution vector for u^dot
NumericVector< Number > *	_u_dotdot
	solution vector for u^dotdot
NumericVector< Number > *	_u_dot_old
	old solution vector for u^dot
NumericVector< Number > *	_u_dotdot_old
	old solution vector for u^dotdot
std::vector< Real >	_du_dot_du
	Derivative of time derivative of u with respect to uj.
Real	_du_dotdot_du
std::vector< NumericVector< Number > * >	_tagged_vectors
	Tagged vectors (pointer)
std::vector< libMesh::SparseMatrix< Number > * >	_tagged_matrices
	Tagged matrices (pointer)
std::unordered_map< TagID, libMesh::SparseMatrix< Number > * >	_active_tagged_matrices
	Active tagged matrices. A matrix is active if its tag-matrix pair is present in the map. We use a map instead of a vector so that users can easily add and remove to this container with calls to (de)activateMatrixTag.
std::vector< bool >	_matrix_tag_active_flags
	Active flags for tagged matrices.
NumericVector< Real > *	_saved_old
NumericVector< Real > *	_saved_older
NumericVector< Real > *	_saved_dot_old
NumericVector< Real > *	_saved_dotdot_old
Moose::VarKindType	_var_kind
	default kind of variables in this system
std::vector< VarCopyInfo >	_var_to_copy
size_t	_max_var_n_dofs_per_elem
	Maximum number of dofs for any one variable on any one element.
size_t	_max_var_n_dofs_per_node
	Maximum number of dofs for any one variable on any one node.
std::vector< std::shared_ptr< TimeIntegrator > >	_time_integrators
	Time integrator.
std::vector< std::vector< MooseVariableFieldBase * > >	_numbered_vars
	Map variable number to its pointer.
bool	_automatic_scaling
	Whether to automatically scale the variables.
bool	_verbose
	True if printing out additional information.
bool	_solution_states_initialized
	Whether or not the solution states have been initialized.
std::vector< dof_id_type >	_var_all_dof_indices
	Container for the dof indices of a given variable.
std::unique_ptr< NumericVector< Number > >	_serialized_solution
	Serialized version of the solution vector, or nullptr if a serialized solution is not needed.
const Parallel::Communicator &	_communicator
MooseApp &	_pg_moose_app
	The MooseApp that owns the PerfGraph.
const std::string	_prefix
	A prefix to use for all sections.
std::unordered_map< const FVGradientMethod *, LinearFVGradientContainer >	_linear_fv_gradient_container_by_method
	Gradient containers keyed by the method object that produces them.

Private Member Functions
std::vector< NumericVector< Number > * > &	getSolutionStates (const Moose::SolutionIterationType iteration_type)
	Get all of the solution states (current, old, ...) for the given iteration type.
TagName	oldSolutionStateVectorName (const unsigned int, Moose::SolutionIterationType iteration_type) const
	Gets the vector name used for an old (not current) solution state.

Private Attributes
std::vector< NumericVector< Number > * >	_solution_state
	The current states of the solution (0 = current, 1 = old, etc)
std::array< std::vector< NumericVector< Number > * >, static_cast< size_t >(Moose::SolutionIterationType::Count)>	_solution_states
	2D array of solution state vector pointers.
std::vector< NumericVector< Number > * >	_saved_solution_states
	The saved solution states (0 = current, 1 = old, 2 = older, etc)
bool	_skip_next_solution_to_old_copy
	Whether to skip the next copy from the solution to the old vector.

Detailed Description

Linear system for dumping objects TODO: consider creating a base class for LinearSystems to be able to create a more minimal linear system.

For now the additional code complexity is not worth it

Definition at line 25 of file DumpObjectsLinearSystem.h.

Member Typedef Documentation

GradientContainer

using LinearFVGradientManager::GradientContainer = LinearFVGradientReader::GradientContainer

protectedinherited

Non-owning view with one vector per spatial component of a cell-centered gradient field.

Definition at line 65 of file LinearFVGradientManager.h.

GradientStateContainer

using LinearFVGradientManager::GradientStateContainer = LinearFVGradientReader::GradientStateContainer

protectedinherited

Gradient fields indexed by solution time state.

Definition at line 68 of file LinearFVGradientManager.h.

OwnedGradientContainer

using LinearFVGradientManager::OwnedGradientContainer = std::vector<std::unique_ptr<libMesh::NumericVector<libMesh::Number> >>

protectedinherited

Owned vectors used for the current gradient and its replacement.

Definition at line 71 of file LinearFVGradientManager.h.

Constructor & Destructor Documentation

DumpObjectsLinearSystem()

DumpObjectsLinearSystem::DumpObjectsLinearSystem	(	FEProblemBase &	problem,
		const std::string &	name
	)

Definition at line 13 of file DumpObjectsLinearSystem.C.

  : LinearSystem(problem, name), _dummy(nullptr)
{
}

Member Function Documentation

activateAllMatrixTags()

void SystemBase::activateAllMatrixTags ( )

virtualinherited

Make all existing matrices active.

Definition at line 1128 of file SystemBase.C.

{
  auto num_matrix_tags = _subproblem.numMatrixTags();
 
  _matrix_tag_active_flags.resize(num_matrix_tags);
  _active_tagged_matrices.clear();
 
  for (const auto tag : make_range(num_matrix_tags))
    if (hasMatrix(tag))
    {
      _matrix_tag_active_flags[tag] = true;
      _active_tagged_matrices.emplace(tag, &getMatrix(tag));
    }
    else
      _matrix_tag_active_flags[tag] = false;
}

Referenced by NonlinearSystemBase::computeJacobianInternal(), LinearSystem::computeLinearSystemInternal(), NonlinearSystemBase::computeResidualAndJacobianInternal(), and NonlinearSystemBase::computeResidualTags().

addDotVectors()

void SystemBase::addDotVectors ( )

virtualinherited

Add u_dot, u_dotdot, u_dot_old and u_dotdot_old vectors if requested by the time integrator.

Reimplemented in DisplacedSystem.

Definition at line 1654 of file SystemBase.C.

{
  if (_fe_problem.uDotRequested())
    _u_dot = &addVector("u_dot", true, GHOSTED);
  if (_fe_problem.uDotOldRequested())
    _u_dot_old = &addVector("u_dot_old", true, GHOSTED);
  if (_fe_problem.uDotDotRequested())
    _u_dotdot = &addVector("u_dotdot", true, GHOSTED);
  if (_fe_problem.uDotDotOldRequested())
    _u_dotdot_old = &addVector("u_dotdot_old", true, GHOSTED);
}

Referenced by DisplacedSystem::addDotVectors().

addKokkosBoundaryCondition()

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

inherited

Add a Kokkos linear finite volume boundary condition to this system.

Parameters

bc_name	The type of the boundary condition to add
name	The name of the boundary condition to add
parameters	The input parameters of the boundary condition

addKokkosKernel()

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

inherited

Add a Kokkos linear finite volume kernel to this system.

Parameters

kernel_name	The type of the kernel to add
name	The name of the kernel to add
parameters	The input parameters of the kernel

addMatrix()

SparseMatrix< Number > & SystemBase::addMatrix ( TagID  tag )

inherited

Adds a matrix with a given tag.

Parameters

tag_name

The name of the tag

Definition at line 567 of file SystemBase.C.

{
  if (!_subproblem.matrixTagExists(tag))
    mooseError("Cannot add tagged matrix with TagID ",
               tag,
               " in system '",
               name(),
               "' because the tag does not exist in the problem");
 
  if (hasMatrix(tag))
    return getMatrix(tag);
 
  const auto matrix_name = _subproblem.matrixTagName(tag);
  SparseMatrix<Number> & mat = system().add_matrix(matrix_name);
  associateMatrixToTag(mat, tag);
 
  return mat;
}

addScalingVector()

void SystemBase::addScalingVector ( )

inherited

Add the scaling factor vector to the system.

Definition at line 1579 of file SystemBase.C.

{
  addVector("scaling_factors", /*project=*/false, GHOSTED);
  _subproblem.hasScalingVector(number());
}

Referenced by MooseVariableBase::initialSetup().

addTimeIntegrator()

void SystemBase::addTimeIntegrator ( const std::string &  type, const std::string &  name, InputParameters &  parameters  )

inherited

Definition at line 1679 of file SystemBase.C.

{
  parameters.set<SystemBase *>("_sys") = this;
  _time_integrators.push_back(_factory.create<TimeIntegrator>(type, name, parameters));
}

addVariable()

void SystemBase::addVariable ( const std::string &  var_type, const std::string &  var_name, InputParameters &  parameters  )

virtualinherited

Canonical method for adding a variable.

Parameters

var_type	the type of the variable, e.g. MooseVariableScalar
var_name	the variable name, e.g. 'u'
params	the InputParameters from which to construct the variable

Reimplemented in AuxiliarySystem.

Definition at line 717 of file SystemBase.C.

{
  _numbered_vars.resize(libMesh::n_threads());
 
  const auto components = parameters.get<unsigned int>("components");
 
  // Convert the std::vector parameter provided by the user into a std::set for use by libMesh's
  // System::add_variable method
  std::set<SubdomainID> blocks;
  const auto & block_param = parameters.get<std::vector<SubdomainName>>("block");
  for (const auto & subdomain_name : block_param)
  {
    SubdomainID blk_id = _mesh.getSubdomainID(subdomain_name);
    blocks.insert(blk_id);
  }
 
  const auto fe_type = MooseUtils::variableFEType(parameters);
  const auto fe_field_type = FEInterface::field_type(fe_type);
 
  unsigned int var_num;
 
  if (var_type == "ArrayMooseVariable")
  {
    if (fe_field_type == libMesh::TYPE_VECTOR)
      mooseError("Vector family type cannot be used in an array variable");
 
    std::vector<std::string> array_var_component_names;
    const bool has_array_names = parameters.isParamValid("array_var_component_names");
    if (has_array_names)
    {
      array_var_component_names =
          parameters.get<std::vector<std::string>>("array_var_component_names");
      if (array_var_component_names.size() != components)
        parameters.paramError("array_var_component_names",
                              "Must be the same size as 'components' (size ",
                              components,
                              ") for array variable '",
                              name,
                              "'");
    }
 
    // Build up the variable names
    std::vector<std::string> var_names;
    for (unsigned int i = 0; i < components; i++)
    {
      if (!has_array_names)
        array_var_component_names.push_back(std::to_string(i));
      var_names.push_back(name + "_" + array_var_component_names[i]);
    }
 
    // makes sure there is always a name, either the provided one or '1 2 3 ...'
    parameters.set<std::vector<std::string>>("array_var_component_names") =
        array_var_component_names;
 
    // The number returned by libMesh is the _last_ variable number... we want to hold onto the
    // _first_
    var_num = system().add_variable_array(var_names, fe_type, &blocks) - (components - 1);
 
    // Set as array variable
    if (parameters.isParamSetByUser("array") && !parameters.get<bool>("array"))
      parameters.paramError("array",
                            "Must be set to true for variable '",
                            name,
                            "' because 'components' > 1 (is an array variable)");
    parameters.set<bool>("array") = true;
  }
  else
  {
    if (parameters.isParamSetByUser("array_var_component_names"))
      parameters.paramError("array_var_component_names",
                            "Should not be set because this variable (",
                            name,
                            ") is a non-array variable");
    var_num = system().add_variable(name, fe_type, &blocks);
  }
 
  parameters.set<unsigned int>("_var_num") = var_num;
  parameters.set<SystemBase *>("_system_base") = this;
 
  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
  {
    parameters.set<THREAD_ID>("tid") = tid;
    std::shared_ptr<MooseVariableBase> var =
        _factory.create<MooseVariableBase>(var_type, name, parameters, tid);
 
    _vars[tid].add(name, var);
 
    if (auto fe_var = dynamic_cast<MooseVariableFieldBase *>(var.get()))
    {
      auto required_size = var_num + components;
      if (required_size > _numbered_vars[tid].size())
        _numbered_vars[tid].resize(required_size);
      for (MooseIndex(components) component = 0; component < components; ++component)
        _numbered_vars[tid][var_num + component] = fe_var;
 
      if (auto * const functor = dynamic_cast<Moose::FunctorBase<ADReal> *>(fe_var))
        _subproblem.addFunctor(name, *functor, tid);
      else if (auto * const functor = dynamic_cast<Moose::FunctorBase<ADRealVectorValue> *>(fe_var))
        _subproblem.addFunctor(name, *functor, tid);
      else if (auto * const functor = dynamic_cast<Moose::FunctorBase<ADRealEigenVector> *>(fe_var))
        _subproblem.addFunctor(name, *functor, tid);
      else
        mooseError("This should be a functor");
    }
 
    if (auto scalar_var = dynamic_cast<MooseVariableScalar *>(var.get()))
    {
      if (auto * const functor = dynamic_cast<Moose::FunctorBase<ADReal> *>(scalar_var))
        _subproblem.addFunctor(name, *functor, tid);
      else
        mooseError("Scalar variables should be functors");
    }
 
    if (var->blockRestricted())
      for (const SubdomainID & id : var->blockIDs())
        for (MooseIndex(components) component = 0; component < components; ++component)
          _var_map[var_num + component].insert(id);
    else
      for (MooseIndex(components) component = 0; component < components; ++component)
        _var_map[var_num + component] = std::set<SubdomainID>();
  }
 
  // getMaxVariableNumber is an API method used in Rattlesnake
  if (var_num > _max_var_number)
    _max_var_number = var_num;
  _du_dot_du.resize(var_num + 1);
}

Referenced by AuxiliarySystem::addVariable().

addVariableToCopy()

void SystemBase::addVariableToCopy ( const std::string &  dest_name, const std::string &  source_name, const std::string &  timestep  )

virtualinherited

Add info about variable that will be copied.

Parameters

dest_name	Name of the nodal variable being used for copying into (name is from the exodusII file)
source_name	Name of the nodal variable being used for copying from (name is from the exodusII file)
timestep	Timestep in the file being used

Definition at line 1172 of file SystemBase.C.

{
  _var_to_copy.push_back(VarCopyInfo(dest_name, source_name, timestep));
}

Referenced by CopyNodalVarsAction::act(), and PhysicsBase::copyVariablesFromMesh().

addVariableToZeroOnJacobian()

void SystemBase::addVariableToZeroOnJacobian ( std::string  var_name )

virtualinherited

Adds this variable to the list of variables to be zeroed during each Jacobian evaluation.

Parameters

var_name

The name of the variable to be zeroed.

Reimplemented in DisplacedSystem.

Definition at line 179 of file SystemBase.C.

{
  _vars_to_be_zeroed_on_jacobian.push_back(var_name);
}

Referenced by ADDGKernel::ADDGKernel(), DisplacedSystem::addVariableToZeroOnJacobian(), ADIntegratedBCTempl< T >::ADIntegratedBCTempl(), ADKernelTempl< T >::ADKernelTempl(), ArrayDGKernel::ArrayDGKernel(), ArrayIntegratedBC::ArrayIntegratedBC(), ArrayKernel::ArrayKernel(), DGKernel::DGKernel(), IntegratedBC::IntegratedBC(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), Kernel::Kernel(), NodalBC::NodalBC(), and NodalKernel::NodalKernel().

addVariableToZeroOnResidual()

void SystemBase::addVariableToZeroOnResidual ( std::string  var_name )

virtualinherited

Adds this variable to the list of variables to be zeroed during each residual evaluation.

Parameters

var_name

The name of the variable to be zeroed.

Reimplemented in DisplacedSystem.

Definition at line 173 of file SystemBase.C.

{
  _vars_to_be_zeroed_on_residual.push_back(var_name);
}

Referenced by ADDGKernel::ADDGKernel(), DisplacedSystem::addVariableToZeroOnResidual(), ADIntegratedBCTempl< T >::ADIntegratedBCTempl(), ADKernelTempl< T >::ADKernelTempl(), ArrayDGKernel::ArrayDGKernel(), ArrayIntegratedBC::ArrayIntegratedBC(), ArrayKernel::ArrayKernel(), DGKernel::DGKernel(), IntegratedBC::IntegratedBC(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), Kernel::Kernel(), NodalBC::NodalBC(), and NodalKernel::NodalKernel().

addVector() [1/2]

NumericVector< Number > & SystemBase::addVector ( const std::string &  vector_name, const bool  project, const libMesh::ParallelType  type  )

inherited

Adds a solution length vector to the system.

Parameters

vector_name	The name of the vector.
project	Whether or not to project this vector when doing mesh refinement. If the vector is just going to be recomputed then there is no need to project it.
type	What type of parallel vector. This is usually either PARALLEL or GHOSTED. GHOSTED is needed if you are going to be accessing off-processor entries. The ghosting pattern is the same as the solution vector.

Definition at line 605 of file SystemBase.C.

{
  if (hasVector(vector_name))
    return getVector(vector_name);
 
  NumericVector<Number> & vec = system().add_vector(vector_name, project, type);
  return vec;
}

Referenced by SystemBase::addDotVectors(), SystemBase::addScalingVector(), NonlinearTimeIntegratorInterface::addVector(), PicardSolve::allocateStorage(), SecantSolve::allocateStorage(), SteffensenSolve::allocateStorage(), NonlinearSystemBase::getResidualNonTimeVector(), NonlinearSystemBase::getResidualTimeVector(), LinearFVGradientManager::initializeLinearFVGradientHistoryStorage(), CentralDifference::initialSetup(), SystemBase::needSolutionState(), NonlinearSystemBase::residualGhosted(), and SystemBase::saveOldSolutions().

addVector() [2/2]

NumericVector< Number > & SystemBase::addVector ( TagID  tag, const bool  project, const libMesh::ParallelType  type  )

inherited

Adds a solution length vector to the system with the specified TagID.

Parameters

tag_name	The name of the tag
project	Whether or not to project this vector when doing mesh refinement. If the vector is just going to be recomputed then there is no need to project it.
type	What type of parallel vector. This is usually either PARALLEL or GHOSTED. GHOSTED is needed if you are going to be accessing off-processor entries. The ghosting pattern is the same as the solution vector.

Definition at line 617 of file SystemBase.C.

{
  if (!_subproblem.vectorTagExists(tag))
    mooseError("Cannot add tagged vector with TagID ",
               tag,
               " in system '",
               name(),
               "' because the tag does not exist in the problem");
 
  if (hasVector(tag))
  {
    auto & vec = getVector(tag);
 
    if (type != AUTOMATIC && vec.type() != type)
      mooseError("Cannot add tagged vector '",
                 _subproblem.vectorTagName(tag),
                 "', in system '",
                 name(),
                 "' because a vector with the same name was found with a different parallel type");
 
    return vec;
  }
 
  const auto vector_name = _subproblem.vectorTagName(tag);
  NumericVector<Number> & vec = system().add_vector(vector_name, project, type);
  associateVectorToTag(vec, tag);
 
  return vec;
}

advanceStateHistory()

void SystemBase::advanceStateHistory ( Moose::SolutionIterationType  iteration_type )

inherited

Advance solution vectors and additional system-owned state together.

Definition at line 1308 of file SystemBase.C.

{
  const bool skip_current_to_old =
      iteration_type == Moose::SolutionIterationType::Time && _skip_next_solution_to_old_copy;
  copyPreviousSolutions(iteration_type);
  copyAdditionalStateBackwards(iteration_type, skip_current_to_old);
}

Referenced by SystemBase::copyStateHistoryBackwards(), and EigenExecutionerBase::inversePowerIteration().

applyFixedPointRelaxation()

void SolverSystem::applyFixedPointRelaxation ( const Real  relaxation_factor, const Moose::SolutionIterationType  iteration_type  )

inherited

Apply solution under/over-relaxation for fixed point iterations.

The relaxed update is: u <- relaxation_factor * u_new + (1 - relaxation_factor) * u_old

Parameters

[in]	relaxation_factor	The factor applied to the new solution
[in]	iteration_type	Type of iteration; which "previous" value to use

Definition at line 77 of file SolverSystem.C.

{
  if (MooseUtils::absoluteFuzzyEqual(relaxation_factor, 1.0))
    return;
 
  mooseAssert(hasSolutionState(1, iteration_type),
              "Fixed point relaxation was requested but the old fixed point solution was not "
              "saved.");
 
  // This might be paranoid but who knows, maybe someone requests nonghosted
  mooseAssert(solutionStateParallelType(1, iteration_type) == solution().type(),
              "Fixed point relaxation requires the previous fixed point solution state to have "
              "the same parallel type as the system solution.");
 
  auto & sol = solution();
  sol.scale(relaxation_factor);
  sol.add(1.0 - relaxation_factor, solutionState(1, iteration_type));
  sol.close();
  update();
}

applyScalingFactors()

void SystemBase::applyScalingFactors ( const std::vector< Real > &  inverse_scaling_factors )

inherited

Applies scaling factors to the system's variables.

Parameters

inverse_scaling_factors

A vector containing the inverse of each variable's scaling factor, e.g. 1 / scaling_factor

Definition at line 1529 of file SystemBase.C.

{
  for (MooseIndex(_vars) thread = 0; thread < _vars.size(); ++thread)
  {
    auto & field_variables = _vars[thread].fieldVariables();
    for (MooseIndex(field_variables) i = 0, p = 0; i < field_variables.size(); ++i)
    {
      auto factors = field_variables[i]->arrayScalingFactor();
      for (unsigned int j = 0; j < field_variables[i]->count(); ++j, ++p)
        factors[j] /= inverse_scaling_factors[p];
 
      field_variables[i]->scalingFactor(factors);
    }
 
    auto offset = field_variables.size();
 
    auto & scalar_variables = _vars[thread].scalars();
    for (MooseIndex(scalar_variables) i = 0; i < scalar_variables.size(); ++i)
      scalar_variables[i]->scalingFactor(
          {1. / inverse_scaling_factors[offset + i] * scalar_variables[i]->scalingFactor()});
 
    if (thread == 0 && _verbose)
    {
      _console << "Automatic scaling factors:\n";
      auto original_flags = _console.flags();
      auto original_precision = _console.precision();
      _console.unsetf(std::ios_base::floatfield);
      _console.precision(6);
 
      for (const auto & field_variable : field_variables)
      {
        const auto & factors = field_variable->arrayScalingFactor();
        _console << "  " << field_variable->name() << ":";
        for (const auto i : make_range(field_variable->count()))
          _console << " " << factors[i];
        _console << "\n";
      }
      for (const auto & scalar_variable : scalar_variables)
        _console << "  " << scalar_variable->name() << ": " << scalar_variable->scalingFactor()
                 << "\n";
      _console << "\n" << std::endl;
 
      // restore state
      _console.flags(original_flags);
      _console.precision(original_precision);
    }
  }
}

Referenced by NonlinearSystemBase::computeScaling().

assignMaxVarNDofsPerElem()

void SystemBase::assignMaxVarNDofsPerElem ( std::size_t  max_dofs )

inlineinherited

assign the maximum element dofs

Definition at line 625 of file SystemBase.h.

{ _max_var_n_dofs_per_elem = max_dofs; }

assignMaxVarNDofsPerNode()

void SystemBase::assignMaxVarNDofsPerNode ( std::size_t  max_dofs )

inlineinherited

assign the maximum node dofs

Definition at line 630 of file SystemBase.h.

{ _max_var_n_dofs_per_node = max_dofs; }

associateMatrixToTag()

void SystemBase::associateMatrixToTag ( libMesh::SparseMatrix< Number > &  matrix, TagID  tag  )

virtualinherited

Associate a matrix to a tag.

Reimplemented in DisplacedSystem.

Definition at line 1073 of file SystemBase.C.

{
  if (!_subproblem.matrixTagExists(tag))
    mooseError("Cannot associate matrix to tag ", tag, " because that tag does not exist");
 
  if (_tagged_matrices.size() < tag + 1)
    _tagged_matrices.resize(tag + 1);
 
  _tagged_matrices[tag] = &matrix;
}

Referenced by SystemBase::addMatrix(), DisplacedSystem::associateMatrixToTag(), NonlinearSystemBase::computeJacobian(), FEProblemBase::computeJacobianInternal(), FEProblemBase::computeJacobianTag(), FEProblemBase::computeLinearSystemSys(), and FEProblemBase::computeResidualAndJacobian().

associateVectorToTag()

void SystemBase::associateVectorToTag ( NumericVector< Number > &  vec, TagID  tag  )

virtualinherited

Associate a vector for a given tag.

Reimplemented in DisplacedSystem.

Definition at line 978 of file SystemBase.C.

{
  if (!_subproblem.vectorTagExists(tag))
    mooseError("Cannot associate vector to tag ", tag, " because that tag does not exist");
 
  if (_tagged_vectors.size() < tag + 1)
    _tagged_vectors.resize(tag + 1);
 
  _tagged_vectors[tag] = &vec;
}

Referenced by SystemBase::addVector(), DisplacedSystem::associateVectorToTag(), FEProblemBase::computeLinearSystemSys(), NonlinearSystemBase::computeNodalBCsResidual(), NonlinearSystemBase::computeNodalBCsResidual(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualInternal(), FEProblemBase::computeResidualTag(), NonlinearSystemBase::computeResidualTag(), FEProblemBase::computeResidualType(), LinearSystem::LinearSystem(), and SolverSystem::setSolution().

augmentSendList()

void SystemBase::augmentSendList ( std::vector< dof_id_type > &  send_list )

virtualinherited

Will modify the send_list to add all of the extra ghosted dofs for this system.

Reimplemented in DisplacedSystem.

Definition at line 451 of file SystemBase.C.

{
  std::set<dof_id_type> & ghosted_elems = _subproblem.ghostedElems();
 
  DofMap & dof_map = dofMap();
 
  std::vector<dof_id_type> dof_indices;
 
  System & sys = system();
 
  unsigned int sys_num = sys.number();
 
  unsigned int n_vars = sys.n_vars();
 
  for (const auto & elem_id : ghosted_elems)
  {
    Elem * elem = _mesh.elemPtr(elem_id);
 
    if (elem->active())
    {
      dof_map.dof_indices(elem, dof_indices);
 
      // Only need to ghost it if it's actually not on this processor
      for (const auto & dof : dof_indices)
        if (dof < dof_map.first_dof() || dof >= dof_map.end_dof())
          send_list.push_back(dof);
 
      // Now add the DoFs from all of the nodes.  This is necessary because of block
      // restricted variables.  A variable might not live _on_ this element but it
      // might live on nodes connected to this element.
      for (unsigned int n = 0; n < elem->n_nodes(); n++)
      {
        Node * node = elem->node_ptr(n);
 
        // Have to get each variable's dofs
        for (unsigned int v = 0; v < n_vars; v++)
        {
          const libMesh::Variable & var = sys.variable(v);
          unsigned int var_num = var.number();
          unsigned int n_comp = var.n_components();
 
          // See if this variable has any dofs at this node
          if (node->n_dofs(sys_num, var_num) > 0)
          {
            // Loop over components of the variable
            for (unsigned int c = 0; c < n_comp; c++)
              send_list.push_back(node->dof_number(sys_num, var_num, c));
          }
        }
      }
    }
  }
}

Referenced by DisplacedSystem::augmentSendList(), and extraSendList().

augmentSparsity()

void LinearSystem::augmentSparsity ( SparsityPattern::Graph &  sparsity, std::vector< dof_id_type > &  n_nz, std::vector< dof_id_type > &  n_oz  )

overridevirtualinherited

Will modify the sparsity pattern to add logical geometric connections.

Implements SystemBase.

Definition at line 317 of file LinearSystem.C.

{
  mooseError("LinearSystem does not support AugmentSparsity!");
}

automaticScaling() [1/2]

bool SystemBase::automaticScaling ( ) const

inlineinherited

Getter for whether we are performing automatic scaling.

Returns

whether we are performing automatic scaling

Definition at line 123 of file SystemBase.h.

{ return _automatic_scaling; }

Referenced by SubProblem::automaticScaling(), and SubProblem::automaticScaling().

automaticScaling() [2/2]

void SystemBase::automaticScaling ( bool  automatic_scaling )

inlineinherited

Setter for whether we are performing automatic scaling.

Parameters

automatic_scaling

A boolean representing whether we are performing automatic scaling

Definition at line 129 of file SystemBase.h.

{ _automatic_scaling = automatic_scaling; }

checkInvalidSolution()

void SolverSystem::checkInvalidSolution ( )

protectedinherited

Definition at line 132 of file SolverSystem.C.

{
  auto & solution_invalidity = _app.solutionInvalidity();
 
  // sync all solution invalid counts to rank 0 process
  solution_invalidity.syncIteration();
 
  if (solution_invalidity.hasInvalidSolution())
  {
    if (_fe_problem.acceptInvalidSolution())
      if (_fe_problem.showInvalidSolutionConsole())
        solution_invalidity.print(_console);
      else
        mooseWarning("The Solution Invalidity warnings are detected but silenced! "
                     "Use Problem/show_invalid_solution_console=true to show solution counts");
    else
      // output the occurrence of solution invalid in a summary table
      if (_fe_problem.showInvalidSolutionConsole())
        solution_invalidity.print(_console);
  }
}

Referenced by LinearSystem::solve(), and NonlinearSystem::solve().

checkRestartedGradientHistory()

void LinearFVGradientManager::checkRestartedGradientHistory ( const FVGradientMethod &  method, LinearFVGradientContainer &  container  )

protectedinherited

Validate and mark gradient history loaded during restart or recovery.

Definition at line 237 of file LinearFVGradientManager.C.

{
  if (container.has_checked_restart_history)
    return;
 
  container.has_checked_restart_history = true;
  if (container.state_values.size() <= 1)
    return;
 
  const auto & app = _sys.feProblem().getMooseApp();
  if (!app.isRestarting() && !app.isRecovering())
    return;
 
  const auto & restartable_equation_systems = _sys.feProblem().getRestartableEquationSystems();
  for (const auto state : make_range(std::size_t(1), container.state_values.size()))
    for (const auto component : index_range(container.state_values[state]))
    {
      const auto vector_name = gradientStateVectorName(method, state, component);
      for (const auto variable_number : container.variable_numbers)
      {
        const auto & variable = _sys.getVariable(0, variable_number);
        if (!restartable_equation_systems.isVariableRestored(
                _sys.name(), vector_name, variable.name()))
          mooseError("Linear FV gradient state ",
                     state,
                     " for variable '",
                     variable.name(),
                     "' using gradient method '",
                     method.name(),
                     "' was requested on system '",
                     _sys.name(),
                     "', but vector '",
                     vector_name,
                     "' was not available in the restart data.");
      }
    }
 
  container.has_initialized_history = true;
}

Referenced by LinearFVGradientManager::initializeLinearFVGradientStorage().

clearAllDofIndices()

void SystemBase::clearAllDofIndices ( )

inherited

Clear all dof indices from moose variables.

Definition at line 1634 of file SystemBase.C.

{
  for (auto & var_warehouse : _vars)
    var_warehouse.clearAllDofIndices();
}

Referenced by SubProblem::clearAllDofIndices().

closeTaggedMatrices()

void SystemBase::closeTaggedMatrices ( const std::set< TagID > &  tags )

inherited

Close all matrices associated the tags.

Definition at line 1057 of file SystemBase.C.

{
  for (auto tag : tags)
    if (hasMatrix(tag))
      getMatrix(tag).close();
}

Referenced by NonlinearSystemBase::computeJacobianInternal(), LinearSystem::computeLinearSystemInternal(), NonlinearSystemBase::computeNodalBCsJacobian(), and NonlinearSystemBase::computeResidualAndJacobianTags().

closeTaggedVector()

void SystemBase::closeTaggedVector ( const TagID  tag )

inherited

Close vector with the given tag.

Definition at line 648 of file SystemBase.C.

{
  if (!_subproblem.vectorTagExists(tag))
    mooseError("Cannot close vector with TagID ",
               tag,
               " in system '",
               name(),
               "' because that tag does not exist in the problem");
  else if (!hasVector(tag))
    mooseError("Cannot close vector tag with name '",
               _subproblem.vectorTagName(tag),
               "' in system '",
               name(),
               "' because there is no vector associated with that tag");
  getVector(tag).close();
}

Referenced by SystemBase::closeTaggedVectors().

closeTaggedVectors()

void SystemBase::closeTaggedVectors ( const std::set< TagID > &  tags )

inherited

Close all vectors for given tags.

Definition at line 666 of file SystemBase.C.

{
  for (const auto tag : tags)
    closeTaggedVector(tag);
}

Referenced by NonlinearSystemBase::computeResidualAndJacobianTags(), NonlinearSystemBase::computeResidualTags(), LinearSystem::stopSolve(), and NonlinearSystem::stopSolve().

compute()

void LinearSystem::compute ( ExecFlagType  type )

overridevirtualinherited

Compute time derivatives, auxiliary variables, etc.

Parameters

type	Our current execution stage

Reimplemented from SolverSystem.

Definition at line 383 of file LinearSystem.C.

{
  // - Linear system assembly is associated with EXEC_NONLINEAR
  // - Avoid division by 0 dt
  if (type == EXEC_NONLINEAR && _fe_problem.dt() > 0.)
    for (auto & ti : _time_integrators)
      // Do things like compute integration weights
      ti->preStep();
}

Referenced by FEProblemBase::computeSystems().

computeGradients()

void LinearFVGradientManager::computeGradients ( )

inherited

Compute and finalize all registered linear FV gradient fields.

Definition at line 75 of file LinearFVGradientManager.C.

{
  if (_linear_fv_gradient_container_by_method.empty() || !_sys.solutionStatesInitialized())
    return;
 
  auto * const perf_graph_interface = dynamic_cast<PerfGraphInterface *>(&_sys);
  mooseAssert(perf_graph_interface,
              "LinearFVGradientManager requires its owning system to implement "
              "PerfGraphInterface.");
  const auto perf_id = perf_graph_interface->registerTimedSection("LinearVariableFV_Gradients", 3);
  mooseAssert(!Threads::in_threads, "PerfGraph timing cannot be used within threaded sections");
  PerfGuard time_guard(perf_graph_interface->perfGraph(), perf_id);
 
  // Keep current values unchanged until every replacement has been computed so boundary
  // conditions consistently use gradients from the previous update.
  // BCs may use cell gradients to compute the boundary face value, which is itself used to
  // compute cell gradients
  for (auto & method_container_pair : _linear_fv_gradient_container_by_method)
    computeLinearFVGradientContainer(*method_container_pair.first);
 
  for (auto & method_container_pair : _linear_fv_gradient_container_by_method)
    finalizeLinearFVGradientContainer(method_container_pair.second);
}

Referenced by LinearSystem::computeLinearSystemInternal(), and FEProblemSolve::solve().

computeKokkosLinearSystem()

void LinearSystem::computeKokkosLinearSystem ( const std::set< TagID > &  vector_tags, const std::set< TagID > &  matrix_tags  )

protectedinherited

Assemble the Kokkos contributions to the linear system for the given tags.

Parameters

vector_tags	The vector (right-hand side) tags to assemble
matrix_tags	The matrix tags to assemble

Referenced by LinearSystem::computeLinearSystemInternal().

computeLinearFVGradientContainer()

LinearFVGradientManager::LinearFVGradientContainer & LinearFVGradientManager::computeLinearFVGradientContainer ( const FVGradientMethod &  method )

protectedinherited

Compute replacement field values for a registered gradient method.

Parameters

method

Gradient method used to compute the replacement values.

Returns

Method container whose replacement values were computed.

Definition at line 279 of file LinearFVGradientManager.C.

{
  // Gradient requests can be registered before the current solution vector exists, so the current
  // and replacement fields cannot always be created when the request is recorded. These fields
  // must be zero clones of the solution vector to inherit its finalized layout and parallel type.
  // Requests can also arrive after the normal initialization phase. Initializing immediately
  // before computation handles both cases, while the empty checks make repeated calls harmless.
  initializeLinearFVGradientStorage();
 
  auto & container = libmesh_map_find(_linear_fv_gradient_container_by_method, &method);
 
  mooseAssert(!container.state_values.empty(),
              "Gradient state storage must contain a current state.");
  mooseAssert(!container.state_values[0].empty(),
              "Gradient storage must be initialized before gradient computation.");
  mooseAssert(!container.next_values.empty(),
              "Replacement gradient storage must be initialized before gradient computation.");
  mooseAssert(container.next_values.size() == container.current_values.size(),
              "Next and current gradient containers must have the same size.");
 
  method.computeGradient(_sys, container.next_values, container.variable_numbers);
 
  return container;
}

Referenced by LinearFVGradientManager::computeGradients(), LinearFVGradientManager::initializeGradientStatesForTimeAdvance(), and LinearFVGradientManager::updateFVGradient().

computeLinearSystemInternal()

void LinearSystem::computeLinearSystemInternal ( const std::set< TagID > &  vector_tags, const std::set< TagID > &  matrix_tags, const bool  compute_gradients = true  )

protectedinherited

Compute the right hand side and system matrix for given tags.

Parameters

vector_tags	The tags of kernels for which the right hand side is to be computed.
matrix_tags	The tags of kernels for which the system matrix is to be computed.
compute_gradients	A flag to disable the computation of new gradients during the assembly, can be used to lag gradients

Definition at line 228 of file LinearSystem.C.

{
  TIME_SECTION("computeLinearSystemInternal", 3);
 
  // Before we assemble we clear up the matrix and the vector
  _linear_implicit_system.matrix->zero();
  _linear_implicit_system.rhs->zero();
 
  // Make matrix ready to use
  activateAllMatrixTags();
 
  for (auto tag : matrix_tags)
  {
    auto & matrix = getMatrix(tag);
    // Necessary for speed
    if (auto petsc_matrix = dynamic_cast<PetscMatrix<Number> *>(&matrix))
    {
      LibmeshPetscCall(MatSetOption(petsc_matrix->mat(),
                                    MAT_KEEP_NONZERO_PATTERN, // This is changed in 3.1
                                    PETSC_TRUE));
      if (!_fe_problem.errorOnJacobianNonzeroReallocation())
        LibmeshPetscCall(
            MatSetOption(petsc_matrix->mat(), MAT_NEW_NONZERO_ALLOCATION_ERR, PETSC_FALSE));
    }
  }
 
  if (compute_gradients)
    computeGradients();
 
#ifdef MOOSE_KOKKOS_ENABLED
  // Kokkos assembly runs first: it accumulates via device-side atomics and syncs
  // back to PETSc before the CPU path writes. The CPU queries below filter out
  // Kokkos objects via AttribKokkos(false) so there is no double-counting.
  if (_fe_problem.hasKokkosResidualObjects())
    computeKokkosLinearSystem(vector_tags, matrix_tags);
#endif
 
  // linear contributions from the domain
  PARALLEL_TRY
  {
    TIME_SECTION("LinearFVKernels_FullSystem", 3 /*, "Computing LinearFVKernels"*/);
 
    using ElemInfoRange = StoredRange<MooseMesh::const_elem_info_iterator, const ElemInfo *>;
    ElemInfoRange elem_info_range(_fe_problem.mesh().ownedElemInfoBegin(),
                                  _fe_problem.mesh().ownedElemInfoEnd());
 
    using FaceInfoRange = StoredRange<MooseMesh::const_face_info_iterator, const FaceInfo *>;
    FaceInfoRange face_info_range(_fe_problem.mesh().ownedFaceInfoBegin(),
                                  _fe_problem.mesh().ownedFaceInfoEnd());
 
    ComputeLinearFVElementalThread elem_thread(
        _fe_problem, this->number(), vector_tags, matrix_tags);
    Threads::parallel_reduce(elem_info_range, elem_thread);
 
    ComputeLinearFVFaceThread face_thread(_fe_problem,
                                          this->number(),
                                          Moose::FV::LinearFVComputationMode::FullSystem,
                                          vector_tags,
                                          matrix_tags);
    Threads::parallel_reduce(face_info_range, face_thread);
  }
  PARALLEL_CATCH;
 
  closeTaggedMatrices(matrix_tags);
 
  _linear_implicit_system.matrix->close();
  _linear_implicit_system.rhs->close();
 
  // Accumulate the occurrence of solution invalid warnings for the current iteration cumulative
  // counters
  _app.solutionInvalidity().syncIteration();
  _app.solutionInvalidity().accumulateIterationIntoTimeStepOccurences();
}

Referenced by LinearSystem::computeLinearSystemTags().

computeLinearSystemTags()

void LinearSystem::computeLinearSystemTags ( const std::set< TagID > &  vector_tags, const std::set< TagID > &  matrix_tags, const bool  compute_gradients = true  )

inherited

Compute the right hand side and the system matrix of the system for given tags.

Parameters

vector_tags	The IDs of the vector tags whose right hand side contribution should be included
matrix_tags	The IDs of the matrix tags whose matrix contribution should be included
compute_gradients	A flag to disable the computation of new gradients during the assembly, can be used to lag gradients

Definition at line 202 of file LinearSystem.C.

{
  parallel_object_only();
 
  TIME_SECTION("LinearSystem::computeLinearSystemTags", 5);
 
  _fe_problem.setCurrentLinearSystem(_fe_problem.linearSysNum(name()));
 
  FloatingPointExceptionGuard fpe_guard(_app);
 
  try
  {
    computeLinearSystemInternal(vector_tags, matrix_tags, compute_gradients);
  }
  catch (MooseException & e)
  {
    _console << "Exception detected " << e.what() << std::endl;
    // The buck stops here, we have already handled the exception by
    // calling stopSolve(), it is now up to PETSc to return a
    // "diverged" reason during the next solve.
  }
}

Referenced by FEProblemBase::computeLinearSystemTags().

computeVariables()

virtual void SystemBase::computeVariables ( const NumericVector< Number > &  )

inlinevirtualinherited

Definition at line 899 of file SystemBase.h.

{}

computingScalingJacobian()

bool SystemBase::computingScalingJacobian ( ) const

inherited

Whether we are computing an initial Jacobian for automatic variable scaling.

Definition at line 1586 of file SystemBase.C.

{
  return _subproblem.computingScalingJacobian();
}

Referenced by Assembly::addJacobianBlock(), Assembly::addJacobianBlockNonlocal(), Assembly::cacheJacobianBlock(), Assembly::cacheJacobianBlock(), EigenKernel::computeJacobian(), Kernel::computeJacobian(), VectorKernel::computeJacobian(), and FEProblemBase::computeJacobianTags().

containsTimeKernel()

bool LinearSystem::containsTimeKernel ( )

overridevirtualinherited

If the system has a kernel that corresponds to a time derivative.

Considering that we don't have transient capabilities for linear systems at the moment, this is false.

Implements SolverSystem.

Definition at line 361 of file LinearSystem.C.

{
  // Right now, FV kernels are in TheWarehouse so we have to use that.
  std::vector<LinearFVKernel *> kernels;
  auto base_query = _fe_problem.theWarehouse()
                        .query()
                        .template condition<AttribSysNum>(this->number())
                        .template condition<AttribSystem>("LinearFVKernel")
                        .queryInto(kernels);
 
  bool contains_time_kernel = false;
  for (const auto kernel : kernels)
  {
    contains_time_kernel = dynamic_cast<LinearFVTimeDerivative *>(kernel);
    if (contains_time_kernel)
      break;
  }
 
  return contains_time_kernel;
}

converged()

virtual bool DumpObjectsLinearSystem::converged ( )

inlineoverridevirtual

At the moment, this is only used for the multi-system fixed point iteration.

We return true here since ther is no way to specify separate linear residuals in FEProblemSolve yet.

Reimplemented from LinearSystem.

Definition at line 32 of file DumpObjectsLinearSystem.h.

{ return true; }

copyAdditionalStateBackwards()

void LinearSystem::copyAdditionalStateBackwards ( Moose::SolutionIterationType  , bool    )

overrideprotectedvirtualinherited

Copy system-owned state not represented by solution vectors.

The first argument selects the solution history being advanced. The second indicates that state 0 must not overwrite state 1 while deeper states still shift; additional state must honor this to remain aligned with the solution history. Default implementation does nothing.

Reimplemented from SystemBase.

Definition at line 188 of file LinearSystem.C.

{
  if (iteration_type == Moose::SolutionIterationType::Time)
    LinearFVGradientManager::copyPreviousGradientStates(iteration_type, skip_current_to_old);
}

copyOldSolutions()

void SystemBase::copyOldSolutions ( )

inherited

Copy the solution back in time (older -> old, etc).

Shifts the solutions backwards in time.

Definition at line 1320 of file SystemBase.C.

{
  copyPreviousSolutions(Moose::SolutionIterationType::Time);
}

copyPreviousGradientStates()

void LinearFVGradientManager::copyPreviousGradientStates ( Moose::SolutionIterationType  iteration_type, bool  skip_current_to_old  )

protectedinherited

Copy published gradient values into requested older states.

Non-time histories are ignored because only time gradient states are currently stored.

Parameters

iteration_type	Type of solution history being advanced.
skip_current_to_old	Whether state zero should not overwrite state one while deeper states still shift, matching the owning system's solution-state advancement.

Definition at line 364 of file LinearFVGradientManager.C.

{
  mooseAssert(iteration_type != Moose::SolutionIterationType::Nonlinear,
              "Linear FV gradient storage does not support nonlinear iteration states.");
  if (iteration_type != Moose::SolutionIterationType::Time)
    return;
 
  mooseAssert(!Threads::in_threads, "Linear FV gradient state copying is not thread-safe.");
  initializeGradientStatesForTimeAdvance();
 
  for (auto & [_, container] : _linear_fv_gradient_container_by_method)
  {
    const auto number_of_states = container.state_values.size();
    if (number_of_states <= 1)
      continue;
 
    mooseAssert(container.has_computed_gradient,
                "Current gradient state must be initialized before advancing time states.");
    // Mirror solution-state advancement: some restore workflows preserve state 1 by skipping the
    // current-to-old copy while still shifting every deeper state.
    const std::size_t stop = skip_current_to_old ? 1 : 0;
    for (std::size_t state = number_of_states - 1; state > stop; --state)
      copyGradient(container.state_values[state - 1], container.state_values[state]);
  }
}

Referenced by AuxiliarySystem::copyAdditionalStateBackwards(), and LinearSystem::copyAdditionalStateBackwards().

copyPreviousSolutions()

void SystemBase::copyPreviousSolutions ( const Moose::SolutionIterationType  iteration_type )

inherited

Copy a specific type of solution back in time (current -> old -> older, etc).

Definition at line 1271 of file SystemBase.C.

{
  // Normally copy through old (index 1). For Time, optionally stop at older
  // and leave old unchanged.
  const bool skip_old =
      iteration_type == Moose::SolutionIterationType::Time && _skip_next_solution_to_old_copy;
 
  const auto num_states = getNumSolutionStates(iteration_type);
  if (num_states > 1)
  {
    const std::size_t stop = skip_old ? 1 : 0;
    for (std::size_t i = num_states - 1; i > stop; --i)
      solutionState(i, iteration_type) = solutionState(i - 1, iteration_type);
  }
 
  // Custom logic for changing state based on iteration type
  switch (iteration_type)
  {
    case Moose::SolutionIterationType::Time:
      _skip_next_solution_to_old_copy = false;
      if (solutionUDotOld())
        *solutionUDotOld() = *solutionUDot();
      if (solutionUDotDotOld())
        *solutionUDotDotOld() = *solutionUDotDot();
      break;
    case Moose::SolutionIterationType::Nonlinear:
      if (solutionPreviousNewton())
        *solutionPreviousNewton() = *currentSolution();
      break;
    case Moose::SolutionIterationType::MultiAppFixedPoint:
    case Moose::SolutionIterationType::MultiSystemFixedPoint:
    case Moose::SolutionIterationType::Count:
      break;
  }
}

Referenced by SystemBase::advanceStateHistory(), SystemBase::copyOldSolutions(), and SystemBase::copySolutionsBackwards().

copySolutionsBackwards()

void SystemBase::copySolutionsBackwards ( )

virtualinherited

Copy current solution into old and older.

Definition at line 1255 of file SystemBase.C.

{
  system().update();
  copyPreviousSolutions(Moose::SolutionIterationType::Time);
  copyPreviousSolutions(Moose::SolutionIterationType::Nonlinear);
}

copyStateHistoryBackwards()

void SystemBase::copyStateHistoryBackwards ( )

inherited

Copy solution vectors and additional system-owned state into older states.

Definition at line 1263 of file SystemBase.C.

{
  system().update();
  advanceStateHistory(Moose::SolutionIterationType::Time);
  advanceStateHistory(Moose::SolutionIterationType::Nonlinear);
}

copyTimeIntegrators()

void SystemBase::copyTimeIntegrators ( const SystemBase &  other_sys )

inherited

Copy time integrators from another system.

Definition at line 1688 of file SystemBase.C.

{
  _time_integrators = other_sys._time_integrators;
}

copyVars()

void SystemBase::copyVars ( libMesh::ExodusII_IO &  io )

inherited

Definition at line 1180 of file SystemBase.C.

{
  int n_steps = io.get_num_time_steps();
 
  bool did_copy = false;
  for (const auto & vci : _var_to_copy)
  {
    int timestep = -1;
 
    if (vci._timestep == "LATEST")
      // Use the last time step in the file from which to retrieve the solution
      timestep = n_steps;
    else
    {
      timestep = MooseUtils::convert<int>(vci._timestep);
      if (timestep > n_steps)
        mooseError("Invalid value passed as \"initial_from_file_timestep\". Expected \"LATEST\" or "
                   "a valid integer between 1 and ",
                   n_steps,
                   " inclusive, received ",
                   vci._timestep);
    }
 
    did_copy = true;
 
    if (hasVariable(vci._dest_name))
    {
      const auto & var = getVariable(0, vci._dest_name);
      if (var.isArray())
      {
        const auto & array_var = getFieldVariable<RealEigenVector>(0, vci._dest_name);
        for (MooseIndex(var.count()) i = 0; i < var.count(); ++i)
        {
          const auto & exodus_var = var.arrayVariableComponent(i);
          const auto & system_var = array_var.componentName(i);
          if (var.isNodal())
            io.copy_nodal_solution(system(), exodus_var, system_var, timestep);
          else
            io.copy_elemental_solution(system(), exodus_var, system_var, timestep);
        }
      }
      else
      {
        if (var.isNodal())
          io.copy_nodal_solution(system(), vci._dest_name, vci._source_name, timestep);
        else
          io.copy_elemental_solution(system(), vci._dest_name, vci._source_name, timestep);
      }
    }
    else if (hasScalarVariable(vci._dest_name))
      io.copy_scalar_solution(system(), {vci._dest_name}, {vci._source_name}, timestep);
    else
      mooseError("Unrecognized variable ", vci._dest_name, " in variables to copy.");
  }
 
  if (did_copy)
    solution().close();
}

currentSolution()

const NumericVector< Number > *const & SolverSystem::currentSolution ( ) const

inlinefinaloverridevirtualinherited

The solution vector that is currently being operated on.

This is typically a ghosted vector that comes in from the Nonlinear solver.

Implements SystemBase.

Definition at line 129 of file SolverSystem.h.

{
  return _current_solution;
}

Referenced by FEProblemBase::computeDamping(), FEProblemBase::computeLinearSystemSys(), FEProblemBase::computeResidualL2Norm(), FEProblemBase::computeResidualL2Norm(), and AB2PredictorCorrector::step().

customSetup()

void SystemBase::customSetup ( const ExecFlagType &  exec_type )

virtualinherited

Reimplemented in AuxiliarySystem, and NonlinearSystemBase.

Definition at line 1606 of file SystemBase.C.

{
  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
    _vars[tid].customSetup(exec_type);
}

Referenced by SystemBase::customSetup(), AuxiliarySystem::customSetup(), and NonlinearSystemBase::customSetup().

deactivateAllMatrixTags()

void SystemBase::deactivateAllMatrixTags ( )

virtualinherited

Make matrices inactive.

Definition at line 1116 of file SystemBase.C.

{
  auto num_matrix_tags = _subproblem.numMatrixTags();
 
  _matrix_tag_active_flags.resize(num_matrix_tags);
 
  for (decltype(num_matrix_tags) tag = 0; tag < num_matrix_tags; tag++)
    _matrix_tag_active_flags[tag] = false;
  _active_tagged_matrices.clear();
}

Referenced by NonlinearSystemBase::computeResidualTags(), and NonlinearSystemBase::setInitialSolution().

defaultMatrixTags()

virtual std::set< TagID > SystemBase::defaultMatrixTags ( ) const

inlinevirtualinherited

Get the default matrix tags associted with this system.

Reimplemented in DisplacedSystem, and NonlinearEigenSystem.

Definition at line 347 of file SystemBase.h.

{ return {systemMatrixTag()}; }

Referenced by DisplacedSystem::defaultMatrixTags(), NonlinearEigenSystem::defaultMatrixTags(), and SystemBase::disassociateDefaultMatrixTags().

defaultVectorTags()

virtual std::set< TagID > SystemBase::defaultVectorTags ( ) const

inlinevirtualinherited

Get the default vector tags associated with this system.

Reimplemented in DisplacedSystem, and NonlinearEigenSystem.

Definition at line 340 of file SystemBase.h.

  {
    return {timeVectorTag(), nonTimeVectorTag(), residualVectorTag()};
  }

Referenced by DisplacedSystem::defaultVectorTags(), NonlinearEigenSystem::defaultVectorTags(), and SystemBase::disassociateDefaultVectorTags().

disassociateDefaultMatrixTags()

void SystemBase::disassociateDefaultMatrixTags ( )

virtualinherited

Disassociate the matrices associated with the default matrix tags of this system.

Reimplemented in DisplacedSystem.

Definition at line 1107 of file SystemBase.C.

{
  const auto tags = defaultMatrixTags();
  for (const auto tag : tags)
    if (_subproblem.matrixTagExists(tag))
      disassociateMatrixFromTag(tag);
}

Referenced by DisplacedSystem::disassociateDefaultMatrixTags().

disassociateDefaultVectorTags()

void SystemBase::disassociateDefaultVectorTags ( )

virtualinherited

Disassociate the vectors associated with the default vector tags of this system.

Reimplemented in DisplacedSystem.

Definition at line 1012 of file SystemBase.C.

{
  const auto tags = defaultVectorTags();
  for (const auto tag : tags)
    if (_subproblem.vectorTagExists(tag))
      disassociateVectorFromTag(tag);
}

Referenced by DisplacedSystem::disassociateDefaultVectorTags().

disassociateMatrixFromTag() [1/2]

void SystemBase::disassociateMatrixFromTag ( libMesh::SparseMatrix< Number > &  matrix, TagID  tag  )

virtualinherited

Disassociate a matrix from a tag.

Reimplemented in DisplacedSystem.

Definition at line 1085 of file SystemBase.C.

{
  if (!_subproblem.matrixTagExists(tag))
    mooseError("Cannot disassociate matrix from tag ", tag, " because that tag does not exist");
  if (hasMatrix(tag) && &getMatrix(tag) != &matrix)
    mooseError("You can not disassociate a matrix from a tag which it was not associated to");
 
  disassociateMatrixFromTag(tag);
}

Referenced by NonlinearSystemBase::computeJacobian(), FEProblemBase::computeJacobianInternal(), FEProblemBase::computeJacobianTag(), FEProblemBase::computeLinearSystemSys(), FEProblemBase::computeResidualAndJacobian(), SystemBase::disassociateDefaultMatrixTags(), SystemBase::disassociateMatrixFromTag(), DisplacedSystem::disassociateMatrixFromTag(), and DisplacedSystem::disassociateMatrixFromTag().

disassociateMatrixFromTag() [2/2]

void SystemBase::disassociateMatrixFromTag ( TagID  tag )

virtualinherited

Disassociate any matrix that is associated with a given tag.

Reimplemented in DisplacedSystem.

Definition at line 1096 of file SystemBase.C.

{
  if (!_subproblem.matrixTagExists(tag))
    mooseError("Cannot disassociate matrix from tag ", tag, " because that tag does not exist");
 
  if (_tagged_matrices.size() < tag + 1)
    _tagged_matrices.resize(tag + 1);
  _tagged_matrices[tag] = nullptr;
}

disassociateVectorFromTag() [1/2]

void SystemBase::disassociateVectorFromTag ( NumericVector< Number > &  vec, TagID  tag  )

virtualinherited

Disassociate a given vector from a given tag.

Reimplemented in DisplacedSystem.

Definition at line 990 of file SystemBase.C.

{
  if (!_subproblem.vectorTagExists(tag))
    mooseError("Cannot disassociate vector from tag ", tag, " because that tag does not exist");
  if (hasVector(tag) && &getVector(tag) != &vec)
    mooseError("You can not disassociate a vector from a tag which it was not associated to");
 
  disassociateVectorFromTag(tag);
}

Referenced by FEProblemBase::computeLinearSystemSys(), NonlinearSystemBase::computeNodalBCsResidual(), NonlinearSystemBase::computeNodalBCsResidual(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualInternal(), FEProblemBase::computeResidualTag(), NonlinearSystemBase::computeResidualTag(), FEProblemBase::computeResidualType(), SystemBase::disassociateDefaultVectorTags(), SystemBase::disassociateVectorFromTag(), DisplacedSystem::disassociateVectorFromTag(), DisplacedSystem::disassociateVectorFromTag(), and CentralDifference::initialSetup().

disassociateVectorFromTag() [2/2]

void SystemBase::disassociateVectorFromTag ( TagID  tag )

virtualinherited

Disassociate any vector that is associated with a given tag.

Reimplemented in DisplacedSystem.

Definition at line 1001 of file SystemBase.C.

{
  if (!_subproblem.vectorTagExists(tag))
    mooseError("Cannot disassociate vector from tag ", tag, " because that tag does not exist");
 
  if (_tagged_vectors.size() < tag + 1)
    _tagged_vectors.resize(tag + 1);
  _tagged_vectors[tag] = nullptr;
}

dofMap() [1/2]

DofMap & SystemBase::dofMap ( )

virtualinherited

Gets writeable reference to the dof map.

Definition at line 1160 of file SystemBase.C.

{
  return system().get_dof_map();
}

Referenced by NonlinearSystemBase::assembleScalingVector(), MooseApp::attachRelationshipManagers(), SystemBase::augmentSendList(), NonlinearSystemBase::augmentSparsity(), NonlinearSystemBase::computeScaling(), FieldSplitPreconditioner::dofMap(), NEML2FEInterpolation::execute(), NonlinearSystemBase::findImplicitGeometricCouplingEntries(), Adaptivity::init(), NonlinearEigenSystem::initializeCondensedMatrices(), ActivateElementsUserObjectBase::initSolutions(), PNGOutput::makeMeshFunc(), GhostingUserObject::meshChanged(), Exodus::outputScalarVariables(), Nemesis::outputScalarVariables(), TableOutput::outputScalarVariables(), and ElementSubdomainModifierBase::setOldAndOlderSolutions().

dofMap() [2/2]

const DofMap & SystemBase::dofMap ( ) const

virtualinherited

Gets const reference to the dof map.

Definition at line 1166 of file SystemBase.C.

{
  return system().get_dof_map();
}

duDotDotDu() [1/2]

virtual Number & SystemBase::duDotDotDu ( )

inlinevirtualinherited

Reimplemented in DisplacedSystem.

Definition at line 285 of file SystemBase.h.

{ return _du_dotdot_du; }

Referenced by DisplacedSystem::duDotDotDu(), DisplacedSystem::duDotDotDu(), and MooseVariableScalar::reinit().

duDotDotDu() [2/2]

virtual const Number & SystemBase::duDotDotDu ( ) const

inlinevirtualinherited

Reimplemented in DisplacedSystem.

Definition at line 287 of file SystemBase.h.

{ return _du_dotdot_du; }

duDotDu()

const Number & SystemBase::duDotDu ( unsigned int  var_num = 0 ) const

virtualinherited

Reimplemented in DisplacedSystem.

Definition at line 1722 of file SystemBase.C.

{
  return _du_dot_du[var_num];
}

Referenced by DisplacedSystem::duDotDu(), MooseVariableScalar::reinit(), Moose::Kokkos::VariableGradientTempl< is_ad >::VariableGradientTempl(), and Moose::Kokkos::VariableValueTempl< is_ad >::VariableValueTempl().

duDotDus()

virtual std::vector< Number > & SystemBase::duDotDus ( )

inlinevirtualinherited

Reimplemented in DisplacedSystem.

Definition at line 284 of file SystemBase.h.

{ return _du_dot_du; }

Referenced by DisplacedSystem::duDotDus().

feProblem() [1/2]

FEProblemBase & SystemBase::feProblem ( )

inlineinherited

Definition at line 104 of file SystemBase.h.

{ return _fe_problem; }

Referenced by LinearFVGradientManager::checkRestartedGradientHistory(), FVGradientMethod::computeGradient(), FVGreenGaussGradient::computeGradientWithoutLimiter(), DMMooseGetEmbedding_Private(), DMSetUp_Moose_Pre(), and LinearFVGradientManager::resolveFVGradientMethod().

feProblem() [2/2]

const FEProblemBase & SystemBase::feProblem ( ) const

inlineinherited

Definition at line 105 of file SystemBase.h.

{ return _fe_problem; }

finalizeLinearFVGradientContainer()

void LinearFVGradientManager::finalizeLinearFVGradientContainer ( LinearFVGradientContainer &  container )

protectedinherited

Replace the current gradient storage with the freshly computed new gradients.

Parameters

container

Method container whose gradient values should be finalized.

Definition at line 305 of file LinearFVGradientManager.C.

{
  mooseAssert(!container.state_values.empty(),
              "Gradient state storage must contain a current state.");
  mooseAssert(container.next_values.size() == container.current_values.size(),
              "Next and current gradient containers must have the same size.");
  container.current_values.swap(container.next_values);
  setCurrentGradientState(container);
 
  if (!container.has_initialized_history)
  {
    for (const auto state : make_range(std::size_t(1), container.state_values.size()))
      copyGradient(container.state_values[0], container.state_values[state]);
    container.has_initialized_history = true;
  }
 
  container.has_computed_gradient = true;
}

Referenced by LinearFVGradientManager::computeGradients(), LinearFVGradientManager::initializeGradientStatesForTimeAdvance(), and LinearFVGradientManager::updateFVGradient().

flushTaggedMatrices()

void SystemBase::flushTaggedMatrices ( const std::set< TagID > &  tags )

inherited

flushes all matrices associated to tags.

Flush assembles the matrix but doesn't shrink memory allocation

Definition at line 1065 of file SystemBase.C.

{
  for (auto tag : tags)
    if (hasMatrix(tag))
      getMatrix(tag).flush();
}

getActualFieldVariable() [1/2]

template<typename T >

template MooseVariableField< RealEigenVector > & SystemBase::getActualFieldVariable< RealEigenVector > ( THREAD_ID  tid, const std::string &  var_name  )

inherited

Returns a field variable pointer - this includes finite volume variables.

Definition at line 117 of file SystemBase.C.

{
  return *_vars[tid].getActualFieldVariable<T>(var_name);
}

Referenced by BoundsBase::BoundsBase(), Assembly::copyFaceShapes(), Assembly::copyNeighborShapes(), and Assembly::copyShapes().

getActualFieldVariable() [2/2]

template<typename T >

template MooseVariableField< RealEigenVector > & SystemBase::getActualFieldVariable< RealEigenVector > ( THREAD_ID  tid, unsigned int  var_number  )

inherited

Returns a field variable pointer - this includes finite volume variables.

Definition at line 138 of file SystemBase.C.

{
  return *_vars[tid].getActualFieldVariable<T>(var_number);
}

getFieldVariable() [1/2]

template<typename T >

template MooseVariableFE< RealEigenVector > & SystemBase::getFieldVariable< RealEigenVector > ( THREAD_ID  tid, const std::string &  var_name  )

inherited

Gets a reference to a variable of with specified name.

This excludes and cannot return finite volume variables.

Parameters

tid	Thread id
var_name	variable name

Returns

reference the variable (class)

Definition at line 110 of file SystemBase.C.

{
  return *_vars[tid].getFieldVariable<T>(var_name);
}

Referenced by Marker::getMarkerValue().

getFieldVariable() [2/2]

template<typename T >

template MooseVariableFE< RealEigenVector > & SystemBase::getFieldVariable< RealEigenVector > ( THREAD_ID  tid, unsigned int  var_number  )

inherited

Gets a reference to a variable with specified number.

This excludes and cannot return finite volume variables.

Parameters

tid	Thread id
var_number	libMesh variable number

Returns

reference the variable (class)

Definition at line 131 of file SystemBase.C.

{
  return *_vars[tid].getFieldVariable<T>(var_number);
}

getFVVariable()

template<typename T >

template MooseVariableFV< Real > & SystemBase::getFVVariable< Real > ( THREAD_ID  tid, const std::string &  var_name  )

inherited

Return a finite volume variable.

Definition at line 124 of file SystemBase.C.

{
  return *_vars[tid].getFVVariable<T>(var_name);
}

getMatrix() [1/2]

SparseMatrix< Number > & SystemBase::getMatrix ( TagID  tag )

virtualinherited

Get a raw SparseMatrix.

Reimplemented in DisplacedSystem.

Definition at line 1021 of file SystemBase.C.

{
  if (!hasMatrix(tag))
  {
    if (!_subproblem.matrixTagExists(tag))
      mooseError("Cannot retrieve matrix with tag ", tag, " because that tag does not exist");
    else
      mooseError("Cannot retrieve matrix with tag ",
                 tag,
                 " in system '",
                 name(),
                 "'\nbecause a matrix has not been associated with that tag.");
  }
 
  return *_tagged_matrices[tag];
}

Referenced by SystemBase::activateAllMatrixTags(), Assembly::addCachedJacobian(), NonlinearSystemBase::addImplicitGeometricCouplingEntries(), Assembly::addJacobianCoupledVarPair(), Assembly::addJacobianLowerD(), Assembly::addJacobianNeighbor(), Assembly::addJacobianNeighborLowerD(), Assembly::addJacobianNonlocal(), SystemBase::addMatrix(), SystemBase::closeTaggedMatrices(), NonlinearSystemBase::computeJacobianInternal(), FEProblemBase::computeJacobianTags(), LinearSystem::computeLinearSystemInternal(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeResidualAndJacobian(), NonlinearSystemBase::computeResidualAndJacobianInternal(), NonlinearSystemBase::constraintJacobians(), SystemBase::disassociateMatrixFromTag(), SystemBase::flushTaggedMatrices(), DisplacedSystem::getMatrix(), DisplacedSystem::getMatrix(), LinearSystemContributionObject::linkTaggedVectorsAndMatrices(), MooseVariableScalar::reinit(), Assembly::setCachedJacobian(), and Assembly::zeroCachedJacobian().

getMatrix() [2/2]

const SparseMatrix< Number > & SystemBase::getMatrix ( TagID  tag ) const

virtualinherited

Get a raw SparseMatrix.

Reimplemented in DisplacedSystem.

Definition at line 1039 of file SystemBase.C.

{
  if (!hasMatrix(tag))
  {
    if (!_subproblem.matrixTagExists(tag))
      mooseError("Cannot retrieve matrix with tag ", tag, " because that tag does not exist");
    else
      mooseError("Cannot retrieve matrix with tag ",
                 tag,
                 " in system '",
                 name(),
                 "'\nbecause a matrix has not been associated with that tag.");
  }
 
  return *_tagged_matrices[tag];
}

getMaxVariableNumber()

unsigned int SystemBase::getMaxVariableNumber ( ) const

inlineinherited

Returns the maximum number of all variables on the system.

Definition at line 897 of file SystemBase.h.

{ return _max_var_number; }

getMaxVarNDofsPerElem()

std::size_t SystemBase::getMaxVarNDofsPerElem ( ) const

inlineinherited

Gets the maximum number of dofs used by any one variable on any one element.

Returns

The max

Definition at line 613 of file SystemBase.h.

{ return _max_var_n_dofs_per_elem; }

Referenced by Moose::globalDofIndexToDerivative().

getMaxVarNDofsPerNode()

std::size_t SystemBase::getMaxVarNDofsPerNode ( ) const

inlineinherited

Gets the maximum number of dofs used by any one variable on any one node.

Returns

The max

Definition at line 620 of file SystemBase.h.

{ return _max_var_n_dofs_per_node; }

getMinQuadratureOrder()

Order SystemBase::getMinQuadratureOrder ( )

virtualinherited

Get minimal quadrature order needed for integrating variables in this system.

Returns

The minimal order of quadrature

Reimplemented in AuxiliarySystem.

Definition at line 240 of file SystemBase.C.

{
  Order order = CONSTANT;
  const std::vector<MooseVariableFieldBase *> & vars = _vars[0].fieldVariables();
  for (const auto & var : vars)
  {
    FEType fe_type = var->feType();
    if (fe_type.default_quadrature_order() > order)
      order = fe_type.default_quadrature_order();
  }
 
  return order;
}

getMooseKSPNormType()

Moose::MooseKSPNormType SolverSystem::getMooseKSPNormType ( )

inlineinherited

Get the norm in which the linear convergence is measured.

Definition at line 99 of file SolverSystem.h.

{ return _ksp_norm; }

Referenced by Moose::PetscSupport::petscSetDefaultKSPNormType().

getNumSolutionStates()

std::size_t SystemBase::getNumSolutionStates ( const Moose::SolutionIterationType  iteration_type ) const

inlineinherited

Get the number of solution states (0 = current, 1 = current + old, ...) for the given iteration type.

Definition at line 1163 of file SystemBase.h.

{
  return getSolutionStates(iteration_type).size();
}

Referenced by SystemBase::copyPreviousSolutions(), SystemBase::hasSolutionState(), SystemBase::restoreOldSolutions(), SystemBase::saveOldSolutions(), and SystemBase::solutionState().

getPCSide()

Moose::PCSideType SolverSystem::getPCSide ( )

inlineinherited

Get the current preconditioner side.

Definition at line 88 of file SolverSystem.h.

{ return _pc_side; }

Referenced by Moose::PetscSupport::petscSetDefaultPCSide().

getRightHandSideNonTimeVector()

NumericVector< Number > & LinearSystem::getRightHandSideNonTimeVector ( )

inherited

Return a numeric vector that is associated with the nontime tag.

Definition at line 311 of file LinearSystem.C.

{
  return *_rhs_non_time;
}

Referenced by LinearSystem::LinearSystem().

getRightHandSideTimeVector()

NumericVector< Number > & LinearSystem::getRightHandSideTimeVector ( )

inherited

Return a numeric vector that is associated with the time tag.

Definition at line 305 of file LinearSystem.C.

{
  return *_rhs_time;
}

getRightHandSideVector() [1/2]

NumericVector< Number > & LinearSystem::getRightHandSideVector ( )

inlineinherited

Fetching the right hand side vector from the libmesh system.

Definition at line 156 of file LinearSystem.h.

{ return *_linear_implicit_system.rhs; }

Referenced by FEProblemBase::computeLinearSystemSys().

getRightHandSideVector() [2/2]

const NumericVector< Number > & LinearSystem::getRightHandSideVector ( ) const

inlineinherited

Definition at line 157 of file LinearSystem.h.

  {
    return *_linear_implicit_system.rhs;
  }

getScalarVariable() [1/2]

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

virtualinherited

Gets a reference to a scalar variable with specified number.

Parameters

tid	Thread id
var_name	A string which is the name of the variable to get.

Returns

reference the variable (class)

Definition at line 144 of file SystemBase.C.

{
  MooseVariableScalar * var = dynamic_cast<MooseVariableScalar *>(_vars[tid].getVariable(var_name));
  if (!var)
    mooseError("Scalar variable '" + var_name + "' does not exist in this system");
  return *var;
}

Referenced by MortarScalarBase::computeOffDiagJacobianScalar(), ArrayIntegratedBC::computeOffDiagJacobianScalar(), IntegratedBC::computeOffDiagJacobianScalar(), VectorIntegratedBC::computeOffDiagJacobianScalar(), ArrayKernel::computeOffDiagJacobianScalar(), Kernel::computeOffDiagJacobianScalar(), ODEKernel::computeOffDiagJacobianScalar(), ScalarLagrangeMultiplier::computeOffDiagJacobianScalar(), VectorKernel::computeOffDiagJacobianScalar(), KernelScalarBase::computeOffDiagJacobianScalarLocal(), MortarScalarBase::computeScalarOffDiagJacobianScalar(), KernelScalarBase::computeScalarOffDiagJacobianScalar(), DMMooseSetVariables(), and NonlinearSystemBase::setupScalingData().

getScalarVariable() [2/2]

MooseVariableScalar & SystemBase::getScalarVariable ( THREAD_ID  tid, unsigned int  var_number  ) const

virtualinherited

Gets a reference to a variable with specified number.

Parameters

tid	Thread id
var_number	libMesh variable number

Returns

reference the variable (class)

Definition at line 153 of file SystemBase.C.

{
  MooseVariableScalar * var =
      dynamic_cast<MooseVariableScalar *>(_vars[tid].getVariable(var_number));
  if (!var)
    mooseError("variable #" + Moose::stringify(var_number) + " does not exist in this system");
  return *var;
}

getScalarVariables()

const std::vector< MooseVariableScalar * > & SystemBase::getScalarVariables ( THREAD_ID  tid )

inlineinherited

Definition at line 786 of file SystemBase.h.

  {
    return _vars[tid].scalars();
  }

Referenced by Assembly::addResidualScalar(), ODEKernel::computeJacobian(), ComputeFullJacobianThread::computeOnBoundary(), ComputeFullJacobianThread::computeOnElement(), AuxiliarySystem::computeScalarVars(), SystemBase::initSolutionState(), NonlinearThread::onElement(), Assembly::prepareOffDiagScalar(), and Assembly::prepareScalar().

getSolutionStates() [1/2]

std::vector< NumericVector< Number > * > & SystemBase::getSolutionStates ( const Moose::SolutionIterationType  iteration_type )

inlineprivateinherited

Get all of the solution states (current, old, ...) for the given iteration type.

Definition at line 1128 of file SystemBase.h.

  {
    return const_cast<std::vector<NumericVector<Number> *> &>(
        cast_ptr<const SystemBase *>(this)->getSolutionStates(iteration_type));
  }

getSolutionStates() [2/2]

const std::vector< NumericVector< Number > * > & SystemBase::getSolutionStates ( const Moose::SolutionIterationType  iteration_type ) const

inlineinherited

Get all of the solution states (current, old, ...) for the given iteration type.

Definition at line 1153 of file SystemBase.h.

{
  const auto iteration_type_index = static_cast<std::size_t>(iteration_type);
  mooseAssert(iteration_type_index < static_cast<std::size_t>(Moose::SolutionIterationType::Count),
              "Invalid solution iteration type");
  mooseAssert(iteration_type_index < _solution_states.size(), "_solution_states sized incorrectly");
  return _solution_states[iteration_type_index];
}

Referenced by SystemBase::getNumSolutionStates(), SystemBase::needSolutionState(), SystemBase::solutionState(), SystemBase::solutionState(), and SystemBase::solutionStateParallelType().

getStandardFieldVariableNames()

void SystemBase::getStandardFieldVariableNames ( std::vector< VariableName > &  std_field_variables ) const

inherited

getSubdomainsForVar() [1/2]

const std::set< SubdomainID > & SystemBase::getSubdomainsForVar ( const std::string &  var_name ) const

inherited

Get the block where a variable of this system is defined.

Parameters

var_name

The name of the variable

Returns

the set of subdomain ids where the variable is active (defined)

Definition at line 1728 of file SystemBase.C.

{
  return getSubdomainsForVar(getVariable(0, var_name).number());
}

getSubdomainsForVar() [2/2]

const std::set< SubdomainID > & SystemBase::getSubdomainsForVar ( unsigned int  var_number ) const

inlineinherited

Definition at line 791 of file SystemBase.h.

  {
    return _var_map.at(var_number);
  }

Referenced by NonlinearSystemBase::checkKernelCoverage(), and SystemBase::getSubdomainsForVar().

getSystemMatrix() [1/2]

SparseMatrix< Number > & LinearSystem::getSystemMatrix ( )

inlineinherited

Fetching the system matrix from the libmesh system.

Definition at line 163 of file LinearSystem.h.

{ return *_linear_implicit_system.matrix; }

Referenced by FEProblemBase::computeLinearSystemSys().

getSystemMatrix() [2/2]

const SparseMatrix< Number > & LinearSystem::getSystemMatrix ( ) const

inlineinherited

Definition at line 164 of file LinearSystem.h.

{ return *_linear_implicit_system.matrix; }

getTimeIntegrator()

const TimeIntegrator & SystemBase::getTimeIntegrator ( const unsigned int  var_num ) const

inherited

Retrieve the time integrator that integrates the given variable's equation.

Definition at line 1704 of file SystemBase.C.

{
  const auto * const ti = queryTimeIntegrator(var_num);
 
  if (ti)
    return *ti;
  else
    mooseError("No time integrator found that integrates variable number ",
               std::to_string(var_num));
}

Referenced by AB2PredictorCorrector::estimateTimeError().

getTimeIntegrators()

const std::vector< std::shared_ptr< TimeIntegrator > > & SystemBase::getTimeIntegrators ( )

inherited

Returns

All the time integrators owned by this system

Definition at line 1716 of file SystemBase.C.

{
  return _time_integrators;
}

getVariable() [1/2]

MooseVariableFieldBase & SystemBase::getVariable ( THREAD_ID  tid, const std::string &  var_name  ) const

inherited

Gets a reference to a variable of with specified name.

Parameters

tid	Thread id
var_name	variable name

Returns

reference the variable (class)

Definition at line 89 of file SystemBase.C.

{
  MooseVariableFieldBase * var =
      dynamic_cast<MooseVariableFieldBase *>(_vars[tid].getVariable(var_name));
  if (!var)
    mooseError("Variable '", var_name, "' does not exist in this system");
  return *var;
}

Referenced by AdaptivityAction::act(), Assembly::addJacobianBlockNonlocal(), FEProblemBase::addJacobianBlockTags(), LinearFVGradientManager::checkRestartedGradientHistory(), NonlocalIntegratedBC::computeNonlocalOffDiagJacobian(), NonlocalKernel::computeNonlocalOffDiagJacobian(), Assembly::copyFaceShapes(), Assembly::copyNeighborShapes(), Assembly::copyShapes(), SystemBase::copyVars(), DMMooseSetVariables(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), NodeElemConstraint::getConnectedDofIndices(), NodeFaceConstraint::getConnectedDofIndices(), SystemBase::getSubdomainsForVar(), ResidualObject::getVariable(), SubProblem::getVariableHelper(), NodalNormalsPreprocessor::initialize(), LinearSystem::initialSetup(), ExplicitTimeIntegrator::initialSetup(), Assembly::initNonlocalCoupling(), PNGOutput::makeMeshFunc(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), UpdateErrorVectorsThread::onElement(), FEProblemBase::prepare(), Assembly::prepareBlock(), Assembly::prepareBlockNonlocal(), NonlinearSystemBase::setupScalingData(), LinearFVGradientReader::stateComponents(), and VariableCondensationPreconditioner::VariableCondensationPreconditioner().

getVariable() [2/2]

MooseVariableFieldBase & SystemBase::getVariable ( THREAD_ID  tid, unsigned int  var_number  ) const

inherited

Gets a reference to a variable with specified number.

Parameters

tid	Thread id
var_number	libMesh variable number

Returns

reference the variable (class)

Definition at line 99 of file SystemBase.C.

{
  if (var_number < _numbered_vars[tid].size())
    if (_numbered_vars[tid][var_number])
      return *_numbered_vars[tid][var_number];
 
  mooseError("Variable #", Moose::stringify(var_number), " does not exist in this system");
}

getVariableBlocks()

const std::set< SubdomainID > * SystemBase::getVariableBlocks ( unsigned int  var_number )

virtualinherited

Get the block where a variable of this system is defined.

Parameters

var_number

The number of the variable

Returns

the set of subdomain ids where the variable is active (defined)

Definition at line 163 of file SystemBase.C.

{
  mooseAssert(_var_map.find(var_number) != _var_map.end(), "Variable does not exist.");
  if (_var_map[var_number].empty())
    return nullptr;
  else
    return &_var_map[var_number];
}

Referenced by PhysicsBasedPreconditioner::addSystem().

getVariableGlobalDoFs()

const std::vector< dof_id_type > & SystemBase::getVariableGlobalDoFs ( )

inlineinherited

Get the global dof indices of a variable, this needs to be called after the indices have been set by setVariableGlobalDoFs

Definition at line 872 of file SystemBase.h.

{ return _var_all_dof_indices; }

getVariableNames()

const std::vector< VariableName > & SystemBase::getVariableNames ( ) const

inlineinherited

Definition at line 890 of file SystemBase.h.

{ return _vars[0].names(); }

Referenced by MooseEigenSystem::buildSystemDoFIndices(), NonlinearSystemBase::checkKernelCoverage(), MFEMProblem::getAuxVariableNames(), SystemBase::hasVariable(), SystemBase::isArrayVariable(), and SingleMatrixPreconditioner::SingleMatrixPreconditioner().

getVariables()

const std::vector< MooseVariableFieldBase * > & SystemBase::getVariables ( THREAD_ID  tid )

inlineinherited

Definition at line 779 of file SystemBase.h.

  {
    return _vars[tid].fieldVariables();
  }

Referenced by Assembly::addResidual(), Assembly::addResidualLower(), Assembly::addResidualNeighbor(), Assembly::cacheResidual(), Assembly::cacheResidualLower(), Assembly::cacheResidualNeighbor(), ComputeFullJacobianThread::computeOnBoundary(), ComputeFullJacobianThread::computeOnElement(), Assembly::initNonlocalCoupling(), SystemBase::initSolutionState(), ComputeLinearFVGreenGaussGradientVolumeThread::operator()(), ComputeLinearFVLimitedGradientThread::operator()(), ComputeLinearFVGreenGaussGradientFaceThread::operator()(), Assembly::prepareLowerD(), Assembly::prepareNeighbor(), Assembly::prepareOffDiagScalar(), Assembly::prepareResidual(), Assembly::setResidual(), and Assembly::setResidualNeighbor().

getVector() [1/4]

NumericVector< Number > & SystemBase::getVector ( const std::string &  name )

virtualinherited

Get a raw NumericVector by name.

Get a raw NumericVector with the given name.

Reimplemented in DisplacedSystem.

Definition at line 930 of file SystemBase.C.

{
  return system().get_vector(name);
}

Referenced by Assembly::addCachedResiduals(), Assembly::addResidual(), Assembly::addResidualLower(), Assembly::addResidualNeighbor(), Assembly::addResidualScalar(), SystemBase::addVector(), SystemBase::addVector(), NonlinearSystemBase::assembleScalingVector(), SystemBase::closeTaggedVector(), FEProblemBase::computeBounds(), FEProblemBase::computeNearNullSpace(), FEProblemBase::computeNullSpace(), NonlinearSystemBase::computeResidualAndJacobianTags(), NonlinearSystemBase::computeResidualTags(), CentralDifference::computeTimeDerivatives(), FEProblemBase::computeTransposeNullSpace(), SystemBase::disassociateVectorFromTag(), DisplacedSystem::getVector(), DisplacedSystem::getVector(), DisplacedSystem::getVector(), DisplacedSystem::getVector(), Assembly::hasScalingVector(), LinearSystemContributionObject::linkTaggedVectorsAndMatrices(), SystemBase::needSolutionState(), ReferenceResidualConvergence::ReferenceResidualConvergence(), MooseVariableScalar::reinit(), PicardSolve::saveVariableValues(), SecantSolve::saveVariableValues(), SteffensenSolve::saveVariableValues(), NonlinearSystemBase::setPreviousNewtonSolution(), TaggingInterface::setResidual(), TaggingInterface::setResidual(), TaggingInterface::setResidual(), SystemBase::solutionPreviousNewton(), SystemBase::solutionPreviousNewton(), SystemBase::solutionState(), MultiAppDofCopyTransfer::transfer(), PicardSolve::transformVariables(), SecantSolve::transformVariables(), SteffensenSolve::transformVariables(), and SystemBase::zeroTaggedVector().

getVector() [2/4]

const NumericVector< Number > & SystemBase::getVector ( const std::string &  name ) const

virtualinherited

Reimplemented in DisplacedSystem.

Definition at line 936 of file SystemBase.C.

{
  return system().get_vector(name);
}

getVector() [3/4]

NumericVector< Number > & SystemBase::getVector ( TagID  tag )

virtualinherited

Get a raw NumericVector by tag.

Reimplemented in DisplacedSystem.

Definition at line 942 of file SystemBase.C.

{
  if (!hasVector(tag))
  {
    if (!_subproblem.vectorTagExists(tag))
      mooseError("Cannot retrieve vector with tag ", tag, " because that tag does not exist");
    else
      mooseError("Cannot retrieve vector with tag ",
                 tag,
                 " in system '",
                 name(),
                 "'\nbecause a vector has not been associated with that tag.");
  }
 
  return *_tagged_vectors[tag];
}

getVector() [4/4]

const NumericVector< Number > & SystemBase::getVector ( TagID  tag ) const

virtualinherited

Reimplemented in DisplacedSystem.

Definition at line 960 of file SystemBase.C.

{
  if (!hasVector(tag))
  {
    if (!_subproblem.vectorTagExists(tag))
      mooseError("Cannot retrieve vector with tag ", tag, " because that tag does not exist");
    else
      mooseError("Cannot retrieve vector with tag ",
                 tag,
                 " in system '",
                 name(),
                 "'\nbecause a vector has not been associated with that tag.");
  }
 
  return *_tagged_vectors[tag];
}

gradientStateVectorName()

std::string LinearFVGradientManager::gradientStateVectorName ( const FVGradientMethod &  method, unsigned int  state, unsigned int  component  )

staticprotectedinherited

Return the stable system-vector name for one old gradient component.

Definition at line 228 of file LinearFVGradientManager.C.

{
  return "linear_fv_gradient_" + method.name() + "_state_" + std::to_string(state) + "_component_" +
         std::to_string(component);
}

Referenced by LinearFVGradientManager::checkRestartedGradientHistory(), and LinearFVGradientManager::initializeLinearFVGradientHistoryStorage().

hasLinearFVGradients()

bool LinearFVGradientManager::hasLinearFVGradients ( ) const

protectedinherited

Whether any linear finite-volume gradient fields have been registered to this object.

Definition at line 165 of file LinearFVGradientManager.C.

{
  return !_linear_fv_gradient_container_by_method.empty();
}

Referenced by AuxiliarySystem::compute().

hasMatrix()

virtual bool SystemBase::hasMatrix ( TagID  tag ) const

inlinevirtualinherited

Check if the tagged matrix exists in the system.

Reimplemented in DisplacedSystem.

Definition at line 388 of file SystemBase.h.

  {
    return tag < _tagged_matrices.size() && _tagged_matrices[tag];
  }

Referenced by SystemBase::activateAllMatrixTags(), Assembly::addCachedJacobian(), NonlinearSystemBase::addImplicitGeometricCouplingEntries(), Assembly::addJacobianCoupledVarPair(), Assembly::addJacobianLowerD(), Assembly::addJacobianNeighbor(), Assembly::addJacobianNeighborLowerD(), Assembly::addJacobianNonlocal(), SystemBase::addMatrix(), Assembly::cacheJacobian(), Assembly::cacheJacobianBlock(), Assembly::cacheJacobianBlockNonzero(), Assembly::cacheJacobianCoupledVarPair(), Assembly::cacheJacobianMortar(), Assembly::cacheJacobianNeighbor(), Assembly::cacheJacobianNonlocal(), SystemBase::closeTaggedMatrices(), NonlinearSystemBase::computeJacobianInternal(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeResidualAndJacobian(), NonlinearSystemBase::computeResidualAndJacobianInternal(), NonlinearSystemBase::constraintJacobians(), SystemBase::disassociateMatrixFromTag(), NonlinearSystemBase::enforceNodalConstraintsJacobian(), SystemBase::flushTaggedMatrices(), SystemBase::getMatrix(), SystemBase::getMatrix(), DisplacedSystem::hasMatrix(), MooseVariableScalar::reinit(), SystemBase::removeMatrix(), SubProblem::selectMatrixTagsFromSystem(), Assembly::setCachedJacobian(), and Assembly::zeroCachedJacobian().

hasScalarVariable()

bool SystemBase::hasScalarVariable ( const std::string &  var_name ) const

virtualinherited

Definition at line 873 of file SystemBase.C.

{
  if (system().has_variable(var_name))
    return system().variable_type(var_name).family == SCALAR;
  else
    return false;
}

Referenced by MortarScalarBase::computeJacobian(), NonlinearSystemBase::computeNodalBCsJacobian(), ComputeFullJacobianThread::computeOnBoundary(), ComputeFullJacobianThread::computeOnElement(), SystemBase::copyVars(), ExplicitTimeIntegrator::initialSetup(), NonlinearEigenSystem::postAddResidualObject(), and NonlinearSystemBase::setupScalingData().

hasSolutionState()

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

inlinevirtualinherited

Whether or not the system has the solution state (0 = current, 1 = old, 2 = older, etc).

Reimplemented in DisplacedSystem.

Definition at line 1169 of file SystemBase.h.

{
  return getNumSolutionStates(iteration_type) > state;
}

Referenced by SolverSystem::applyFixedPointRelaxation(), PointwiseRenormalizeVector::execute(), PointwiseRenormalizeVector::finalize(), DisplacedSystem::hasSolutionState(), SystemBase::needSolutionState(), SystemBase::restoreSolutions(), ElementSubdomainModifierBase::setOldAndOlderSolutions(), SystemBase::solutionState(), SystemBase::solutionState(), and SystemBase::solutionStateParallelType().

hasVarCopy()

bool SystemBase::hasVarCopy ( ) const

inlineinherited

Whether or not there are variables to be restarted from an Exodus mesh file.

Definition at line 918 of file SystemBase.h.

{ return _var_to_copy.size() > 0; }

hasVariable()

bool SystemBase::hasVariable ( const std::string &  var_name ) const

virtualinherited

Query a system for a variable.

Parameters

var_name

name of the variable

Returns

true if the variable exists

Definition at line 848 of file SystemBase.C.

{
  auto & names = getVariableNames();
  if (system().has_variable(var_name))
    return system().variable_type(var_name).family != SCALAR;
  if (std::find(names.begin(), names.end(), var_name) != names.end())
    // array variable
    return true;
  else
    return false;
}

Referenced by ADDGKernel::ADDGKernel(), ADKernelTempl< T >::ADKernelTempl(), ArrayDGKernel::ArrayDGKernel(), ArrayKernel::ArrayKernel(), SystemBase::copyVars(), DGKernel::DGKernel(), DMMooseSetVariables(), FEProblemBase::duplicateVariableCheck(), FixedPointSolve::findTransformedSystem(), SubProblem::getVariableHelper(), SubProblem::hasAuxiliaryVariable(), SubProblem::hasLinearVariable(), ElementSubdomainModifierBase::initialSetup(), ExplicitTimeIntegrator::initialSetup(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), Kernel::Kernel(), PNGOutput::makeMeshFunc(), MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer(), NonlinearSystemBase::setupScalingData(), and Coupleable::writableCoupledValue().

hasVector() [1/2]

bool SystemBase::hasVector ( const std::string &  tag_name ) const

inherited

Check if the named vector exists in the system.

Definition at line 921 of file SystemBase.C.

{
  return system().have_vector(name);
}

Referenced by FEProblemBase::addCachedResidualDirectly(), Assembly::addCachedResiduals(), Assembly::addResidual(), Assembly::addResidualLower(), Assembly::addResidualNeighbor(), Assembly::addResidualScalar(), SystemBase::addVector(), SystemBase::addVector(), NonlinearSystemBase::assembleScalingVector(), Assembly::cacheResidual(), Assembly::cacheResidualLower(), Assembly::cacheResidualNeighbor(), SystemBase::closeTaggedVector(), FEProblemBase::computeBounds(), NonlinearSystemBase::computeResidualTags(), CentralDifference::computeTimeDerivatives(), SystemBase::disassociateVectorFromTag(), SystemBase::getVector(), SystemBase::getVector(), DisplacedSystem::hasVector(), MooseVariableScalar::reinit(), SystemBase::removeVector(), SubProblem::selectVectorTagsFromSystem(), NonlinearSystemBase::setPreviousNewtonSolution(), TaggingInterface::setResidual(), TaggingInterface::setResidual(), TaggingInterface::setResidual(), SystemBase::solutionPreviousNewton(), SystemBase::solutionPreviousNewton(), and SystemBase::zeroTaggedVector().

hasVector() [2/2]

virtual bool SystemBase::hasVector ( TagID  tag_id ) const

inlinevirtualinherited

Check if the tagged vector exists in the system.

Reimplemented in DisplacedSystem.

Definition at line 309 of file SystemBase.h.

  {
    return tag_id < _tagged_vectors.size() && _tagged_vectors[tag_id];
  }

initializeContainer()

void LinearFVGradientManager::initializeContainer ( OwnedGradientContainer &  container ) const

protectedinherited

Allocate one zeroed vector per spatial component for gradient storage.

Parameters

container

Component-vector container to rebuild.

Definition at line 171 of file LinearFVGradientManager.C.

{
  container.clear();
  const auto & current_solution = _sys.system().current_local_solution;
  mooseAssert(current_solution && current_solution->initialized(),
              "Current solution must exist before building FV gradient storage.");
  container.resize(_sys.mesh().dimension());
  for (auto & component : container)
    component = current_solution->zero_clone();
}

Referenced by LinearFVGradientManager::initializeLinearFVGradientStorage(), and AuxiliarySystem::updateFVGradient().

initializeGradientStatesForTimeAdvance()

void LinearFVGradientManager::initializeGradientStatesForTimeAdvance ( )

protectedinherited

Compute and publish uninitialized gradients before their first time-state advancement.

Definition at line 352 of file LinearFVGradientManager.C.

{
  for (auto & [method, container] : _linear_fv_gradient_container_by_method)
    if (container.state_values.size() > 1 && !container.has_computed_gradient)
      computeLinearFVGradientContainer(*method);
 
  for (auto & [_, container] : _linear_fv_gradient_container_by_method)
    if (container.state_values.size() > 1 && !container.has_computed_gradient)
      finalizeLinearFVGradientContainer(container);
}

Referenced by LinearFVGradientManager::copyPreviousGradientStates().

initializeLinearFVGradientHistoryStorage()

void LinearFVGradientManager::initializeLinearFVGradientHistoryStorage ( )

protectedinherited

Register named system vectors for requested historical gradient states.

This must run after gradient state requirements are known and before restart or recovery data is loaded, so checkpoint data can be restored into these vectors. It does not initialize the current or replacement working storage.

Definition at line 201 of file LinearFVGradientManager.C.

{
  for (auto & [method, container] : _linear_fv_gradient_container_by_method)
    for (const auto state : make_range(std::size_t(1), container.state_values.size()))
      if (container.state_values[state].empty())
      {
        GradientContainer state_values(_sys.mesh().dimension());
        for (const auto component : index_range(state_values))
          state_values[component] = &_sys.addVector(
              gradientStateVectorName(*method, state, component), true, libMesh::GHOSTED);
        container.state_values[state] = std::move(state_values);
      }
}

Referenced by AuxiliarySystem::AuxiliarySystem(), and LinearSystem::initSolutionState().

initializeLinearFVGradientStorage()

void LinearFVGradientManager::initializeLinearFVGradientStorage ( )

protectedinherited

Initialize private current and replacement gradient storage.

This must run after the current local solution has been created and initialized, and after restart or recovery data has been loaded. At that point, it also checks if the restored historical gradient storage is set up correctly.

Definition at line 325 of file LinearFVGradientManager.C.

{
  for (auto & [method, container] : _linear_fv_gradient_container_by_method)
  {
    if (container.current_values.empty())
      initializeContainer(container.current_values);
    if (container.next_values.empty())
      initializeContainer(container.next_values);
    setCurrentGradientState(container);
    checkRestartedGradientHistory(*method, container);
  }
}

Referenced by LinearFVGradientManager::computeLinearFVGradientContainer(), AuxiliarySystem::initialSetup(), LinearSystem::initialSetup(), and LinearFVGradientManager::rebuildLinearFVGradientStorage().

initializeObjects()

virtual void SystemBase::initializeObjects ( )

inlinevirtualinherited

Called only once, just before the solve begins so objects can do some precalculations.

Definition at line 174 of file SystemBase.h.

{}

initialSetup()

void LinearSystem::initialSetup ( )

overridevirtualinherited

Setup Functions.

Reimplemented from SystemBase.

Definition at line 122 of file LinearSystem.C.

{
  SystemBase::initialSetup();
  _current_solution = system().current_local_solution.get();
  LinearFVGradientManager::initializeLinearFVGradientStorage();
  // Checking if somebody accidentally assigned nonlinear variables to this system
  const auto & var_names = _vars[0].names();
  for (const auto & name : var_names)
    if (!dynamic_cast<MooseLinearVariableFVReal *>(_vars[0].getVariable(name)))
      mooseError("You are trying to add a nonlinear variable to a linear system! The variable "
                 "which is assigned to the wrong system: ",
                 name);
 
  // Calling initial setup for the linear kernels
  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
  {
    std::vector<LinearFVElementalKernel *> fv_elemental_kernels;
    _fe_problem.theWarehouse()
        .query()
        .template condition<AttribSysNum>(number())
        .template condition<AttribSystem>("LinearFVElementalKernel")
        .template condition<AttribKokkos>(false)
        .template condition<AttribThread>(tid)
        .queryInto(fv_elemental_kernels);
 
    for (auto * fv_kernel : fv_elemental_kernels)
      fv_kernel->initialSetup();
 
    std::vector<LinearFVFluxKernel *> fv_flux_kernels;
    _fe_problem.theWarehouse()
        .query()
        .template condition<AttribSysNum>(number())
        .template condition<AttribSystem>("LinearFVFluxKernel")
        .template condition<AttribKokkos>(false)
        .template condition<AttribThread>(tid)
        .queryInto(fv_flux_kernels);
 
    for (auto * fv_kernel : fv_flux_kernels)
      fv_kernel->initialSetup();
 
    std::vector<LinearFVBoundaryCondition *> fv_bcs;
    _fe_problem.theWarehouse()
        .query()
        .template condition<AttribSysNum>(number())
        .template condition<AttribSystem>("LinearFVBoundaryCondition")
        .template condition<AttribKokkos>(false)
        .template condition<AttribThread>(tid)
        .queryInto(fv_bcs);
 
    for (auto * fv_bc : fv_bcs)
      fv_bc->initialSetup();
  }
 
#ifdef MOOSE_KOKKOS_ENABLED
  initialSetupKokkosLinearFV();
#endif
}

initialSetupKokkosLinearFV()

void LinearSystem::initialSetupKokkosLinearFV ( )

protectedinherited

Perform the initial setup of the Kokkos linear finite volume kernels and boundary conditions.

Referenced by LinearSystem::initialSetup().

initSolutionState()

void LinearSystem::initSolutionState ( )

overridevirtualinherited

Initializes the solution state.

Reimplemented from SystemBase.

Definition at line 115 of file LinearSystem.C.

{
  SolverSystem::initSolutionState();
  LinearFVGradientManager::initializeLinearFVGradientHistoryStorage();
}

isArrayVariable()

bool SystemBase::isArrayVariable ( const std::string &  var_name ) const

virtualinherited

If a variable is an array variable.

Definition at line 861 of file SystemBase.C.

{
  auto & names = getVariableNames();
  if (!system().has_variable(var_name) &&
      std::find(names.begin(), names.end(), var_name) != names.end())
    // array variable
    return true;
  else
    return false;
}

isScalarVariable()

bool SystemBase::isScalarVariable ( unsigned int  var_name ) const

virtualinherited

Definition at line 882 of file SystemBase.C.

{
  return (system().variable(var_num).type().family == SCALAR);
}

Referenced by Assembly::initNonlocalCoupling().

jacobianSetup()

virtual void LinearSystem::jacobianSetup ( )

inlineoverridevirtualinherited

Reimplemented from SystemBase.

Definition at line 92 of file LinearSystem.h.

{}

linearImplicitSystem()

libMesh::LinearImplicitSystem & LinearSystem::linearImplicitSystem ( )

inlineinherited

Return a reference to the stored linear implicit system.

Definition at line 123 of file LinearSystem.h.

{ return _linear_implicit_system; }

Referenced by FEProblemBase::computeResidualL2Norm(), and Moose::PetscSupport::petscSetDefaults().

matrixFromColoring()

virtual bool SolverSystem::matrixFromColoring ( ) const

inlineprotectedvirtualinherited

Whether a system matrix is formed from coloring.

This influences things like when to compute time derivatives

Reimplemented in NonlinearSystem.

Definition at line 114 of file SolverSystem.h.

{ return false; }

Referenced by SolverSystem::compute(), and NonlinearSystemBase::destroyColoring().

matrixTagActive()

bool SystemBase::matrixTagActive ( TagID  tag ) const

virtualinherited

If or not a matrix tag is active.

Definition at line 1146 of file SystemBase.C.

{
  mooseAssert(_subproblem.matrixTagExists(tag), "Matrix tag " << tag << " does not exist");
 
  return tag < _matrix_tag_active_flags.size() && _matrix_tag_active_flags[tag];
}

mesh() [1/2]

MooseMesh & SystemBase::mesh ( )

inlineinherited

Definition at line 100 of file SystemBase.h.

{ return _mesh; }

Referenced by CreateDisplacedProblemAction::addProxyRelationshipManagers(), DMMooseGetEmbedding_Private(), DMSetUp_Moose_Pre(), LinearFVGradientManager::initializeContainer(), LinearFVGradientManager::initializeLinearFVGradientHistoryStorage(), SolutionIC::initialSetup(), ComputeNodalKernelJacobiansThread::onNode(), ComputeNodalKernelsThread::onNode(), and ComputeNodalUserObjectsThread::onNode().

mesh() [2/2]

const MooseMesh & SystemBase::mesh ( ) const

inlineinherited

Definition at line 101 of file SystemBase.h.

{ return _mesh; }

name()

const std::string & SystemBase::name ( ) const

virtualinherited

Definition at line 1359 of file SystemBase.C.

{
  return system().name();
}

Referenced by NonlinearSystemBase::addBoundaryCondition(), NonlinearSystemBase::addConstraint(), NonlinearSystemBase::addDamper(), NonlinearSystemBase::addDGKernel(), NonlinearSystemBase::addDiracKernel(), NonlinearSystemBase::addHDGKernel(), NonlinearSystemBase::addInterfaceKernel(), AuxiliarySystem::addKernel(), MooseEigenSystem::addKernel(), NonlinearSystemBase::addKernel(), SystemBase::addMatrix(), NonlinearSystemBase::addNodalKernel(), Moose::PetscSupport::addPetscOptionsFromCommandline(), AuxiliarySystem::addScalarKernel(), NonlinearSystemBase::addScalarKernel(), NonlinearSystemBase::addSplit(), SystemBase::addTimeIntegrator(), AuxiliarySystem::addVariable(), SystemBase::addVector(), DiffusionLHDGAssemblyHelper::checkCoupling(), LinearFVGradientManager::checkRestartedGradientHistory(), SystemBase::closeTaggedVector(), LinearSystem::computeLinearSystemTags(), DisplacedProblem::DisplacedProblem(), SystemBase::getMatrix(), SystemBase::getMatrix(), NonlinearSystemBase::getSplit(), SystemBase::getVector(), DisplacedSystem::getVector(), DisplacedSystem::getVector(), SystemBase::getVector(), SystemBase::getVector(), SystemBase::hasVector(), LinearSystem::initialSetup(), NonlinearEigenSystem::postAddResidualObject(), MooseStaticCondensationPreconditioner::prefix(), SystemBase::removeMatrix(), SystemBase::removeVector(), SystemBase::removeVector(), LinearFVGradientManager::resizeGradientStateStorage(), NonlinearSystemBase::setupScalingData(), SystemBase::solutionState(), LinearSystem::solve(), LinearFVGradientReader::stateComponents(), NonlinearSystemBase::subdomainSetup(), LinearTimeIntegratorInterface::timeDerivativeMatrixContribution(), LinearTimeIntegratorInterface::timeDerivativeRHSContribution(), AuxiliarySystem::updateFVGradient(), LinearFVGradientManager::updateFVGradient(), and SystemBase::zeroTaggedVector().

needSolutionState()

void SystemBase::needSolutionState ( const unsigned int  state, Moose::SolutionIterationType  iteration_type = Moose::SolutionIterationType::Time, libMesh::ParallelType  parallel_type = GHOSTED  )

virtualinherited

Registers that the solution state state is needed.

Reimplemented in DisplacedSystem.

Definition at line 1484 of file SystemBase.C.

{
  libmesh_parallel_only(this->comm());
  mooseAssert(!Threads::in_threads,
              "This routine is not thread-safe. Request the solution state before using it in "
              "a threaded region.");
 
  if (hasSolutionState(state, iteration_type))
    return;
 
  auto & solution_states = getSolutionStates(iteration_type);
  solution_states.resize(state + 1);
 
  // The 0-th (current) solution state is owned by libMesh
  if (!solution_states[0])
    solution_states[0] = &solutionInternal();
  else
    mooseAssert(solution_states[0] == &solutionInternal(), "Inconsistent current solution");
 
  // We will manually add all states past current
  for (unsigned int i = 1; i <= state; ++i)
    if (!solution_states[i])
    {
      auto tag = _subproblem.addVectorTag(oldSolutionStateVectorName(i, iteration_type),
                                          Moose::VECTOR_TAG_SOLUTION);
      solution_states[i] = &addVector(tag, true, parallel_type);
    }
    else
    {
      // If the existing parallel type is PARALLEL and GHOSTED is now requested,
      // this would require an upgrade, which is risky if anybody has already
      // stored a pointer to the existing vector, since the upgrade would create
      // a new vector and make that pointer null. If the existing parallel type
      // is GHOSTED and PARALLEL is now requested, we don't need to do anything.
      if (parallel_type == GHOSTED && solutionStateParallelType(i, iteration_type) == PARALLEL)
        mooseError("The solution state has already been declared as PARALLEL");
 
      mooseAssert(solution_states[i] == &getVector(oldSolutionStateVectorName(i, iteration_type)),
                  "Inconsistent solution state");
    }
}

Referenced by PicardSolve::allocateStorage(), SecantSolve::allocateStorage(), EigenExecutionerBase::EigenExecutionerBase(), FEProblemSolve::initialSetup(), SystemBase::initSolutionState(), DisplacedSystem::needSolutionState(), and SystemBase::solutionState().

nFieldVariables()

unsigned int SystemBase::nFieldVariables ( ) const

inherited

Get the number of field variables in this system.

Returns

the number of field variables

Definition at line 897 of file SystemBase.C.

{
  unsigned int n = 0;
  for (auto & var : _vars[0].fieldVariables())
    n += var->count();
 
  return n;
}

Referenced by SystemBase::nVariables().

nFVVariables()

unsigned int SystemBase::nFVVariables ( ) const

inherited

Get the number of finite volume variables in this system.

Returns

the number of finite volume variables

Definition at line 907 of file SystemBase.C.

{
  unsigned int n = 0;
  for (auto & var : _vars[0].fieldVariables())
    if (var->isFV())
      n += var->count();
 
  return n;
}

nLinearIterations()

unsigned int LinearSystem::nLinearIterations ( ) const

inlineinherited

Return the number of linear iterations.

Definition at line 142 of file LinearSystem.h.

{ return _n_linear_iters; }

Referenced by IterationAdaptiveDT::acceptStep().

nonTimeVectorTag()

virtual TagID SystemBase::nonTimeVectorTag ( ) const

inlinevirtualinherited

Reimplemented in DisplacedSystem, and NonlinearSystemBase.

Definition at line 330 of file SystemBase.h.

{ mooseError("Not implemented yet"); }

Referenced by SystemBase::defaultVectorTags(), and DisplacedSystem::nonTimeVectorTag().

number()

unsigned int SystemBase::number ( ) const

inherited

Gets the number of this system.

Returns

The number of this system

Definition at line 1154 of file SystemBase.C.

{
  return system().number();
}

Referenced by SetupResidualDebugAction::act(), FEProblemBase::addCachedResidualDirectly(), FEProblemBase::addJacobian(), FEProblemBase::addJacobianBlockTags(), FEProblemBase::addJacobianLowerD(), FEProblemBase::addJacobianNeighbor(), FEProblemBase::addJacobianNeighborLowerD(), FEProblemBase::addJacobianOffDiagScalar(), FEProblemBase::addJacobianScalar(), FEProblemBase::addObjectParamsHelper(), FEProblemBase::addResidual(), FEProblemBase::addResidualLower(), FEProblemBase::addResidualNeighbor(), FEProblemBase::addResidualScalar(), SystemBase::addScalingVector(), ADKernelTempl< T >::ADKernelTempl(), ElementSubdomainModifierBase::applyIC(), ArrayKernel::ArrayKernel(), NonlinearSystemBase::assembleScalingVector(), NonlinearEigenSystem::attachPreconditioner(), DiffusionLHDGAssemblyHelper::checkCoupling(), FVFluxBC::checkFaceIntegrity(), SolverSystem::compute(), ComputeResidualAndJacobianThread::compute(), MooseVariableScalar::computeAD(), FEProblemBase::computeBounds(), Assembly::computeFaceMap(), InternalSideIndicatorBase::computeIndicator(), ArrayNodalBC::computeJacobian(), NodalBC::computeJacobian(), VectorNodalBC::computeJacobian(), MortarScalarBase::computeJacobian(), ODEKernel::computeJacobian(), FVInterfaceKernel::computeJacobian(), FVFluxKernel::computeJacobian(), FVBoundaryScalarLagrangeMultiplierConstraint::computeJacobian(), FEProblemBase::computeJacobianBlock(), NonlinearSystemBase::computeJacobianInternal(), LinearSystem::computeLinearSystemInternal(), FEProblemBase::computeNearNullSpace(), NonlinearSystemBase::computeNodalBCsJacobian(), NonlinearSystemBase::computeNodalBCsResidualAndJacobian(), FEProblemBase::computeNullSpace(), ArrayNodalBC::computeOffDiagJacobian(), NodalBC::computeOffDiagJacobian(), VectorNodalBC::computeOffDiagJacobian(), NodalKernel::computeOffDiagJacobian(), ComputeFullJacobianThread::computeOnBoundary(), ComputeFullJacobianThread::computeOnElement(), ComputeFullJacobianThread::computeOnInterface(), ComputeFullJacobianThread::computeOnInternalFace(), FEProblemBase::computePostCheck(), FVInterfaceKernel::computeResidual(), FVFluxKernel::computeResidual(), FVBoundaryScalarLagrangeMultiplierConstraint::computeResidual(), IntegratedBC::computeResidualAndJacobian(), NodalBC::computeResidualAndJacobian(), Kernel::computeResidualAndJacobian(), KernelScalarBase::computeResidualAndJacobian(), NonlinearSystemBase::computeResidualAndJacobianInternal(), NonlinearSystemBase::computeResidualInternal(), FEProblemBase::computeResidualL2Norm(), NonlinearSystemBase::computeResidualTags(), NonlinearSystemBase::computeScaling(), Assembly::computeSinglePointMapAD(), FEProblemBase::computeTransposeNullSpace(), DebugResidualAux::computeValue(), NearestNodeValueAux::computeValue(), SlepcEigenSolverConfiguration::configure_solver(), NonlinearSystemBase::constraintJacobians(), LinearSystem::containsTimeKernel(), Coupleable::coupled(), FEProblemBase::currentLinearSysNum(), FEProblemBase::currentNlSysNum(), PseudoTimestep::currentResidualNorm(), ComputeResidualAndJacobianThread::determineObjectWarehouses(), ComputeResidualThread::determineObjectWarehouses(), Moose::doDerivatives(), GreaterThanLessThanPostprocessor::execute(), VariableResidual::execute(), NodalNormalsCorner::execute(), NodalNormalsEvaluator::execute(), NodalNormalsPreprocessor::execute(), ExplicitTimeIntegrator::ExplicitTimeIntegrator(), InternalSideIndicatorBase::finalize(), NumNonlinearIterations::finalize(), NonlinearEigenSystem::finalNonlinearResidual(), FunctorNodalCorrector::FunctorNodalCorrector(), BoundsBase::getDoFIndex(), NonlinearSystemBase::getFVSetupObjects(), NonlinearSystemBase::getNodeDofs(), NonlinearEigenSystem::getSNES(), SystemBase::getSubdomainsForVar(), NumLinearIterations::getValue(), NumResidualEvaluations::getValue(), Residual::getValue(), Moose::globalDofIndexToDerivative(), FVBoundaryCondition::hasFaceSide(), ExplicitTimeIntegrator::init(), AttribSysNum::initFrom(), AuxKernelBase::initialSetup(), LinearSystem::initialSetup(), NonlinearSystemBase::initialSetup(), ExplicitTimeIntegrator::initialSetup(), ActivateElementsUserObjectBase::initSolutions(), EigenExecutionerBase::inversePowerIteration(), MooseMesh::isTranslatedPeriodic(), Kernel::Kernel(), MooseMesh::minPeriodicDistance(), MooseMesh::minPeriodicVector(), Moose::SlepcSupport::mooseSlepcEigenFormFunctionA(), Moose::SlepcSupport::mooseSlepcEigenFormFunctionAB(), Moose::SlepcSupport::mooseSlepcEigenFormFunctionB(), Moose::SlepcSupport::mooseSlepcEigenFormJacobianA(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), MoveNodesByParsedExpressionModifier::MoveNodesByParsedExpressionModifier(), NonlinearEigenSystem::nLinearIterations(), NonlinearEigenSystem::nNonlinearIterations(), EigenExecutionerBase::nonlinearSolve(), ComputeDiracThread::onElement(), ComputeNodalKernelBCJacobiansThread::onNode(), ComputeNodalKernelJacobiansThread::onNode(), VariableResidualNormsDebugOutput::output(), Moose::PetscSupport::petscLinearConverged(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), PointwiseRenormalizeVector::PointwiseRenormalizeVector(), FEProblemBase::prepare(), FEProblemBase::prepareAssembly(), FEProblemBase::prepareAssemblyNeighbor(), SystemBase::prepareFace(), FEProblemBase::prepareFaceShapes(), FEProblemBase::prepareNeighborShapes(), FEProblemBase::prepareShapes(), MooseMesh::queryPeriodicDimensions(), FEProblemBase::reinitDirac(), FEProblemBase::reinitNeighborPhys(), FEProblemBase::reinitNeighborPhys(), FEProblemBase::reinitOffDiagScalars(), NonlinearSystem::residualAndJacobianTogether(), FEProblemBase::setResidual(), FEProblemBase::setResidualNeighbor(), PhysicsBasedPreconditioner::setup(), FVInterfaceKernel::setupData(), NonlinearSystemBase::shouldEvaluatePreSMOResidual(), NonlinearEigenSystem::solve(), ActuallyExplicitEuler::solve(), AStableDirk4::solve(), ExplicitRK2::solve(), ExplicitTVDRK2::solve(), ImplicitMidpoint::solve(), LStableDirk2::solve(), LStableDirk3::solve(), LStableDirk4::solve(), ExplicitSSPRungeKutta::solveStage(), UserObjectBase::systemNumber(), MultiAppDofCopyTransfer::transferDofObject(), FVQpFluxBC::uOnGhost(), FVQpFluxBC::uOnUSub(), NodalDamper::variableDefinedOnNode(), and MortarConstraintBase::zeroInactiveLMDofs().

nVariables()

unsigned int SystemBase::nVariables ( ) const

virtualinherited

Get the number of variables in this system.

Returns

the number of variables

Definition at line 888 of file SystemBase.C.

{
  unsigned int n = nFieldVariables();
  n += _vars[0].scalars().size();
 
  return n;
}

Referenced by AdaptivityAction::act(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), NonlinearSystemBase::getNodeDofs(), ExplicitTimeIntegrator::initialSetup(), MaxVarNDofsPerElem::onElement(), MaxVarNDofsPerNode::onNode(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), SingleMatrixPreconditioner::SingleMatrixPreconditioner(), and AuxiliarySystem::variableWiseRelativeSolutionDifferenceNorm().

oldSolutionStateVectorName()

TagName SystemBase::oldSolutionStateVectorName ( const unsigned int  state, Moose::SolutionIterationType  iteration_type  ) const

privateinherited

Gets the vector name used for an old (not current) solution state.

Definition at line 1400 of file SystemBase.C.

{
  mooseAssert(state != 0, "Not an old state");
  mooseAssert(static_cast<unsigned short>(iteration_type) <
                  static_cast<unsigned short>(Moose::SolutionIterationType::Count),
              "Invalid iteration_type");
 
  switch (iteration_type)
  {
    case Moose::SolutionIterationType::Time:
      if (state == 1)
        return Moose::OLD_SOLUTION_TAG;
      else if (state == 2)
        return Moose::OLDER_SOLUTION_TAG;
      break;
    case Moose::SolutionIterationType::Nonlinear:
      if (state == 1)
        return Moose::PREVIOUS_NL_SOLUTION_TAG;
      break;
    case Moose::SolutionIterationType::MultiAppFixedPoint:
      if (state == 1)
        return Moose::PREVIOUS_MULTIAPP_FP_SOLUTION_TAG;
      break;
    case Moose::SolutionIterationType::MultiSystemFixedPoint:
      if (state == 1)
        return Moose::PREVIOUS_MULTISYSTEM_FP_SOLUTION_TAG;
      break;
    case Moose::SolutionIterationType::Count:
      break;
  }
 
  return "solution_state_" + std::to_string(state) + "_" + Moose::stringify(iteration_type);
}

Referenced by SystemBase::needSolutionState(), and SystemBase::solutionState().

perfGraph()

PerfGraph & PerfGraphInterface::perfGraph ( )

inherited

Get the PerfGraph.

Definition at line 86 of file PerfGraphInterface.C.

{
  return _pg_moose_app.perfGraph();
}

Referenced by CommonOutputAction::act(), PerfGraphData::finalize(), PerfGraphReporter::finalize(), and PerfGraphOutput::output().

postInit()

virtual void SystemBase::postInit ( )

inlinevirtualinherited

Reimplemented in NonlinearEigenSystem.

Definition at line 163 of file SystemBase.h.

{}

Referenced by NonlinearEigenSystem::postInit().

prefix()

std::string SystemBase::prefix ( ) const

inherited

Returns

The prefix used for this system for solver settings for PETSc. This prefix is used to prevent collision of solver settings for different systems. Note that this prefix does not have a leading dash so it's appropriate for passage straight to PETSc APIs

Definition at line 1734 of file SystemBase.C.

{
  return system().prefix_with_name() ? system().prefix() : "";
}

Referenced by FieldSplitPreconditioner::FieldSplitPreconditioner(), MoosePreconditioner::initialSetup(), and FieldSplitPreconditioner::prefix().

preInit()

void LinearSystem::preInit ( )

overridevirtualinherited

This is called prior to the libMesh system has been init'd.

MOOSE system wrappers can use this method to add vectors and matrices to the libMesh system

Reimplemented from SolverSystem.

Definition at line 104 of file LinearSystem.C.

{
  SolverSystem::preInit();
 
#ifdef MOOSE_KOKKOS_ENABLED
  if (_fe_problem.hasKokkosResidualObjects())
    _sys.get_dof_map().full_sparsity_pattern_needed();
#endif
}

prepare()

void SystemBase::prepare ( THREAD_ID  tid )

virtualinherited

Prepare the system for use.

Parameters

tid	ID of the thread

Definition at line 255 of file SystemBase.C.

{
  if (_subproblem.hasActiveElementalMooseVariables(tid))
  {
    const std::set<MooseVariableFieldBase *> & active_elemental_moose_variables =
        _subproblem.getActiveElementalMooseVariables(tid);
    const std::vector<MooseVariableFieldBase *> & vars = _vars[tid].fieldVariables();
    for (const auto & var : vars)
      var->clearDofIndices();
 
    for (const auto & var : active_elemental_moose_variables)
      if (&(var->sys()) == this)
        var->prepare();
  }
  else
  {
    const std::vector<MooseVariableFieldBase *> & vars = _vars[tid].fieldVariables();
    for (const auto & var : vars)
      var->prepare();
  }
}

Referenced by SubProblem::reinitElemFaceRef().

prepareFace()

void SystemBase::prepareFace ( THREAD_ID  tid, bool  resize_data  )

virtualinherited

Prepare the system for use on sides.

This will try to reuse the preparation done on the element.

Parameters

tid	ID of the thread
resize_data	Pass True if this system needs to resize residual and jacobian datastructures based on preparing this face

Definition at line 278 of file SystemBase.C.

{
  // We only need to do something if the element prepare was restricted
  if (_subproblem.hasActiveElementalMooseVariables(tid))
  {
    const std::set<MooseVariableFieldBase *> & active_elemental_moose_variables =
        _subproblem.getActiveElementalMooseVariables(tid);
 
    std::vector<MooseVariableFieldBase *> newly_prepared_vars;
 
    const std::vector<MooseVariableFieldBase *> & vars = _vars[tid].fieldVariables();
    for (const auto & var : vars)
    {
      mooseAssert(&var->sys() == this,
                  "I will cry if we store variables in our warehouse that don't belong to us");
 
      // If it wasn't in the active list, we need to prepare it. This has the potential to duplicate
      // prepare if we have these conditions:
      //
      // 1. We have a displaced problem
      // 2. We are using AD
      // 3. We are not using global AD indexing
      //
      // But I think I would rather risk duplicate prepare than introduce an additional member set
      // variable for tracking prepared variables. Set insertion is slow and some simulations have a
      // ton of variables
      if (!active_elemental_moose_variables.count(var))
      {
        var->prepare();
        newly_prepared_vars.push_back(var);
      }
    }
 
    // Make sure to resize the residual and jacobian datastructures for all the new variables
    if (resize_data)
      for (const auto var_ptr : newly_prepared_vars)
      {
        _subproblem.assembly(tid, number()).prepareVariable(var_ptr);
        if (_subproblem.checkNonlocalCouplingRequirement())
          _subproblem.assembly(tid, number()).prepareVariableNonlocal(var_ptr);
      }
  }
}

prepareLowerD()

void SystemBase::prepareLowerD ( THREAD_ID  tid )

virtualinherited

Prepare the system for use for lower dimensional elements.

Parameters

tid	ID of the thread

Definition at line 331 of file SystemBase.C.

{
  const std::vector<MooseVariableFieldBase *> & vars = _vars[tid].fieldVariables();
  for (const auto & var : vars)
    var->prepareLowerD();
}

Referenced by SubProblem::reinitLowerDElem().

prepareNeighbor()

void SystemBase::prepareNeighbor ( THREAD_ID  tid )

virtualinherited

Prepare the system for use.

Parameters

tid	ID of the thread

Definition at line 323 of file SystemBase.C.

{
  const std::vector<MooseVariableFieldBase *> & vars = _vars[tid].fieldVariables();
  for (const auto & var : vars)
    var->prepareNeighbor();
}

Referenced by SubProblem::reinitNeighborFaceRef().

queryTimeIntegrator()

const TimeIntegrator * SystemBase::queryTimeIntegrator ( const unsigned int  var_num ) const

inherited

Retrieve the time integrator that integrates the given variable's equation.

If no suitable time integrator is found (this could happen for instance if we're solving a non-transient problem), then a nullptr will be returned

Definition at line 1694 of file SystemBase.C.

{
  for (auto & ti : _time_integrators)
    if (ti->integratesVar(var_num))
      return ti.get();
 
  return nullptr;
}

Referenced by SystemBase::getTimeIntegrator(), HDGKernel::HDGKernel(), and MooseVariableData< OutputType >::MooseVariableData().

rebuildLinearFVGradientStorage()

void LinearFVGradientManager::rebuildLinearFVGradientStorage ( )

protectedinherited

Rebuild cached gradient values and reusable scratch storage after mesh/DOF changes.

Definition at line 339 of file LinearFVGradientManager.C.

{
  for (auto & method_container_pair : _linear_fv_gradient_container_by_method)
  {
    method_container_pair.second.current_values.clear();
    method_container_pair.second.next_values.clear();
    method_container_pair.second.has_computed_gradient = false;
  }
 
  initializeLinearFVGradientStorage();
}

Referenced by AuxiliarySystem::reinit(), and LinearSystem::reinit().

registerFVGradient()

LinearFVGradientReader LinearFVGradientManager::registerFVGradient ( unsigned int  variable_number, const FVGradientMethod &  method, unsigned int  oldest_state = 0  )

inherited

Register a variable for gradient values produced by a method object.

Parameters

variable_number	Variable number whose gradient should be stored.
method	Gradient method that computes the field values.
oldest_state	Oldest time state that consumers need to read.

Definition at line 59 of file LinearFVGradientManager.C.

{
  auto * const variable =
      dynamic_cast<MooseVariableFieldBase *>(_sys.variableWarehouse().getVariable(variable_number));
  if (!variable)
    mooseError("Linear FV gradients were requested for variable number ",
               variable_number,
               " on system '",
               _sys.name(),
               "', but no field variable with that number exists on the system.");
 
  auto & container = _linear_fv_gradient_container_by_method[&method];
  container.variable_numbers.insert(variable_number);
 
  resizeGradientStateStorage(container, oldest_state);
 
  const auto & current_solution = _sys.system().current_local_solution;
  if (current_solution && current_solution->initialized())
  {
    if (container.current_values.empty())
      initializeContainer(container.current_values);
    if (container.next_values.empty())
      initializeContainer(container.next_values);
    setCurrentGradientState(container);
  }
 
  return LinearFVGradientReader(_sys, container.state_values, method, variable_number);
}

registerTimedSection() [1/2]

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

protectedinherited

Call to register a named section for timing.

Parameters

section_name	The name of the code section to be timed
level	The importance of the timer - lower is more important (0 will always come out)

Returns

The ID of the section - use when starting timing

Definition at line 61 of file PerfGraphInterface.C.

{
  const auto timed_section_name = timedSectionName(section_name);
  if (!moose::internal::getPerfGraphRegistry().sectionExists(timed_section_name))
    return moose::internal::getPerfGraphRegistry().registerSection(timed_section_name, level);
  else
    return moose::internal::getPerfGraphRegistry().sectionID(timed_section_name);
}

registerTimedSection() [2/2]

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

protectedinherited

Call to register a named section for timing.

Parameters

section_name	The name of the code section to be timed
level	The importance of the timer - lower is more important (0 will always come out)
live_message	The message to be printed to the screen during execution
print_dots	Whether or not progress dots should be printed for this section

Returns

The ID of the section - use when starting timing

Definition at line 72 of file PerfGraphInterface.C.

{
  const auto timed_section_name = timedSectionName(section_name);
  if (!moose::internal::getPerfGraphRegistry().sectionExists(timed_section_name))
    return moose::internal::getPerfGraphRegistry().registerSection(
        timedSectionName(section_name), level, live_message, print_dots);
  else
    return moose::internal::getPerfGraphRegistry().sectionID(timed_section_name);
}

reinit()

void LinearSystem::reinit ( )

overridevirtualinherited

Reinitialize the system when the degrees of freedom in this system have changed.

This is called after the libMesh system has been reinit'd

Reimplemented from SystemBase.

Definition at line 181 of file LinearSystem.C.

{
  _current_solution = system().current_local_solution.get();
  LinearFVGradientManager::rebuildLinearFVGradientStorage();
}

reinitElem()

void SystemBase::reinitElem ( const Elem *  elem, THREAD_ID  tid  )

virtualinherited

Reinit an element assembly info.

Parameters

elem	Which element we are reinitializing for
tid	ID of the thread

Reimplemented in AuxiliarySystem.

Definition at line 339 of file SystemBase.C.

{
  if (_subproblem.hasActiveElementalMooseVariables(tid))
  {
    const std::set<MooseVariableFieldBase *> & active_elemental_moose_variables =
        _subproblem.getActiveElementalMooseVariables(tid);
    for (const auto & var : active_elemental_moose_variables)
      if (&(var->sys()) == this)
        var->computeElemValues();
  }
  else
  {
    const std::vector<MooseVariableFieldBase *> & vars = _vars[tid].fieldVariables();
    for (const auto & var : vars)
      var->computeElemValues();
  }
 
  if (system().has_static_condensation())
    for (auto & [tag, matrix] : _active_tagged_matrices)
    {
      libmesh_ignore(tag);
      cast_ptr<libMesh::StaticCondensation *>(matrix)->set_current_elem(*elem);
    }
}

reinitElemFace()

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

virtualinherited

Reinit assembly info for a side of an element.

Parameters

elem	The element
side	Side of of the element
tid	Thread ID

Reimplemented in AuxiliarySystem.

Definition at line 365 of file SystemBase.C.

{
  const std::vector<MooseVariableFieldBase *> & vars = _vars[tid].fieldVariables();
  for (const auto & var : vars)
    var->computeElemValuesFace();
}

Referenced by SubProblem::reinitElemFaceRef().

reinitLowerD()

void SystemBase::reinitLowerD ( THREAD_ID  tid )

virtualinherited

Compute the values of the variables on the lower dimensional element.

Definition at line 389 of file SystemBase.C.

{
  const std::vector<MooseVariableFieldBase *> & vars = _vars[tid].fieldVariables();
  for (const auto & var : vars)
    var->computeLowerDValues();
}

Referenced by SubProblem::reinitLowerDElem().

reinitNeighbor()

void SystemBase::reinitNeighbor ( const Elem *  elem, THREAD_ID  tid  )

virtualinherited

Compute the values of the variables at all the current points.

Definition at line 381 of file SystemBase.C.

{
  const std::vector<MooseVariableFieldBase *> & vars = _vars[tid].fieldVariables();
  for (const auto & var : vars)
    var->computeNeighborValues();
}

reinitNeighborFace()

void SystemBase::reinitNeighborFace ( const Elem *  elem, unsigned int  side, THREAD_ID  tid  )

virtualinherited

Compute the values of the variables at all the current points.

Definition at line 373 of file SystemBase.C.

{
  const std::vector<MooseVariableFieldBase *> & vars = _vars[tid].fieldVariables();
  for (const auto & var : vars)
    var->computeNeighborValuesFace();
}

Referenced by SubProblem::reinitNeighborFaceRef().

reinitNode()

void SystemBase::reinitNode ( const Node *  node, THREAD_ID  tid  )

virtualinherited

Reinit nodal assembly info.

Parameters

node	Node to reinit for
tid	Thread ID

Definition at line 397 of file SystemBase.C.

{
  const std::vector<MooseVariableFieldBase *> & vars = _vars[tid].fieldVariables();
  for (const auto & var : vars)
  {
    var->reinitNode();
    if (var->isNodalDefined())
      var->computeNodalValues();
  }
}

reinitNodeFace()

void SystemBase::reinitNodeFace ( const Node *  node, BoundaryID  bnd_id, THREAD_ID  tid  )

virtualinherited

Reinit nodal assembly info on a face.

Parameters

node	Node to reinit
bnd_id	Boundary ID
tid	Thread ID

Reimplemented in NonlinearSystemBase.

Definition at line 409 of file SystemBase.C.

{
  const std::vector<MooseVariableFieldBase *> & vars = _vars[tid].fieldVariables();
  for (const auto & var : vars)
  {
    var->reinitNode();
    if (var->isNodalDefined())
      var->computeNodalValues();
  }
}

reinitNodes()

void SystemBase::reinitNodes ( const std::vector< dof_id_type > &  nodes, THREAD_ID  tid  )

virtualinherited

Reinit variables at a set of nodes.

Parameters

nodes	List of node ids to reinit
tid	Thread ID

Definition at line 421 of file SystemBase.C.

{
  const std::vector<MooseVariableFieldBase *> & vars = _vars[tid].fieldVariables();
  for (const auto & var : vars)
  {
    var->reinitNodes(nodes);
    var->computeNodalValues();
  }
}

Referenced by SubProblem::reinitNodes().

reinitNodesNeighbor()

void SystemBase::reinitNodesNeighbor ( const std::vector< dof_id_type > &  nodes, THREAD_ID  tid  )

virtualinherited

Reinit variables at a set of neighbor nodes.

Parameters

nodes	List of node ids to reinit
tid	Thread ID

Definition at line 432 of file SystemBase.C.

{
  const std::vector<MooseVariableFieldBase *> & vars = _vars[tid].fieldVariables();
  for (const auto & var : vars)
  {
    var->reinitNodesNeighbor(nodes);
    var->computeNodalNeighborValues();
  }
}

Referenced by SubProblem::reinitNodesNeighbor().

reinitScalars()

void SystemBase::reinitScalars ( THREAD_ID  tid, bool  reinit_for_derivative_reordering = false  )

virtualinherited

Reinit scalar varaibles.

Parameters

tid	Thread ID
reinit_for_derivative_reordering	A flag indicating whether we are reinitializing for the purpose of re-ordering derivative information for ADNodalBCs

Definition at line 443 of file SystemBase.C.

{
  const std::vector<MooseVariableScalar *> & vars = _vars[tid].scalars();
  for (const auto & var : vars)
    var->reinit(reinit_for_derivative_reordering);
}

removeMatrix()

void SystemBase::removeMatrix ( TagID  tag )

inherited

Removes a matrix with a given tag.

Parameters

tag_name

The name of the tag

Definition at line 587 of file SystemBase.C.

{
  if (!_subproblem.matrixTagExists(tag_id))
    mooseError("Cannot remove the matrix with TagID ",
               tag_id,
               "\nin system '",
               name(),
               "', because that tag does not exist in the problem");
 
  if (hasMatrix(tag_id))
  {
    const auto matrix_name = _subproblem.matrixTagName(tag_id);
    system().remove_matrix(matrix_name);
    _tagged_matrices[tag_id] = nullptr;
  }
}

removeVector() [1/2]

void SystemBase::removeVector ( const std::string &  name )

inherited

Remove a vector from the system with the given name.

Definition at line 1353 of file SystemBase.C.

{
  system().remove_vector(name);
}

Referenced by SystemBase::restoreOldSolutions().

removeVector() [2/2]

void SystemBase::removeVector ( TagID  tag_id )

inherited

Remove a solution length vector from the system with the specified TagID.

Parameters

tag_id

Tag ID

Definition at line 699 of file SystemBase.C.

{
  if (!_subproblem.vectorTagExists(tag_id))
    mooseError("Cannot remove the vector with TagID ",
               tag_id,
               "\nin system '",
               name(),
               "', because that tag does not exist in the problem");
 
  if (hasVector(tag_id))
  {
    auto vector_name = _subproblem.vectorTagName(tag_id);
    system().remove_vector(vector_name);
    _tagged_vectors[tag_id] = nullptr;
  }
}

residualCopy()

virtual NumericVector< Number > & SystemBase::residualCopy ( )

inlinevirtualinherited

Reimplemented in DisplacedSystem, and NonlinearSystemBase.

Definition at line 454 of file SystemBase.h.

  {
    mooseError("This system does not support getting a copy of the residual");
  }

Referenced by DisplacedSystem::residualCopy().

residualGhosted()

virtual NumericVector< Number > & SystemBase::residualGhosted ( )

inlinevirtualinherited

Reimplemented in DisplacedSystem, and NonlinearSystemBase.

Definition at line 458 of file SystemBase.h.

  {
    mooseError("This system does not support getting a ghosted copy of the residual");
  }

Referenced by DisplacedSystem::residualGhosted().

residualSetup()

virtual void LinearSystem::residualSetup ( )

inlineoverridevirtualinherited

Reimplemented from SystemBase.

Definition at line 91 of file LinearSystem.h.

{}

residualVectorTag()

virtual TagID SystemBase::residualVectorTag ( ) const

inlinevirtualinherited

Reimplemented in DisplacedSystem, and NonlinearSystemBase.

Definition at line 335 of file SystemBase.h.

{ mooseError("Not implemented yet"); }

Referenced by SystemBase::defaultVectorTags(), and DisplacedSystem::residualVectorTag().

resizeGradientStateStorage()

void LinearFVGradientManager::resizeGradientStateStorage ( LinearFVGradientContainer &  container, unsigned int  oldest_state  )

protectedinherited

Ensure that a method container stores every requested time state.

Parameters

container	Method container whose state storage should be grown.
oldest_state	Oldest time state that must be stored.

Definition at line 183 of file LinearFVGradientManager.C.

{
  const auto required_states = static_cast<std::size_t>(oldest_state) + 1;
  const auto old_size = container.state_values.size();
  if (required_states > old_size && _sys.solutionStatesInitialized() && oldest_state > 0)
    mooseError("Linear FV gradient state ",
               oldest_state,
               " was requested on system '",
               _sys.name(),
               "' after solution states were initialized. Old gradient states must be requested "
               "during setup.");
 
  if (required_states > old_size)
    container.state_values.resize(required_states);
}

Referenced by AuxiliarySystem::updateFVGradient().

resolveFVGradientMethod()

const FVGradientMethod & LinearFVGradientManager::resolveFVGradientMethod ( const GradientMethodName &  method_name )

inherited

Resolve a named gradient method, constructing a built-in method when needed.

Parameters

method_name

Name of the gradient method to retrieve.

Returns

Gradient method associated with the supplied name.

Definition at line 52 of file LinearFVGradientManager.C.

{
  auto & fe_problem = _sys.feProblem();
 
  if (!fe_problem.hasFVGradientMethod(method_name))
  {
    if (method_name == "green-gauss")
    {
      auto params = fe_problem.getMooseApp().getFactory().getValidParams("FVGreenGaussGradient");
      fe_problem.addFVGradientMethod("FVGreenGaussGradient", method_name, params);
    }
    else if (method_name == "green-gauss-venkatakrishnan")
    {
      auto params = fe_problem.getMooseApp().getFactory().getValidParams("FVGreenGaussGradient");
      params.set<MooseEnum>("limiter") = "venkatakrishnan";
      fe_problem.addFVGradientMethod("FVGreenGaussGradient", method_name, params);
    }
  }
 
  if (!fe_problem.hasFVGradientMethod(method_name))
    mooseError("Unable to find FVGradientMethod with name '", method_name, "'");
 
  return fe_problem.getFVGradientMethod(method_name);
}

restoreAdditionalStates()

void LinearSystem::restoreAdditionalStates ( )

overrideprotectedvirtualinherited

Restore system-owned state not represented by solution vectors.

Default implementation does nothing.

Reimplemented from SystemBase.

Definition at line 196 of file LinearSystem.C.

{
  LinearFVGradientManager::restoreGradientStates();
}

restoreGradientStates()

void LinearFVGradientManager::restoreGradientStates ( )

protectedinherited

Restore current gradients from state one after a failed timestep.

Definition at line 392 of file LinearFVGradientManager.C.

{
  mooseAssert(!Threads::in_threads, "Linear FV gradient state copying is not thread-safe.");
  for (auto & [_, container] : _linear_fv_gradient_container_by_method)
  {
    if (container.state_values.size() <= 1)
      continue;
 
    mooseAssert(container.has_computed_gradient,
                "Current gradient state must be initialized before restoration.");
    copyGradient(container.state_values[1], container.state_values[0]);
    copyGradient(container.state_values[0], container.next_values);
  }
}

Referenced by AuxiliarySystem::restoreAdditionalStates(), and LinearSystem::restoreAdditionalStates().

restoreOldSolutions()

void SystemBase::restoreOldSolutions ( )

virtualinherited

Restore the old and older solutions when the saved solutions present.

Definition at line 540 of file SystemBase.C.

{
  const auto num_states = getNumSolutionStates(Moose::SolutionIterationType::Time);
  if (num_states > 1)
    for (unsigned int i = 1; i <= num_states - 1; ++i)
      if (_saved_solution_states[i])
      {
        solutionState(i) = *(_saved_solution_states[i]);
        removeVector("save_solution_state_" + std::to_string(i));
        _saved_solution_states[i] = nullptr;
      }
 
  if (_saved_dot_old && solutionUDotOld())
  {
    *solutionUDotOld() = *_saved_dot_old;
    removeVector("save_solution_dot_old");
    _saved_dot_old = nullptr;
  }
  if (_saved_dotdot_old && solutionUDotDotOld())
  {
    *solutionUDotDotOld() = *_saved_dotdot_old;
    removeVector("save_solution_dotdot_old");
    _saved_dotdot_old = nullptr;
  }
}

restoreSolutions()

void SolverSystem::restoreSolutions ( )

finaloverridevirtualinherited

Restore current solutions (call after your solve failed)

Reimplemented from SystemBase.

Definition at line 41 of file SolverSystem.C.

{
  // call parent
  SystemBase::restoreSolutions();
  // and update _current_solution
  _current_solution = system().current_local_solution.get();
}

restoreStateHistory()

void SystemBase::restoreStateHistory ( )

inherited

Restore solution vectors and additional system-owned state together.

Definition at line 1346 of file SystemBase.C.

{
  restoreSolutions();
  restoreAdditionalStates();
}

rightHandSideNonTimeVectorTag()

TagID LinearSystem::rightHandSideNonTimeVectorTag ( ) const

inlineinherited

Definition at line 150 of file LinearSystem.h.

{ return _rhs_non_time_tag; }

rightHandSideTimeVectorTag()

TagID LinearSystem::rightHandSideTimeVectorTag ( ) const

inlineinherited

Accessors of important tag IDs

Definition at line 149 of file LinearSystem.h.

{ return _rhs_time_tag; }

rightHandSideVectorTag()

TagID LinearSystem::rightHandSideVectorTag ( ) const

inlineinherited

Definition at line 151 of file LinearSystem.h.

{ return _rhs_tag; }

Referenced by FEProblemBase::computeLinearSystemSys().

saveOldSolutions()

void SystemBase::saveOldSolutions ( )

virtualinherited

Save the old and older solutions.

Definition at line 509 of file SystemBase.C.

{
  const auto num_states = getNumSolutionStates(Moose::SolutionIterationType::Time);
  if (num_states > 1)
  {
    _saved_solution_states.resize(num_states);
    for (unsigned int i = 1; i <= num_states - 1; ++i)
      if (!_saved_solution_states[i])
        _saved_solution_states[i] =
            &addVector("save_solution_state_" + std::to_string(i), false, PARALLEL);
 
    for (unsigned int i = 1; i <= num_states - 1; ++i)
      *(_saved_solution_states[i]) = solutionState(i);
  }
 
  if (!_saved_dot_old && solutionUDotOld())
    _saved_dot_old = &addVector("save_solution_dot_old", false, PARALLEL);
  if (!_saved_dotdot_old && solutionUDotDotOld())
    _saved_dotdot_old = &addVector("save_solution_dotdot_old", false, PARALLEL);
 
  if (solutionUDotOld())
    *_saved_dot_old = *solutionUDotOld();
 
  if (solutionUDotDotOld())
    *_saved_dotdot_old = *solutionUDotDotOld();
}

serializedSolution()

NumericVector< Number > & SystemBase::serializedSolution ( )

virtualinherited

Returns a reference to a serialized version of the solution vector for this subproblem.

Reimplemented in DisplacedSystem.

Definition at line 1667 of file SystemBase.C.

{
  if (!_serialized_solution.get())
  {
    _serialized_solution = NumericVector<Number>::build(_communicator);
    _serialized_solution->init(system().n_dofs(), false, SERIAL);
  }
 
  return *_serialized_solution;
}

Referenced by PNGOutput::calculateRescalingValues(), PNGOutput::makeMeshFunc(), and DisplacedSystem::serializedSolution().

serializeSolution()

void SolverSystem::serializeSolution ( )

inherited

Definition at line 50 of file SolverSystem.C.

{
  if (_serialized_solution.get())
  {
    if (!_serialized_solution->initialized() || _serialized_solution->size() != system().n_dofs())
    {
      _serialized_solution->clear();
      _serialized_solution->init(system().n_dofs(), false, SERIAL);
    }
 
    _current_solution->localize(*_serialized_solution);
  }
}

Referenced by SolverSystem::setSolution().

setActiveScalarVariableCoupleableVectorTags()

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

inherited

Set the active vector tags for the scalar variables.

Definition at line 1647 of file SystemBase.C.

{
  _vars[tid].setActiveScalarVariableCoupleableVectorTags(vtags);
}

Referenced by SubProblem::setActiveScalarVariableCoupleableVectorTags().

setActiveVariableCoupleableVectorTags()

void SystemBase::setActiveVariableCoupleableVectorTags ( const std::set< TagID > &  vtags, THREAD_ID  tid  )

inherited

Set the active vector tags for the variables.

Definition at line 1641 of file SystemBase.C.

{
  _vars[tid].setActiveVariableCoupleableVectorTags(vtags);
}

Referenced by SubProblem::setActiveFEVariableCoupleableVectorTags().

setCurrentGradientState()

void LinearFVGradientManager::setCurrentGradientState ( LinearFVGradientContainer &  container ) const

protectedinherited

Set solution state zero to the current gradient.

Definition at line 216 of file LinearFVGradientManager.C.

{
  mooseAssert(!container.state_values.empty(),
              "Gradient state storage must contain a current state.");
  auto & current_view = container.state_values[0];
  current_view.clear();
  current_view.reserve(container.current_values.size());
  for (auto & component : container.current_values)
    current_view.push_back(component.get());
}

Referenced by LinearFVGradientManager::finalizeLinearFVGradientContainer(), LinearFVGradientManager::initializeLinearFVGradientStorage(), and AuxiliarySystem::updateFVGradient().

setMooseKSPNormType()

void SolverSystem::setMooseKSPNormType ( MooseEnum  kspnorm )

inherited

Set the norm in which the linear convergence will be measured.

Parameters

kspnorm

The required norm

Definition at line 115 of file SolverSystem.C.

{
  if (kspnorm == "none")
    _ksp_norm = Moose::KSPN_NONE;
  else if (kspnorm == "preconditioned")
    _ksp_norm = Moose::KSPN_PRECONDITIONED;
  else if (kspnorm == "unpreconditioned")
    _ksp_norm = Moose::KSPN_UNPRECONDITIONED;
  else if (kspnorm == "natural")
    _ksp_norm = Moose::KSPN_NATURAL;
  else if (kspnorm == "default")
    _ksp_norm = Moose::KSPN_DEFAULT;
  else
    mooseError("Unknown ksp norm type specified.");
}

Referenced by MoosePreconditioner::MoosePreconditioner().

setPCSide()

void SolverSystem::setPCSide ( MooseEnum  pcs )

inherited

Set the side on which the preconditioner is applied to.

Parameters

pcs	The required preconditioning side

Definition at line 100 of file SolverSystem.C.

{
  if (pcs == "left")
    _pc_side = Moose::PCS_LEFT;
  else if (pcs == "right")
    _pc_side = Moose::PCS_RIGHT;
  else if (pcs == "symmetric")
    _pc_side = Moose::PCS_SYMMETRIC;
  else if (pcs == "default")
    _pc_side = Moose::PCS_DEFAULT;
  else
    mooseError("Unknown PC side specified.");
}

Referenced by MoosePreconditioner::MoosePreconditioner().

setSolution()

void SolverSystem::setSolution ( const NumericVector< Number > &  soln )

inherited

Set the solution to a given vector.

Parameters

soln	The vector which should be treated as the solution.

Definition at line 65 of file SolverSystem.C.

{
  _current_solution = &soln;
 
  auto tag = _subproblem.getVectorTagID(Moose::SOLUTION_TAG);
  associateVectorToTag(const_cast<NumericVector<Number> &>(soln), tag);
 
  if (_serialized_solution.get())
    serializeSolution();
}

Referenced by FEProblemBase::computeDamping(), FEProblemBase::computeJacobianInternal(), FEProblemBase::computeJacobianTag(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualInternal(), FEProblemBase::computeResidualTag(), FEProblemBase::computeResidualType(), ActuallyExplicitEuler::solve(), and ExplicitSSPRungeKutta::solveStage().

setVariableGlobalDoFs()

void SystemBase::setVariableGlobalDoFs ( const std::string &  var_name )

inherited

set all the global dof indices for a variable

Parameters

var_name

The name of the variable

Definition at line 185 of file SystemBase.C.

{
  AllLocalDofIndicesThread aldit(_subproblem, {var_name});
  const ConstElemRange & elem_range = *_mesh.getActiveLocalElementRange();
  Threads::parallel_reduce(elem_range, aldit);
 
  // Gather the dof indices across procs to get all the dof indices for var_name
  aldit.dofIndicesSetUnion();
 
  const auto & all_dof_indices = aldit.getDofIndices();
  _var_all_dof_indices.assign(all_dof_indices.begin(), all_dof_indices.end());
}

setVerboseFlag()

void SystemBase::setVerboseFlag ( const bool &  verbose )

inlineinherited

Sets the verbose flag.

Parameters

[in]

verbose

Verbose flag

Definition at line 135 of file SystemBase.h.

{ _verbose = verbose; }

Referenced by Executioner::Executioner().

sizeVariableMatrixData()

void SystemBase::sizeVariableMatrixData ( )

inherited

size the matrix data for each variable for the number of matrix tags we have

Definition at line 1740 of file SystemBase.C.

{
  for (const auto & warehouse : _vars)
    for (const auto & [var_num, var_ptr] : warehouse.numberToVariableMap())
      var_ptr->sizeMatrixTagData();
}

skipNextSolutionToOldCopy()

void SystemBase::skipNextSolutionToOldCopy ( )

inlineinherited

Skip the next copy from the solution vector to the old solution vector old -> older is still performed.

Definition at line 1005 of file SystemBase.h.

{ _skip_next_solution_to_old_copy = true; }

solution() [1/2]

NumericVector< Number > & SystemBase::solution ( )

inlineinherited

Definition at line 212 of file SystemBase.h.

{ return solutionState(0); }

Referenced by Adaptivity::adaptMesh(), SolverSystem::applyFixedPointRelaxation(), TransientMultiApp::appTransferVector(), MooseEigenSystem::combineSystemSolution(), AuxiliarySystem::compute(), NonlinearSystemBase::computeDamping(), AuxiliarySystem::computeElementalVarsHelper(), NonlinearSystemBase::computeJacobianInternal(), AuxiliarySystem::computeMortarNodalVars(), NonlinearSystemBase::computeNodalBCsJacobian(), NonlinearSystemBase::computeNodalBCsResidual(), AuxiliarySystem::computeNodalVarsHelper(), NonlinearSystemBase::computeResidualTags(), AuxiliarySystem::computeScalarVars(), NonlinearSystemBase::constraintResiduals(), SystemBase::copyVars(), GreaterThanLessThanPostprocessor::execute(), MultiAppPostprocessorToAuxScalarTransfer::execute(), MultiAppScalarToAuxScalarTransfer::execute(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), NodalNormalsCorner::execute(), NodalNormalsEvaluator::execute(), NodalNormalsPreprocessor::execute(), NodalNormalsCorner::finalize(), NodalNormalsEvaluator::finalize(), NodalNormalsPreprocessor::finalize(), NodalNormalsCorner::initialize(), NodalNormalsEvaluator::initialize(), NodalNormalsPreprocessor::initialize(), FEProblemSolve::initialSetup(), MooseEigenSystem::initSystemSolution(), ComputeIndicatorThread::onElement(), ComputeMarkerThread::onElement(), ComputeUserObjectsThread::onElement(), ComputeNodalUserObjectsThread::onNode(), FEProblemBase::projectInitialConditionOnCustomRange(), FEProblemBase::projectSolution(), Transient::relativeSolutionDifferenceNorm(), MultiApp::restore(), ElementSubdomainModifierBase::restoreOverriddenDofValues(), SystemBase::restoreSolutions(), PicardSolve::saveVariableValues(), SecantSolve::saveVariableValues(), SteffensenSolve::saveVariableValues(), MooseEigenSystem::scaleSystemSolution(), AuxiliarySystem::serializeSolution(), NonlinearSystemBase::setConstraintSecondaryValues(), NonlinearSystemBase::setInitialSolution(), DisplacedSystem::solutionInternal(), NonlinearEigenSystem::solve(), MultiAppDofCopyTransfer::transfer(), PicardSolve::transformVariables(), SecantSolve::transformVariables(), SteffensenSolve::transformVariables(), AuxiliarySystem::variableWiseRelativeSolutionDifferenceNorm(), MoveNodesByParsedExpressionModifier::writeOutputs(), and SystemBase::zeroVariables().

solution() [2/2]

const NumericVector< Number > & SystemBase::solution ( ) const

inlineinherited

Definition at line 215 of file SystemBase.h.

{ return solutionState(0); }

solutionInternal()

NumericVector< Number > & SolverSystem::solutionInternal ( ) const

inlinefinaloverrideprotectedvirtualinherited

Internal getter for solution owned by libMesh.

Implements SystemBase.

Definition at line 135 of file SolverSystem.h.

{
  return *system().solution;
}

solutionOld() [1/2]

NumericVector< Number > & SystemBase::solutionOld ( )

inlineinherited

Definition at line 213 of file SystemBase.h.

{ return solutionState(1); }

Referenced by MooseEigenSystem::combineSystemSolution(), CentralDifference::computeTimeDerivatives(), NonlinearSystemBase::constraintResiduals(), ActivateElementsUserObjectBase::initSolutions(), MooseEigenSystem::initSystemSolutionOld(), MooseVariableScalar::reinit(), Transient::relativeSolutionDifferenceNorm(), SystemBase::restoreSolutions(), ElementSubdomainModifierBase::setOldAndOlderSolutions(), ActuallyExplicitEuler::solve(), AdamsPredictor::timestepSetup(), and AuxiliarySystem::variableWiseRelativeSolutionDifferenceNorm().

solutionOld() [2/2]

const NumericVector< Number > & SystemBase::solutionOld ( ) const

inlineinherited

Definition at line 216 of file SystemBase.h.

{ return solutionState(1); }

solutionOlder() [1/2]

NumericVector< Number > & SystemBase::solutionOlder ( )

inlineinherited

Definition at line 214 of file SystemBase.h.

{ return solutionState(2); }

Referenced by MooseEigenSystem::combineSystemSolution(), CentralDifference::computeTimeDerivatives(), ActivateElementsUserObjectBase::initSolutions(), MooseVariableScalar::reinit(), and ElementSubdomainModifierBase::setOldAndOlderSolutions().

solutionOlder() [2/2]

const NumericVector< Number > & SystemBase::solutionOlder ( ) const

inlineinherited

Definition at line 217 of file SystemBase.h.

{ return solutionState(2); }

solutionPreviousNewton() [1/2]

NumericVector< Number > * SystemBase::solutionPreviousNewton ( )

virtualinherited

Reimplemented in DisplacedSystem.

Definition at line 1365 of file SystemBase.C.

{
  if (hasVector(Moose::PREVIOUS_NL_SOLUTION_TAG))
    return &getVector(Moose::PREVIOUS_NL_SOLUTION_TAG);
  else
    return nullptr;
}

solutionPreviousNewton() [2/2]

const NumericVector< Number > * SystemBase::solutionPreviousNewton ( ) const

virtualinherited

Reimplemented in DisplacedSystem.

Definition at line 1374 of file SystemBase.C.

{
  if (hasVector(Moose::PREVIOUS_NL_SOLUTION_TAG))
    return &getVector(Moose::PREVIOUS_NL_SOLUTION_TAG);
  else
    return nullptr;
}

Referenced by AuxiliarySystem::copyCurrentIntoPreviousNL(), SystemBase::copyPreviousSolutions(), and SystemBase::restoreSolutions().

solutionState() [1/2]

NumericVector< Number > & SystemBase::solutionState ( const unsigned int  state, Moose::SolutionIterationType  iteration_type = Moose::SolutionIterationType::Time  )

virtualinherited

Get a state of the solution (0 = current, 1 = old, 2 = older, etc).

If the state does not exist, it will be initialized in addition to any newer states before it that have not been initialized.

Reimplemented in DisplacedSystem.

Definition at line 1466 of file SystemBase.C.

{
  if (!hasSolutionState(state, iteration_type))
    needSolutionState(state, iteration_type);
  return *getSolutionStates(iteration_type)[state];
}

Referenced by SolverSystem::applyFixedPointRelaxation(), SystemBase::copyPreviousSolutions(), FunctorNodalCorrector::execute(), PointwiseRenormalizeVector::execute(), PointwiseRenormalizeVector::finalize(), MooseVariableBase::getSolution(), SystemBase::restoreOldSolutions(), SystemBase::saveOldSolutions(), SystemBase::solution(), SystemBase::solution(), SystemBase::solutionOld(), SystemBase::solutionOld(), SystemBase::solutionOlder(), SystemBase::solutionOlder(), DisplacedSystem::solutionState(), and DisplacedSystem::solutionState().

solutionState() [2/2]

const NumericVector< Number > & SystemBase::solutionState ( const unsigned int  state, Moose::SolutionIterationType  iteration_type = Moose::SolutionIterationType::Time  ) const

virtualinherited

Get a state of the solution (0 = current, 1 = old, 2 = older, etc).

Reimplemented in DisplacedSystem.

Definition at line 1436 of file SystemBase.C.

{
  if (!hasSolutionState(state, iteration_type))
  {
    const auto num_states = getNumSolutionStates(iteration_type);
    mooseError("For iteration type '",
               Moose::stringify(iteration_type),
               "': solution state ",
               state,
               " was requested in ",
               name(),
               " but only up to state ",
               (num_states == 0) ? 0 : num_states - 1,
               " is available.");
  }
 
  const auto & solution_states = getSolutionStates(iteration_type);
 
  if (state == 0)
    mooseAssert(solution_states[0] == &solutionInternal(), "Inconsistent current solution");
  else
    mooseAssert(solution_states[state] ==
                    &getVector(oldSolutionStateVectorName(state, iteration_type)),
                "Inconsistent solution state");
 
  return *solution_states[state];
}

solutionStateParallelType()

libMesh::ParallelType SystemBase::solutionStateParallelType ( const unsigned int  state, const Moose::SolutionIterationType  iteration_type  ) const

inherited

Returns the parallel type of the given solution state.

Definition at line 1475 of file SystemBase.C.

{
  if (!hasSolutionState(state, iteration_type))
    mooseError("solutionStateParallelType() may only be called if the solution state exists.");
  return getSolutionStates(iteration_type)[state]->type();
}

Referenced by SolverSystem::applyFixedPointRelaxation(), and SystemBase::needSolutionState().

solutionStatesInitialized()

bool SystemBase::solutionStatesInitialized ( ) const

inlineinherited

Whether or not the solution states have been initialized via initSolutionState()

After the solution states have been initialized, additional solution states cannot be added.

Definition at line 931 of file SystemBase.h.

{ return _solution_states_initialized; }

Referenced by LinearFVGradientManager::computeGradients(), LinearFVGradientManager::resizeGradientStateStorage(), AuxScalarKernel::uOld(), and ScalarKernelBase::uOld().

solutionUDot() [1/2]

virtual NumericVector< Number > * SystemBase::solutionUDot ( )

inlinevirtualinherited

Reimplemented in DisplacedSystem.

Definition at line 289 of file SystemBase.h.

{ return _u_dot; }

Referenced by MooseVariableScalar::adUDot(), ActuallyExplicitEuler::computeTimeDerivatives(), AStableDirk4::computeTimeDerivatives(), BDF2::computeTimeDerivatives(), CentralDifference::computeTimeDerivatives(), CrankNicolson::computeTimeDerivatives(), ExplicitEuler::computeTimeDerivatives(), ExplicitRK2::computeTimeDerivatives(), ExplicitTVDRK2::computeTimeDerivatives(), ImplicitEuler::computeTimeDerivatives(), ImplicitMidpoint::computeTimeDerivatives(), LStableDirk2::computeTimeDerivatives(), LStableDirk3::computeTimeDerivatives(), LStableDirk4::computeTimeDerivatives(), NewmarkBeta::computeTimeDerivatives(), SystemBase::copyPreviousSolutions(), CrankNicolson::init(), CentralDifference::initialSetup(), MooseVariableScalar::reinit(), SystemBase::restoreSolutions(), DisplacedSystem::solutionUDot(), DisplacedSystem::solutionUDot(), and MooseVariableScalar::uDot().

solutionUDot() [2/2]

virtual const NumericVector< Number > * SystemBase::solutionUDot ( ) const

inlinevirtualinherited

Reimplemented in DisplacedSystem.

Definition at line 293 of file SystemBase.h.

{ return _u_dot; }

solutionUDotDot() [1/2]

virtual NumericVector< Number > * SystemBase::solutionUDotDot ( )

inlinevirtualinherited

Reimplemented in DisplacedSystem.

Definition at line 290 of file SystemBase.h.

{ return _u_dotdot; }

Referenced by CentralDifference::computeTimeDerivatives(), NewmarkBeta::computeTimeDerivatives(), SystemBase::copyPreviousSolutions(), CentralDifference::initialSetup(), MooseVariableScalar::reinit(), SystemBase::restoreSolutions(), DisplacedSystem::solutionUDotDot(), DisplacedSystem::solutionUDotDot(), and MooseVariableScalar::uDotDot().

solutionUDotDot() [2/2]

virtual const NumericVector< Number > * SystemBase::solutionUDotDot ( ) const

inlinevirtualinherited

Reimplemented in DisplacedSystem.

Definition at line 294 of file SystemBase.h.

{ return _u_dotdot; }

solutionUDotDotOld() [1/2]

virtual NumericVector< Number > * SystemBase::solutionUDotDotOld ( )

inlinevirtualinherited

Reimplemented in DisplacedSystem.

Definition at line 292 of file SystemBase.h.

{ return _u_dotdot_old; }

Referenced by NewmarkBeta::computeADTimeDerivatives(), NewmarkBeta::computeTimeDerivatives(), SystemBase::copyPreviousSolutions(), MooseVariableScalar::reinit(), SystemBase::restoreOldSolutions(), SystemBase::restoreSolutions(), SystemBase::saveOldSolutions(), DisplacedSystem::solutionUDotDotOld(), DisplacedSystem::solutionUDotDotOld(), and MooseVariableScalar::uDotDotOld().

solutionUDotDotOld() [2/2]

virtual const NumericVector< Number > * SystemBase::solutionUDotDotOld ( ) const

inlinevirtualinherited

Reimplemented in DisplacedSystem.

Definition at line 296 of file SystemBase.h.

{ return _u_dotdot_old; }

solutionUDotOld() [1/2]

virtual NumericVector< Number > * SystemBase::solutionUDotOld ( )

inlinevirtualinherited

Reimplemented in DisplacedSystem.

Definition at line 291 of file SystemBase.h.

{ return _u_dot_old; }

Referenced by NewmarkBeta::computeADTimeDerivatives(), NewmarkBeta::computeTimeDerivatives(), SystemBase::copyPreviousSolutions(), MooseVariableScalar::reinit(), SystemBase::restoreOldSolutions(), SystemBase::restoreSolutions(), SystemBase::saveOldSolutions(), DisplacedSystem::solutionUDotOld(), DisplacedSystem::solutionUDotOld(), and MooseVariableScalar::uDotOld().

solutionUDotOld() [2/2]

virtual const NumericVector< Number > * SystemBase::solutionUDotOld ( ) const

inlinevirtualinherited

Reimplemented in DisplacedSystem.

Definition at line 295 of file SystemBase.h.

{ return _u_dot_old; }

solve()

virtual void DumpObjectsLinearSystem::solve ( )

inlineoverridevirtual

Solve the system (using libMesh magic)

Reimplemented from LinearSystem.

Definition at line 30 of file DumpObjectsLinearSystem.h.

{}

stopSolve()

virtual void DumpObjectsLinearSystem::stopSolve ( const ExecFlagType &  exec_flag, const std::set< TagID > &  vector_tags_to_close  )

inlineoverridevirtual

Quit the current solve as soon as possible.

Reimplemented from LinearSystem.

Definition at line 31 of file DumpObjectsLinearSystem.h.

{}

subdomainSetup()

void SystemBase::subdomainSetup ( )

virtualinherited

Reimplemented in NonlinearSystemBase, and AuxiliarySystem.

Definition at line 1613 of file SystemBase.C.

{
  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
    _vars[tid].subdomainSetup();
}

Referenced by SystemBase::subdomainSetup(), AuxiliarySystem::subdomainSetup(), and NonlinearSystemBase::subdomainSetup().

subproblem() [1/2]

SubProblem & SystemBase::subproblem ( )

inlineinherited

Definition at line 102 of file SystemBase.h.

{ return _subproblem; }

Referenced by CreateDisplacedProblemAction::addProxyRelationshipManagers(), MooseVariableBase::allDofIndices(), NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::constraintResiduals(), Moose::globalDofIndexToDerivative(), NonlinearSystemBase::initialSetup(), MooseVariableScalar::MooseVariableScalar(), NonlinearSystemBase::overwriteNodeFace(), MooseVariableScalar::reinit(), NonlinearSystemBase::reinitNodeFace(), NonlinearSystemBase::setConstraintSecondaryValues(), and MooseVariableScalar::sizeMatrixTagData().

subproblem() [2/2]

const SubProblem & SystemBase::subproblem ( ) const

inlineinherited

Definition at line 103 of file SystemBase.h.

{ return _subproblem; }

system() [1/2]

virtual const System & LinearSystem::system ( ) const

inlineoverridevirtualinherited

Implements SystemBase.

Definition at line 145 of file LinearSystem.h.

{ return _sys; }

system() [2/2]

virtual System & LinearSystem::system ( )

inlineoverridevirtualinherited

Get the reference to the libMesh system.

Implements SystemBase.

Definition at line 144 of file LinearSystem.h.

{ return _sys; }

Referenced by LinearSystem::initialSetup(), LinearSystem::reinit(), and LinearSystem::solve().

systemMatrixTag()

virtual TagID LinearSystem::systemMatrixTag ( ) const

inlineoverridevirtualinherited

Return the Matrix Tag ID for System.

Reimplemented from SystemBase.

Definition at line 152 of file LinearSystem.h.

{ return _system_matrix_tag; }

Referenced by FEProblemBase::computeLinearSystemSys().

timedSectionName()

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

protectedinherited

Returns

The name of the timed section with the name section_name.

Optionally adds a prefix if one is defined.

Definition at line 55 of file PerfGraphInterface.C.

{
  return _prefix.empty() ? "" : (_prefix + "::") + section_name;
}

Referenced by PerfGraphInterface::registerTimedSection(), and PerfGraphInterface::registerTimedSection().

timeKernelVariableNames()

virtual std::vector< std::string > LinearSystem::timeKernelVariableNames ( )

inlineoverridevirtualinherited

Returns the names of the variables that have time derivative kernels in the system.

Implements SolverSystem.

Definition at line 106 of file LinearSystem.h.

{ return {}; }

timestepSetup()

void SystemBase::timestepSetup ( )

virtualinherited

Reimplemented in AuxiliarySystem, and NonlinearSystemBase.

Definition at line 1599 of file SystemBase.C.

{
  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
    _vars[tid].timestepSetup();
}

Referenced by SystemBase::timestepSetup(), AuxiliarySystem::timestepSetup(), and NonlinearSystemBase::timestepSetup().

timeVectorTag()

virtual TagID SystemBase::timeVectorTag ( ) const

inlinevirtualinherited

Ideally, we should not need this API.

There exists a really bad API "addCachedResidualDirectly " in FEProblem and DisplacedProblem This API should go away once addCachedResidualDirectly is removed in the future Return Tag ID for Time

Reimplemented in DisplacedSystem, and NonlinearSystemBase.

Definition at line 320 of file SystemBase.h.

{ mooseError("Not implemented yet"); }

Referenced by SystemBase::defaultVectorTags(), and DisplacedSystem::timeVectorTag().

update()

void SystemBase::update ( )

inherited

Update the system (doing libMesh magic)

Definition at line 1240 of file SystemBase.C.

{
  system().update();
}

Referenced by Adaptivity::adaptMesh(), SolverSystem::applyFixedPointRelaxation(), MooseEigenSystem::combineSystemSolution(), NonlinearSystemBase::computeDamping(), NonlinearSystemBase::computeJacobianInternal(), NonlinearSystemBase::computeResidualTags(), EigenProblem::doFreeNonlinearPowerIterations(), FunctorNodalCorrector::finalize(), PointwiseRenormalizeVector::finalize(), MooseEigenSystem::initSystemSolution(), MooseEigenSystem::initSystemSolutionOld(), MooseEigenSystem::scaleSystemSolution(), NonlinearSystemBase::setConstraintSecondaryValues(), NonlinearSystemBase::setInitialSolution(), FEProblemBase::solve(), EigenProblem::solve(), DisplacedProblem::syncSolutions(), MultiAppDofCopyTransfer::transfer(), PicardSolve::transformVariables(), SecantSolve::transformVariables(), and SteffensenSolve::transformVariables().

updateFVGradient()

void LinearFVGradientManager::updateFVGradient ( const LinearFVGradientReader &  reader )

inherited

Update a registered gradient reader explicitly.

Parameters

reader

Gradient reader to update.

Definition at line 81 of file LinearFVGradientManager.C.

{
  if (&reader.system() != &_sys)
    mooseError("Requested update for a linear FV gradient field from a different system than '",
               _sys.name(),
               "'.");
 
  const auto method_container_pair = _linear_fv_gradient_container_by_method.find(&reader.method());
  if (method_container_pair != _linear_fv_gradient_container_by_method.end())
  {
    auto * const perf_graph_interface = dynamic_cast<PerfGraphInterface *>(&_sys);
    mooseAssert(perf_graph_interface,
                "LinearFVGradientManager requires its owning system to implement "
                "PerfGraphInterface.");
    const auto perf_id =
        perf_graph_interface->registerTimedSection("LinearVariableFV_Gradients", 3);
    mooseAssert(!Threads::in_threads, "PerfGraph timing cannot be used within threaded sections");
    PerfGuard time_guard(perf_graph_interface->perfGraph(), perf_id);
 
    auto & container = computeLinearFVGradientContainer(reader.method());
    finalizeLinearFVGradientContainer(container);
    return;
  }
 
  mooseError("Requested update for an unregistered linear FV gradient field on system '",
             _sys.name(),
             "'.");
}

validParams()

InputParameters PerfGraphInterface::validParams ( )

staticinherited

Definition at line 16 of file PerfGraphInterface.C.

{
  InputParameters params = emptyInputParameters();
  return params;
}

Referenced by Convergence::validParams().

variableWarehouse()

const VariableWarehouse & SystemBase::variableWarehouse ( THREAD_ID  tid = 0 ) const

inlineinherited

Definition at line 784 of file SystemBase.h.

{ return _vars[tid]; }

Referenced by AuxiliarySystem::updateFVGradient().

varKind()

Moose::VarKindType SystemBase::varKind ( ) const

inlineinherited

Returns

the type of variables this system holds, e.g. nonlinear or auxiliary

Definition at line 959 of file SystemBase.h.

{ return _var_kind; }

Referenced by Coupleable::coupled().

zeroTaggedVector()

void SystemBase::zeroTaggedVector ( const TagID  tag )

inherited

Zero vector with the given tag.

Definition at line 673 of file SystemBase.C.

{
  if (!_subproblem.vectorTagExists(tag))
    mooseError("Cannot zero vector with TagID ",
               tag,
               " in system '",
               name(),
               "' because that tag does not exist in the problem");
  else if (!hasVector(tag))
    mooseError("Cannot zero vector tag with name '",
               _subproblem.vectorTagName(tag),
               "' in system '",
               name(),
               "' because there is no vector associated with that tag");
  if (!_subproblem.vectorTagNotZeroed(tag))
    getVector(tag).zero();
}

Referenced by SystemBase::zeroTaggedVectors().

zeroTaggedVectors()

void SystemBase::zeroTaggedVectors ( const std::set< TagID > &  tags )

inherited

Zero all vectors for given tags.

Definition at line 692 of file SystemBase.C.

{
  for (const auto tag : tags)
    zeroTaggedVector(tag);
}

Referenced by NonlinearSystemBase::computeResidualAndJacobianTags(), and NonlinearSystemBase::computeResidualTags().

zeroVariables()

void SystemBase::zeroVariables ( std::vector< std::string > &  vars_to_be_zeroed )

virtualinherited

Zero out the solution for the list of variables passed in.

@ param vars_to_be_zeroed The variable names in this vector will have their solutions set to zero after this call

Reimplemented in DisplacedSystem.

Definition at line 199 of file SystemBase.C.

{
  if (vars_to_be_zeroed.size() > 0)
  {
    NumericVector<Number> & solution = this->solution();
 
    auto problem = dynamic_cast<FEProblemBase *>(&_subproblem);
    if (!problem)
      mooseError("System needs to be registered in FEProblemBase for using zeroVariables.");
 
    AllLocalDofIndicesThread aldit(*problem, vars_to_be_zeroed, true);
    const ConstElemRange & elem_range = *_mesh.getActiveLocalElementRange();
    Threads::parallel_reduce(elem_range, aldit);
 
    const auto & dof_indices_to_zero = aldit.getDofIndices();
 
    solution.close();
 
    for (const auto & dof : dof_indices_to_zero)
      solution.set(dof, 0);
 
    solution.close();
 
    // Call update to update the current_local_solution for this system
    system().update();
  }
}

Referenced by DisplacedSystem::zeroVariables(), SystemBase::zeroVariablesForJacobian(), and SystemBase::zeroVariablesForResidual().

zeroVariablesForJacobian()

void SystemBase::zeroVariablesForJacobian ( )

virtualinherited

Zero out the solution for the variables that were registered as needing to have their solutions zeroed on out on Jacobian evaluation by a call to addVariableToZeroOnResidual()

Definition at line 234 of file SystemBase.C.

{
  zeroVariables(_vars_to_be_zeroed_on_jacobian);
}

zeroVariablesForResidual()

void SystemBase::zeroVariablesForResidual ( )

virtualinherited

Zero out the solution for the variables that were registered as needing to have their solutions zeroed on out on residual evaluation by a call to addVariableToZeroOnResidual()

Definition at line 228 of file SystemBase.C.

{
  zeroVariables(_vars_to_be_zeroed_on_residual);
}

Member Data Documentation

_active_tagged_matrices

std::unordered_map<TagID, libMesh::SparseMatrix<Number> *> SystemBase::_active_tagged_matrices

protectedinherited

Active tagged matrices. A matrix is active if its tag-matrix pair is present in the map. We use a map instead of a vector so that users can easily add and remove to this container with calls to (de)activateMatrixTag.

Definition at line 1072 of file SystemBase.h.

Referenced by SystemBase::activateAllMatrixTags(), SystemBase::deactivateAllMatrixTags(), and SystemBase::reinitElem().

_app

MooseApp& SystemBase::_app

protectedinherited

Definition at line 1035 of file SystemBase.h.

Referenced by SolverSystem::checkInvalidSolution(), NonlinearSystemBase::computeJacobianBlocks(), NonlinearSystemBase::computeJacobianInternal(), NonlinearSystemBase::computeJacobianTags(), LinearSystem::computeLinearSystemInternal(), LinearSystem::computeLinearSystemTags(), NonlinearSystemBase::computeResidualInternal(), NonlinearSystemBase::computeResidualTags(), NonlinearSystem::converged(), and NonlinearSystemBase::shouldEvaluatePreSMOResidual().

_automatic_scaling

bool SystemBase::_automatic_scaling

protectedinherited

Whether to automatically scale the variables.

Definition at line 1102 of file SystemBase.h.

Referenced by SystemBase::automaticScaling(), SystemBase::automaticScaling(), NonlinearSystemBase::initialSetup(), and NonlinearSystemBase::preSolve().

_console

const ConsoleStream ConsoleStreamInterface::_console

inherited

An instance of helper class to write streams to the Console objects.

Definition at line 31 of file ConsoleStreamInterface.h.

Referenced by IterationAdaptiveDT::acceptStep(), MaterialOutputAction::act(), MeshOnlyAction::act(), SetupDebugAction::act(), FEProblemBase::adaptMesh(), Adaptivity::adaptMesh(), PerfGraph::addToExecutionList(), SimplePredictor::apply(), SystemBase::applyScalingFactors(), MultiApp::backup(), FEProblemBase::backupMultiApps(), CoarsenedPiecewiseLinear::buildCoarsenedGrid(), DefaultSteadyStateConvergence::checkConvergence(), MeshDiagnosticsGenerator::checkElementOverlap(), MeshDiagnosticsGenerator::checkElementTypes(), MeshDiagnosticsGenerator::checkElementVolumes(), FEProblemBase::checkExceptionAndStopSolve(), SolverSystem::checkInvalidSolution(), MeshDiagnosticsGenerator::checkLocalJacobians(), MeshDiagnosticsGenerator::checkNonConformalMesh(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MeshDiagnosticsGenerator::checkNonConformingFaces(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), MeshDiagnosticsGenerator::checkNonPlanarSides(), MeshDiagnosticsGenerator::checkPolygons(), FEProblemBase::checkProblemIntegrity(), ReferenceResidualConvergence::checkResidualConvergence(), MeshDiagnosticsGenerator::checkSidesetsOrientation(), MeshDiagnosticsGenerator::checkWatertightNodesets(), MeshDiagnosticsGenerator::checkWatertightSidesets(), CoarsenSurfaceMeshAlongSidesetGenerator::coarsenAlongSidesets(), IterationAdaptiveDT::computeAdaptiveDT(), TransientBase::computeConstrainedDT(), DefaultMultiAppFixedPointConvergence::computeCustomConvergencePostprocessor(), NonlinearSystemBase::computeDamping(), FixedPointIterationAdaptiveDT::computeDT(), IterationAdaptiveDT::computeDT(), IterationAdaptiveDT::computeFailedDT(), IterationAdaptiveDT::computeInitialDT(), IterationAdaptiveDT::computeInterpolationDT(), FEProblemBase::computeLinearSystemTags(), LinearSystem::computeLinearSystemTags(), NonlinearSystemBase::computeScaling(), Problem::console(), TimeStepper::constrainStep(), IterationAdaptiveDT::constrainStep(), MultiApp::createApp(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), Eigenvalue::execute(), SteadyBase::execute(), MFEMSteady::execute(), MessageFromInput::execute(), ActionWarehouse::executeActionsWithAction(), ActionWarehouse::executeAllActions(), MeshGeneratorSystem::executeMeshGenerators(), SidesetAroundSubdomainUpdater::finalize(), ElementQualityChecker::finalize(), FEProblemBase::finishMultiAppStep(), MeshRepairGenerator::fixOverlappingNodes(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), CoarsenBlockGenerator::generate(), CoarsenSurfaceMeshAlongSidesetGenerator::generate(), OrientSurfaceMeshGenerator::generate(), PolyLineMeshFollowingNodeSetGenerator::generate(), MeshGenerator::generateInternal(), VariableCondensationPreconditioner::getDofToCondense(), InversePowerMethod::init(), NonlinearEigen::init(), FEProblemBase::initialAdaptMesh(), DefaultMultiAppFixedPointConvergence::initialize(), SubProblem::initialSetup(), EigenExecutionerBase::inversePowerIteration(), FEProblemBase::joinAndFinalize(), TransientBase::keepGoing(), IterationAdaptiveDT::limitDTByFunction(), IterationAdaptiveDT::limitDTToPostprocessorValue(), FEProblemBase::logAdd(), EigenExecutionerBase::makeBXConsistent(), Console::meshChanged(), SurfaceDelaunayGeneratorBase::meshNormalDeviation2D(), MooseBase::mooseDeprecated(), MooseBase::mooseDeprecatedNoTrace(), MooseBase::mooseInfo(), MooseBase::mooseWarning(), MooseBase::mooseWarningNonPrefixed(), ReferenceResidualConvergence::nonlinearConvergenceSetup(), Console::output(), DOFMapOutput::output(), MaterialPropertyDebugOutput::output(), PerfGraphOutput::output(), ReporterDebugOutput::output(), SolutionInvalidityOutput::output(), VariableResidualNormsDebugOutput::output(), ControlOutput::outputActiveObjects(), ControlOutput::outputChangedControls(), ControlOutput::outputControls(), Console::outputInput(), WebServerControl::outputMessage(), Console::outputPostprocessors(), PseudoTimestep::outputPseudoTimestep(), Console::outputReporters(), DefaultMultiAppFixedPointConvergence::outputResidualNorm(), Console::outputScalarVariables(), Console::outputSystemInformation(), FEProblemBase::possiblyRebuildGeomSearchPatches(), EigenExecutionerBase::postExecute(), AB2PredictorCorrector::postSolve(), ActionWarehouse::printActionDependencySets(), BlockRestrictionDebugOutput::printBlockRestrictionGroups(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), BlockRestrictionDebugOutput::printBoundaryRestrictionGroups(), SolutionInvalidity::printDebug(), EigenExecutionerBase::printEigenvalue(), PicardSolve::printFixedPointConvergenceHistory(), SecantSolve::printFixedPointConvergenceHistory(), SteffensenSolve::printFixedPointConvergenceHistory(), FixedPointSolve::printFixedPointConvergenceReason(), PerfGraphLivePrint::printLiveMessage(), MaterialPropertyDebugOutput::printMaterialMap(), PerfGraphLivePrint::printStats(), NEML2Action::printSummary(), AutomaticMortarGeneration::projectPrimaryNodesSinglePair(), AutomaticMortarGeneration::projectSecondaryNodesSinglePair(), CoarsenBlockGenerator::recursiveCoarsen(), SolutionTimeAdaptiveDT::rejectStep(), MultiApp::restore(), FEProblemBase::restoreMultiApps(), FEProblemBase::restoreSolutions(), NonlinearSystemBase::setInitialSolution(), MooseApp::setupOptions(), Checkpoint::shouldOutput(), SubProblem::showFunctorRequestors(), SubProblem::showFunctors(), FullSolveMultiApp::showStatusMessage(), FEProblemSolve::solve(), FixedPointSolve::solve(), LinearSystem::solve(), NonlinearSystem::solve(), AStableDirk4::solve(), ExplicitRK2::solve(), ExplicitTVDRK2::solve(), ImplicitMidpoint::solve(), LStableDirk2::solve(), LStableDirk3::solve(), LStableDirk4::solve(), EigenProblem::solve(), FixedPointSolve::solveStep(), TransientMultiApp::solveStep(), MeshRepairGenerator::splitNonConvexPolygons(), PerfGraphLivePrint::start(), WebServerControl::startServer(), AB2PredictorCorrector::step(), NonlinearEigen::takeStep(), TransientBase::takeStep(), MFEMTransient::takeStep(), TerminateChainControl::terminate(), SubProblem::timestepSetup(), FEProblemBase::updateMeshXFEM(), Convergence::verboseOutput(), Console::writeTimestepInformation(), Console::writeVariableNorms(), and FEProblemBase::~FEProblemBase().

_converged

bool LinearSystem::_converged

protectedinherited

If the solve on the linear system converged.

Definition at line 246 of file LinearSystem.h.

Referenced by LinearSystem::converged(), and LinearSystem::solve().

_current_l_its

unsigned int LinearSystem::_current_l_its

protectedinherited

The linear iterations needed for convergence.

Definition at line 207 of file LinearSystem.h.

Referenced by LinearSystem::solve().

_current_solution

const NumericVector<Number>* SolverSystem::_current_solution

protectedinherited

solution vector from solver

Definition at line 117 of file SolverSystem.h.

Referenced by NonlinearEigenSystem::computeScalingJacobian(), NonlinearSystem::computeScalingJacobian(), NonlinearEigenSystem::computeScalingResidual(), NonlinearSystem::computeScalingResidual(), SolverSystem::currentSolution(), LinearSystem::initialSetup(), SolverSystem::preInit(), LinearSystem::reinit(), SolverSystem::restoreSolutions(), SolverSystem::serializeSolution(), SolverSystem::setSolution(), and NonlinearSystem::solve().

_du_dot_du

std::vector<Real> SystemBase::_du_dot_du

protectedinherited

Derivative of time derivative of u with respect to uj.

This depends on the time integration scheme

Definition at line 1064 of file SystemBase.h.

Referenced by SystemBase::duDotDu(), and SystemBase::duDotDus().

_du_dotdot_du

Real SystemBase::_du_dotdot_du

protectedinherited

Definition at line 1065 of file SystemBase.h.

Referenced by SystemBase::duDotDotDu(), and SystemBase::duDotDotDu().

_dummy

NumericVector<Number>* DumpObjectsLinearSystem::_dummy

protected

Definition at line 35 of file DumpObjectsLinearSystem.h.

_factory

Factory& SystemBase::_factory

protectedinherited

Definition at line 1036 of file SystemBase.h.

Referenced by NonlinearSystemBase::addBoundaryCondition(), NonlinearSystemBase::addConstraint(), NonlinearSystemBase::addDamper(), NonlinearSystemBase::addDGKernel(), NonlinearSystemBase::addDiracKernel(), NonlinearSystemBase::addHDGKernel(), NonlinearSystemBase::addInterfaceKernel(), AuxiliarySystem::addKernel(), MooseEigenSystem::addKernel(), NonlinearSystemBase::addKernel(), NonlinearSystemBase::addNodalKernel(), AuxiliarySystem::addScalarKernel(), NonlinearSystemBase::addScalarKernel(), NonlinearSystemBase::addSplit(), and SystemBase::addTimeIntegrator().

_fe_problem

FEProblemBase& SystemBase::_fe_problem

protectedinherited

the governing finite element/volume problem

Definition at line 1033 of file SystemBase.h.

Referenced by NonlinearSystemBase::addBoundaryCondition(), NonlinearSystemBase::addConstraint(), NonlinearSystemBase::addDGKernel(), NonlinearSystemBase::addDiracKernel(), SystemBase::addDotVectors(), NonlinearSystemBase::addHDGKernel(), NonlinearSystemBase::addInterfaceKernel(), NonlinearSystemBase::addKernel(), NonlinearSystemBase::addNodalKernel(), NonlinearSystemBase::addScalarKernel(), NonlinearSystemBase::addSplit(), NonlinearSystemBase::assembleScalingVector(), NonlinearSystemBase::augmentSparsity(), SolverSystem::checkInvalidSolution(), NonlinearSystemBase::checkKernelCoverage(), AuxiliarySystem::clearScalarVariableCoupleableTags(), AuxiliarySystem::compute(), LinearSystem::compute(), SolverSystem::compute(), NonlinearSystemBase::computeDamping(), NonlinearSystemBase::computeDiracContributions(), AuxiliarySystem::computeElementalVarsHelper(), NonlinearSystemBase::computeJacobian(), NonlinearSystemBase::computeJacobianBlocks(), NonlinearSystemBase::computeJacobianBlocks(), NonlinearSystemBase::computeJacobianInternal(), LinearSystem::computeLinearSystemInternal(), LinearSystem::computeLinearSystemTags(), AuxiliarySystem::computeMortarNodalVars(), NonlinearSystemBase::computeNodalBCsJacobian(), NonlinearSystemBase::computeNodalBCsResidual(), NonlinearSystemBase::computeNodalBCsResidual(), NonlinearSystemBase::computeNodalBCsResidualAndJacobian(), AuxiliarySystem::computeNodalVarsHelper(), NonlinearSystemBase::computeResidualAndJacobianInternal(), NonlinearSystemBase::computeResidualInternal(), NonlinearSystemBase::computeResidualTags(), NonlinearSystemBase::computeScalarKernelsJacobians(), AuxiliarySystem::computeScalarVars(), NonlinearSystemBase::computeScaling(), NonlinearSystem::computeScalingJacobian(), NonlinearSystem::computeScalingResidual(), NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::constraintResiduals(), LinearSystem::containsTimeKernel(), NonlinearSystem::converged(), NonlinearSystemBase::convergence(), NonlinearSystemBase::customSetup(), MooseEigenSystem::eigenKernelOnCurrent(), MooseEigenSystem::eigenKernelOnOld(), NonlinearSystemBase::enforceNodalConstraintsJacobian(), NonlinearSystemBase::enforceNodalConstraintsResidual(), SystemBase::feProblem(), SystemBase::feProblem(), NonlinearSystemBase::getFVSetupObjects(), NonlinearSystemBase::getResidualNonTimeVector(), NonlinearSystemBase::getResidualTimeVector(), LinearSystem::initialSetup(), NonlinearSystemBase::initialSetup(), NonlinearSystemBase::jacobianSetup(), LinearSystem::LinearSystem(), NonlinearSystemBase::NonlinearSystemBase(), NonlinearSystemBase::overwriteNodeFace(), NonlinearSystem::potentiallySetupFiniteDifferencing(), LinearSystem::preInit(), NonlinearSystemBase::preInit(), NonlinearSystemBase::reinitNodeFace(), NonlinearSystem::residualAndJacobianTogether(), NonlinearSystemBase::residualSetup(), NonlinearSystemBase::setConstraintSecondaryValues(), NonlinearSystemBase::setInitialSolution(), AuxiliarySystem::setScalarVariableCoupleableTags(), NonlinearSystemBase::shouldEvaluatePreSMOResidual(), NonlinearSystem::solve(), and NonlinearSystemBase::timestepSetup().

_final_linear_residual

Real LinearSystem::_final_linear_residual

protectedinherited

The final linear residual.

Definition at line 243 of file LinearSystem.h.

Referenced by LinearSystem::solve().

_initial_linear_residual

Real LinearSystem::_initial_linear_residual

protectedinherited

The initial linear residual.

Definition at line 240 of file LinearSystem.h.

Referenced by LinearSystem::solve().

_ksp_norm

Moose::MooseKSPNormType SolverSystem::_ksp_norm

protectedinherited

KSP norm type.

Definition at line 122 of file SolverSystem.h.

Referenced by SolverSystem::getMooseKSPNormType(), and SolverSystem::setMooseKSPNormType().

_linear_fv_gradient_container_by_method

std::unordered_map<const FVGradientMethod *, LinearFVGradientContainer> LinearFVGradientManager::_linear_fv_gradient_container_by_method

protectedinherited

Gradient containers keyed by the method object that produces them.

Definition at line 197 of file LinearFVGradientManager.h.

Referenced by LinearFVGradientManager::computeGradients(), LinearFVGradientManager::computeLinearFVGradientContainer(), LinearFVGradientManager::copyPreviousGradientStates(), LinearFVGradientManager::hasLinearFVGradients(), LinearFVGradientManager::initializeGradientStatesForTimeAdvance(), LinearFVGradientManager::initializeLinearFVGradientHistoryStorage(), LinearFVGradientManager::initializeLinearFVGradientStorage(), LinearFVGradientManager::rebuildLinearFVGradientStorage(), LinearFVGradientManager::restoreGradientStates(), AuxiliarySystem::updateFVGradient(), and LinearFVGradientManager::updateFVGradient().

_linear_implicit_system

libMesh::LinearImplicitSystem& LinearSystem::_linear_implicit_system

protectedinherited

Base class reference to the linear implicit system in libmesh.

Definition at line 249 of file LinearSystem.h.

Referenced by LinearSystem::computeLinearSystemInternal(), LinearSystem::getRightHandSideVector(), LinearSystem::getRightHandSideVector(), LinearSystem::getSystemMatrix(), LinearSystem::getSystemMatrix(), LinearSystem::linearImplicitSystem(), LinearSystem::LinearSystem(), LinearSystem::solve(), and LinearSystem::stopSolve().

_matrix_tag_active_flags

std::vector<bool> SystemBase::_matrix_tag_active_flags

protectedinherited

Active flags for tagged matrices.

Definition at line 1074 of file SystemBase.h.

Referenced by SystemBase::activateAllMatrixTags(), SystemBase::deactivateAllMatrixTags(), and SystemBase::matrixTagActive().

_matrix_tags

std::set<TagID> LinearSystem::_matrix_tags

protectedinherited

Matrix tags to temporarily store all tags associated with the current system.

Definition at line 213 of file LinearSystem.h.

_max_var_n_dofs_per_elem

size_t SystemBase::_max_var_n_dofs_per_elem

protectedinherited

Maximum number of dofs for any one variable on any one element.

Definition at line 1090 of file SystemBase.h.

Referenced by SystemBase::assignMaxVarNDofsPerElem(), and SystemBase::getMaxVarNDofsPerElem().

_max_var_n_dofs_per_node

size_t SystemBase::_max_var_n_dofs_per_node

protectedinherited

Maximum number of dofs for any one variable on any one node.

Definition at line 1093 of file SystemBase.h.

Referenced by SystemBase::assignMaxVarNDofsPerNode(), and SystemBase::getMaxVarNDofsPerNode().

_max_var_number

unsigned int SystemBase::_max_var_number

protectedinherited

Maximum variable number.

Definition at line 1047 of file SystemBase.h.

Referenced by SystemBase::getMaxVariableNumber().

_mesh

MooseMesh& SystemBase::_mesh

protectedinherited

Definition at line 1038 of file SystemBase.h.

Referenced by SystemBase::addVariable(), NonlinearSystemBase::assembleScalingVector(), SystemBase::augmentSendList(), NonlinearSystemBase::checkKernelCoverage(), AuxiliarySystem::computeElementalVarsHelper(), AuxiliarySystem::computeMortarNodalVars(), NonlinearSystemBase::computeNodalBCsJacobian(), AuxiliarySystem::computeNodalVarsHelper(), NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::constraintResiduals(), NonlinearSystemBase::findImplicitGeometricCouplingEntries(), NonlinearSystemBase::getNodeDofs(), SystemBase::mesh(), SystemBase::mesh(), NonlinearSystemBase::overwriteNodeFace(), NonlinearSystemBase::reinitNodeFace(), NonlinearSystemBase::setConstraintSecondaryValues(), SystemBase::setVariableGlobalDoFs(), AuxiliarySystem::variableWiseRelativeSolutionDifferenceNorm(), and SystemBase::zeroVariables().

_n_linear_iters

unsigned int LinearSystem::_n_linear_iters

protectedinherited

Number of linear iterations.

Definition at line 237 of file LinearSystem.h.

Referenced by LinearSystem::nLinearIterations(), and LinearSystem::solve().

_name

std::string SystemBase::_name

protectedinherited

The name of this system.

Definition at line 1040 of file SystemBase.h.

_numbered_vars

std::vector<std::vector<MooseVariableFieldBase *> > SystemBase::_numbered_vars

protectedinherited

Map variable number to its pointer.

Definition at line 1099 of file SystemBase.h.

Referenced by SystemBase::addVariable(), and SystemBase::getVariable().

_pc_side

Moose::PCSideType SolverSystem::_pc_side

protectedinherited

Preconditioning side.

Definition at line 120 of file SolverSystem.h.

Referenced by SolverSystem::getPCSide(), and SolverSystem::setPCSide().

_pg_moose_app

MooseApp& PerfGraphInterface::_pg_moose_app

protectedinherited

The MooseApp that owns the PerfGraph.

Definition at line 135 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::perfGraph().

_prefix

const std::string PerfGraphInterface::_prefix

protectedinherited

A prefix to use for all sections.

Definition at line 138 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::timedSectionName().

_rhs_non_time

NumericVector<Number>* LinearSystem::_rhs_non_time

protectedinherited

right hand side vector for non-time contributions

Definition at line 225 of file LinearSystem.h.

Referenced by LinearSystem::getRightHandSideNonTimeVector().

_rhs_non_time_tag

TagID LinearSystem::_rhs_non_time_tag

protectedinherited

Tag for non-time contribution rhs.

Definition at line 222 of file LinearSystem.h.

Referenced by LinearSystem::rightHandSideNonTimeVectorTag().

_rhs_tag

TagID LinearSystem::_rhs_tag

protectedinherited

Used for the right hand side vector from PETSc.

Definition at line 228 of file LinearSystem.h.

Referenced by LinearSystem::LinearSystem(), and LinearSystem::rightHandSideVectorTag().

_rhs_time

NumericVector<Number>* LinearSystem::_rhs_time

protectedinherited

right hand side vector for time contributions

Definition at line 219 of file LinearSystem.h.

Referenced by LinearSystem::getRightHandSideTimeVector().

_rhs_time_tag

TagID LinearSystem::_rhs_time_tag

protectedinherited

Tag for time contribution rhs.

Definition at line 216 of file LinearSystem.h.

Referenced by LinearSystem::rightHandSideTimeVectorTag().

_saved_dot_old

NumericVector<Real>* SystemBase::_saved_dot_old

protectedinherited

Definition at line 1081 of file SystemBase.h.

Referenced by SystemBase::restoreOldSolutions(), and SystemBase::saveOldSolutions().

_saved_dotdot_old

NumericVector<Real>* SystemBase::_saved_dotdot_old

protectedinherited

Definition at line 1082 of file SystemBase.h.

Referenced by SystemBase::restoreOldSolutions(), and SystemBase::saveOldSolutions().

_saved_old

NumericVector<Real>* SystemBase::_saved_old

protectedinherited

Definition at line 1077 of file SystemBase.h.

_saved_older

NumericVector<Real>* SystemBase::_saved_older

protectedinherited

Definition at line 1078 of file SystemBase.h.

_saved_solution_states

std::vector<NumericVector<Number> *> SystemBase::_saved_solution_states

privateinherited

The saved solution states (0 = current, 1 = old, 2 = older, etc)

Definition at line 1147 of file SystemBase.h.

Referenced by SystemBase::restoreOldSolutions(), and SystemBase::saveOldSolutions().

_serialized_solution

std::unique_ptr<NumericVector<Number> > SystemBase::_serialized_solution

protectedinherited

Serialized version of the solution vector, or nullptr if a serialized solution is not needed.

Definition at line 1115 of file SystemBase.h.

Referenced by AuxiliarySystem::compute(), SolverSystem::preInit(), SystemBase::serializedSolution(), AuxiliarySystem::serializeSolution(), SolverSystem::serializeSolution(), and SolverSystem::setSolution().

_skip_next_solution_to_old_copy

bool SystemBase::_skip_next_solution_to_old_copy

privateinherited

Whether to skip the next copy from the solution to the old vector.

Definition at line 1149 of file SystemBase.h.

Referenced by SystemBase::advanceStateHistory(), SystemBase::copyPreviousSolutions(), and SystemBase::skipNextSolutionToOldCopy().

_solution_is_invalid

bool SolverSystem::_solution_is_invalid

protectedinherited

Boolean to see if solution is invalid.

Definition at line 125 of file SolverSystem.h.

_solution_state

std::vector<NumericVector<Number> *> LinearSystem::_solution_state

privateinherited

The current states of the solution (0 = current, 1 = old, etc)

Definition at line 253 of file LinearSystem.h.

_solution_states

std::array<std::vector<NumericVector<Number> *>, static_cast<size_t>(Moose::SolutionIterationType::Count)> SystemBase::_solution_states

privateinherited

2D array of solution state vector pointers.

Outer (array) index: SolutionIterationType (Time, Nonlinear, ...) Inner (vector) index: State (0=current, 1=old, ...)

Should only be accessed through getSolutionStates() when possible for bounds checking.

Definition at line 1145 of file SystemBase.h.

Referenced by SystemBase::getSolutionStates().

_solution_states_initialized

bool SystemBase::_solution_states_initialized

protectedinherited

Whether or not the solution states have been initialized.

Definition at line 1108 of file SystemBase.h.

Referenced by SystemBase::initSolutionState(), and SystemBase::solutionStatesInitialized().

_subproblem

SubProblem& SystemBase::_subproblem

protectedinherited

The subproblem for whom this class holds variable data, etc; this can either be the governing finite element/volume problem or a subjugate displaced problem.

Definition at line 1030 of file SystemBase.h.

Referenced by SystemBase::activateAllMatrixTags(), SystemBase::addMatrix(), SystemBase::addScalingVector(), SystemBase::addVector(), SystemBase::associateMatrixToTag(), SystemBase::associateVectorToTag(), SystemBase::augmentSendList(), SystemBase::closeTaggedVector(), SystemBase::computingScalingJacobian(), SystemBase::deactivateAllMatrixTags(), SystemBase::disassociateDefaultMatrixTags(), SystemBase::disassociateDefaultVectorTags(), SystemBase::disassociateMatrixFromTag(), SystemBase::disassociateMatrixFromTag(), SystemBase::disassociateVectorFromTag(), SystemBase::disassociateVectorFromTag(), SystemBase::getMatrix(), SystemBase::getMatrix(), NonlinearSystemBase::getResidualNonTimeVector(), NonlinearSystemBase::getResidualTimeVector(), SystemBase::getVector(), SystemBase::getVector(), SystemBase::matrixTagActive(), SystemBase::needSolutionState(), SystemBase::prepare(), SystemBase::prepareFace(), SystemBase::reinitElem(), SystemBase::removeMatrix(), SystemBase::removeVector(), NonlinearSystemBase::residualGhosted(), SolverSystem::setSolution(), SystemBase::setVariableGlobalDoFs(), SystemBase::subproblem(), SystemBase::subproblem(), SystemBase::zeroTaggedVector(), and SystemBase::zeroVariables().

_sys

System& LinearSystem::_sys

protectedinherited

Base class reference to the libmesh system.

Definition at line 204 of file LinearSystem.h.

Referenced by LinearSystem::preInit(), LinearSystem::system(), and LinearSystem::system().

_system_matrix_non_time_tag

TagID LinearSystem::_system_matrix_non_time_tag

protectedinherited

Tag for non-time contribution to the system matrix.

Definition at line 231 of file LinearSystem.h.

_system_matrix_tag

TagID LinearSystem::_system_matrix_tag

protectedinherited

Tag for every contribution to system matrix.

Definition at line 234 of file LinearSystem.h.

Referenced by LinearSystem::LinearSystem(), and LinearSystem::systemMatrixTag().

_tagged_matrices

std::vector<libMesh::SparseMatrix<Number> *> SystemBase::_tagged_matrices

protectedinherited

Tagged matrices (pointer)

Definition at line 1070 of file SystemBase.h.

Referenced by SystemBase::associateMatrixToTag(), SystemBase::disassociateMatrixFromTag(), SystemBase::getMatrix(), SystemBase::getMatrix(), SystemBase::hasMatrix(), and SystemBase::removeMatrix().

_tagged_vectors

std::vector<NumericVector<Number> *> SystemBase::_tagged_vectors

protectedinherited

Tagged vectors (pointer)

Definition at line 1068 of file SystemBase.h.

Referenced by SystemBase::associateVectorToTag(), SystemBase::disassociateVectorFromTag(), SystemBase::getVector(), SystemBase::getVector(), SystemBase::hasVector(), and SystemBase::removeVector().

_time_integrators

std::vector<std::shared_ptr<TimeIntegrator> > SystemBase::_time_integrators

protectedinherited

Time integrator.

Definition at line 1096 of file SystemBase.h.

Referenced by SystemBase::addTimeIntegrator(), AuxiliarySystem::compute(), LinearSystem::compute(), SolverSystem::compute(), NonlinearSystemBase::computeResidualAndJacobianTags(), NonlinearSystemBase::computeResidualTags(), SystemBase::copyTimeIntegrators(), SystemBase::getTimeIntegrators(), NonlinearEigenSystem::nLinearIterations(), NonlinearEigenSystem::nNonlinearIterations(), NonlinearSystemBase::onTimestepBegin(), SystemBase::queryTimeIntegrator(), NonlinearEigenSystem::solve(), and NonlinearSystem::solve().

_u_dot

NumericVector<Number>* SystemBase::_u_dot

protectedinherited

solution vector for u^dot

Definition at line 1053 of file SystemBase.h.

Referenced by SystemBase::addDotVectors(), NonlinearSystemBase::setSolutionUDot(), SystemBase::solutionUDot(), and SystemBase::solutionUDot().

_u_dot_old

NumericVector<Number>* SystemBase::_u_dot_old

protectedinherited

old solution vector for u^dot

Definition at line 1058 of file SystemBase.h.

Referenced by SystemBase::addDotVectors(), NonlinearSystemBase::setSolutionUDotOld(), SystemBase::solutionUDotOld(), and SystemBase::solutionUDotOld().

_u_dotdot

NumericVector<Number>* SystemBase::_u_dotdot

protectedinherited

solution vector for u^dotdot

Definition at line 1055 of file SystemBase.h.

Referenced by SystemBase::addDotVectors(), NonlinearSystemBase::setSolutionUDotDot(), SystemBase::solutionUDotDot(), and SystemBase::solutionUDotDot().

_u_dotdot_old

NumericVector<Number>* SystemBase::_u_dotdot_old

protectedinherited

old solution vector for u^dotdot

Definition at line 1060 of file SystemBase.h.

Referenced by SystemBase::addDotVectors(), NonlinearSystemBase::setSolutionUDotDotOld(), SystemBase::solutionUDotDotOld(), and SystemBase::solutionUDotDotOld().

_var_all_dof_indices

std::vector<dof_id_type> SystemBase::_var_all_dof_indices

protectedinherited

Container for the dof indices of a given variable.

Definition at line 1111 of file SystemBase.h.

Referenced by SystemBase::getVariableGlobalDoFs(), and SystemBase::setVariableGlobalDoFs().

_var_kind

Moose::VarKindType SystemBase::_var_kind

protectedinherited

default kind of variables in this system

Definition at line 1085 of file SystemBase.h.

Referenced by SystemBase::varKind().

_var_map

std::map<unsigned int, std::set<SubdomainID> > SystemBase::_var_map

protectedinherited

Map of variables (variable id -> array of subdomains where it lives)

Definition at line 1045 of file SystemBase.h.

Referenced by SystemBase::getSubdomainsForVar(), and SystemBase::getVariableBlocks().

_var_to_copy

std::vector<VarCopyInfo> SystemBase::_var_to_copy

protectedinherited

Definition at line 1087 of file SystemBase.h.

Referenced by SystemBase::addVariableToCopy(), SystemBase::copyVars(), and SystemBase::hasVarCopy().

_vars

std::vector<VariableWarehouse> SystemBase::_vars

protectedinherited

Variable warehouses (one for each thread)

Definition at line 1043 of file SystemBase.h.

Referenced by NonlinearSystemBase::addBoundaryCondition(), NonlinearSystemBase::addInterfaceKernel(), AuxiliarySystem::addVariable(), SystemBase::applyScalingFactors(), NonlinearSystemBase::assembleScalingVector(), SystemBase::clearAllDofIndices(), AuxiliarySystem::compute(), SystemBase::customSetup(), SystemBase::getActualFieldVariable(), SystemBase::getActualFieldVariable(), SystemBase::getFieldVariable(), SystemBase::getFieldVariable(), SystemBase::getFVVariable(), SystemBase::getMinQuadratureOrder(), AuxiliarySystem::getMinQuadratureOrder(), SystemBase::getScalarVariable(), SystemBase::getScalarVariable(), SystemBase::getScalarVariables(), SystemBase::getVariable(), SystemBase::getVariableNames(), SystemBase::getVariables(), SystemBase::initialSetup(), LinearSystem::initialSetup(), SystemBase::jacobianSetup(), SystemBase::nFieldVariables(), SystemBase::nFVVariables(), SystemBase::nVariables(), SystemBase::prepare(), SystemBase::prepareFace(), SystemBase::prepareLowerD(), SystemBase::prepareNeighbor(), SystemBase::reinitElem(), SystemBase::reinitElemFace(), SystemBase::reinitLowerD(), SystemBase::reinitNeighbor(), SystemBase::reinitNeighborFace(), SystemBase::reinitNode(), SystemBase::reinitNodeFace(), SystemBase::reinitNodes(), SystemBase::reinitNodesNeighbor(), SystemBase::reinitScalars(), SystemBase::residualSetup(), SystemBase::setActiveScalarVariableCoupleableVectorTags(), SystemBase::setActiveVariableCoupleableVectorTags(), NonlinearSystemBase::setupScalingData(), SystemBase::sizeVariableMatrixData(), SystemBase::subdomainSetup(), SystemBase::timestepSetup(), and SystemBase::variableWarehouse().

_vars_to_be_zeroed_on_jacobian

std::vector<std::string> SystemBase::_vars_to_be_zeroed_on_jacobian

protectedinherited

Definition at line 1050 of file SystemBase.h.

Referenced by SystemBase::addVariableToZeroOnJacobian(), and SystemBase::zeroVariablesForJacobian().

_vars_to_be_zeroed_on_residual

std::vector<std::string> SystemBase::_vars_to_be_zeroed_on_residual

protectedinherited

Definition at line 1049 of file SystemBase.h.

Referenced by SystemBase::addVariableToZeroOnResidual(), and SystemBase::zeroVariablesForResidual().

_vector_tags

std::set<TagID> LinearSystem::_vector_tags

protectedinherited

Vector tags to temporarily store all tags associated with the current system.

Definition at line 210 of file LinearSystem.h.

_verbose

bool SystemBase::_verbose

protectedinherited

True if printing out additional information.

Definition at line 1105 of file SystemBase.h.

Referenced by SystemBase::applyScalingFactors(), and SystemBase::setVerboseFlag().

---

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

• include/systems/DumpObjectsLinearSystem.h
• src/systems/DumpObjectsLinearSystem.C