Nonlinear system to be solved. More...

#include <NonlinearSystem.h>

Inheritance diagram for NonlinearSystem:

Public Member Functions
	NonlinearSystem (FEProblemBase &problem, const std::string &name)

virtual	~NonlinearSystem ()

virtual void	solve () override
	Solve the system (using libMesh magic)

virtual void	stopSolve (const ExecFlagType &exec_flag, const std::set< TagID > &vector_tags_to_close) override
	Quit the current solve as soon as possible.

virtual unsigned int	getCurrentNonlinearIterationNumber () override
	Returns the current nonlinear iteration number.

virtual void	setupFiniteDifferencedPreconditioner () override

virtual bool	converged () override
	Returns the convergence state.

virtual NumericVector< Number > &	RHS () override

virtual libMesh::NonlinearSolver< Number > *	nonlinearSolver () override

virtual SNES	getSNES () override

virtual libMesh::NonlinearImplicitSystem &	sys ()

virtual void	attachPreconditioner (libMesh::Preconditioner< Number > *preconditioner) override
	Attach a customized preconditioner that requires physics knowledge.

virtual void	residualAndJacobianTogether () override
	Call this method if you want the residual and Jacobian to be computed simultaneously.

virtual void	potentiallySetupFiniteDifferencing () override
	Create finite differencing contexts for assembly of the Jacobian and/or approximating the action of the Jacobian on vectors (e.g.

virtual void	preInit () override
	This is called prior to the libMesh system has been init'd.

void	reinitMortarFunctors ()
	Update the mortar functors if the mesh has changed.

bool	computedScalingJacobian () const

virtual void	turnOffJacobian ()
	Turn off the Jacobian (must be called before equation system initialization)

bool	computingPreSMOResidual ()
	Returns true if this system is currently computing the pre-SMO residual for a solve.

virtual void	initialSetup () override
	Setup Functions.

virtual void	timestepSetup () override

virtual void	customSetup (const ExecFlagType &exec_type) override

virtual void	residualSetup () override

virtual void	jacobianSetup () override

bool	haveFiniteDifferencedPreconditioner () const

bool	haveFieldSplitPreconditioner () const

virtual void	addKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
	Adds a kernel.

virtual void	addHDGKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
	Adds a hybridized discontinuous Galerkin (HDG) kernel.

virtual void	addNodalKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
	Adds a NodalKernel.

void	addScalarKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
	Adds a scalar kernel.

void	addBoundaryCondition (const std::string &bc_name, const std::string &name, InputParameters &parameters)
	Adds a boundary condition.

virtual void	addKokkosKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
	Adds a Kokkos kernel.

virtual void	addKokkosNodalKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
	Adds a Kokkos nodal kernel.

void	addKokkosBoundaryCondition (const std::string &bc_name, const std::string &name, InputParameters &parameters)
	Adds a Kokkos boundary condition.

void	addConstraint (const std::string &c_name, const std::string &name, InputParameters &parameters)
	Adds a Constraint.

void	addDiracKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
	Adds a Dirac kernel.

void	addDGKernel (std::string dg_kernel_name, const std::string &name, InputParameters &parameters)
	Adds a DG kernel.

void	addInterfaceKernel (std::string interface_kernel_name, const std::string &name, InputParameters &parameters)
	Adds an interface kernel.

void	addDamper (const std::string &damper_name, const std::string &name, InputParameters &parameters)
	Adds a damper.

void	addSplit (const std::string &split_name, const std::string &name, InputParameters &parameters)
	Adds a split.

std::shared_ptr< Split >	getSplit (const std::string &name)
	Retrieves a split by name.

MooseObjectWarehouseBase< Split > &	getSplits ()
	Retrieves all splits.

bool	shouldEvaluatePreSMOResidual () const
	We offer the option to check convergence against the pre-SMO residual.

void	setPreSMOResidual (bool use)
	Set whether to evaluate the pre-SMO residual and use it in the subsequent relative convergence checks.

const bool &	usePreSMOResidual () const
	Whether we are using pre-SMO residual in relative convergence checks.

Real	referenceResidual () const
	The reference residual used in relative convergence check.

Real	preSMOResidual () const
	The pre-SMO residual.

Real	initialResidual () const
	The initial residual.

void	setInitialResidual (Real r)
	Record the initial residual (for later relative convergence check)

void	zeroVectorForResidual (const std::string &vector_name)

void	setInitialSolution ()

void	setKokkosInitialSolution ()

void	setConstraintSecondaryValues (NumericVector< Number > &solution, bool displaced)
	Sets the value of constrained variables in the solution vector.

void	constraintResiduals (NumericVector< Number > &residual, bool displaced)
	Add residual contributions from Constraints.

void	computeResidualTag (NumericVector< Number > &residual, TagID tag_id)
	Computes residual for a given tag.

void	computeResidualTags (const std::set< TagID > &tags)
	Form multiple tag-associated residual vectors for all the given tags.

void	computeResidualAndJacobianTags (const std::set< TagID > &vector_tags, const std::set< TagID > &matrix_tags)
	Form possibly multiple tag-associated vectors and matrices.

void	computeResidualAndJacobianInternal (const std::set< TagID > &vector_tags, const std::set< TagID > &matrix_tags)
	Compute residual and Jacobian from contributions not related to constraints, such as nodal boundary conditions.

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

void	computeResidual (NumericVector< Number > &residual, TagID tag_id)
	Form a residual vector for a given tag.

void	addImplicitGeometricCouplingEntries (GeometricSearchData &geom_search_data)
	Adds entries to the Jacobian in the correct positions for couplings coming from dofs being coupled that are related geometrically (i.e.

void	constraintJacobians (const SparseMatrix< Number > &jacobian_to_view, bool displaced)
	Add jacobian contributions from Constraints.

void	computeJacobianTags (const std::set< TagID > &tags)
	Computes multiple (tag associated) Jacobian matricese.

bool	computeScaling ()
	Method used to obtain scaling factors for variables.

void	computeJacobian (libMesh::SparseMatrix< Number > &jacobian, const std::set< TagID > &tags)
	Associate jacobian to systemMatrixTag, and then form a matrix for all the tags.

void	computeJacobian (libMesh::SparseMatrix< Number > &jacobian)
	Take all tags in the system, and form a matrix for all tags in the system.

void	computeJacobianBlocks (std::vector< JacobianBlock * > &blocks)
	Computes several Jacobian blocks simultaneously, summing their contributions into smaller preconditioning matrices.

void	computeJacobianBlocks (std::vector< JacobianBlock * > &blocks, const std::set< TagID > &tags)

Real	computeDamping (const NumericVector< Number > &solution, const NumericVector< Number > &update)
	Compute damping.

void	onTimestepBegin ()
	Called at the beginning of the time step.

virtual void	subdomainSetup (SubdomainID subdomain, THREAD_ID tid)
	Called from assembling when we hit a new subdomain.

virtual void	subdomainSetup ()

void	overwriteNodeFace (NumericVector< Number > &soln)
	Called from explicit time stepping to overwrite boundary positions (explicit dynamics).

void	updateActive (THREAD_ID tid)
	Update active objects of Warehouses owned by NonlinearSystemBase.

virtual void	setSolutionUDot (const NumericVector< Number > &udot)
	Set transient term used by residual and Jacobian evaluation.

virtual void	setSolutionUDotDot (const NumericVector< Number > &udotdot)
	Set transient term used by residual and Jacobian evaluation.

NumericVector< Number > &	getResidualTimeVector ()
	Return a numeric vector that is associated with the time tag.

NumericVector< Number > &	getResidualNonTimeVector ()
	Return a numeric vector that is associated with the nontime tag.

NumericVector< Number > &	residualVector (TagID tag)
	Return a residual vector that is associated with the residual tag.

virtual NumericVector< Number > &	residualCopy () override

virtual NumericVector< Number > &	residualGhosted () override

virtual void	augmentSparsity (libMesh::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.

void	setPreconditioner (std::shared_ptr< MoosePreconditioner > pc)
	Sets a preconditioner.

MoosePreconditioner const *	getPreconditioner () const

void	useFiniteDifferencedPreconditioner (bool use=true)
	If called with true this system will use a finite differenced form of the Jacobian as the preconditioner.

void	useFieldSplitPreconditioner (FieldSplitPreconditionerBase *fsp)
	If called with a non-null object true this system will use a field split preconditioner matrix.

FieldSplitPreconditionerBase &	getFieldSplitPreconditioner ()

void	addImplicitGeometricCouplingEntriesToJacobian (bool add=true)
	If called with true this will add entries into the jacobian to link together degrees of freedom that are found to be related through the geometric search system.

void	assembleConstraintsSeparately (bool separately=true)
	Indicates whether to assemble residual and Jacobian after each constraint application.

void	setupDampers ()
	Setup damping stuff (called before we actually start)

void	reinitIncrementAtQpsForDampers (THREAD_ID tid, const std::set< MooseVariable * > &damped_vars)
	Compute the incremental change in variables at QPs for dampers.

void	reinitIncrementAtNodeForDampers (THREAD_ID tid, const std::set< MooseVariable * > &damped_vars)
	Compute the incremental change in variables at nodes for dampers.

virtual unsigned int	nNonlinearIterations () const
	Return the number of non-linear iterations.

virtual unsigned int	nLinearIterations () const
	Return the number of linear iterations.

unsigned int	nResidualEvaluations () const
	Return the total number of residual evaluations done so far in this calculation.

virtual Real	finalNonlinearResidual () const
	Return the final nonlinear residual.

Real	nonlinearNorm () const
	Return the last nonlinear norm.

void	printAllVariableNorms (bool state)
	Force the printing of all variable norms after each solve.

void	debuggingResiduals (bool state)

void	setPredictor (std::shared_ptr< Predictor > predictor)

Predictor *	getPredictor ()

bool	needBoundaryMaterialOnSide (BoundaryID bnd_id, THREAD_ID tid) const
	Indicated whether this system needs material properties on boundaries.

bool	needInterfaceMaterialOnSide (BoundaryID bnd_id, THREAD_ID tid) const
	Indicated whether this system needs material properties on interfaces.

bool	needInternalNeighborSideMaterial (SubdomainID subdomain_id, THREAD_ID tid) const
	Indicates whether this system needs material properties on internal sides.

bool	doingDG () const
	Getter for _doing_dg.

MooseObjectTagWarehouse< KernelBase > &	getKernelWarehouse ()
	Access functions to Warehouses from outside NonlinearSystemBase.

const MooseObjectTagWarehouse< KernelBase > &	getKernelWarehouse () const

MooseObjectTagWarehouse< DGKernelBase > &	getDGKernelWarehouse ()

MooseObjectTagWarehouse< InterfaceKernelBase > &	getInterfaceKernelWarehouse ()

MooseObjectTagWarehouse< DiracKernelBase > &	getDiracKernelWarehouse ()

MooseObjectTagWarehouse< IntegratedBCBase > &	getIntegratedBCWarehouse ()

const MooseObjectTagWarehouse< IntegratedBCBase > &	getIntegratedBCWarehouse () const
	Return the IntegratedBCBase warehouse.

const MooseObjectTagWarehouse< ScalarKernelBase > &	getScalarKernelWarehouse () const

const MooseObjectTagWarehouse< NodalKernelBase > &	getNodalKernelWarehouse () const

MooseObjectTagWarehouse< HDGKernel > &	getHDGKernelWarehouse ()

const MooseObjectWarehouse< ElementDamper > &	getElementDamperWarehouse () const

const MooseObjectWarehouse< NodalDamper > &	getNodalDamperWarehouse () const

const ConstraintWarehouse &	getConstraintWarehouse () const

const MooseObjectTagWarehouse< NodalBCBase > &	getNodalBCWarehouse () const
	Return the NodalBCBase warehouse.

bool	hasSaveIn () const
	Weather or not the nonlinear system has save-ins.

bool	hasDiagSaveIn () const
	Weather or not the nonlinear system has diagonal Jacobian save-ins.

virtual libMesh::System &	system () override
	Get the reference to the libMesh system.

virtual const libMesh::System &	system () const override

virtual void	setSolutionUDotOld (const NumericVector< Number > &u_dot_old)

virtual void	setSolutionUDotDotOld (const NumericVector< Number > &u_dotdot_old)

virtual void	setPreviousNewtonSolution (const NumericVector< Number > &soln)

TagID	timeVectorTag () const override
	Ideally, we should not need this API.

TagID	nonTimeVectorTag () const override

TagID	residualVectorTag () const override

TagID	systemMatrixTag () const override
	Return the Matrix Tag ID for System.

bool	computeScalingOnce () const

void	computeScalingOnce (bool compute_scaling_once)

void	autoScalingParam (Real resid_vs_jac_scaling_param)
	Sets the param that indicates the weighting of the residual vs the Jacobian in determining variable scaling parameters.

void	scalingGroupVariables (const std::vector< std::vector< std::string > > &scaling_group_variables)

void	ignoreVariablesForAutoscaling (const std::vector< std::string > &ignore_variables_for_autoscaling)

bool	offDiagonalsInAutoScaling () const

void	offDiagonalsInAutoScaling (bool off_diagonals_in_auto_scaling)

void	setupDM ()
	Setup the PETSc DM object (when appropriate)

void	destroyColoring ()
	Destroy the coloring object if it exists.

void	setConvergenceName (const ConvergenceName &convergence_name)
	Sets the name of the associated Convergence object.

Convergence &	convergence ()
	Retrieves the associated Convergence object.

virtual void	reinitNodeFace (const Node *node, BoundaryID bnd_id, THREAD_ID tid)
	Reinit nodal assembly info on a face.

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.

virtual void	compute (ExecFlagType type) override
	Compute time derivatives, auxiliary variables, etc.

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

THREAD_ID	numThreads () 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	reinit ()
	Reinitialize the system when the degrees of freedom in this system have changed.

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

virtual void	initSolutionState ()
	Initializes the solution state.

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

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

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.


void	checkKernelCoverage (const std::set< SubdomainID > &mesh_subdomains) const

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.


MooseObjectTagWarehouse< ResidualObject > &	getKokkosKernelWarehouse ()

MooseObjectTagWarehouse< ResidualObject > &	getKokkosNodalKernelWarehouse ()

MooseObjectTagWarehouse< ResidualObject > &	getKokkosNodalBCWarehouse ()

MooseObjectTagWarehouse< ResidualObject > &	getKokkosIntegratedBCWarehouse ()


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
unsigned int	_num_residual_evaluations

libMesh::System &	_sys

Real	_last_nl_rnorm

std::vector< unsigned int >	_current_l_its

unsigned int	_current_nl_its

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

Protected Member Functions
void	computeScalingJacobian () override
	Compute a "Jacobian" for automatic scaling purposes.

void	computeScalingResidual () override
	Compute a "residual" for automatic scaling purposes.

void	computeResidualInternal (const std::set< TagID > &tags)
	Compute the residual for a given tag.

void	computeKokkosResidual (const std::set< TagID > &tags)
	Compute residual with Kokkos objects.

void	computeKokkosNodalBCsResidual (const std::set< TagID > &tags)
	Compute Kokkos nodal BCs.

void	computeNodalBCsResidual (NumericVector< Number > &residual)
	Enforces nodal boundary conditions.

void	computeNodalBCsResidual (NumericVector< Number > &residual, const std::set< TagID > &tags)
	Form a residual for BCs that at least has one of the given tags.

void	computeNodalBCsResidual (const std::set< TagID > &tags)
	Form multiple tag-associated residual vectors for the given tags.

void	computeNodalBCsJacobian (const std::set< TagID > &tags)
	Compute the Jacobian for nodal boundary conditions.

void	computeNodalBCsResidualAndJacobian (const std::set< TagID > &vector_tags, const std::set< TagID > &matrix_tags)
	Compute the residual and Jacobian together for nodal boundary conditions.

void	computeJacobianInternal (const std::set< TagID > &tags)
	Form multiple matrices for all the tags.

void	setMatrixOptions (const std::set< TagID > &tags)
	Set the PETSc options used for assembling the matrices of the given tags.

void	computeKokkosJacobian (const std::set< TagID > &tags)
	Compute Jacobian with Kokkos objects.

void	computeDiracContributions (const std::set< TagID > &vector_tags, const std::set< TagID > &matrix_tags, Moose::ComputeType compute_type)

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

void	enforceNodalConstraintsResidual (NumericVector< Number > &residual)
	Enforce nodal constraints.

bool	enforceNodalConstraintsJacobian (const SparseMatrix< Number > &jacobian)
	Enforce nodal constraints in the Jacobian.

void	mortarConstraints (Moose::ComputeType compute_type, const std::set< TagID > &vector_tags, const std::set< TagID > &matrix_tags)
	Do mortar constraint residual/jacobian computations.

virtual void	postAddResidualObject (ResidualObject &)
	Called after any ResidualObject-derived objects are added to the system.

void	reinitNodeFace (const Node &secondary_node, const BoundaryID secondary_boundary, const PenetrationInfo &info, const bool displaced)
	Reinitialize quantities such as variables, residuals, Jacobians, materials for node-face constraints.

bool	preSolve ()
	Perform some steps to get ready for the solver.

void	getNodeDofs (dof_id_type node_id, std::vector< dof_id_type > &dofs)

void	checkInvalidSolution ()

virtual NumericVector< Number > &	solutionInternal () const override final
	Internal getter for solution owned by libMesh.

virtual void	copyAdditionalStateBackwards (Moose::SolutionIterationType, bool)
	Copy system-owned state not represented by solution vectors.

virtual void	restoreAdditionalStates ()
	Restore system-owned state not represented by solution vectors.

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

Protected Attributes
libMesh::NonlinearImplicitSystem &	_nl_implicit_sys

ComputeResidualFunctor	_nl_residual_functor

ComputeFDResidualFunctor	_fd_residual_functor

ComputeResidualAndJacobian	_resid_and_jac_functor

NumericVector< Number > *	_residual_ghosted
	ghosted form of the residual

std::unique_ptr< NumericVector< Number > >	_residual_copy
	Copy of the residual vector, or nullptr if a copy is not needed.

Number	_du_dot_du
	\( {du^dot}\over{du} \)

Number	_du_dotdot_du
	\( {du^dotdot}\over{du} \)

TagID	_Re_time_tag
	Tag for time contribution residual.

std::set< TagID >	_nl_vector_tags
	Vector tags to temporarily store all tags associated with the current system.

std::set< TagID >	_nl_matrix_tags
	Matrix tags to temporarily store all tags associated with the current system.

NumericVector< Number > *	_Re_time
	residual vector for time contributions

TagID	_Re_non_time_tag
	Tag for non-time contribution residual.

NumericVector< Number > *	_Re_non_time
	residual vector for non-time contributions

TagID	_Re_tag
	Used for the residual vector from PETSc.

TagID	_Ke_non_time_tag
	Tag for non-time contribution Jacobian.

TagID	_Ke_system_tag
	Tag for system contribution Jacobian.

MooseObjectTagWarehouse< DiracKernelBase >	_dirac_kernels
	Dirac Kernel storage for each thread.

MooseObjectWarehouse< ElementDamper >	_element_dampers
	Element Dampers for each thread.

MooseObjectWarehouse< NodalDamper >	_nodal_dampers
	Nodal Dampers for each thread.

MooseObjectWarehouse< GeneralDamper >	_general_dampers
	General Dampers.

MooseObjectTagWarehouse< NodalKernelBase >	_nodal_kernels
	NodalKernels for each thread.

MooseObjectWarehouseBase< Split >	_splits
	Decomposition splits.

ConstraintWarehouse	_constraints
	Constraints storage object.

NumericVector< Number > *	_increment_vec
	increment vector

std::shared_ptr< MoosePreconditioner >	_preconditioner
	Preconditioner.

bool	_use_finite_differenced_preconditioner
	Whether or not to use a finite differenced preconditioner.

MatFDColoring	_fdcoloring

FieldSplitPreconditionerBase *	_fsp
	The field split preconditioner if this sytem is using one.

bool	_add_implicit_geometric_coupling_entries_to_jacobian
	Whether or not to add implicit geometric couplings to the Jacobian for FDP.

bool	_assemble_constraints_separately
	Whether or not to assemble the residual and Jacobian after the application of each constraint.

bool	_need_residual_ghosted
	Whether or not a ghosted copy of the residual needs to be made.

bool	_debugging_residuals
	true if debugging residuals

bool	_doing_dg
	true if DG is active (optimization reasons)

std::vector< std::string >	_vecs_to_zero_for_residual
	vectors that will be zeroed before a residual computation

unsigned int	_n_iters

unsigned int	_n_linear_iters

unsigned int	_n_residual_evaluations
	Total number of residual evaluations that have been performed.

Real	_final_residual

std::shared_ptr< Predictor >	_predictor
	If predictor is active, this is non-NULL.

bool	_computing_pre_smo_residual

Real	_pre_smo_residual
	The pre-SMO residual, see setPreSMOResidual for a detailed explanation.

Real	_initial_residual
	The initial (i.e., 0th nonlinear iteration) residual, see setPreSMOResidual for a detailed explanation.

bool	_use_pre_smo_residual
	Whether to use the pre-SMO initial residual in the relative convergence check.

bool	_print_all_var_norms

bool	_has_save_in
	If there is any Kernel or IntegratedBC having save_in.

bool	_has_diag_save_in
	If there is any Kernel or IntegratedBC having diag_save_in.

bool	_has_nodalbc_save_in
	If there is a nodal BC having save_in.

bool	_has_nodalbc_diag_save_in
	If there is a nodal BC having diag_save_in.

bool	_computed_scaling
	Flag used to indicate whether we have already computed the scaling Jacobian.

bool	_compute_scaling_once
	Whether the scaling factors should only be computed once at the beginning of the simulation through an extra Jacobian evaluation.

Real	_resid_vs_jac_scaling_param
	The param that indicates the weighting of the residual vs the Jacobian in determining variable scaling parameters.

std::vector< std::vector< std::string > >	_scaling_group_variables
	A container of variable groupings that can be used in scaling calculations.

std::vector< bool >	_variable_autoscaled
	Container to hold flag if variable is to participate in autoscaling.

std::vector< std::string >	_ignore_variables_for_autoscaling
	A container for variables that do not partipate in autoscaling.

bool	_off_diagonals_in_auto_scaling
	Whether to include off diagonals when determining automatic scaling factors.

std::unique_ptr< libMesh::DiagonalMatrix< Number > >	_scaling_matrix
	A diagonal matrix used for computing scaling.

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


MooseObjectTagWarehouse< KernelBase >	_kernels

MooseObjectTagWarehouse< HDGKernel >	_hybridized_kernels

MooseObjectTagWarehouse< ScalarKernelBase >	_scalar_kernels

MooseObjectTagWarehouse< DGKernelBase >	_dg_kernels

MooseObjectTagWarehouse< InterfaceKernelBase >	_interface_kernels


MooseObjectTagWarehouse< IntegratedBCBase >	_integrated_bcs

MooseObjectTagWarehouse< NodalBCBase >	_nodal_bcs

MooseObjectWarehouse< DirichletBCBase >	_preset_nodal_bcs

MooseObjectWarehouse< ADDirichletBCBase >	_ad_preset_nodal_bcs


MooseObjectTagWarehouse< ResidualObject >	_kokkos_kernels

MooseObjectTagWarehouse< ResidualObject >	_kokkos_integrated_bcs

MooseObjectTagWarehouse< ResidualObject >	_kokkos_nodal_bcs

MooseObjectWarehouse< ResidualObject >	_kokkos_preset_nodal_bcs

MooseObjectTagWarehouse< ResidualObject >	_kokkos_nodal_kernels

Private Member Functions
void	setupStandardFiniteDifferencedPreconditioner ()
	Form preconditioning matrix via a standard finite difference method column-by-column.

void	setupColoringFiniteDifferencedPreconditioner ()
	According to the nonzero pattern provided in the matrix, a graph is constructed.

virtual bool	matrixFromColoring () const override
	Whether a system matrix is formed from coloring.

std::vector< SetupInterface * >	getFVSetupObjects (THREAD_ID tid)
	Retrieve every finite volume object belonging to this system on thread `tid`, as SetupInterfaces, so that the setup methods can be dispatched to all finite volume families with a single loop.

void	findImplicitGeometricCouplingEntries (GeometricSearchData &geom_search_data, std::unordered_map< dof_id_type, std::vector< dof_id_type > > &graph)
	Finds the implicit sparsity graph between geometrically related dofs.

void	setupScalingData ()
	Setup group scaling containers.

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

std::unordered_map< std::pair< BoundaryID, BoundaryID >, ComputeMortarFunctor >	_undisplaced_mortar_functors
	Functors for computing undisplaced mortar constraints.

std::unordered_map< std::pair< BoundaryID, BoundaryID >, ComputeMortarFunctor >	_displaced_mortar_functors
	Functors for computing displaced mortar constraints.

std::vector< NumericVector< Number > * >	_solution_state
	The current states of the solution (0 = current, 1 = old, etc)

bool	_auto_scaling_initd
	Whether we've initialized the automatic scaling data structures.

std::unordered_map< unsigned int, unsigned int >	_var_to_group_var
	A map from variable index to group variable index and it's associated (inverse) scaling factor.

std::size_t	_num_scaling_groups
	The number of scaling groups.

ConvergenceName	_convergence_name
	Associated convergence object name.

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

Nonlinear system to be solved.

It is a part of FEProblemBase ;-)

Definition at line 27 of file NonlinearSystem.h.

Constructor & Destructor Documentation

◆ NonlinearSystem()

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

Definition at line 95 of file NonlinearSystem.C.

  : NonlinearSystemBase(
        fe_problem, fe_problem.es().add_system<NonlinearImplicitSystem>(name), name),
    _nl_implicit_sys(fe_problem.es().get_system<NonlinearImplicitSystem>(name)),
    _nl_residual_functor(_fe_problem),
    _fd_residual_functor(_fe_problem),
    _resid_and_jac_functor(_fe_problem),
    _use_coloring_finite_difference(false)
{
  nonlinearSolver()->residual_object = &_nl_residual_functor;
  nonlinearSolver()->jacobian = Moose::compute_jacobian;
  nonlinearSolver()->bounds = Moose::compute_bounds;
  nonlinearSolver()->nullspace = Moose::compute_nullspace;
  nonlinearSolver()->transpose_nullspace = Moose::compute_transpose_nullspace;
  nonlinearSolver()->nearnullspace = Moose::compute_nearnullspace;
 
  libMesh::PetscNonlinearSolver<Real> * petsc_solver =
      cast_ptr<libMesh::PetscNonlinearSolver<Real> *>(_nl_implicit_sys.nonlinear_solver.get());
  if (petsc_solver)
  {
    petsc_solver->set_residual_zero_out(false);
    petsc_solver->set_jacobian_zero_out(false);
    petsc_solver->use_default_monitor(false);
  }
}

◆ ~NonlinearSystem()

NonlinearSystem::~NonlinearSystem ( )

virtual

Definition at line 121 of file NonlinearSystem.C.

121{}

Member Function Documentation

◆ activateAllMatrixTags()

void SystemBase::activateAllMatrixTags ( )

virtualinherited

Make all existing matrices active.

Definition at line 1131 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().

◆ addBoundaryCondition()

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

inherited

Adds a boundary condition.

Parameters

bc_name	The type of the boundary condition
name	The name of the boundary condition
parameters	Boundary condition parameters

Definition at line 524 of file NonlinearSystemBase.C.

{
  // ThreadID
  THREAD_ID tid = 0;
 
  // Create the object
  std::shared_ptr<BoundaryCondition> bc =
      _factory.create<BoundaryCondition>(bc_name, name, parameters, tid);
  postAddResidualObject(*bc);
 
  // Active BoundaryIDs for the object
  const std::set<BoundaryID> & boundary_ids = bc->boundaryIDs();
  auto bc_var = dynamic_cast<const MooseVariableFieldBase *>(&bc->variable());
  _vars[tid].addBoundaryVar(boundary_ids, bc_var);
 
  // Cast to the various types of BCs
  std::shared_ptr<NodalBCBase> nbc = std::dynamic_pointer_cast<NodalBCBase>(bc);
  std::shared_ptr<IntegratedBCBase> ibc = std::dynamic_pointer_cast<IntegratedBCBase>(bc);
 
  // NodalBCBase
  if (nbc)
  {
    if (nbc->checkNodalVar() && !nbc->variable().isNodal())
      mooseError("Trying to use nodal boundary condition '",
                 nbc->name(),
                 "' on a non-nodal variable '",
                 nbc->variable().name(),
                 "'.");
 
    _nodal_bcs.addObject(nbc);
    // Add to theWarehouse, a centralized storage for all moose objects
    _fe_problem.theWarehouse().add(nbc);
    _vars[tid].addBoundaryVars(boundary_ids, nbc->getCoupledVars());
 
    if (parameters.get<std::vector<AuxVariableName>>("save_in").size() > 0)
      _has_nodalbc_save_in = true;
    if (parameters.get<std::vector<AuxVariableName>>("diag_save_in").size() > 0)
      _has_nodalbc_diag_save_in = true;
 
    // DirichletBCs that are preset
    std::shared_ptr<DirichletBCBase> dbc = std::dynamic_pointer_cast<DirichletBCBase>(bc);
    if (dbc && dbc->preset())
      _preset_nodal_bcs.addObject(dbc);
 
    std::shared_ptr<ADDirichletBCBase> addbc = std::dynamic_pointer_cast<ADDirichletBCBase>(bc);
    if (addbc && addbc->preset())
      _ad_preset_nodal_bcs.addObject(addbc);
  }
 
  // IntegratedBCBase
  else if (ibc)
  {
    _integrated_bcs.addObject(ibc, tid);
    // Add to theWarehouse, a centralized storage for all moose objects
    _fe_problem.theWarehouse().add(ibc);
    _vars[tid].addBoundaryVars(boundary_ids, ibc->getCoupledVars());
 
    if (parameters.get<std::vector<AuxVariableName>>("save_in").size() > 0)
      _has_save_in = true;
    if (parameters.get<std::vector<AuxVariableName>>("diag_save_in").size() > 0)
      _has_diag_save_in = true;
 
    for (tid = 1; tid < this->numThreads(); tid++)
    {
      // Create the object
      bc = _factory.create<BoundaryCondition>(bc_name, name, parameters, tid);
 
      // Give users opportunity to set some parameters
      postAddResidualObject(*bc);
 
      // Active BoundaryIDs for the object
      const std::set<BoundaryID> & boundary_ids = bc->boundaryIDs();
      _vars[tid].addBoundaryVar(boundary_ids, bc_var);
 
      ibc = std::static_pointer_cast<IntegratedBCBase>(bc);
 
      _integrated_bcs.addObject(ibc, tid);
      _vars[tid].addBoundaryVars(boundary_ids, ibc->getCoupledVars());
    }
  }
 
  else
    mooseError("Unknown BoundaryCondition type for object named ", bc->name());
}

◆ addConstraint()

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

inherited

Adds a Constraint.

Parameters

c_name	The type of the constraint
name	The name of the constraint
parameters	Constraint parameters

Definition at line 612 of file NonlinearSystemBase.C.

{
  std::shared_ptr<Constraint> constraint = _factory.create<Constraint>(c_name, name, parameters);
  _constraints.addObject(constraint);
  postAddResidualObject(*constraint);
 
  if (!_fe_problem.useHashTableMatrixAssembly())
    if (constraint && constraint->addCouplingEntriesToJacobian())
      addImplicitGeometricCouplingEntriesToJacobian(true);
}

◆ addDamper()

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

inherited

Adds a damper.

Parameters

damper_name	The type of the damper
name	The name of the damper
parameters	Damper parameters

Definition at line 686 of file NonlinearSystemBase.C.

{
  for (THREAD_ID tid = 0; tid < this->numThreads(); ++tid)
  {
    std::shared_ptr<Damper> damper = _factory.create<Damper>(damper_name, name, parameters, tid);
 
    // Attempt to cast to the damper types
    std::shared_ptr<ElementDamper> ed = std::dynamic_pointer_cast<ElementDamper>(damper);
    std::shared_ptr<NodalDamper> nd = std::dynamic_pointer_cast<NodalDamper>(damper);
    std::shared_ptr<GeneralDamper> gd = std::dynamic_pointer_cast<GeneralDamper>(damper);
 
    if (gd)
    {
      _general_dampers.addObject(gd);
      break; // not threaded
    }
    else if (ed)
      _element_dampers.addObject(ed, tid);
    else if (nd)
      _nodal_dampers.addObject(nd, tid);
    else
      mooseError("Invalid damper type");
  }
}

◆ addDGKernel()

void NonlinearSystemBase::addDGKernel	(	std::string	dg_kernel_name,
		const std::string &	name,
		InputParameters &	parameters
	)

inherited

Adds a DG kernel.

Parameters

dg_kernel_name	The type of the DG kernel
name	The name of the DG kernel
parameters	DG kernel parameters

Definition at line 642 of file NonlinearSystemBase.C.

{
  for (THREAD_ID tid = 0; tid < this->numThreads(); ++tid)
  {
    auto dg_kernel = _factory.create<DGKernelBase>(dg_kernel_name, name, parameters, tid);
    _dg_kernels.addObject(dg_kernel, tid);
    // Add to theWarehouse, a centralized storage for all moose objects
    _fe_problem.theWarehouse().add(dg_kernel);
    postAddResidualObject(*dg_kernel);
  }
 
  _doing_dg = true;
 
  if (parameters.get<std::vector<AuxVariableName>>("save_in").size() > 0)
    _has_save_in = true;
  if (parameters.get<std::vector<AuxVariableName>>("diag_save_in").size() > 0)
    _has_diag_save_in = true;
}

◆ addDiracKernel()

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

inherited

Adds a Dirac kernel.

Parameters

kernel_name	The type of the dirac kernel
name	The name of the Dirac kernel
parameters	Dirac kernel parameters

Definition at line 626 of file NonlinearSystemBase.C.

{
  for (THREAD_ID tid = 0; tid < this->numThreads(); tid++)
  {
    std::shared_ptr<DiracKernelBase> kernel =
        _factory.create<DiracKernelBase>(kernel_name, name, parameters, tid);
    postAddResidualObject(*kernel);
    _dirac_kernels.addObject(kernel, tid);
    // Add to theWarehouse, a centralized storage for all moose objects
    _fe_problem.theWarehouse().add(kernel);
  }
}

◆ 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 1650 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().

◆ addHDGKernel()

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

virtualinherited

Adds a hybridized discontinuous Galerkin (HDG) kernel.

Parameters

kernel_name	The type of the hybridized kernel
name	The name of the hybridized kernel
parameters	HDG kernel parameters

Definition at line 470 of file NonlinearSystemBase.C.

{
  for (THREAD_ID tid = 0; tid < this->numThreads(); tid++)
  {
    // Create the kernel object via the factory and add to warehouse
    auto kernel = _factory.create<HDGKernel>(kernel_name, name, parameters, tid);
    _kernels.addObject(kernel, tid);
    _hybridized_kernels.addObject(kernel, tid);
    // Add to theWarehouse, a centralized storage for all moose objects
    _fe_problem.theWarehouse().add(kernel);
    postAddResidualObject(*kernel);
  }
}

◆ addImplicitGeometricCouplingEntries()

void NonlinearSystemBase::addImplicitGeometricCouplingEntries ( GeometricSearchData & geom_search_data )

inherited

Adds entries to the Jacobian in the correct positions for couplings coming from dofs being coupled that are related geometrically (i.e.

near each other across a gap).

Definition at line 2463 of file NonlinearSystemBase.C.

{
  if (!hasMatrix(systemMatrixTag()))
    mooseError("Need a system matrix ");
 
  // At this point, have no idea how to make
  // this work with tag system
  auto & jacobian = getMatrix(systemMatrixTag());
 
  std::unordered_map<dof_id_type, std::vector<dof_id_type>> graph;
 
  findImplicitGeometricCouplingEntries(geom_search_data, graph);
 
  for (const auto & it : graph)
  {
    dof_id_type dof = it.first;
    const auto & row = it.second;
 
    for (const auto & coupled_dof : row)
      jacobian.add(dof, coupled_dof, 0);
  }
}

Referenced by NonlinearSystemBase::computeJacobianInternal().

◆ addImplicitGeometricCouplingEntriesToJacobian()

void NonlinearSystemBase::addImplicitGeometricCouplingEntriesToJacobian ( bool add = true )

inlineinherited

If called with true this will add entries into the jacobian to link together degrees of freedom that are found to be related through the geometric search system.

These entries are really only used by the Finite Difference Preconditioner and the constraint system right now.

Definition at line 516 of file NonlinearSystemBase.h.

  {
    _add_implicit_geometric_coupling_entries_to_jacobian = add;
  }

Referenced by NonlinearSystemBase::addConstraint(), and FiniteDifferencePreconditioner::FiniteDifferencePreconditioner().

◆ addInterfaceKernel()

void NonlinearSystemBase::addInterfaceKernel	(	std::string	interface_kernel_name,
		const std::string &	name,
		InputParameters &	parameters
	)

inherited

Adds an interface kernel.

Parameters

interface_kernel_name	The type of the interface kernel
name	The name of the interface kernel
parameters	interface kernel parameters

Definition at line 664 of file NonlinearSystemBase.C.

{
  for (THREAD_ID tid = 0; tid < this->numThreads(); ++tid)
  {
    std::shared_ptr<InterfaceKernelBase> interface_kernel =
        _factory.create<InterfaceKernelBase>(interface_kernel_name, name, parameters, tid);
    postAddResidualObject(*interface_kernel);
 
    const std::set<BoundaryID> & boundary_ids = interface_kernel->boundaryIDs();
    auto ik_var = dynamic_cast<const MooseVariableFieldBase *>(&interface_kernel->variable());
    _vars[tid].addBoundaryVar(boundary_ids, ik_var);
 
    _interface_kernels.addObject(interface_kernel, tid);
    // Add to theWarehouse, a centralized storage for all moose objects
    _fe_problem.theWarehouse().add(interface_kernel);
    _vars[tid].addBoundaryVars(boundary_ids, interface_kernel->getCoupledVars());
  }
}

◆ addKernel()

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

virtualinherited

Adds a kernel.

Parameters

kernel_name	The type of the kernel
name	The name of the kernel
parameters	Kernel parameters

Reimplemented in MooseEigenSystem.

Definition at line 448 of file NonlinearSystemBase.C.

{
  for (THREAD_ID tid = 0; tid < this->numThreads(); tid++)
  {
    // Create the kernel object via the factory and add to warehouse
    std::shared_ptr<KernelBase> kernel =
        _factory.create<KernelBase>(kernel_name, name, parameters, tid);
    _kernels.addObject(kernel, tid);
    postAddResidualObject(*kernel);
    // Add to theWarehouse, a centralized storage for all moose objects
    _fe_problem.theWarehouse().add(kernel);
  }
 
  if (parameters.get<std::vector<AuxVariableName>>("save_in").size() > 0)
    _has_save_in = true;
  if (parameters.get<std::vector<AuxVariableName>>("diag_save_in").size() > 0)
    _has_diag_save_in = true;
}

◆ addKokkosBoundaryCondition()

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

inherited

Adds a Kokkos boundary condition.

Parameters

bc_name	The type of the boundary condition
name	The name of the boundary condition
parameters	Boundary condition parameters

◆ addKokkosKernel()

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

virtualinherited

Adds a Kokkos kernel.

Parameters

kernel_name	The type of the kernel
name	The name of the kernel
parameters	Kernel parameters

◆ addKokkosNodalKernel()

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

virtualinherited

Adds a Kokkos nodal kernel.

Parameters

kernel_name	The type of the nodal kernel
name	The name of the kernel
parameters	Kernel parameters

◆ 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 570 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;
}

◆ addNodalKernel()

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

virtualinherited

Adds a NodalKernel.

Parameters

kernel_name	The type of the nodal kernel
name	The name of the kernel
parameters	Kernel parameters

Definition at line 487 of file NonlinearSystemBase.C.

{
  for (THREAD_ID tid = 0; tid < this->numThreads(); tid++)
  {
    // Create the kernel object via the factory and add to the warehouse
    std::shared_ptr<NodalKernelBase> kernel =
        _factory.create<NodalKernelBase>(kernel_name, name, parameters, tid);
    _nodal_kernels.addObject(kernel, tid);
    // Add to theWarehouse, a centralized storage for all moose objects
    _fe_problem.theWarehouse().add(kernel);
    postAddResidualObject(*kernel);
  }
 
  if (parameters.have_parameter<std::vector<AuxVariableName>>("save_in") &&
      parameters.get<std::vector<AuxVariableName>>("save_in").size() > 0)
    _has_save_in = true;
  if (parameters.have_parameter<std::vector<AuxVariableName>>("save_in") &&
      parameters.get<std::vector<AuxVariableName>>("diag_save_in").size() > 0)
    _has_diag_save_in = true;
}

◆ addScalarKernel()

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

inherited

Adds a scalar kernel.

Parameters

kernel_name	The type of the kernel
name	The name of the kernel
parameters	Kernel parameters

Definition at line 511 of file NonlinearSystemBase.C.

{
  std::shared_ptr<ScalarKernelBase> kernel =
      _factory.create<ScalarKernelBase>(kernel_name, name, parameters);
  postAddResidualObject(*kernel);
  // Add to theWarehouse, a centralized storage for all moose objects
  _fe_problem.theWarehouse().add(kernel);
  _scalar_kernels.addObject(kernel);
}

◆ addSplit()

void NonlinearSystemBase::addSplit	(	const std::string &	split_name,
		const std::string &	name,
		InputParameters &	parameters
	)

inherited

Adds a split.

Parameters

split_name	The type of the split
name	The name of the split
parameters	Split parameters

Definition at line 714 of file NonlinearSystemBase.C.

{
  std::shared_ptr<Split> split = _factory.create<Split>(split_name, name, parameters);
  _splits.addObject(split);
  // Add to theWarehouse, a centralized storage for all moose objects
  _fe_problem.theWarehouse().add(split);
}

◆ addTimeIntegrator()

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

inherited

Definition at line 1675 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 720 of file SystemBase.C.

{
  _numbered_vars.resize(numThreads());
 
  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 < numThreads(); 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 1175 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 182 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 176 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 608 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(), 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 620 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 1311 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 1532 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().

◆ assembleConstraintsSeparately()

void NonlinearSystemBase::assembleConstraintsSeparately ( bool separately = true )

inlineinherited

Indicates whether to assemble residual and Jacobian after each constraint application.

When true, enables "transitive" constraint application: subsequent constraints can use prior constraints' results.

Definition at line 526 of file NonlinearSystemBase.h.

  {
    _assemble_constraints_separately = separately;
  }

◆ assignMaxVarNDofsPerElem()

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

inlineinherited

assign the maximum element dofs

Definition at line 628 of file SystemBase.h.

628{ _max_var_n_dofs_per_elem = max_dofs; }

SystemBase::_max_var_n_dofs_per_elem

size_t _max_var_n_dofs_per_elem

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

Definition SystemBase.h:1088

◆ assignMaxVarNDofsPerNode()

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

inlineinherited

assign the maximum node dofs

Definition at line 633 of file SystemBase.h.

633{ _max_var_n_dofs_per_node = max_dofs; }

SystemBase::_max_var_n_dofs_per_node

size_t _max_var_n_dofs_per_node

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

Definition SystemBase.h:1091

◆ associateMatrixToTag()

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

virtualinherited

Associate a matrix to a tag.

Reimplemented in DisplacedSystem.

Definition at line 1076 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 981 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().

◆ attachPreconditioner()

void NonlinearSystem::attachPreconditioner ( libMesh::Preconditioner< Number > * preconditioner )

overridevirtual

Attach a customized preconditioner that requires physics knowledge.

Generic preconditioners should be implemented in PETSc, instead.

Implements NonlinearSystemBase.

Definition at line 353 of file NonlinearSystem.C.

{
  nonlinearSolver()->attach_preconditioner(preconditioner);
}

◆ 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 454 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 NonlinearSystemBase::augmentSparsity	(	libMesh::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 3619 of file NonlinearSystemBase.C.

{
  if (_add_implicit_geometric_coupling_entries_to_jacobian)
  {
    _fe_problem.updateGeomSearch();
 
    std::unordered_map<dof_id_type, std::vector<dof_id_type>> graph;
 
    findImplicitGeometricCouplingEntries(_fe_problem.geomSearchData(), graph);
 
    if (_fe_problem.getDisplacedProblem())
      findImplicitGeometricCouplingEntries(_fe_problem.getDisplacedProblem()->geomSearchData(),
                                           graph);
 
    const dof_id_type first_dof_on_proc = dofMap().first_dof(processor_id());
    const dof_id_type end_dof_on_proc = dofMap().end_dof(processor_id());
 
    // The total number of dofs on and off processor
    const dof_id_type n_dofs_on_proc = dofMap().n_local_dofs();
    const dof_id_type n_dofs_not_on_proc = dofMap().n_dofs() - dofMap().n_local_dofs();
 
    for (const auto & git : graph)
    {
      dof_id_type dof = git.first;
      dof_id_type local_dof = dof - first_dof_on_proc;
 
      if (dof < first_dof_on_proc || dof >= end_dof_on_proc)
        continue;
 
      const auto & row = git.second;
 
      SparsityPattern::Row & sparsity_row = sparsity[local_dof];
 
      unsigned int original_row_length = sparsity_row.size();
 
      sparsity_row.insert(sparsity_row.end(), row.begin(), row.end());
 
      SparsityPattern::sort_row(
          sparsity_row.begin(), sparsity_row.begin() + original_row_length, sparsity_row.end());
 
      // Fix up nonzero arrays
      for (const auto & coupled_dof : row)
      {
        if (coupled_dof < first_dof_on_proc || coupled_dof >= end_dof_on_proc)
        {
          if (n_oz[local_dof] < n_dofs_not_on_proc)
            n_oz[local_dof]++;
        }
        else
        {
          if (n_nz[local_dof] < n_dofs_on_proc)
            n_nz[local_dof]++;
        }
      }
    }
  }
}

◆ 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 126 of file SystemBase.h.

126{ return _automatic_scaling; }

SystemBase::_automatic_scaling

bool _automatic_scaling

Whether to automatically scale the variables.

Definition SystemBase.h:1100

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 132 of file SystemBase.h.

132{ _automatic_scaling = automatic_scaling; }

◆ autoScalingParam()

void NonlinearSystemBase::autoScalingParam ( Real resid_vs_jac_scaling_param )

inlineinherited

Sets the param that indicates the weighting of the residual vs the Jacobian in determining variable scaling parameters.

A value of 1 indicates pure residual-based scaling. A value of 0 indicates pure Jacobian-based scaling

Definition at line 731 of file NonlinearSystemBase.h.

  {
    _resid_vs_jac_scaling_param = resid_vs_jac_scaling_param;
  }

◆ 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 solve().

◆ checkKernelCoverage()

void NonlinearSystemBase::checkKernelCoverage ( const std::set< SubdomainID > & mesh_subdomains ) const

inherited

System Integrity Checks

Definition at line 3741 of file NonlinearSystemBase.C.

{
  // Obtain all blocks and variables covered by all kernels
  std::set<SubdomainID> input_subdomains;
  std::set<std::string> kernel_variables;
 
  bool global_kernels_exist = false;
  global_kernels_exist |= _scalar_kernels.hasActiveObjects();
  global_kernels_exist |= _nodal_kernels.hasActiveObjects();
 
  _kernels.subdomainsCovered(input_subdomains, kernel_variables);
  _dg_kernels.subdomainsCovered(input_subdomains, kernel_variables);
  _nodal_kernels.subdomainsCovered(input_subdomains, kernel_variables);
  _scalar_kernels.subdomainsCovered(input_subdomains, kernel_variables);
  _constraints.subdomainsCovered(input_subdomains, kernel_variables);
 
#ifdef MOOSE_KOKKOS_ENABLED
  _kokkos_kernels.subdomainsCovered(input_subdomains, kernel_variables);
  _kokkos_nodal_kernels.subdomainsCovered(input_subdomains, kernel_variables);
#endif
 
  if (_fe_problem.haveFV())
  {
    std::vector<FVElementalKernel *> fv_elemental_kernels;
    _fe_problem.theWarehouse()
        .query()
        .template condition<AttribSystem>("FVElementalKernel")
        .queryInto(fv_elemental_kernels);
 
    for (auto fv_kernel : fv_elemental_kernels)
    {
      if (fv_kernel->blockRestricted())
        for (auto block_id : fv_kernel->blockIDs())
          input_subdomains.insert(block_id);
      else
        global_kernels_exist = true;
      kernel_variables.insert(fv_kernel->variable().name());
 
      // Check for lagrange multiplier
      if (dynamic_cast<FVScalarLagrangeMultiplierConstraint *>(fv_kernel))
        kernel_variables.insert(dynamic_cast<FVScalarLagrangeMultiplierConstraint *>(fv_kernel)
                                    ->lambdaVariable()
                                    .name());
    }
 
    std::vector<FVFluxKernel *> fv_flux_kernels;
    _fe_problem.theWarehouse()
        .query()
        .template condition<AttribSystem>("FVFluxKernel")
        .queryInto(fv_flux_kernels);
 
    for (auto fv_kernel : fv_flux_kernels)
    {
      if (fv_kernel->blockRestricted())
        for (auto block_id : fv_kernel->blockIDs())
          input_subdomains.insert(block_id);
      else
        global_kernels_exist = true;
      kernel_variables.insert(fv_kernel->variable().name());
    }
 
    std::vector<FVInterfaceKernel *> fv_interface_kernels;
    _fe_problem.theWarehouse()
        .query()
        .template condition<AttribSystem>("FVInterfaceKernel")
        .queryInto(fv_interface_kernels);
 
    for (auto fvik : fv_interface_kernels)
      if (auto scalar_fvik = dynamic_cast<FVScalarLagrangeMultiplierInterface *>(fvik))
        kernel_variables.insert(scalar_fvik->lambdaVariable().name());
 
    std::vector<FVFluxBC *> fv_flux_bcs;
    _fe_problem.theWarehouse()
        .query()
        .template condition<AttribSystem>("FVFluxBC")
        .queryInto(fv_flux_bcs);
 
    for (auto fvbc : fv_flux_bcs)
      if (auto scalar_fvbc = dynamic_cast<FVBoundaryScalarLagrangeMultiplierConstraint *>(fvbc))
        kernel_variables.insert(scalar_fvbc->lambdaVariable().name());
  }
 
  for (const auto & ibc : _integrated_bcs.getActiveObjects())
  {
    const auto additional_variables_covered = ibc->additionalROVariables();
    kernel_variables.insert(additional_variables_covered.begin(),
                            additional_variables_covered.end());
  }
 
  // Check kernel coverage of subdomains (blocks) in your mesh
  if (!global_kernels_exist)
  {
    // Only require kernel coverage on blocks where this nonlinear system has field variables
    std::set<SubdomainID> system_subdomains;
    for (const auto * const variable : variableWarehouse(0).fieldVariables())
    {
      const auto & variable_subdomains = getSubdomainsForVar(variable->number());
 
      // An empty variable subdomain set denotes an unrestricted variable
      if (variable_subdomains.empty())
      {
        system_subdomains = mesh_subdomains;
        break;
      }
 
      for (const auto subdomain : variable_subdomains)
        if (mesh_subdomains.count(subdomain))
          system_subdomains.insert(subdomain);
    }
 
    std::set<SubdomainID> difference;
    std::set_difference(system_subdomains.begin(),
                        system_subdomains.end(),
                        input_subdomains.begin(),
                        input_subdomains.end(),
                        std::inserter(difference, difference.end()));
 
    // there supposed to be no kernels on this lower-dimensional subdomain
    for (const auto & id : _mesh.interiorLowerDBlocks())
      difference.erase(id);
    for (const auto & id : _mesh.boundaryLowerDBlocks())
      difference.erase(id);
 
    if (!difference.empty())
    {
      std::vector<SubdomainID> difference_vec =
          std::vector<SubdomainID>(difference.begin(), difference.end());
      std::vector<SubdomainName> difference_names = _mesh.getSubdomainNames(difference_vec);
      std::stringstream missing_block_names;
      std::copy(difference_names.begin(),
                difference_names.end(),
                std::ostream_iterator<std::string>(missing_block_names, " "));
      std::stringstream missing_block_ids;
      std::copy(difference.begin(),
                difference.end(),
                std::ostream_iterator<unsigned int>(missing_block_ids, " "));
 
      mooseError("Each subdomain must contain at least one Kernel.\nThe following block(s) lack an "
                 "active kernel: " +
                     missing_block_names.str(),
                 " (ids: ",
                 missing_block_ids.str(),
                 ")");
    }
  }
 
  // Check kernel use of variables
  std::set<VariableName> variables(getVariableNames().begin(), getVariableNames().end());
 
  std::set<VariableName> difference;
  std::set_difference(variables.begin(),
                      variables.end(),
                      kernel_variables.begin(),
                      kernel_variables.end(),
                      std::inserter(difference, difference.end()));
 
  // skip checks for varaibles defined on lower-dimensional subdomain
  std::set<VariableName> vars(difference);
  for (auto & var_name : vars)
  {
    auto blks = getSubdomainsForVar(var_name);
    for (const auto & id : blks)
      if (_mesh.interiorLowerDBlocks().count(id) > 0 || _mesh.boundaryLowerDBlocks().count(id) > 0)
        difference.erase(var_name);
  }
 
  if (!difference.empty())
  {
    std::stringstream missing_kernel_vars;
    std::copy(difference.begin(),
              difference.end(),
              std::ostream_iterator<std::string>(missing_kernel_vars, " "));
    mooseError("Each variable must be referenced by at least one active Kernel.\nThe following "
               "variable(s) lack an active kernel: " +
               missing_kernel_vars.str());
  }
}

◆ clearAllDofIndices()

void SystemBase::clearAllDofIndices ( )

inherited

Clear all dof indices from moose variables.

Definition at line 1630 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 1060 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 651 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 669 of file SystemBase.C.

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

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

◆ compute()

void SolverSystem::compute ( ExecFlagType type )

overridevirtualinherited

Compute time derivatives, auxiliary variables, etc.

Parameters

type	Our current execution stage

Implements SystemBase.

Reimplemented in LinearSystem.

Definition at line 155 of file SolverSystem.C.

{
  // Let's try not to overcompute
  bool compute_tds = false;
  if (type == EXEC_LINEAR)
    compute_tds = true;
  else if (type == EXEC_NONLINEAR)
  {
    if (_fe_problem.computingScalingJacobian() || matrixFromColoring())
      compute_tds = true;
  }
  else if ((type == EXEC_TIMESTEP_END) || (type == EXEC_FINAL))
  {
    if (_fe_problem.solverParams(number())._type == Moose::ST_LINEAR)
      // We likely don't have a final residual evaluation upon which we compute the time derivatives
      // so we need to do so now
      compute_tds = true;
  }
 
  // avoid division by dt which might be zero.
  if (compute_tds && _fe_problem.dt() > 0.)
    for (auto & ti : _time_integrators)
    {
      // Do things like compute integration weights
      ti->preStep();
      ti->computeTimeDerivatives();
    }
}

◆ computeDamping()

Real NonlinearSystemBase::computeDamping	(	const NumericVector< Number > &	solution,
		const NumericVector< Number > &	update
	)

inherited

Compute damping.

Parameters

solution	The trail solution vector
update	The incremental update to the solution vector

Returns: returns The damping factor

Definition at line 3446 of file NonlinearSystemBase.C.

{
  // Default to no damping
  Real damping = 1.0;
  bool has_active_dampers = false;
 
  try
  {
    if (_element_dampers.hasActiveObjects())
    {
      PARALLEL_TRY
      {
        TIME_SECTION("computeDampers", 3, "Computing Dampers");
        has_active_dampers = true;
        *_increment_vec = update;
        ComputeElemDampingThread cid(_fe_problem, *this);
        Threads::parallel_reduce(
            _fe_problem.getCurrentAlgebraicElementRange(), cid, this->numThreads());
        damping = std::min(cid.damping(), damping);
      }
      PARALLEL_CATCH;
    }
 
    if (_nodal_dampers.hasActiveObjects())
    {
      PARALLEL_TRY
      {
        TIME_SECTION("computeDamping::element", 3, "Computing Element Damping");
 
        has_active_dampers = true;
        *_increment_vec = update;
        ComputeNodalDampingThread cndt(_fe_problem, *this);
        Threads::parallel_reduce(
            _fe_problem.getCurrentAlgebraicNodeRange(), cndt, this->numThreads());
        damping = std::min(cndt.damping(), damping);
      }
      PARALLEL_CATCH;
    }
 
    if (_general_dampers.hasActiveObjects())
    {
      PARALLEL_TRY
      {
        TIME_SECTION("computeDamping::general", 3, "Computing General Damping");
 
        has_active_dampers = true;
        const auto & gdampers = _general_dampers.getActiveObjects();
        for (const auto & damper : gdampers)
        {
          Real gd_damping = damper->computeDamping(solution, update);
          try
          {
            damper->checkMinDamping(gd_damping);
          }
          catch (MooseException & e)
          {
            _fe_problem.setException(e.what());
          }
          damping = std::min(gd_damping, damping);
        }
      }
      PARALLEL_CATCH;
    }
  }
  catch (MooseException & e)
  {
    // 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.
  }
  catch (std::exception & e)
  {
    // Allow the libmesh error/exception on negative jacobian
    const std::string & message = e.what();
    if (message.find("Jacobian") == std::string::npos)
      throw;
  }
 
  _communicator.min(damping);
 
  if (has_active_dampers && damping < 1.0)
    _console << " Damping factor: " << damping << std::endl;
 
  return damping;
}

Referenced by FEProblemBase::computeDamping().

◆ computeDiracContributions()

void NonlinearSystemBase::computeDiracContributions	(	const std::set< TagID > &	vector_tags,
		const std::set< TagID > &	matrix_tags,
		Moose::ComputeType	compute_type
	)

protectedinherited

Definition at line 3534 of file NonlinearSystemBase.C.

{
  _fe_problem.clearDiracInfo();
 
  std::set<const Elem *> dirac_elements;
 
  if (_dirac_kernels.hasActiveObjects())
  {
    TIME_SECTION("computeDirac", 3, "Computing DiracKernels");
 
    // TODO: Need a threading fix... but it's complicated!
    for (THREAD_ID tid = 0; tid < this->numThreads(); ++tid)
    {
      const auto & dkernels = _dirac_kernels.getActiveObjects(tid);
      for (const auto & dkernel : dkernels)
      {
        dkernel->clearPoints();
        dkernel->addPoints();
      }
    }
 
    ComputeDiracThread cd(_fe_problem, vector_tags, matrix_tags, compute_type);
 
    _fe_problem.getDiracElements(dirac_elements);
 
    DistElemRange range(dirac_elements.begin(), dirac_elements.end(), 1);
    // TODO: Make Dirac work thread!
    // Threads::parallel_reduce(range, cd);
 
    cd(range);
 
    // AD DiracKernels computing the residual and Jacobian together cache their residual
    // contributions (via addResidualsAndJacobian), so those must be flushed too
    if (compute_type != Moose::ComputeType::Jacobian)
      for (const auto tid : make_range(this->numThreads()))
        _fe_problem.addCachedResidual(tid);
 
    if (compute_type != Moose::ComputeType::Residual)
      for (const auto tid : make_range(this->numThreads()))
        _fe_problem.addCachedJacobian(tid);
  }
}

Referenced by NonlinearSystemBase::computeJacobianInternal(), NonlinearSystemBase::computeResidualAndJacobianInternal(), and NonlinearSystemBase::computeResidualInternal().

◆ computedScalingJacobian()

bool NonlinearSystemBase::computedScalingJacobian ( ) const

inlineinherited

Definition at line 79 of file NonlinearSystemBase.h.

79{ return _computed_scaling; }

NonlinearSystemBase::_computed_scaling

bool _computed_scaling

Flag used to indicate whether we have already computed the scaling Jacobian.

Definition NonlinearSystemBase.h:1062

◆ computeJacobian() [1/2]

void NonlinearSystemBase::computeJacobian ( libMesh::SparseMatrix< Number > & jacobian )

inherited

Take all tags in the system, and form a matrix for all tags in the system.

Definition at line 3273 of file NonlinearSystemBase.C.

{
  _nl_matrix_tags.clear();
 
  auto & tags = _fe_problem.getMatrixTags();
 
  for (auto & tag : tags)
    _nl_matrix_tags.insert(tag.second);
 
  computeJacobian(jacobian, _nl_matrix_tags);
}

◆ computeJacobian() [2/2]

void NonlinearSystemBase::computeJacobian	(	libMesh::SparseMatrix< Number > &	jacobian,
		const std::set< TagID > &	tags
	)

inherited

Associate jacobian to systemMatrixTag, and then form a matrix for all the tags.

Definition at line 3286 of file NonlinearSystemBase.C.

{
  associateMatrixToTag(jacobian, systemMatrixTag());
 
  computeJacobianTags(tags);
 
  disassociateMatrixFromTag(jacobian, systemMatrixTag());
}

Referenced by NonlinearSystemBase::computeJacobian().

◆ computeJacobianBlocks() [1/2]

void NonlinearSystemBase::computeJacobianBlocks ( std::vector< JacobianBlock * > & blocks )

inherited

Computes several Jacobian blocks simultaneously, summing their contributions into smaller preconditioning matrices.

Used by Physics-based preconditioning

Parameters

blocks The blocks to fill in (JacobianBlock is defined in ComputeJacobianBlocksThread)

Definition at line 3315 of file NonlinearSystemBase.C.

{
  _nl_matrix_tags.clear();
 
  auto & tags = _fe_problem.getMatrixTags();
  for (auto & tag : tags)
    _nl_matrix_tags.insert(tag.second);
 
  computeJacobianBlocks(blocks, _nl_matrix_tags);
}

Referenced by NonlinearSystemBase::computeJacobianBlocks(), FEProblemBase::computeJacobianBlocks(), and EigenProblem::computeJacobianBlocks().

◆ computeJacobianBlocks() [2/2]

void NonlinearSystemBase::computeJacobianBlocks	(	std::vector< JacobianBlock * > &	blocks,
		const std::set< TagID > &	tags
	)

inherited

Definition at line 3327 of file NonlinearSystemBase.C.

{
  TIME_SECTION("computeJacobianBlocks", 3);
  FloatingPointExceptionGuard fpe_guard(_app);
 
  for (unsigned int i = 0; i < blocks.size(); i++)
  {
    SparseMatrix<Number> & jacobian = blocks[i]->_jacobian;
 
    LibmeshPetscCall(MatSetOption(cast_ref<PetscMatrix<Number> &>(jacobian).mat(),
                                  MAT_KEEP_NONZERO_PATTERN, // This is changed in 3.1
                                  PETSC_TRUE));
    if (!_fe_problem.errorOnJacobianNonzeroReallocation())
      LibmeshPetscCall(MatSetOption(cast_ref<PetscMatrix<Number> &>(jacobian).mat(),
                                    MAT_NEW_NONZERO_ALLOCATION_ERR,
                                    PETSC_TRUE));
 
    jacobian.zero();
  }
 
  for (unsigned int tid = 0; tid < this->numThreads(); tid++)
    _fe_problem.reinitScalars(tid);
 
  PARALLEL_TRY
  {
    const ConstElemRange & elem_range = _fe_problem.getCurrentAlgebraicElementRange();
    ComputeJacobianBlocksThread cjb(_fe_problem, blocks, tags);
    Threads::parallel_reduce(elem_range, cjb, this->numThreads());
  }
  PARALLEL_CATCH;
 
  for (unsigned int i = 0; i < blocks.size(); i++)
    blocks[i]->_jacobian.close();
 
  for (unsigned int i = 0; i < blocks.size(); i++)
  {
    libMesh::System & precond_system = blocks[i]->_precond_system;
    SparseMatrix<Number> & jacobian = blocks[i]->_jacobian;
 
    unsigned int ivar = blocks[i]->_ivar;
    unsigned int jvar = blocks[i]->_jvar;
 
    // Dirichlet BCs
    std::vector<numeric_index_type> zero_rows;
    PARALLEL_TRY
    {
      const ConstBndNodeRange & bnd_nodes = _fe_problem.getCurrentAlgebraicBndNodeRange();
      for (const auto & bnode : bnd_nodes)
      {
        BoundaryID boundary_id = bnode->_bnd_id;
        Node * node = bnode->_node;
 
        if (_nodal_bcs.hasActiveBoundaryObjects(boundary_id))
        {
          const auto & bcs = _nodal_bcs.getActiveBoundaryObjects(boundary_id);
 
          if (node->processor_id() == processor_id())
          {
            _fe_problem.reinitNodeFace(node, boundary_id, 0);
 
            for (const auto & bc : bcs)
              if (bc->variable().number() == ivar && bc->shouldApply())
              {
                // The first zero is for the variable number... there is only one variable in
                // each mini-system The second zero only works with Lagrange elements!
                zero_rows.push_back(node->dof_number(precond_system.number(), 0, 0));
              }
          }
        }
      }
    }
    PARALLEL_CATCH;
 
    jacobian.close();
 
    // This zeroes the rows corresponding to Dirichlet BCs and puts a 1.0 on the diagonal
    if (ivar == jvar)
      jacobian.zero_rows(zero_rows, 1.0);
    else
      jacobian.zero_rows(zero_rows, 0.0);
 
    jacobian.close();
  }
}

◆ computeJacobianInternal()

void NonlinearSystemBase::computeJacobianInternal ( const std::set< TagID > & tags )

protectedinherited

Form multiple matrices for all the tags.

Users should not call this func directly.

Definition at line 3023 of file NonlinearSystemBase.C.

{
  TIME_SECTION("computeJacobianInternal", 3);
 
  _fe_problem.setCurrentNonlinearSystem(number());
 
  // Make matrix ready to use
  activateAllMatrixTags();
 
  setMatrixOptions(tags);
 
  jacobianSetup();
 
  // Jacobian contributions from UOs - for now this is used for ray tracing
  // and ray kernels that contribute to the Jacobian (think line sources)
  std::vector<UserObject *> uos;
  _fe_problem.theWarehouse()
      .query()
      .condition<AttribSystem>("UserObject")
      .condition<AttribExecOns>(EXEC_PRE_KERNELS)
      .queryInto(uos);
  for (auto & uo : uos)
    uo->jacobianSetup();
  for (auto & uo : uos)
  {
    uo->initialize();
    uo->execute();
    uo->finalize();
  }
 
  // reinit scalar variables
  for (unsigned int tid = 0; tid < this->numThreads(); tid++)
    _fe_problem.reinitScalars(tid);
 
#ifdef MOOSE_KOKKOS_ENABLED
  if (_fe_problem.hasKokkosResidualObjects())
  {
    computeKokkosJacobian(tags);
    // The first Kokkos assembly preallocates the matrices for COO assembly, which recreates the
    // diagonal and off-diagonal blocks of distributed PETSc matrices and drops the options set on
    // them above
    setMatrixOptions(tags);
  }
#endif
 
  PARALLEL_TRY
  {
    // We would like to compute ScalarKernels, block NodalKernels, FVFluxKernels, and mortar objects
    // up front because we want these included whether we are computing an ordinary Jacobian or a
    // Jacobian for determining variable scaling factors
    computeScalarKernelsJacobians(tags);
 
    // Block restricted Nodal Kernels
    if (_nodal_kernels.hasActiveBlockObjects())
    {
      ComputeNodalKernelJacobiansThread cnkjt(_fe_problem, *this, _nodal_kernels, tags);
      const ConstNodeRange & range = _fe_problem.getCurrentAlgebraicNodeRange();
      Threads::parallel_reduce(range, cnkjt, this->numThreads());
 
      unsigned int n_threads = this->numThreads();
      for (unsigned int i = 0; i < n_threads;
           i++) // Add any cached jacobians that might be hanging around
        _fe_problem.assembly(i, number()).addCachedJacobian(Assembly::GlobalDataKey{});
    }
 
    using FVRange = StoredRange<MooseMesh::const_face_info_iterator, const FaceInfo *>;
    if (_fe_problem.haveFV())
    {
      // the same loop works for both residual and jacobians because it keys
      // off of FEProblem's _currently_computing_jacobian parameter
      ComputeFVFluxJacobianThread<FVRange> fvj(
          _fe_problem, this->number(), tags, /*on_displaced=*/false);
      FVRange faces(_fe_problem.mesh().ownedFaceInfoBegin(), _fe_problem.mesh().ownedFaceInfoEnd());
      Threads::parallel_reduce(faces, fvj, this->numThreads());
    }
    if (auto displaced_problem = _fe_problem.getDisplacedProblem();
        displaced_problem && displaced_problem->haveFV())
    {
      ComputeFVFluxJacobianThread<FVRange> fvr(
          _fe_problem, this->number(), tags, /*on_displaced=*/true);
      FVRange faces(displaced_problem->mesh().ownedFaceInfoBegin(),
                    displaced_problem->mesh().ownedFaceInfoEnd());
      Threads::parallel_reduce(faces, fvr, this->numThreads());
    }
 
    mortarConstraints(Moose::ComputeType::Jacobian, {}, tags);
 
    // Get our element range for looping over
    const ConstElemRange & elem_range = _fe_problem.getCurrentAlgebraicElementRange();
 
    if (_fe_problem.computingScalingJacobian())
    {
      // Only compute Jacobians corresponding to the diagonals of volumetric compute objects
      // because this typically gives us a good representation of the physics. NodalBCs and
      // Constraints can introduce dramatically different scales (often order unity).
      // IntegratedBCs and/or InterfaceKernels may use penalty factors. DGKernels may be ok, but
      // they are almost always used in conjunction with Kernels
      ComputeJacobianForScalingThread cj(_fe_problem, tags);
      Threads::parallel_reduce(elem_range, cj, this->numThreads());
      unsigned int n_threads = this->numThreads();
      for (unsigned int i = 0; i < n_threads;
           i++) // Add any Jacobian contributions still hanging around
        _fe_problem.addCachedJacobian(i);
 
      // Check whether any exceptions were thrown and propagate this information for parallel
      // consistency before
      // 1) we do parallel communication when closing tagged matrices
      // 2) early returning before reaching our PARALLEL_CATCH below
      _fe_problem.checkExceptionAndStopSolve();
 
      closeTaggedMatrices(tags);
 
      return;
    }
 
    switch (_fe_problem.coupling())
    {
      case Moose::COUPLING_DIAG:
      {
        ComputeJacobianThread cj(_fe_problem, tags);
        Threads::parallel_reduce(elem_range, cj, this->numThreads());
 
        unsigned int n_threads = this->numThreads();
        for (unsigned int i = 0; i < n_threads;
             i++) // Add any Jacobian contributions still hanging around
          _fe_problem.addCachedJacobian(i);
 
        // Boundary restricted Nodal Kernels
        if (_nodal_kernels.hasActiveBoundaryObjects())
        {
          ComputeNodalKernelBCJacobiansThread cnkjt(_fe_problem, *this, _nodal_kernels, tags);
          const ConstBndNodeRange & bnd_range = _fe_problem.getCurrentAlgebraicBndNodeRange();
 
          Threads::parallel_reduce(bnd_range, cnkjt, this->numThreads());
          unsigned int n_threads = this->numThreads();
          for (unsigned int i = 0; i < n_threads;
               i++) // Add any cached jacobians that might be hanging around
            _fe_problem.assembly(i, number()).addCachedJacobian(Assembly::GlobalDataKey{});
        }
      }
      break;
 
      default:
      case Moose::COUPLING_CUSTOM:
      {
        ComputeFullJacobianThread cj(_fe_problem, tags);
        Threads::parallel_reduce(elem_range, cj, this->numThreads());
        unsigned int n_threads = this->numThreads();
 
        for (unsigned int i = 0; i < n_threads; i++)
          _fe_problem.addCachedJacobian(i);
 
        // Boundary restricted Nodal Kernels
        if (_nodal_kernels.hasActiveBoundaryObjects())
        {
          ComputeNodalKernelBCJacobiansThread cnkjt(_fe_problem, *this, _nodal_kernels, tags);
          const ConstBndNodeRange & bnd_range = _fe_problem.getCurrentAlgebraicBndNodeRange();
 
          Threads::parallel_reduce(bnd_range, cnkjt, this->numThreads());
          unsigned int n_threads = this->numThreads();
          for (unsigned int i = 0; i < n_threads;
               i++) // Add any cached jacobians that might be hanging around
            _fe_problem.assembly(i, number()).addCachedJacobian(Assembly::GlobalDataKey{});
        }
      }
      break;
    }
 
    computeDiracContributions({}, tags, Moose::ComputeType::Jacobian);
 
    static bool first = true;
 
    // This adds zeroes into geometric coupling entries to ensure they stay in the matrix
    if ((_fe_problem.restoreOriginalNonzeroPattern() || first) &&
        _add_implicit_geometric_coupling_entries_to_jacobian)
    {
      first = false;
      addImplicitGeometricCouplingEntries(_fe_problem.geomSearchData());
 
      if (_fe_problem.getDisplacedProblem())
        addImplicitGeometricCouplingEntries(_fe_problem.getDisplacedProblem()->geomSearchData());
    }
  }
  PARALLEL_CATCH;
 
  // Have no idea how to have constraints work
  // with the tag system
  PARALLEL_TRY
  {
    // Add in Jacobian contributions from other Constraints
    if (_fe_problem._has_constraints && tags.count(systemMatrixTag()))
    {
      // Some constraints need to be able to read values from the Jacobian, which requires that it
      // be closed/assembled
      auto & system_matrix = getMatrix(systemMatrixTag());
      std::unique_ptr<SparseMatrix<Number>> hash_copy;
      const SparseMatrix<Number> * view_jac_ptr;
      auto make_readable_jacobian = [&]()
      {
#if PETSC_RELEASE_GREATER_EQUALS(3, 23, 0)
        if (system_matrix.use_hash_table())
        {
          hash_copy = cast_ref<PetscMatrix<Number> &>(system_matrix).copy_from_hash();
          view_jac_ptr = hash_copy.get();
        }
        else
          view_jac_ptr = &system_matrix;
#else
        view_jac_ptr = &system_matrix;
#endif
        if (view_jac_ptr == &system_matrix)
          system_matrix.close();
      };
 
      make_readable_jacobian();
 
      // Nodal Constraints
      const bool had_nodal_constraints = enforceNodalConstraintsJacobian(*view_jac_ptr);
      if (had_nodal_constraints)
        // We have to make a new readable Jacobian
        make_readable_jacobian();
 
      // Undisplaced Constraints
      constraintJacobians(*view_jac_ptr, false);
 
      // Displaced Constraints
      if (_fe_problem.getDisplacedProblem())
        constraintJacobians(*view_jac_ptr, true);
    }
  }
  PARALLEL_CATCH;
 
  computeNodalBCsJacobian(tags);
  closeTaggedMatrices(tags);
 
  // We need to close the save_in variables on the aux system before NodalBCBases clear the dofs
  // on boundary nodes
  if (_has_nodalbc_diag_save_in)
    _fe_problem.getAuxiliarySystem().solution().close();
 
  if (hasDiagSaveIn())
    _fe_problem.getAuxiliarySystem().update();
 
  // Accumulate the occurrence of solution invalid warnings for the current iteration cumulative
  // counters
  _app.solutionInvalidity().syncIteration();
  _app.solutionInvalidity().accumulateIterationIntoTimeStepOccurences();
}

Referenced by NonlinearSystemBase::computeJacobianTags().

◆ computeJacobianTags()

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

inherited

Computes multiple (tag associated) Jacobian matricese.

Definition at line 3296 of file NonlinearSystemBase.C.

{
  TIME_SECTION("computeJacobianTags", 5);
 
  FloatingPointExceptionGuard fpe_guard(_app);
 
  try
  {
    computeJacobianInternal(tags);
  }
  catch (MooseException & e)
  {
    // 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 NonlinearSystemBase::computeJacobian(), and FEProblemBase::computeJacobianTags().

◆ computeKokkosJacobian()

void NonlinearSystemBase::computeKokkosJacobian ( const std::set< TagID > & tags )

protectedinherited

Compute Jacobian with Kokkos objects.

Referenced by NonlinearSystemBase::computeJacobianInternal().

◆ computeKokkosNodalBCsResidual()

void NonlinearSystemBase::computeKokkosNodalBCsResidual ( const std::set< TagID > & tags )

protectedinherited

Compute Kokkos nodal BCs.

Referenced by NonlinearSystemBase::computeNodalBCsResidual(), and NonlinearSystemBase::computeNodalBCsResidualAndJacobian().

◆ computeKokkosResidual()

void NonlinearSystemBase::computeKokkosResidual ( const std::set< TagID > & tags )

protectedinherited

Compute residual with Kokkos objects.

Referenced by NonlinearSystemBase::computeResidualInternal().

◆ computeKokkosResidualAndJacobian()

void NonlinearSystemBase::computeKokkosResidualAndJacobian	(	const std::set< TagID > &	vector_tags,
		const std::set< TagID > &	matrix_tags
	)

inherited

Referenced by NonlinearSystemBase::computeResidualAndJacobianInternal().

◆ computeNodalBCsJacobian()

void NonlinearSystemBase::computeNodalBCsJacobian ( const std::set< TagID > & tags )

protectedinherited

Compute the Jacobian for nodal boundary conditions.

Definition at line 2170 of file NonlinearSystemBase.C.

{
  // We need to close the save_in variables on the aux system before NodalBCBases clear the dofs
  // on boundary nodes
  if (_has_diag_save_in)
    _fe_problem.getAuxiliarySystem().solution().close();
 
  MooseObjectWarehouse<NodalBCBase> * nbc_warehouse;
 
  // Select nodal kernels
  if (tags.size() == _fe_problem.numMatrixTags() || !tags.size())
    nbc_warehouse = &_nodal_bcs;
  else if (tags.size() == 1)
    nbc_warehouse = &(_nodal_bcs.getMatrixTagObjectWarehouse(*(tags.begin()), 0));
  else
    nbc_warehouse = &(_nodal_bcs.getMatrixTagsObjectWarehouse(tags, 0));
 
  // Return early if there is no nodal kernel
  if (!nbc_warehouse->hasActiveObjects())
    return;
 
  PARALLEL_TRY
  {
    // We may be switching from add to set. Moreover, we rely on a call to MatZeroRows to enforce
    // the nodal boundary condition constraints which requires that the matrix be truly assembled
    // as opposed to just flushed. Consequently we can't do the following despite any desire to
    // keep our initial sparsity pattern honored (see https://gitlab.com/petsc/petsc/-/issues/852)
    //
    // flushTaggedMatrices(tags);
    closeTaggedMatrices(tags);
 
    // Cache the information about which BCs are coupled to which
    // variables, so we don't have to figure it out for each node.
    std::map<std::string, std::set<unsigned int>> bc_involved_vars;
    const std::set<BoundaryID> & all_boundary_ids = _mesh.getBoundaryIDs();
    for (const auto & bid : all_boundary_ids)
    {
      // Get reference to all the NodalBCs for this ID.  This is only
      // safe if there are NodalBCBases there to be gotten...
      if (nbc_warehouse->hasActiveBoundaryObjects(bid))
      {
        const auto & bcs = nbc_warehouse->getActiveBoundaryObjects(bid);
        for (const auto & bc : bcs)
        {
          const std::vector<MooseVariableFEBase *> & coupled_moose_vars = bc->getCoupledMooseVars();
 
          // Create the set of "involved" MOOSE nonlinear vars, which includes all coupled vars
          // and the BC's own variable
          std::set<unsigned int> & var_set = bc_involved_vars[bc->name()];
          for (const auto & coupled_var : coupled_moose_vars)
            if (coupled_var->kind() == Moose::VAR_SOLVER)
              var_set.insert(coupled_var->number());
 
          var_set.insert(bc->variable().number());
        }
      }
    }
 
    // reinit scalar variables again. This reinit does not re-fill any of the scalar variable
    // solution arrays because that was done above. It only will reorder the derivative
    // information for AD calculations to be suitable for NodalBC calculations
    for (unsigned int tid = 0; tid < this->numThreads(); tid++)
      _fe_problem.reinitScalars(tid, true);
 
    // Get variable coupling list.  We do all the NodalBCBase stuff on
    // thread 0...  The couplingEntries() data structure determines
    // which variables are "coupled" as far as the preconditioner is
    // concerned, not what variables a boundary condition specifically
    // depends on.
    auto & coupling_entries = _fe_problem.couplingEntries(/*_tid=*/0, this->number());
 
    // Compute Jacobians for NodalBCBases
    const ConstBndNodeRange & bnd_nodes = _fe_problem.getCurrentAlgebraicBndNodeRange();
    for (const auto & bnode : bnd_nodes)
    {
      BoundaryID boundary_id = bnode->_bnd_id;
      Node * node = bnode->_node;
 
      if (nbc_warehouse->hasActiveBoundaryObjects(boundary_id) &&
          node->processor_id() == processor_id())
      {
        _fe_problem.reinitNodeFace(node, boundary_id, 0);
 
        const auto & bcs = nbc_warehouse->getActiveBoundaryObjects(boundary_id);
        for (const auto & bc : bcs)
        {
          // Get the set of involved MOOSE vars for this BC
          std::set<unsigned int> & var_set = bc_involved_vars[bc->name()];
 
          // Loop over all the variables whose Jacobian blocks are
          // actually being computed, call computeOffDiagJacobian()
          // for each one which is actually coupled (otherwise the
          // value is zero.)
          for (const auto & it : coupling_entries)
          {
            unsigned int ivar = it.first->number(), jvar = it.second->number();
 
            // We are only going to call computeOffDiagJacobian() if:
            // 1.) the BC's variable is ivar
            // 2.) jvar is "involved" with the BC (including jvar==ivar), and
            // 3.) the BC should apply.
            if ((bc->variable().number() == ivar) && var_set.count(jvar) && bc->shouldApply())
              bc->computeOffDiagJacobian(jvar);
          }
 
          // only if this coupling is being used by the preconditioner (otherwise the value is
          // zero)
          const auto & coupled_scalar_vars = bc->getCoupledMooseScalarVars();
          for (const auto & jvariable : coupled_scalar_vars)
            if (hasScalarVariable(jvariable->name()) &&
                _fe_problem.areCoupled(bc->variable().number(), jvariable->number(), number()))
              bc->computeOffDiagJacobianScalar(jvariable->number());
        }
      }
    } // end loop over boundary nodes
 
    // Set the cached NodalBCBase values in the Jacobian matrix
    _fe_problem.assembly(0, number()).setCachedJacobian(Assembly::GlobalDataKey{});
  }
  PARALLEL_CATCH;
}

Referenced by NonlinearSystemBase::computeJacobianInternal().

◆ computeNodalBCsResidual() [1/3]

void NonlinearSystemBase::computeNodalBCsResidual ( const std::set< TagID > & tags )

protectedinherited

Form multiple tag-associated residual vectors for the given tags.

Definition at line 2109 of file NonlinearSystemBase.C.

{
#ifdef MOOSE_KOKKOS_ENABLED
  if (_fe_problem.hasKokkosResidualObjects())
    computeKokkosNodalBCsResidual(tags);
#endif
 
  // We need to close the diag_save_in variables on the aux system before NodalBCBases clear the
  // dofs on boundary nodes
  if (_has_save_in)
    _fe_problem.getAuxiliarySystem().solution().close();
 
  // Select nodal kernels
  MooseObjectWarehouse<NodalBCBase> * nbc_warehouse;
 
  if (tags.size() == _fe_problem.numVectorTags(Moose::VECTOR_TAG_RESIDUAL) || !tags.size())
    nbc_warehouse = &_nodal_bcs;
  else if (tags.size() == 1)
    nbc_warehouse = &(_nodal_bcs.getVectorTagObjectWarehouse(*(tags.begin()), 0));
  else
    nbc_warehouse = &(_nodal_bcs.getVectorTagsObjectWarehouse(tags, 0));
 
  // Return early if there is no nodal kernel
  if (!nbc_warehouse->hasActiveObjects())
    return;
 
  PARALLEL_TRY
  {
    const ConstBndNodeRange & bnd_nodes = _fe_problem.getCurrentAlgebraicBndNodeRange();
 
    if (!bnd_nodes.empty())
    {
      TIME_SECTION("NodalBCs", 3 /*, "Computing NodalBCs"*/);
 
      for (const auto & bnode : bnd_nodes)
      {
        BoundaryID boundary_id = bnode->_bnd_id;
        Node * node = bnode->_node;
 
        if (node->processor_id() == processor_id() &&
            nbc_warehouse->hasActiveBoundaryObjects(boundary_id))
        {
          // reinit variables in nodes
          _fe_problem.reinitNodeFace(node, boundary_id, 0);
 
          const auto & bcs = nbc_warehouse->getActiveBoundaryObjects(boundary_id);
          for (const auto & nbc : bcs)
            if (nbc->shouldApply())
              nbc->computeResidual();
        }
      }
    }
  }
  PARALLEL_CATCH;
 
  if (_Re_time)
    _Re_time->close();
  _Re_non_time->close();
}

◆ computeNodalBCsResidual() [2/3]

void NonlinearSystemBase::computeNodalBCsResidual ( NumericVector< Number > & residual )

protectedinherited

Enforces nodal boundary conditions.

The boundary condition will be implemented in the residual using all the tags in the system.

Definition at line 2084 of file NonlinearSystemBase.C.

{
  _nl_vector_tags.clear();
 
  const auto & residual_vector_tags = _fe_problem.getVectorTags(Moose::VECTOR_TAG_RESIDUAL);
  for (const auto & residual_vector_tag : residual_vector_tags)
    _nl_vector_tags.insert(residual_vector_tag._id);
 
  associateVectorToTag(residual, residualVectorTag());
  computeNodalBCsResidual(residual, _nl_vector_tags);
  disassociateVectorFromTag(residual, residualVectorTag());
}

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

◆ computeNodalBCsResidual() [3/3]

void NonlinearSystemBase::computeNodalBCsResidual	(	NumericVector< Number > &	residual,
		const std::set< TagID > &	tags
	)

protectedinherited

Form a residual for BCs that at least has one of the given tags.

Definition at line 2098 of file NonlinearSystemBase.C.

{
  associateVectorToTag(residual, residualVectorTag());
 
  computeNodalBCsResidual(tags);
 
  disassociateVectorFromTag(residual, residualVectorTag());
}

◆ computeNodalBCsResidualAndJacobian()

void NonlinearSystemBase::computeNodalBCsResidualAndJacobian	(	const std::set< TagID > &	vector_tags,
		const std::set< TagID > &	matrix_tags
	)

protectedinherited

Compute the residual and Jacobian together for nodal boundary conditions.

Definition at line 2293 of file NonlinearSystemBase.C.

{
#ifdef MOOSE_KOKKOS_ENABLED
  if (_fe_problem.hasKokkosResidualObjects())
    computeKokkosNodalBCsResidual(vector_tags);
#endif
 
  // Return early if there is no nodal kernel
  if (!_nodal_bcs.hasActiveObjects())
    return;
 
  PARALLEL_TRY
  {
    const ConstBndNodeRange & bnd_nodes = _fe_problem.getCurrentAlgebraicBndNodeRange();
 
    if (!bnd_nodes.empty())
    {
      TIME_SECTION("NodalBCs", 3 /*, "Computing NodalBCs"*/);
 
      for (const auto & bnode : bnd_nodes)
      {
        BoundaryID boundary_id = bnode->_bnd_id;
        Node * node = bnode->_node;
 
        if (node->processor_id() == processor_id())
        {
          // reinit variables in nodes
          _fe_problem.reinitNodeFace(node, boundary_id, 0);
          if (_nodal_bcs.hasActiveBoundaryObjects(boundary_id))
          {
            const auto & bcs = _nodal_bcs.getActiveBoundaryObjects(boundary_id);
            for (const auto & nbc : bcs)
              if (nbc->shouldApply())
                nbc->computeResidualAndJacobian();
          }
        }
      }
    }
  }
  PARALLEL_CATCH;
 
  // Set the cached NodalBCBase values in the Jacobian matrix
  _fe_problem.assembly(0, number()).setCachedJacobian(Assembly::GlobalDataKey{});
}

Referenced by NonlinearSystemBase::computeResidualAndJacobianTags().

◆ computeResidual()

void NonlinearSystemBase::computeResidual	(	NumericVector< Number > &	residual,
		TagID	tag_id
	)

inherited

Form a residual vector for a given tag.

Definition at line 800 of file NonlinearSystemBase.C.

{
  mooseDeprecated(" Please use computeResidualTag");
 
  computeResidualTag(residual, tag_id);
}

◆ computeResidualAndJacobianInternal()

void NonlinearSystemBase::computeResidualAndJacobianInternal	(	const std::set< TagID > &	vector_tags,
		const std::set< TagID > &	matrix_tags
	)

inherited

Compute residual and Jacobian from contributions not related to constraints, such as nodal boundary conditions.

Definition at line 1969 of file NonlinearSystemBase.C.

{
  TIME_SECTION("computeResidualAndJacobianInternal", 3);
 
  // These residual objects are only computed in the separate residual/Jacobian paths. Erroring
  // here prevents them from being silently dropped, which would produce wrong answers
  if (_scalar_kernels.hasActiveObjects())
    mooseDocumentedError("moose",
                         33531,
                         "residual_and_jacobian_together does not yet support ScalarKernels. Their "
                         "contributions would be silently dropped. Please use "
                         "residual_and_jacobian_together = false");
  if (_nodal_kernels.hasActiveBlockObjects() || _nodal_kernels.hasActiveBoundaryObjects())
    mooseDocumentedError("moose",
                         33531,
                         "residual_and_jacobian_together does not yet support NodalKernels. Their "
                         "contributions would be silently dropped. Please use "
                         "residual_and_jacobian_together = false");
  if (_constraints.hasActiveNodalConstraints())
    mooseDocumentedError(
        "moose",
        33531,
        "residual_and_jacobian_together does not yet support nodal constraints. Their "
        "contributions would be silently dropped. Please use "
        "residual_and_jacobian_together = false");
 
  // Make matrix ready to use
  activateAllMatrixTags();
 
  setMatrixOptions(matrix_tags);
 
  residualSetup();
 
  // Residual contributions from UOs - for now this is used for ray tracing
  // and ray kernels that contribute to the residual (think line sources)
  std::vector<UserObject *> uos;
  _fe_problem.theWarehouse()
      .query()
      .condition<AttribSystem>("UserObject")
      .condition<AttribExecOns>(EXEC_PRE_KERNELS)
      .queryInto(uos);
  for (auto & uo : uos)
    uo->residualSetup();
  for (auto & uo : uos)
  {
    uo->initialize();
    uo->execute();
    uo->finalize();
  }
 
  // reinit scalar variables
  for (unsigned int tid = 0; tid < this->numThreads(); tid++)
    _fe_problem.reinitScalars(tid);
 
#ifdef MOOSE_KOKKOS_ENABLED
  if (_fe_problem.hasKokkosResidualObjects())
  {
    computeKokkosResidualAndJacobian(vector_tags, matrix_tags);
    // The first Kokkos assembly preallocates the matrices for COO assembly, which recreates the
    // diagonal and off-diagonal blocks of distributed PETSc matrices and drops the options set on
    // them above
    setMatrixOptions(matrix_tags);
  }
#endif
 
  // residual contributions from the domain
  PARALLEL_TRY
  {
    TIME_SECTION("Kernels", 3 /*, "Computing Kernels"*/);
 
    const ConstElemRange & elem_range = _fe_problem.getCurrentAlgebraicElementRange();
 
    ComputeResidualAndJacobianThread crj(_fe_problem, vector_tags, matrix_tags);
    Threads::parallel_reduce(elem_range, crj, this->numThreads());
 
    using FVRange = StoredRange<MooseMesh::const_face_info_iterator, const FaceInfo *>;
    if (_fe_problem.haveFV())
    {
      ComputeFVFluxRJThread<FVRange> fvrj(
          _fe_problem, this->number(), vector_tags, matrix_tags, /*on_displaced=*/false);
      FVRange faces(_fe_problem.mesh().ownedFaceInfoBegin(), _fe_problem.mesh().ownedFaceInfoEnd());
      Threads::parallel_reduce(faces, fvrj, this->numThreads());
    }
    if (auto displaced_problem = _fe_problem.getDisplacedProblem();
        displaced_problem && displaced_problem->haveFV())
    {
      ComputeFVFluxRJThread<FVRange> fvr(
          _fe_problem, this->number(), vector_tags, matrix_tags, /*on_displaced=*/true);
      FVRange faces(displaced_problem->mesh().ownedFaceInfoBegin(),
                    displaced_problem->mesh().ownedFaceInfoEnd());
      Threads::parallel_reduce(faces, fvr, this->numThreads());
    }
 
    mortarConstraints(Moose::ComputeType::ResidualAndJacobian, vector_tags, matrix_tags);
 
    unsigned int n_threads = this->numThreads();
    for (unsigned int i = 0; i < n_threads;
         i++) // Add any cached residuals that might be hanging around
    {
      _fe_problem.addCachedResidual(i);
      _fe_problem.addCachedJacobian(i);
    }
  }
  PARALLEL_CATCH;
 
  // residual and Jacobian contributions from DiracKernels, computed together in a single pass
  PARALLEL_TRY
  {
    computeDiracContributions(vector_tags, matrix_tags, Moose::ComputeType::ResidualAndJacobian);
  }
  PARALLEL_CATCH;
}

Referenced by NonlinearSystemBase::computeResidualAndJacobianTags().

◆ computeResidualAndJacobianTags()

void NonlinearSystemBase::computeResidualAndJacobianTags	(	const std::set< TagID > &	vector_tags,
		const std::set< TagID > &	matrix_tags
	)

inherited

Form possibly multiple tag-associated vectors and matrices.

Definition at line 888 of file NonlinearSystemBase.C.

{
  const bool required_residual =
      vector_tags.find(residualVectorTag()) == vector_tags.end() ? false : true;
 
  try
  {
    zeroTaggedVectors(vector_tags);
    computeResidualAndJacobianInternal(vector_tags, matrix_tags);
    closeTaggedVectors(vector_tags);
    closeTaggedMatrices(matrix_tags);
 
    if (required_residual)
    {
      auto & residual = getVector(residualVectorTag());
      if (!_time_integrators.empty())
      {
        for (auto & ti : _time_integrators)
          ti->postResidual(residual);
      }
      else
        residual += *_Re_non_time;
      residual.close();
    }
 
    computeNodalBCsResidualAndJacobian(vector_tags, matrix_tags);
    closeTaggedVectors(vector_tags);
    closeTaggedMatrices(matrix_tags);
  }
  catch (MooseException & e)
  {
    // 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::computeResidualAndJacobian().

◆ computeResidualInternal()

void NonlinearSystemBase::computeResidualInternal ( const std::set< TagID > & tags )

protectedinherited

Compute the residual for a given tag.

Parameters

tags	The tags of kernels for which the residual is to be computed.

Definition at line 1746 of file NonlinearSystemBase.C.

{
  parallel_object_only();
 
  TIME_SECTION("computeResidualInternal", 3);
 
  residualSetup();
 
  // Residual contributions from UOs - for now this is used for ray tracing
  // and ray kernels that contribute to the residual (think line sources)
  std::vector<GeneralUserObject *> uos;
  _fe_problem.theWarehouse()
      .query()
      .condition<AttribSystem>("UserObject")
      .condition<AttribExecOns>(EXEC_PRE_KERNELS)
      .queryInto(uos);
  for (auto & uo : uos)
    uo->residualSetup();
  for (auto & uo : uos)
  {
    uo->initialize();
    uo->execute();
    uo->finalize();
  }
 
  // reinit scalar variables
  for (unsigned int tid = 0; tid < this->numThreads(); tid++)
    _fe_problem.reinitScalars(tid);
 
#ifdef MOOSE_KOKKOS_ENABLED
  if (_fe_problem.hasKokkosResidualObjects())
    computeKokkosResidual(tags);
#endif
 
  // residual contributions from the domain
  PARALLEL_TRY
  {
    TIME_SECTION("Kernels", 3 /*, "Computing Kernels"*/);
 
    const ConstElemRange & elem_range = _fe_problem.getCurrentAlgebraicElementRange();
 
    ComputeResidualThread cr(_fe_problem, tags);
    Threads::parallel_reduce(elem_range, cr, this->numThreads());
 
    // We pass face information directly to FV residual objects for their evaluation. Consequently
    // we must make sure to do separate threaded loops for 1) undisplaced face information objects
    // and undisplaced residual objects and 2) displaced face information objects and displaced
    // residual objects
    using FVRange = StoredRange<MooseMesh::const_face_info_iterator, const FaceInfo *>;
    if (_fe_problem.haveFV())
    {
      ComputeFVFluxResidualThread<FVRange> fvr(
          _fe_problem, this->number(), tags, /*on_displaced=*/false);
      FVRange faces(_fe_problem.mesh().ownedFaceInfoBegin(), _fe_problem.mesh().ownedFaceInfoEnd());
      Threads::parallel_reduce(faces, fvr, this->numThreads());
    }
    if (auto displaced_problem = _fe_problem.getDisplacedProblem();
        displaced_problem && displaced_problem->haveFV())
    {
      ComputeFVFluxResidualThread<FVRange> fvr(
          _fe_problem, this->number(), tags, /*on_displaced=*/true);
      FVRange faces(displaced_problem->mesh().ownedFaceInfoBegin(),
                    displaced_problem->mesh().ownedFaceInfoEnd());
      Threads::parallel_reduce(faces, fvr, this->numThreads());
    }
 
    unsigned int n_threads = this->numThreads();
    for (unsigned int i = 0; i < n_threads;
         i++) // Add any cached residuals that might be hanging around
      _fe_problem.addCachedResidual(i);
  }
  PARALLEL_CATCH;
 
  // residual contributions from the scalar kernels
  PARALLEL_TRY
  {
    // do scalar kernels (not sure how to thread this)
    if (_scalar_kernels.hasActiveObjects())
    {
      TIME_SECTION("ScalarKernels", 3 /*, "Computing ScalarKernels"*/);
 
      MooseObjectWarehouse<ScalarKernelBase> * scalar_kernel_warehouse;
      // This code should be refactored once we can do tags for scalar
      // kernels
      // Should redo this based on Warehouse
      if (!tags.size() || tags.size() == _fe_problem.numVectorTags(Moose::VECTOR_TAG_RESIDUAL))
        scalar_kernel_warehouse = &_scalar_kernels;
      else if (tags.size() == 1)
        scalar_kernel_warehouse =
            &(_scalar_kernels.getVectorTagObjectWarehouse(*(tags.begin()), 0));
      else
        // scalar_kernels is not threading
        scalar_kernel_warehouse = &(_scalar_kernels.getVectorTagsObjectWarehouse(tags, 0));
 
      bool have_scalar_contributions = false;
      const auto & scalars = scalar_kernel_warehouse->getActiveObjects();
      for (const auto & scalar_kernel : scalars)
      {
        scalar_kernel->reinit();
        const std::vector<dof_id_type> & dof_indices = scalar_kernel->variable().dofIndices();
        const DofMap & dof_map = scalar_kernel->variable().dofMap();
        const dof_id_type first_dof = dof_map.first_dof();
        const dof_id_type end_dof = dof_map.end_dof();
        for (dof_id_type dof : dof_indices)
        {
          if (dof >= first_dof && dof < end_dof)
          {
            scalar_kernel->computeResidual();
            have_scalar_contributions = true;
            break;
          }
        }
      }
      if (have_scalar_contributions)
        _fe_problem.addResidualScalar();
    }
  }
  PARALLEL_CATCH;
 
  // residual contributions from Block NodalKernels
  PARALLEL_TRY
  {
    if (_nodal_kernels.hasActiveBlockObjects())
    {
      TIME_SECTION("NodalKernels", 3 /*, "Computing NodalKernels"*/);
 
      ComputeNodalKernelsThread cnk(_fe_problem, _nodal_kernels, tags);
 
      const ConstNodeRange & range = _fe_problem.getCurrentAlgebraicNodeRange();
 
      if (range.begin() != range.end())
      {
        _fe_problem.reinitNode(*range.begin(), 0);
 
        Threads::parallel_reduce(range, cnk, this->numThreads());
 
        unsigned int n_threads = this->numThreads();
        for (unsigned int i = 0; i < n_threads;
             i++) // Add any cached residuals that might be hanging around
          _fe_problem.addCachedResidual(i);
      }
    }
  }
  PARALLEL_CATCH;
 
  if (_fe_problem.computingScalingResidual())
    // We computed the volumetric objects. We can return now before we get into
    // any strongly enforced constraint conditions or penalty-type objects
    // (DGKernels, IntegratedBCs, InterfaceKernels, Constraints)
    return;
 
  // residual contributions from boundary NodalKernels
  PARALLEL_TRY
  {
    if (_nodal_kernels.hasActiveBoundaryObjects())
    {
      TIME_SECTION("NodalKernelBCs", 3 /*, "Computing NodalKernelBCs"*/);
 
      ComputeNodalKernelBcsThread cnk(_fe_problem, _nodal_kernels, tags);
 
      const ConstBndNodeRange & bnd_node_range = _fe_problem.getCurrentAlgebraicBndNodeRange();
 
      Threads::parallel_reduce(bnd_node_range, cnk, this->numThreads());
 
      unsigned int n_threads = this->numThreads();
      for (unsigned int i = 0; i < n_threads;
           i++) // Add any cached residuals that might be hanging around
        _fe_problem.addCachedResidual(i);
    }
  }
  PARALLEL_CATCH;
 
  mortarConstraints(Moose::ComputeType::Residual, tags, {});
 
  if (_residual_copy.get())
  {
    _Re_non_time->close();
    _Re_non_time->localize(*_residual_copy);
  }
 
  if (_need_residual_ghosted)
  {
    _Re_non_time->close();
    *_residual_ghosted = *_Re_non_time;
    _residual_ghosted->close();
  }
 
  PARALLEL_TRY { computeDiracContributions(tags, {}, Moose::ComputeType::Residual); }
  PARALLEL_CATCH;
 
  if (_fe_problem._has_constraints)
  {
    PARALLEL_TRY { enforceNodalConstraintsResidual(*_Re_non_time); }
    PARALLEL_CATCH;
    _Re_non_time->close();
  }
 
  // Add in Residual contributions from other Constraints
  if (_fe_problem._has_constraints)
  {
    PARALLEL_TRY
    {
      // Undisplaced Constraints
      constraintResiduals(*_Re_non_time, false);
 
      // Displaced Constraints
      if (_fe_problem.getDisplacedProblem())
        constraintResiduals(*_Re_non_time, true);
 
      if (_fe_problem.computingNonlinearResid())
        _constraints.residualEnd();
    }
    PARALLEL_CATCH;
    _Re_non_time->close();
  }
 
  // Accumulate the occurrence of solution invalid warnings for the current iteration cumulative
  // counters
  _app.solutionInvalidity().syncIteration();
  _app.solutionInvalidity().accumulateIterationIntoTimeStepOccurences();
}

Referenced by NonlinearSystemBase::computeResidualTags().

◆ computeResidualTag()

void NonlinearSystemBase::computeResidualTag	(	NumericVector< Number > &	residual,
		TagID	tag_id
	)

inherited

Computes residual for a given tag.

Parameters

residual	Residual is formed in here
the	tag of kernels for which the residual is to be computed.

Definition at line 786 of file NonlinearSystemBase.C.

{
  _nl_vector_tags.clear();
  _nl_vector_tags.insert(tag_id);
  _nl_vector_tags.insert(residualVectorTag());
 
  associateVectorToTag(residual, residualVectorTag());
 
  computeResidualTags(_nl_vector_tags);
 
  disassociateVectorFromTag(residual, residualVectorTag());
}

Referenced by NonlinearSystemBase::computeResidual(), and CrankNicolson::init().

◆ computeResidualTags()

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

inherited

Form multiple tag-associated residual vectors for all the given tags.

Definition at line 808 of file NonlinearSystemBase.C.

{
  parallel_object_only();
 
  TIME_SECTION("nl::computeResidualTags", 5);
 
  _fe_problem.setCurrentNonlinearSystem(number());
  _fe_problem.setCurrentlyComputingResidual(true);
 
  bool required_residual = tags.find(residualVectorTag()) == tags.end() ? false : true;
 
  _n_residual_evaluations++;
 
  // not suppose to do anythin on matrix
  deactivateAllMatrixTags();
 
  FloatingPointExceptionGuard fpe_guard(_app);
 
  for (const auto & numeric_vec : _vecs_to_zero_for_residual)
    if (hasVector(numeric_vec))
    {
      NumericVector<Number> & vec = getVector(numeric_vec);
      vec.close();
      vec.zero();
    }
 
  try
  {
    zeroTaggedVectors(tags);
    computeResidualInternal(tags);
    closeTaggedVectors(tags);
 
    if (required_residual)
    {
      auto & residual = getVector(residualVectorTag());
      if (!_time_integrators.empty())
      {
        for (auto & ti : _time_integrators)
          ti->postResidual(residual);
      }
      else
        residual += *_Re_non_time;
      residual.close();
    }
    if (_fe_problem.computingScalingResidual())
      // We don't want to do nodal bcs or anything else
      return;
 
    computeNodalBCsResidual(tags);
    closeTaggedVectors(tags);
 
    // If we are debugging residuals we need one more assignment to have the ghosted copy up to
    // date
    if (_need_residual_ghosted && _debugging_residuals && required_residual)
    {
      auto & residual = getVector(residualVectorTag());
 
      *_residual_ghosted = residual;
      _residual_ghosted->close();
    }
    // Need to close and update the aux system in case residuals were saved to it.
    if (_has_nodalbc_save_in)
      _fe_problem.getAuxiliarySystem().solution().close();
    if (hasSaveIn())
      _fe_problem.getAuxiliarySystem().update();
  }
  catch (MooseException & e)
  {
    // 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.
  }
 
  // not supposed to do anything on matrix
  activateAllMatrixTags();
 
  _fe_problem.setCurrentlyComputingResidual(false);
}

Referenced by NonlinearSystemBase::computeResidualTag(), and FEProblemBase::computeResidualTags().

◆ computeScalarKernelsJacobians()

void NonlinearSystemBase::computeScalarKernelsJacobians ( const std::set< TagID > & tags )

protectedinherited

Definition at line 2913 of file NonlinearSystemBase.C.

{
  MooseObjectWarehouse<ScalarKernelBase> * scalar_kernel_warehouse;
 
  if (!tags.size() || tags.size() == _fe_problem.numMatrixTags())
    scalar_kernel_warehouse = &_scalar_kernels;
  else if (tags.size() == 1)
    scalar_kernel_warehouse = &(_scalar_kernels.getMatrixTagObjectWarehouse(*(tags.begin()), 0));
  else
    scalar_kernel_warehouse = &(_scalar_kernels.getMatrixTagsObjectWarehouse(tags, 0));
 
  // Compute the diagonal block for scalar variables
  if (scalar_kernel_warehouse->hasActiveObjects())
  {
    const auto & scalars = scalar_kernel_warehouse->getActiveObjects();
 
    _fe_problem.reinitScalars(/*tid=*/0);
 
    _fe_problem.reinitOffDiagScalars(/*_tid*/ 0);
 
    bool have_scalar_contributions = false;
    for (const auto & kernel : scalars)
    {
      if (!kernel->computesJacobian())
        continue;
 
      kernel->reinit();
      const std::vector<dof_id_type> & dof_indices = kernel->variable().dofIndices();
      const DofMap & dof_map = kernel->variable().dofMap();
      const dof_id_type first_dof = dof_map.first_dof();
      const dof_id_type end_dof = dof_map.end_dof();
      for (dof_id_type dof : dof_indices)
      {
        if (dof >= first_dof && dof < end_dof)
        {
          kernel->computeJacobian();
          _fe_problem.addJacobianOffDiagScalar(kernel->variable().number());
          have_scalar_contributions = true;
          break;
        }
      }
    }
 
    if (have_scalar_contributions)
      _fe_problem.addJacobianScalar();
  }
}

Referenced by NonlinearSystemBase::computeJacobianInternal().

◆ computeScaling()

bool NonlinearSystemBase::computeScaling ( )

inherited

Method used to obtain scaling factors for variables.

Returns: whether this method ran without exceptions

Definition at line 4102 of file NonlinearSystemBase.C.

{
  if (_compute_scaling_once && _computed_scaling)
    return true;
 
  _console << "\nPerforming automatic scaling calculation\n" << std::endl;
 
  TIME_SECTION("computeScaling", 3, "Computing Automatic Scaling");
 
  // container for repeated access of element global dof indices
  std::vector<dof_id_type> dof_indices;
 
  if (!_auto_scaling_initd)
    setupScalingData();
 
  std::vector<Real> inverse_scaling_factors(_num_scaling_groups, 0);
  std::vector<Real> resid_inverse_scaling_factors(_num_scaling_groups, 0);
  std::vector<Real> jac_inverse_scaling_factors(_num_scaling_groups, 0);
  auto & dof_map = dofMap();
 
  // what types of scaling do we want?
  bool jac_scaling = _resid_vs_jac_scaling_param < 1. - TOLERANCE;
  bool resid_scaling = _resid_vs_jac_scaling_param > TOLERANCE;
 
  const NumericVector<Number> & scaling_residual = RHS();
 
  if (jac_scaling)
  {
    // if (!_auto_scaling_initd)
    // We need to reinit this when the number of dofs changes
    // but there is no good way to track that
    // In theory, it is the job of libmesh system to track this,
    // but this special matrix is not owned by libMesh system
    // Let us reinit eveytime since it is not expensive
    {
      auto init_vector = NumericVector<Number>::build(this->comm());
      init_vector->init(system().n_dofs(), system().n_local_dofs(), /*fast=*/false, PARALLEL);
 
      _scaling_matrix->clear();
      _scaling_matrix->init(*init_vector);
    }
 
    _fe_problem.computingScalingJacobian(true);
    // Dispatch to derived classes to ensure that we use the correct matrix tag
    computeScalingJacobian();
    _fe_problem.computingScalingJacobian(false);
  }
 
  if (resid_scaling)
  {
    _fe_problem.computingScalingResidual(true);
    _fe_problem.computingNonlinearResid(true);
    // Dispatch to derived classes to ensure that we use the correct vector tag
    computeScalingResidual();
    _fe_problem.computingNonlinearResid(false);
    _fe_problem.computingScalingResidual(false);
  }
 
  // Did something bad happen during residual/Jacobian scaling computation?
  if (_fe_problem.getFailNextNonlinearConvergenceCheck())
    return false;
 
  auto examine_dof_indices = [this,
                              jac_scaling,
                              resid_scaling,
                              &dof_map,
                              &jac_inverse_scaling_factors,
                              &resid_inverse_scaling_factors,
                              &scaling_residual](const auto & dof_indices, const auto var_number)
  {
    for (auto dof_index : dof_indices)
      if (dof_map.local_index(dof_index))
      {
        if (jac_scaling)
        {
          // For now we will use the diagonal for determining scaling
          auto mat_value = (*_scaling_matrix)(dof_index, dof_index);
          auto & factor = jac_inverse_scaling_factors[_var_to_group_var[var_number]];
          factor = std::max(factor, std::abs(mat_value));
        }
        if (resid_scaling)
        {
          auto vec_value = scaling_residual(dof_index);
          auto & factor = resid_inverse_scaling_factors[_var_to_group_var[var_number]];
          factor = std::max(factor, std::abs(vec_value));
        }
      }
  };
 
  // Compute our scaling factors for the spatial field variables
  for (const auto & elem : _fe_problem.getCurrentAlgebraicElementRange())
    for (const auto i : make_range(system().n_vars()))
      if (_variable_autoscaled[i] && system().variable_type(i).family != SCALAR)
      {
        dof_map.dof_indices(elem, dof_indices, i);
        examine_dof_indices(dof_indices, i);
      }
 
  for (const auto i : make_range(system().n_vars()))
    if (_variable_autoscaled[i] && system().variable_type(i).family == SCALAR)
    {
      dof_map.SCALAR_dof_indices(dof_indices, i);
      examine_dof_indices(dof_indices, i);
    }
 
  if (resid_scaling)
    _communicator.max(resid_inverse_scaling_factors);
  if (jac_scaling)
    _communicator.max(jac_inverse_scaling_factors);
 
  if (jac_scaling && resid_scaling)
    for (MooseIndex(inverse_scaling_factors) i = 0; i < inverse_scaling_factors.size(); ++i)
    {
      // Be careful not to take log(0)
      if (!resid_inverse_scaling_factors[i])
      {
        if (!jac_inverse_scaling_factors[i])
          inverse_scaling_factors[i] = 1;
        else
          inverse_scaling_factors[i] = jac_inverse_scaling_factors[i];
      }
      else if (!jac_inverse_scaling_factors[i])
        // We know the resid is not zero
        inverse_scaling_factors[i] = resid_inverse_scaling_factors[i];
      else
        inverse_scaling_factors[i] =
            std::exp(_resid_vs_jac_scaling_param * std::log(resid_inverse_scaling_factors[i]) +
                     (1 - _resid_vs_jac_scaling_param) * std::log(jac_inverse_scaling_factors[i]));
    }
  else if (jac_scaling)
    inverse_scaling_factors = jac_inverse_scaling_factors;
  else if (resid_scaling)
    inverse_scaling_factors = resid_inverse_scaling_factors;
  else
    mooseError("We shouldn't be calling this routine if we're not performing any scaling");
 
  // We have to make sure that our scaling values are not zero
  for (auto & scaling_factor : inverse_scaling_factors)
    if (scaling_factor == 0)
      scaling_factor = 1;
 
  // Now flatten the group scaling factors to the individual variable scaling factors
  std::vector<Real> flattened_inverse_scaling_factors(system().n_vars());
  for (const auto i : index_range(flattened_inverse_scaling_factors))
    flattened_inverse_scaling_factors[i] = inverse_scaling_factors[_var_to_group_var[i]];
 
  // Now set the scaling factors for the variables
  applyScalingFactors(flattened_inverse_scaling_factors);
  if (auto displaced_problem = _fe_problem.getDisplacedProblem().get())
    displaced_problem->systemBaseNonlinear(number()).applyScalingFactors(
        flattened_inverse_scaling_factors);
 
  _computed_scaling = true;
  return true;
}

Referenced by NonlinearSystemBase::preSolve().

◆ computeScalingJacobian()

void NonlinearSystem::computeScalingJacobian ( )

overrideprotectedvirtual

Compute a "Jacobian" for automatic scaling purposes.

Implements NonlinearSystemBase.

Definition at line 359 of file NonlinearSystem.C.

{
#ifdef MOOSE_KOKKOS_ENABLED
  // The Kokkos assembler writes Jacobian contributions directly into the underlying PETSc
  // Mat (see Moose::Kokkos::Matrix::create), which requires the matrix to be a
  // PetscMatrix rather than the DiagonalMatrix/LumpedMassMatrix used to store scaling
  // factors.
  if (_fe_problem.hasKokkosResidualObjects())
  {
    // Assemble the Jacobian into the system libMesh matrix, which is a PetscMatrix, so that the
    // Kokkos kernels can write directly into its Mat.
    auto & jacobian = _nl_implicit_sys.get_system_matrix();
    _fe_problem.computeJacobianSys(_nl_implicit_sys, *_current_solution, jacobian);
 
    auto & petsc_matrix = cast_ref<PetscMatrix<Number> &>(jacobian);
 
    // Create the Petsc reduction vector with the layout of the matrix so that extracting the
    // reduction values matches the matrix's vector type on device or host.
    Vec scaling_vec = nullptr;
    LibmeshPetscCall(MatCreateVecs(petsc_matrix.mat(), nullptr, &scaling_vec));
 
    {
      libMesh::PetscVector<Number> scaling_vector(scaling_vec, this->comm());
 
      // For off-diagonal scaling, sum the absolute values of the assembled matrix entries.
      // The host LumpedMassMatrix instead takes the absolute value of each element contribution
      // before assembling it. The results differ if contributions from local element matrices to
      // the same global matrix entry cancel because they have opposite signs. MatGetDiagonal runs
      // on the device for Kokkos matrices, but MatGetRowSumAbs currently synchronizes the matrix
      // data to the host.
      if (_off_diagonals_in_auto_scaling)
        LibmeshPetscCall(MatGetRowSumAbs(petsc_matrix.mat(), scaling_vec));
      else
        LibmeshPetscCall(MatGetDiagonal(petsc_matrix.mat(), scaling_vec));
 
      *_scaling_matrix = scaling_vector;
      _scaling_matrix->close();
    }
 
    LibmeshPetscCall(VecDestroy(&scaling_vec));
    return;
  }
#endif
 
  _fe_problem.computeJacobianSys(_nl_implicit_sys, *_current_solution, *_scaling_matrix);
}

◆ computeScalingOnce() [1/2]

bool NonlinearSystemBase::computeScalingOnce ( ) const

inlineinherited

Definition at line 720 of file NonlinearSystemBase.h.

720{ return _compute_scaling_once; }

◆ computeScalingOnce() [2/2]

void NonlinearSystemBase::computeScalingOnce ( bool compute_scaling_once )

inlineinherited

Definition at line 721 of file NonlinearSystemBase.h.

  {
    _compute_scaling_once = compute_scaling_once;
  }

◆ computeScalingResidual()

void NonlinearSystem::computeScalingResidual ( )

overrideprotectedvirtual

Compute a "residual" for automatic scaling purposes.

Implements NonlinearSystemBase.

Definition at line 407 of file NonlinearSystem.C.

{
  _fe_problem.computeResidualSys(_nl_implicit_sys, *_current_solution, RHS());
}

◆ computeVariables()

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

inlinevirtualinherited

Definition at line 902 of file SystemBase.h.

902{}

◆ computingPreSMOResidual()

bool NonlinearSystemBase::computingPreSMOResidual ( )

inlineinherited

Returns true if this system is currently computing the pre-SMO residual for a solve.

Returns: Whether or not we are currently computing the pre-SMO residual.

Definition at line 98 of file NonlinearSystemBase.h.

98{ return _computing_pre_smo_residual; }

NonlinearSystemBase::_computing_pre_smo_residual

bool _computing_pre_smo_residual

Definition NonlinearSystemBase.h:1036

◆ computingScalingJacobian()

bool SystemBase::computingScalingJacobian ( ) const

inherited

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

Definition at line 1582 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().

◆ constraintJacobians()

void NonlinearSystemBase::constraintJacobians	(	const SparseMatrix< Number > &	jacobian_to_view,
		bool	displaced
	)

inherited

Add jacobian contributions from Constraints.

Parameters

jacobian	reference to a read-only view of the Jacobian matrix
displaced	Controls whether to do the displaced Constraints or non-displaced

Definition at line 2487 of file NonlinearSystemBase.C.

{
  if (!hasMatrix(systemMatrixTag()))
    mooseError("A system matrix is required");
 
  auto & jacobian = getMatrix(systemMatrixTag());
 
  if (!_fe_problem.errorOnJacobianNonzeroReallocation())
    LibmeshPetscCall(MatSetOption(cast_ref<PetscMatrix<Number> &>(jacobian).mat(),
                                  MAT_NEW_NONZERO_ALLOCATION_ERR,
                                  PETSC_FALSE));
  if (_fe_problem.ignoreZerosInJacobian())
    LibmeshPetscCall(MatSetOption(
        cast_ref<PetscMatrix<Number> &>(jacobian).mat(), MAT_IGNORE_ZERO_ENTRIES, PETSC_TRUE));
 
  std::vector<numeric_index_type> zero_rows;
 
  if (displaced)
    mooseAssert(_fe_problem.getDisplacedProblem(),
                "If we're calling this method with displaced = true, then we better well have a "
                "displaced problem");
  auto & subproblem = displaced ? cast_ref<SubProblem &>(*_fe_problem.getDisplacedProblem())
                                : cast_ref<SubProblem &>(_fe_problem);
  const auto & penetration_locators = subproblem.geomSearchData()._penetration_locators;
 
  bool constraints_applied;
  if (!_assemble_constraints_separately)
    constraints_applied = false;
  for (const auto & it : penetration_locators)
  {
    if (_assemble_constraints_separately)
    {
      // Reset the constraint_applied flag before each new constraint, as they need to be
      // assembled separately
      constraints_applied = false;
    }
    PenetrationLocator & pen_loc = *(it.second);
 
    std::vector<dof_id_type> & secondary_nodes = pen_loc._nearest_node._secondary_nodes;
 
    BoundaryID secondary_boundary = pen_loc._secondary_boundary;
    BoundaryID primary_boundary = pen_loc._primary_boundary;
 
    zero_rows.clear();
    if (_constraints.hasActiveNodeFaceConstraints(secondary_boundary, displaced))
    {
      const auto & constraints =
          _constraints.getActiveNodeFaceConstraints(secondary_boundary, displaced);
 
      for (const auto & secondary_node_num : secondary_nodes)
      {
        Node & secondary_node = _mesh.nodeRef(secondary_node_num);
 
        if (secondary_node.processor_id() == processor_id())
        {
          if (pen_loc._penetration_info[secondary_node_num])
          {
            PenetrationInfo & info = *pen_loc._penetration_info[secondary_node_num];
 
            reinitNodeFace(secondary_node, secondary_boundary, info, displaced);
            _fe_problem.reinitOffDiagScalars(0);
 
            for (const auto & nfc : constraints)
            {
              if (nfc->isExplicitConstraint())
                continue;
              // Return if this constraint does not correspond to the primary-secondary pair
              // prepared by the outer loops.
              // This continue statement is required when, e.g. one secondary surface constrains
              // more than one primary surface.
              if (nfc->secondaryBoundary() != secondary_boundary ||
                  nfc->primaryBoundary() != primary_boundary)
                continue;
 
              nfc->_jacobian = &jacobian_to_view;
 
              if (nfc->shouldApply())
              {
                constraints_applied = true;
 
                // Begin the diagonal node-face constraint accumulation phase for neighbor Jacobian
                // blocks.
                _fe_problem.prepareAssemblyNeighbor(0);
 
                nfc->prepareShapes(nfc->variable().number());
                nfc->prepareNeighborShapes(nfc->variable().number());
 
                nfc->computeJacobian();
 
                if (nfc->overwriteSecondaryJacobian())
                {
                  // Add this variable's dof's row to be zeroed
                  zero_rows.push_back(nfc->variable().nodalDofIndex());
                }
 
                std::vector<dof_id_type> secondary_dofs(1, nfc->variable().nodalDofIndex());
 
                // Assume that if the user is overwriting the secondary Jacobian, then they are
                // supplying Jacobians that do not correspond to their other physics
                // (e.g. Kernels), hence we should not apply a scalingFactor that is normally
                // based on the order of their other physics (e.g. Kernels)
                Real scaling_factor =
                    nfc->overwriteSecondaryJacobian() ? 1. : nfc->variable().scalingFactor();
 
                // Cache the jacobian block for the secondary side
                nfc->addJacobian(_fe_problem.assembly(0, number()),
                                 nfc->_Kee,
                                 secondary_dofs,
                                 nfc->_connected_dof_indices,
                                 scaling_factor);
 
                // Cache Ken, Kne, Knn
                if (nfc->addCouplingEntriesToJacobian())
                {
                  // Make sure we use a proper scaling factor (e.g. don't use an interior scaling
                  // factor when we're overwriting secondary stuff)
                  nfc->addJacobian(_fe_problem.assembly(0, number()),
                                   nfc->_Ken,
                                   secondary_dofs,
                                   nfc->primaryVariable().dofIndicesNeighbor(),
                                   scaling_factor);
 
                  // Use _connected_dof_indices to get all the correct columns
                  nfc->addJacobian(_fe_problem.assembly(0, number()),
                                   nfc->_Kne,
                                   nfc->primaryVariable().dofIndicesNeighbor(),
                                   nfc->_connected_dof_indices,
                                   nfc->primaryVariable().scalingFactor());
 
                  // We've handled Ken and Kne, finally handle Knn
                  _fe_problem.cacheJacobianNeighbor(0);
                }
 
                // Do the off-diagonals next
                const std::vector<MooseVariableFEBase *> coupled_vars = nfc->getCoupledMooseVars();
                for (const auto & jvar : coupled_vars)
                {
                  // Only compute jacobians for nonlinear variables
                  if (jvar->kind() != Moose::VAR_SOLVER)
                    continue;
 
                  // Only compute Jacobian entries if this coupling is being used by the
                  // preconditioner
                  if (nfc->variable().number() == jvar->number() ||
                      !_fe_problem.areCoupled(
                          nfc->variable().number(), jvar->number(), this->number()))
                    continue;
 
                  // Begin the off-diagonal node-face constraint accumulation phase for
                  // element and neighbor Jacobian blocks.
                  _fe_problem.prepareAssembly(0);
                  _fe_problem.prepareAssemblyNeighbor(0);
 
                  nfc->prepareShapes(nfc->variable().number());
                  nfc->prepareNeighborShapes(jvar->number());
 
                  nfc->computeOffDiagJacobian(jvar->number());
 
                  // Cache the jacobian block for the secondary side
                  nfc->addJacobian(_fe_problem.assembly(0, number()),
                                   nfc->_Kee,
                                   secondary_dofs,
                                   nfc->_connected_dof_indices,
                                   scaling_factor);
 
                  // Cache Ken, Kne, Knn
                  if (nfc->addCouplingEntriesToJacobian())
                  {
                    // Make sure we use a proper scaling factor (e.g. don't use an interior scaling
                    // factor when we're overwriting secondary stuff)
                    nfc->addJacobian(_fe_problem.assembly(0, number()),
                                     nfc->_Ken,
                                     secondary_dofs,
                                     jvar->dofIndicesNeighbor(),
                                     scaling_factor);
 
                    // Use _connected_dof_indices to get all the correct columns
                    nfc->addJacobian(_fe_problem.assembly(0, number()),
                                     nfc->_Kne,
                                     nfc->variable().dofIndicesNeighbor(),
                                     nfc->_connected_dof_indices,
                                     nfc->variable().scalingFactor());
 
                    // We've handled Ken and Kne, finally handle Knn
                    _fe_problem.cacheJacobianNeighbor(0);
                  }
                }
              }
            }
          }
        }
      }
    }
    if (_assemble_constraints_separately)
    {
      // See if constraints were applied anywhere
      _communicator.max(constraints_applied);
 
      if (constraints_applied)
      {
        LibmeshPetscCall(MatSetOption(cast_ref<PetscMatrix<Number> &>(jacobian).mat(),
                                      MAT_KEEP_NONZERO_PATTERN, // This is changed in 3.1
                                      PETSC_TRUE));
 
        jacobian.close();
        jacobian.zero_rows(zero_rows, 0.0);
        jacobian.close();
        _fe_problem.addCachedJacobian(0);
        jacobian.close();
      }
    }
  }
  if (!_assemble_constraints_separately)
  {
    // See if constraints were applied anywhere
    _communicator.max(constraints_applied);
 
    if (constraints_applied)
    {
      LibmeshPetscCall(MatSetOption(cast_ref<PetscMatrix<Number> &>(jacobian).mat(),
                                    MAT_KEEP_NONZERO_PATTERN, // This is changed in 3.1
                                    PETSC_TRUE));
 
      jacobian.close();
      jacobian.zero_rows(zero_rows, 0.0);
      jacobian.close();
      _fe_problem.addCachedJacobian(0);
      jacobian.close();
    }
  }
 
  THREAD_ID tid = 0;
  // go over element-element constraint interface
  const auto & element_pair_locators = subproblem.geomSearchData()._element_pair_locators;
  for (const auto & it : element_pair_locators)
  {
    ElementPairLocator & elem_pair_loc = *(it.second);
 
    if (_constraints.hasActiveElemElemConstraints(it.first, displaced))
    {
      // ElemElemConstraint objects
      const auto & element_constraints =
          _constraints.getActiveElemElemConstraints(it.first, displaced);
 
      // go over pair elements
      const std::list<std::pair<const Elem *, const Elem *>> & elem_pairs =
          elem_pair_loc.getElemPairs();
      for (const auto & pr : elem_pairs)
      {
        const Elem * elem1 = pr.first;
        const Elem * elem2 = pr.second;
 
        if (elem1->processor_id() != processor_id())
          continue;
 
        const ElementPairInfo & info = elem_pair_loc.getElemPairInfo(pr);
 
        // for each element process constraints on the
        for (const auto & ec : element_constraints)
        {
          _fe_problem.setCurrentSubdomainID(elem1, tid);
          subproblem.reinitElemPhys(elem1, info._elem1_constraint_q_point, tid);
          _fe_problem.setNeighborSubdomainID(elem2, tid);
          subproblem.reinitNeighborPhys(elem2, info._elem2_constraint_q_point, tid);
 
          // Begin the element-element constraint accumulation phase for element and neighbor
          // Jacobian blocks.
          _fe_problem.prepareAssembly(tid);
          _fe_problem.prepareAssemblyNeighbor(tid);
 
          ec->prepareShapes(ec->variable().number());
          ec->prepareNeighborShapes(ec->variable().number());
 
          ec->reinit(info);
          ec->computeJacobian();
          _fe_problem.cacheJacobian(tid);
          _fe_problem.cacheJacobianNeighbor(tid);
        }
        _fe_problem.addCachedJacobian(tid);
      }
    }
  }
 
  // go over NodeElemConstraints
  std::set<dof_id_type> unique_secondary_node_ids;
  constraints_applied = false;
  for (const auto & secondary_id : _mesh.meshSubdomains())
  {
    for (const auto & primary_id : _mesh.meshSubdomains())
    {
      if (_constraints.hasActiveNodeElemConstraints(secondary_id, primary_id, displaced))
      {
        const auto & constraints =
            _constraints.getActiveNodeElemConstraints(secondary_id, primary_id, displaced);
 
        // get unique set of ids of all nodes on current block
        unique_secondary_node_ids.clear();
        const MeshBase & meshhelper = _mesh.getMesh();
        for (const auto & elem : as_range(meshhelper.active_subdomain_elements_begin(secondary_id),
                                          meshhelper.active_subdomain_elements_end(secondary_id)))
        {
          for (auto & n : elem->node_ref_range())
            unique_secondary_node_ids.insert(n.id());
        }
 
        for (auto secondary_node_id : unique_secondary_node_ids)
        {
          const Node & secondary_node = _mesh.nodeRef(secondary_node_id);
          // check if secondary node is on current processor
          if (secondary_node.processor_id() == processor_id())
          {
            // This reinits the variables that exist on the secondary node
            _fe_problem.reinitNodeFace(&secondary_node, secondary_id, 0);
 
            _fe_problem.reinitOffDiagScalars(0);
 
            for (const auto & nec : constraints)
            {
              if (nec->shouldApply())
              {
                constraints_applied = true;
 
                // Begin the diagonal node-element constraint accumulation phase for
                // element and neighbor Jacobian blocks.
                _fe_problem.prepareAssembly(0);
                _fe_problem.prepareAssemblyNeighbor(0);
 
                nec->_jacobian = &jacobian_to_view;
                nec->prepareShapes(nec->variable().number());
                nec->prepareNeighborShapes(nec->variable().number());
 
                nec->computeJacobian();
 
                if (nec->overwriteSecondaryJacobian())
                {
                  // Add this variable's dof's row to be zeroed
                  zero_rows.push_back(nec->variable().nodalDofIndex());
                }
 
                std::vector<dof_id_type> secondary_dofs(1, nec->variable().nodalDofIndex());
 
                // Cache the jacobian block for the secondary side
                nec->addJacobian(_fe_problem.assembly(0, number()),
                                 nec->_Kee,
                                 secondary_dofs,
                                 nec->_connected_dof_indices,
                                 nec->variable().scalingFactor());
 
                // Cache the jacobian block for the primary side
                nec->addJacobian(_fe_problem.assembly(0, number()),
                                 nec->_Kne,
                                 nec->primaryVariable().dofIndicesNeighbor(),
                                 nec->_connected_dof_indices,
                                 nec->primaryVariable().scalingFactor());
 
                _fe_problem.cacheJacobian(0);
                _fe_problem.cacheJacobianNeighbor(0);
 
                // Do the off-diagonals next
                const std::vector<MooseVariableFEBase *> coupled_vars = nec->getCoupledMooseVars();
                for (const auto & jvar : coupled_vars)
                {
                  // Only compute jacobians for nonlinear variables
                  if (jvar->kind() != Moose::VAR_SOLVER)
                    continue;
 
                  // Only compute Jacobian entries if this coupling is being used by the
                  // preconditioner
                  if (nec->variable().number() == jvar->number() ||
                      !_fe_problem.areCoupled(
                          nec->variable().number(), jvar->number(), this->number()))
                    continue;
 
                  // Begin the off-diagonal node-element constraint accumulation phase for
                  // element and neighbor Jacobian blocks.
                  _fe_problem.prepareAssembly(0);
                  _fe_problem.prepareAssemblyNeighbor(0);
 
                  nec->prepareShapes(nec->variable().number());
                  nec->prepareNeighborShapes(jvar->number());
 
                  nec->computeOffDiagJacobian(jvar->number());
 
                  // Cache the jacobian block for the secondary side
                  nec->addJacobian(_fe_problem.assembly(0, number()),
                                   nec->_Kee,
                                   secondary_dofs,
                                   nec->_connected_dof_indices,
                                   nec->variable().scalingFactor());
 
                  // Cache the jacobian block for the primary side
                  nec->addJacobian(_fe_problem.assembly(0, number()),
                                   nec->_Kne,
                                   nec->variable().dofIndicesNeighbor(),
                                   nec->_connected_dof_indices,
                                   nec->variable().scalingFactor());
 
                  _fe_problem.cacheJacobian(0);
                  _fe_problem.cacheJacobianNeighbor(0);
                }
              }
            }
          }
        }
      }
    }
  }
  // See if constraints were applied anywhere
  _communicator.max(constraints_applied);
 
  if (constraints_applied)
  {
    LibmeshPetscCall(MatSetOption(cast_ref<PetscMatrix<Number> &>(jacobian).mat(),
                                  MAT_KEEP_NONZERO_PATTERN, // This is changed in 3.1
                                  PETSC_TRUE));
 
    jacobian.close();
    jacobian.zero_rows(zero_rows, 0.0);
    jacobian.close();
    _fe_problem.addCachedJacobian(0);
    jacobian.close();
  }
}

Referenced by NonlinearSystemBase::computeJacobianInternal().

◆ constraintResiduals()

void NonlinearSystemBase::constraintResiduals	(	NumericVector< Number > &	residual,
		bool	displaced
	)

inherited

Add residual contributions from Constraints.

Parameters

residual	- reference to the residual vector where constraint contributions will be computed
displaced	Controls whether to do the displaced Constraints or non-displaced

Definition at line 1343 of file NonlinearSystemBase.C.

{
  // Make sure the residual is in a good state
  residual.close();
 
  if (displaced)
    mooseAssert(_fe_problem.getDisplacedProblem(),
                "If we're calling this method with displaced = true, then we better well have a "
                "displaced problem");
  auto & subproblem = displaced ? cast_ref<SubProblem &>(*_fe_problem.getDisplacedProblem())
                                : cast_ref<SubProblem &>(_fe_problem);
  const auto & penetration_locators = subproblem.geomSearchData()._penetration_locators;
 
  bool constraints_applied;
  bool residual_has_inserted_values = false;
  if (!_assemble_constraints_separately)
    constraints_applied = false;
  for (const auto & it : penetration_locators)
  {
    if (_assemble_constraints_separately)
    {
      // Reset the constraint_applied flag before each new constraint, as they need to be
      // assembled separately
      constraints_applied = false;
    }
    PenetrationLocator & pen_loc = *(it.second);
 
    std::vector<dof_id_type> & secondary_nodes = pen_loc._nearest_node._secondary_nodes;
 
    BoundaryID secondary_boundary = pen_loc._secondary_boundary;
    BoundaryID primary_boundary = pen_loc._primary_boundary;
 
    bool has_writable_variables(false);
 
    if (_constraints.hasActiveNodeFaceConstraints(secondary_boundary, displaced))
    {
      const auto & constraints =
          _constraints.getActiveNodeFaceConstraints(secondary_boundary, displaced);
 
      for (unsigned int i = 0; i < secondary_nodes.size(); i++)
      {
        dof_id_type secondary_node_num = secondary_nodes[i];
        Node & secondary_node = _mesh.nodeRef(secondary_node_num);
 
        if (secondary_node.processor_id() == processor_id())
        {
          if (pen_loc._penetration_info[secondary_node_num])
          {
            PenetrationInfo & info = *pen_loc._penetration_info[secondary_node_num];
 
            reinitNodeFace(secondary_node, secondary_boundary, info, displaced);
 
            for (const auto & nfc : constraints)
            {
              // Return if this constraint does not correspond to the primary-secondary pair
              // prepared by the outer loops.
              // This continue statement is required when, e.g. one secondary surface constrains
              // more than one primary surface.
              if (nfc->secondaryBoundary() != secondary_boundary ||
                  nfc->primaryBoundary() != primary_boundary)
                continue;
 
              if (nfc->shouldApply())
              {
                constraints_applied = true;
                nfc->computeResidual();
 
                if (nfc->overwriteSecondaryResidual())
                {
                  // The below will actually overwrite the residual for every single dof that
                  // lives on the node. We definitely don't want to do that!
                  // _fe_problem.setResidual(residual, 0);
 
                  const auto & secondary_var = nfc->variable();
                  const auto & secondary_dofs = secondary_var.dofIndices();
                  mooseAssert(secondary_dofs.size() == secondary_var.count(),
                              "We are on a node so there should only be one dof per variable (for "
                              "an ArrayVariable we should have a number of dofs equal to the "
                              "number of components");
 
                  // Assume that if the user is overwriting the secondary residual, then they are
                  // supplying residuals that do not correspond to their other physics
                  // (e.g. Kernels), hence we should not apply a scalingFactor that is normally
                  // based on the order of their other physics (e.g. Kernels)
                  std::vector<Number> values = {nfc->secondaryResidual()};
                  residual.insert(values, secondary_dofs);
                  residual_has_inserted_values = true;
                }
                else
                  _fe_problem.cacheResidual(0);
                _fe_problem.cacheResidualNeighbor(0);
              }
              if (nfc->hasWritableCoupledVariables())
              {
                Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
                has_writable_variables = true;
                for (auto * var : nfc->getWritableCoupledVariables())
                {
                  if (var->isNodalDefined())
                    var->insert(_fe_problem.getAuxiliarySystem().solution());
                }
              }
            }
          }
        }
      }
    }
    _communicator.max(has_writable_variables);
 
    if (has_writable_variables)
    {
      // Explicit contact dynamic constraints write to auxiliary variables and update the old
      // displacement solution on the constraint boundaries. Close solutions and update system
      // accordingly.
      _fe_problem.getAuxiliarySystem().solution().close();
      _fe_problem.getAuxiliarySystem().system().update();
      solutionOld().close();
    }
 
    if (_assemble_constraints_separately)
    {
      // Make sure that secondary contribution to primary are assembled, and ghosts have been
      // exchanged, as current primaries might become secondaries on next iteration and will need to
      // contribute their former secondaries' contributions to the future primaries. See if
      // constraints were applied anywhere
      _communicator.max(constraints_applied);
 
      if (constraints_applied)
      {
        // If any of the above constraints inserted values in the residual, it needs to be
        // assembled before adding the cached residuals below.
        _communicator.max(residual_has_inserted_values);
        if (residual_has_inserted_values)
        {
          residual.close();
          residual_has_inserted_values = false;
        }
        _fe_problem.addCachedResidualDirectly(residual, 0);
        residual.close();
 
        if (_need_residual_ghosted)
          *_residual_ghosted = residual;
      }
    }
  }
  if (!_assemble_constraints_separately)
  {
    _communicator.max(constraints_applied);
 
    if (constraints_applied)
    {
      // If any of the above constraints inserted values in the residual, it needs to be assembled
      // before adding the cached residuals below.
      _communicator.max(residual_has_inserted_values);
      if (residual_has_inserted_values)
        residual.close();
 
      _fe_problem.addCachedResidualDirectly(residual, 0);
      residual.close();
 
      if (_need_residual_ghosted)
        *_residual_ghosted = residual;
    }
  }
 
  // go over element-element constraint interface
  THREAD_ID tid = 0;
  const auto & element_pair_locators = subproblem.geomSearchData()._element_pair_locators;
  for (const auto & it : element_pair_locators)
  {
    ElementPairLocator & elem_pair_loc = *(it.second);
 
    if (_constraints.hasActiveElemElemConstraints(it.first, displaced))
    {
      // ElemElemConstraint objects
      const auto & element_constraints =
          _constraints.getActiveElemElemConstraints(it.first, displaced);
 
      // go over pair elements
      const std::list<std::pair<const Elem *, const Elem *>> & elem_pairs =
          elem_pair_loc.getElemPairs();
      for (const auto & pr : elem_pairs)
      {
        const Elem * elem1 = pr.first;
        const Elem * elem2 = pr.second;
 
        if (elem1->processor_id() != processor_id())
          continue;
 
        const ElementPairInfo & info = elem_pair_loc.getElemPairInfo(pr);
 
        // for each element process constraints on the
        for (const auto & ec : element_constraints)
        {
          _fe_problem.setCurrentSubdomainID(elem1, tid);
          subproblem.reinitElemPhys(elem1, info._elem1_constraint_q_point, tid);
          _fe_problem.setNeighborSubdomainID(elem2, tid);
          subproblem.reinitNeighborPhys(elem2, info._elem2_constraint_q_point, tid);
 
          ec->prepareShapes(ec->variable().number());
          ec->prepareNeighborShapes(ec->variable().number());
 
          ec->reinit(info);
          ec->computeResidual();
          _fe_problem.cacheResidual(tid);
          _fe_problem.cacheResidualNeighbor(tid);
        }
        _fe_problem.addCachedResidual(tid);
      }
    }
  }
 
  // go over NodeElemConstraints
  std::set<dof_id_type> unique_secondary_node_ids;
 
  constraints_applied = false;
  residual_has_inserted_values = false;
  bool has_writable_variables = false;
  for (const auto & secondary_id : _mesh.meshSubdomains())
  {
    for (const auto & primary_id : _mesh.meshSubdomains())
    {
      if (_constraints.hasActiveNodeElemConstraints(secondary_id, primary_id, displaced))
      {
        const auto & constraints =
            _constraints.getActiveNodeElemConstraints(secondary_id, primary_id, displaced);
 
        // get unique set of ids of all nodes on current block
        unique_secondary_node_ids.clear();
        const MeshBase & meshhelper = _mesh.getMesh();
        for (const auto & elem : as_range(meshhelper.active_subdomain_elements_begin(secondary_id),
                                          meshhelper.active_subdomain_elements_end(secondary_id)))
        {
          for (auto & n : elem->node_ref_range())
            unique_secondary_node_ids.insert(n.id());
        }
 
        for (auto secondary_node_id : unique_secondary_node_ids)
        {
          Node & secondary_node = _mesh.nodeRef(secondary_node_id);
          // check if secondary node is on current processor
          if (secondary_node.processor_id() == processor_id())
          {
            // This reinits the variables that exist on the secondary node
            _fe_problem.reinitNodeFace(&secondary_node, secondary_id, 0);
 
            // This will set aside residual and jacobian space for the variables that have dofs
            // on the secondary node
            _fe_problem.prepareAssembly(0);
 
            for (const auto & nec : constraints)
            {
              if (nec->shouldApply())
              {
                constraints_applied = true;
                nec->computeResidual();
 
                if (nec->overwriteSecondaryResidual())
                {
                  _fe_problem.setResidual(residual, 0);
                  residual_has_inserted_values = true;
                }
                else
                  _fe_problem.cacheResidual(0);
                _fe_problem.cacheResidualNeighbor(0);
              }
              if (nec->hasWritableCoupledVariables())
              {
                Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
                has_writable_variables = true;
                for (auto * var : nec->getWritableCoupledVariables())
                {
                  if (var->isNodalDefined())
                    var->insert(_fe_problem.getAuxiliarySystem().solution());
                }
              }
            }
            _fe_problem.addCachedResidual(0);
          }
        }
      }
    }
  }
  _communicator.max(constraints_applied);
 
  if (constraints_applied)
  {
    // If any of the above constraints inserted values in the residual, it needs to be assembled
    // before adding the cached residuals below.
    _communicator.max(residual_has_inserted_values);
    if (residual_has_inserted_values)
      residual.close();
 
    _fe_problem.addCachedResidualDirectly(residual, 0);
    residual.close();
 
    if (_need_residual_ghosted)
      *_residual_ghosted = residual;
  }
  _communicator.max(has_writable_variables);
 
  if (has_writable_variables)
  {
    // Explicit contact dynamic constraints write to auxiliary variables and update the old
    // displacement solution on the constraint boundaries. Close solutions and update system
    // accordingly.
    _fe_problem.getAuxiliarySystem().solution().close();
    _fe_problem.getAuxiliarySystem().system().update();
    solutionOld().close();
  }
 
  // We may have additional tagged vectors that also need to be accumulated
  _fe_problem.addCachedResidual(0);
}

Referenced by NonlinearSystemBase::computeResidualInternal().

◆ containsTimeKernel()

bool NonlinearSystemBase::containsTimeKernel ( )

overridevirtualinherited

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

Implements SolverSystem.

Definition at line 3920 of file NonlinearSystemBase.C.

{
  auto & time_kernels = _kernels.getVectorTagObjectWarehouse(timeVectorTag(), 0);
 
  return time_kernels.hasActiveObjects();
}

Referenced by EigenExecutionerBase::checkIntegrity(), and Eigenvalue::checkIntegrity().

◆ converged()

bool NonlinearSystem::converged ( )

overridevirtual

Returns the convergence state.

Returns: true if converged, otherwise false

Implements SolverSystem.

Definition at line 336 of file NonlinearSystem.C.

{
  if (_fe_problem.hasException() || _fe_problem.getFailNextNonlinearConvergenceCheck())
    return false;
  // When not computing the residual (for example at the beginning of a time step),
  // we may be in the process of counting invalid solution warnings, so the call to
  // acceptInvalidSolution() would fail due to lack of parallel synchronization
  // TODO: think of a better solution
  if (_app.solutionInvalidity().hasSynced() && !_fe_problem.acceptInvalidSolution())
  {
    mooseWarning("The solution is not converged due to the solution being invalid.");
    return false;
  }
  return _nl_implicit_sys.nonlinear_solver->converged;
}

◆ convergence()

Convergence & NonlinearSystemBase::convergence ( )

inherited

Retrieves the associated Convergence object.

Definition at line 4299 of file NonlinearSystemBase.C.

{
  return _fe_problem.getConvergence(_convergence_name);
}

Referenced by EigenExecutionerBase::getEigenSystemConvergence(), Moose::PetscSupport::petscNonlinearConverged(), and NonlinearSystemBase::preSolve().

◆ copyAdditionalStateBackwards()

virtual void SystemBase::copyAdditionalStateBackwards	(	Moose::SolutionIterationType	,
		bool
	)

inlineprotectedvirtualinherited

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 in AuxiliarySystem, and LinearSystem.

Definition at line 1013 of file SystemBase.h.

1013{}

Referenced by SystemBase::advanceStateHistory().

◆ copyOldSolutions()

void SystemBase::copyOldSolutions ( )

inherited

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

Shifts the solutions backwards in time.

Definition at line 1323 of file SystemBase.C.

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

◆ 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 1274 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 1258 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 1266 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 1684 of file SystemBase.C.

{
  _time_integrators = other_sys._time_integrators;
}

◆ copyVars()

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

inherited

Definition at line 1183 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 NonlinearSystemBase::customSetup ( const ExecFlagType & exec_type )

overridevirtualinherited

Reimplemented from SystemBase.

Definition at line 405 of file NonlinearSystemBase.C.

{
  SolverSystem::customSetup(exec_type);
 
  for (THREAD_ID tid = 0; tid < this->numThreads(); tid++)
  {
    _kernels.customSetup(exec_type, tid);
    _nodal_kernels.customSetup(exec_type, tid);
    _dirac_kernels.customSetup(exec_type, tid);
    if (_doing_dg)
      _dg_kernels.customSetup(exec_type, tid);
    _interface_kernels.customSetup(exec_type, tid);
    _element_dampers.customSetup(exec_type, tid);
    _nodal_dampers.customSetup(exec_type, tid);
    _integrated_bcs.customSetup(exec_type, tid);
 
    if (_fe_problem.haveFV())
      for (auto * fv_object : getFVSetupObjects(tid))
        fv_object->customSetup(exec_type);
  }
  _scalar_kernels.customSetup(exec_type);
  _constraints.customSetup(exec_type);
  _general_dampers.customSetup(exec_type);
  _nodal_bcs.customSetup(exec_type);
  _preset_nodal_bcs.customSetup(exec_type);
  _ad_preset_nodal_bcs.customSetup(exec_type);
 
#ifdef MOOSE_KOKKOS_ENABLED
  _kokkos_kernels.customSetup(exec_type);
  _kokkos_nodal_kernels.customSetup(exec_type);
  _kokkos_integrated_bcs.customSetup(exec_type);
  _kokkos_nodal_bcs.customSetup(exec_type);
#endif
}

◆ deactivateAllMatrixTags()

void SystemBase::deactivateAllMatrixTags ( )

virtualinherited

Make matrices inactive.

Definition at line 1119 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().

◆ debuggingResiduals()

void NonlinearSystemBase::debuggingResiduals ( bool state )

inlineinherited

Definition at line 595 of file NonlinearSystemBase.h.

595{ _debugging_residuals = state; }

◆ 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 350 of file SystemBase.h.

350{ return {systemMatrixTag()}; }

SystemBase::systemMatrixTag

virtual TagID systemMatrixTag() const

Return the Matrix Tag ID for System.

Definition SystemBase.h:328

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 343 of file SystemBase.h.

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

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

◆ destroyColoring()

void NonlinearSystemBase::destroyColoring ( )

inherited

Destroy the coloring object if it exists.

Definition at line 4283 of file NonlinearSystemBase.C.

{
  if (matrixFromColoring())
    LibmeshPetscCall(MatFDColoringDestroy(&_fdcoloring));
}

Referenced by LStableDirk2::solve(), LStableDirk3::solve(), and LStableDirk4::solve().

◆ disassociateDefaultMatrixTags()

void SystemBase::disassociateDefaultMatrixTags ( )

virtualinherited

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

Reimplemented in DisplacedSystem.

Definition at line 1110 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 1015 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 1088 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 1099 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 993 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 1004 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 1163 of file SystemBase.C.

{
  return system().get_dof_map();
}

Referenced by 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 1169 of file SystemBase.C.

{
  return system().get_dof_map();
}

◆ doingDG()

bool NonlinearSystemBase::doingDG ( ) const

inherited

Getter for _doing_dg.

Definition at line 3995 of file NonlinearSystemBase.C.

{
  return _doing_dg;
}

◆ duDotDotDu() [1/2]

virtual Number & SystemBase::duDotDotDu ( )

inlinevirtualinherited

Reimplemented in DisplacedSystem.

Definition at line 288 of file SystemBase.h.

288{ return _du_dotdot_du; }

SystemBase::_du_dotdot_du

Real _du_dotdot_du

Definition SystemBase.h:1063

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 290 of file SystemBase.h.

290{ return _du_dotdot_du; }

◆ duDotDu()

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

virtualinherited

Reimplemented in DisplacedSystem.

Definition at line 1718 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 287 of file SystemBase.h.

287{ return _du_dot_du; }

Referenced by DisplacedSystem::duDotDus().

◆ enforceNodalConstraintsJacobian()

bool NonlinearSystemBase::enforceNodalConstraintsJacobian ( const SparseMatrix< Number > & jacobian )

protectedinherited

Enforce nodal constraints in the Jacobian.

Parameters

jacobian The Jacobian to read from while constructing the Jacobians corresponding to the nodal constraints

Returns: Whether there were active nodal constraints

Definition at line 1109 of file NonlinearSystemBase.C.

{
  if (!hasMatrix(systemMatrixTag()))
    mooseError(" A system matrix is required");
 
  THREAD_ID tid = 0; // constraints are going to be done single-threaded
 
  if (_constraints.hasActiveNodalConstraints())
  {
    const auto & ncs = _constraints.getActiveNodalConstraints();
    for (const auto & nc : ncs)
    {
      std::vector<dof_id_type> & secondary_node_ids = nc->getSecondaryNodeId();
      std::vector<dof_id_type> & primary_node_ids = nc->getPrimaryNodeId();
 
      if ((secondary_node_ids.size() > 0) && (primary_node_ids.size() > 0))
      {
        nc->reinitConstraintNodes();
        nc->computeJacobian(jacobian_to_view);
      }
    }
    _fe_problem.addCachedJacobian(tid);
 
    return true;
  }
  else
    return false;
}

Referenced by NonlinearSystemBase::computeJacobianInternal().

◆ enforceNodalConstraintsResidual()

void NonlinearSystemBase::enforceNodalConstraintsResidual ( NumericVector< Number > & residual )

protectedinherited

Enforce nodal constraints.

Definition at line 1085 of file NonlinearSystemBase.C.

{
  THREAD_ID tid = 0; // constraints are going to be done single-threaded
  residual.close();
  if (_constraints.hasActiveNodalConstraints())
  {
    const auto & ncs = _constraints.getActiveNodalConstraints();
    for (const auto & nc : ncs)
    {
      std::vector<dof_id_type> & secondary_node_ids = nc->getSecondaryNodeId();
      std::vector<dof_id_type> & primary_node_ids = nc->getPrimaryNodeId();
 
      if ((secondary_node_ids.size() > 0) && (primary_node_ids.size() > 0))
      {
        nc->reinitConstraintNodes();
        nc->computeResidual(residual);
      }
    }
    _fe_problem.addCachedResidualDirectly(residual, tid);
    residual.close();
  }
}

Referenced by NonlinearSystemBase::computeResidualInternal().

◆ feProblem() [1/2]

FEProblemBase & SystemBase::feProblem ( )

inlineinherited

Definition at line 104 of file SystemBase.h.

104{ return _fe_problem; }

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

◆ feProblem() [2/2]

const FEProblemBase & SystemBase::feProblem ( ) const

inlineinherited

Definition at line 105 of file SystemBase.h.

105{ return _fe_problem; }

◆ finalNonlinearResidual()

virtual Real NonlinearSystemBase::finalNonlinearResidual ( ) const

inlinevirtualinherited

Return the final nonlinear residual.

Reimplemented in NonlinearEigenSystem.

Definition at line 581 of file NonlinearSystemBase.h.

581{ return _final_residual; }

NonlinearSystemBase::_final_residual

Real _final_residual

Definition NonlinearSystemBase.h:1031

◆ findImplicitGeometricCouplingEntries()

void NonlinearSystemBase::findImplicitGeometricCouplingEntries	(	GeometricSearchData &	geom_search_data,
		std::unordered_map< dof_id_type, std::vector< dof_id_type > > &	graph
	)

privateinherited

Finds the implicit sparsity graph between geometrically related dofs.

Definition at line 2354 of file NonlinearSystemBase.C.

{
  const auto & node_to_elem_map = _mesh.nodeToElemMap();
  const auto & nearest_node_locators = geom_search_data._nearest_node_locators;
  for (const auto & it : nearest_node_locators)
  {
    std::vector<dof_id_type> & secondary_nodes = it.second->_secondary_nodes;
 
    for (const auto & secondary_node : secondary_nodes)
    {
      std::set<dof_id_type> unique_secondary_indices;
      std::set<dof_id_type> unique_primary_indices;
 
      auto node_to_elem_pair = node_to_elem_map.find(secondary_node);
      if (node_to_elem_pair != node_to_elem_map.end())
      {
        const std::vector<dof_id_type> & elems = node_to_elem_pair->second;
 
        // Get the dof indices from each elem connected to the node
        for (const auto & cur_elem : elems)
        {
          std::vector<dof_id_type> dof_indices;
          dofMap().dof_indices(_mesh.elemPtr(cur_elem), dof_indices);
 
          for (const auto & dof : dof_indices)
            unique_secondary_indices.insert(dof);
        }
      }
 
      std::vector<dof_id_type> primary_nodes = it.second->_neighbor_nodes[secondary_node];
 
      for (const auto & primary_node : primary_nodes)
      {
        auto primary_node_to_elem_pair = node_to_elem_map.find(primary_node);
        mooseAssert(primary_node_to_elem_pair != node_to_elem_map.end(),
                    "Missing entry in node to elem map");
        const std::vector<dof_id_type> & primary_node_elems = primary_node_to_elem_pair->second;
 
        // Get the dof indices from each elem connected to the node
        for (const auto & cur_elem : primary_node_elems)
        {
          std::vector<dof_id_type> dof_indices;
          dofMap().dof_indices(_mesh.elemPtr(cur_elem), dof_indices);
 
          for (const auto & dof : dof_indices)
            unique_primary_indices.insert(dof);
        }
      }
 
      for (const auto & secondary_id : unique_secondary_indices)
        for (const auto & primary_id : unique_primary_indices)
        {
          graph[secondary_id].push_back(primary_id);
          graph[primary_id].push_back(secondary_id);
        }
    }
  }
 
  // handle node-to-node constraints
  const auto & ncs = _constraints.getActiveNodalConstraints();
  for (const auto & nc : ncs)
  {
    std::vector<dof_id_type> primary_dofs;
    std::vector<dof_id_type> & primary_node_ids = nc->getPrimaryNodeId();
    for (const auto & node_id : primary_node_ids)
    {
      Node * node = _mesh.queryNodePtr(node_id);
      if (node && node->processor_id() == this->processor_id())
      {
        getNodeDofs(node_id, primary_dofs);
      }
    }
 
    _communicator.allgather(primary_dofs);
 
    std::vector<dof_id_type> secondary_dofs;
    std::vector<dof_id_type> & secondary_node_ids = nc->getSecondaryNodeId();
    for (const auto & node_id : secondary_node_ids)
    {
      Node * node = _mesh.queryNodePtr(node_id);
      if (node && node->processor_id() == this->processor_id())
      {
        getNodeDofs(node_id, secondary_dofs);
      }
    }
 
    _communicator.allgather(secondary_dofs);
 
    for (const auto & primary_id : primary_dofs)
      for (const auto & secondary_id : secondary_dofs)
      {
        graph[primary_id].push_back(secondary_id);
        graph[secondary_id].push_back(primary_id);
      }
  }
 
  // Make every entry sorted and unique
  for (auto & it : graph)
  {
    std::vector<dof_id_type> & row = it.second;
    std::sort(row.begin(), row.end());
    std::vector<dof_id_type>::iterator uit = std::unique(row.begin(), row.end());
    row.resize(uit - row.begin());
  }
}

Referenced by NonlinearSystemBase::addImplicitGeometricCouplingEntries(), and NonlinearSystemBase::augmentSparsity().

◆ 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 1068 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 120 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 141 of file SystemBase.C.

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

◆ getConstraintWarehouse()

const ConstraintWarehouse & NonlinearSystemBase::getConstraintWarehouse ( ) const

inlineinherited

Definition at line 655 of file NonlinearSystemBase.h.

655{ return _constraints; }

Referenced by BlockRestrictionDebugOutput::printBlockRestrictionGroups(), and BlockRestrictionDebugOutput::printBoundaryRestrictionGroups().

◆ getCurrentNonlinearIterationNumber()

virtual unsigned int NonlinearSystem::getCurrentNonlinearIterationNumber ( )

inlineoverridevirtual

Returns the current nonlinear iteration number.

In libmesh, this is updated during the nonlinear solve, so it should be up-to-date.

Implements NonlinearSystemBase.

Definition at line 45 of file NonlinearSystem.h.

  {
    return _nl_implicit_sys.get_current_nonlinear_iteration_number();
  }

◆ getDGKernelWarehouse()

MooseObjectTagWarehouse< DGKernelBase > & NonlinearSystemBase::getDGKernelWarehouse ( )

inlineinherited

Definition at line 631 of file NonlinearSystemBase.h.

631{ return _dg_kernels; }

Referenced by ExplicitTimeIntegrator::initialSetup().

◆ getDiracKernelWarehouse()

MooseObjectTagWarehouse< DiracKernelBase > & NonlinearSystemBase::getDiracKernelWarehouse ( )

inlineinherited

Definition at line 636 of file NonlinearSystemBase.h.

636{ return _dirac_kernels; }

◆ getElementDamperWarehouse()

const MooseObjectWarehouse< ElementDamper > & NonlinearSystemBase::getElementDamperWarehouse ( ) const

inlineinherited

Definition at line 647 of file NonlinearSystemBase.h.

  {
    return _element_dampers;
  }

Referenced by ComputeElemDampingThread::printGeneralExecutionInformation().

◆ getFieldSplitPreconditioner()

FieldSplitPreconditionerBase & NonlinearSystemBase::getFieldSplitPreconditioner ( )

inherited

Returns: A field split preconditioner. This will error if there is no field split preconditioner

Definition at line 4290 of file NonlinearSystemBase.C.

{
  if (!_fsp)
    mooseError("No field split preconditioner is present for this system");
 
  return *_fsp;
}

◆ 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 113 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 134 of file SystemBase.C.

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

◆ getFVSetupObjects()

std::vector< SetupInterface * > NonlinearSystemBase::getFVSetupObjects ( THREAD_ID tid )

privateinherited

Retrieve every finite volume object belonging to this system on thread tid, as SetupInterfaces, so that the setup methods can be dispatched to all finite volume families with a single loop.

Each family is queried through a MooseObject-derived base class to avoid runtime side-casts in TheWarehouse.

Definition at line 262 of file NonlinearSystemBase.C.

{
  std::vector<SetupInterface *> fv_objects;
  auto & warehouse = _fe_problem.theWarehouse();
 
  appendFVSetupObjects<FVElementalKernel>(
      warehouse, "FVElementalKernel", number(), tid, fv_objects);
  appendFVSetupObjects<FVFluxKernel>(warehouse, "FVFluxKernel", number(), tid, fv_objects);
  appendFVSetupObjects<FVBoundaryCondition>(warehouse, "FVDirichletBC", number(), tid, fv_objects);
  appendFVSetupObjects<FVBoundaryCondition>(warehouse, "FVFluxBC", number(), tid, fv_objects);
  appendFVSetupObjects<FVInterfaceKernel>(
      warehouse, "FVInterfaceKernel", number(), tid, fv_objects);
 
  return fv_objects;
}

Referenced by NonlinearSystemBase::customSetup(), NonlinearSystemBase::initialSetup(), and NonlinearSystemBase::timestepSetup().

◆ 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 127 of file SystemBase.C.

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

◆ getHDGKernelWarehouse()

MooseObjectTagWarehouse< HDGKernel > & NonlinearSystemBase::getHDGKernelWarehouse ( )

inlineinherited

Definition at line 646 of file NonlinearSystemBase.h.

646{ return _hybridized_kernels; }

◆ getIntegratedBCWarehouse() [1/2]

MooseObjectTagWarehouse< IntegratedBCBase > & NonlinearSystemBase::getIntegratedBCWarehouse ( )

inlineinherited

Definition at line 637 of file NonlinearSystemBase.h.

637{ return _integrated_bcs; }

Referenced by BoundaryElemIntegrityCheckThread::operator()().

◆ getIntegratedBCWarehouse() [2/2]

const MooseObjectTagWarehouse< IntegratedBCBase > & NonlinearSystemBase::getIntegratedBCWarehouse ( ) const

inlineinherited

Return the IntegratedBCBase warehouse.

Definition at line 665 of file NonlinearSystemBase.h.

  {
    return _integrated_bcs;
  }

◆ getInterfaceKernelWarehouse()

MooseObjectTagWarehouse< InterfaceKernelBase > & NonlinearSystemBase::getInterfaceKernelWarehouse ( )

inlineinherited

Definition at line 632 of file NonlinearSystemBase.h.

  {
    return _interface_kernels;
  }

◆ getKernelWarehouse() [1/2]

MooseObjectTagWarehouse< KernelBase > & NonlinearSystemBase::getKernelWarehouse ( )

inlineinherited

Access functions to Warehouses from outside NonlinearSystemBase.

Definition at line 629 of file NonlinearSystemBase.h.

629{ return _kernels; }

Referenced by ExplicitTimeIntegrator::initialSetup(), DOFMapOutput::output(), and BlockRestrictionDebugOutput::printBlockRestrictionMap().

◆ getKernelWarehouse() [2/2]

const MooseObjectTagWarehouse< KernelBase > & NonlinearSystemBase::getKernelWarehouse ( ) const

inlineinherited

Definition at line 630 of file NonlinearSystemBase.h.

630{ return _kernels; }

◆ getKokkosIntegratedBCWarehouse()

MooseObjectTagWarehouse< ResidualObject > & NonlinearSystemBase::getKokkosIntegratedBCWarehouse ( )

inlineinherited

Definition at line 682 of file NonlinearSystemBase.h.

  {
    return _kokkos_integrated_bcs;
  }

◆ getKokkosKernelWarehouse()

MooseObjectTagWarehouse< ResidualObject > & NonlinearSystemBase::getKokkosKernelWarehouse ( )

inlineinherited

Return the Kokkos residual object warehouses

Definition at line 673 of file NonlinearSystemBase.h.

673{ return _kokkos_kernels; }

Referenced by ExplicitTimeIntegrator::initialSetup().

◆ getKokkosNodalBCWarehouse()

MooseObjectTagWarehouse< ResidualObject > & NonlinearSystemBase::getKokkosNodalBCWarehouse ( )

inlineinherited

Definition at line 678 of file NonlinearSystemBase.h.

  {
    return _kokkos_nodal_bcs;
  }

◆ getKokkosNodalKernelWarehouse()

MooseObjectTagWarehouse< ResidualObject > & NonlinearSystemBase::getKokkosNodalKernelWarehouse ( )

inlineinherited

Definition at line 674 of file NonlinearSystemBase.h.

  {
    return _kokkos_nodal_kernels;
  }

Referenced by ExplicitTimeIntegrator::initialSetup().

◆ getMatrix() [1/2]

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

virtualinherited

Get a raw SparseMatrix.

Reimplemented in DisplacedSystem.

Definition at line 1024 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(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeResidualAndJacobian(), NonlinearSystemBase::constraintJacobians(), SystemBase::disassociateMatrixFromTag(), SystemBase::flushTaggedMatrices(), DisplacedSystem::getMatrix(), DisplacedSystem::getMatrix(), LinearSystemContributionObject::linkTaggedVectorsAndMatrices(), MooseVariableScalar::reinit(), Assembly::setCachedJacobian(), LinearSystem::setMatrixOptions(), NonlinearSystemBase::setMatrixOptions(), 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 1042 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 900 of file SystemBase.h.

900{ 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 616 of file SystemBase.h.

616{ 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 623 of file SystemBase.h.

623{ 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 243 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.

99{ return _ksp_norm; }

SolverSystem::_ksp_norm

Moose::MooseKSPNormType _ksp_norm

KSP norm type.

Definition SolverSystem.h:122

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

◆ getNodalBCWarehouse()

const MooseObjectTagWarehouse< NodalBCBase > & NonlinearSystemBase::getNodalBCWarehouse ( ) const

inlineinherited

Return the NodalBCBase warehouse.

Definition at line 660 of file NonlinearSystemBase.h.

660{ return _nodal_bcs; }

◆ getNodalDamperWarehouse()

const MooseObjectWarehouse< NodalDamper > & NonlinearSystemBase::getNodalDamperWarehouse ( ) const

inlineinherited

Definition at line 651 of file NonlinearSystemBase.h.

  {
    return _nodal_dampers;
  }

Referenced by ComputeNodalDampingThread::printGeneralExecutionInformation().

◆ getNodalKernelWarehouse()

const MooseObjectTagWarehouse< NodalKernelBase > & NonlinearSystemBase::getNodalKernelWarehouse ( ) const

inlineinherited

Definition at line 642 of file NonlinearSystemBase.h.

  {
    return _nodal_kernels;
  }

Referenced by ExplicitTimeIntegrator::initialSetup().

◆ getNodeDofs()

void NonlinearSystemBase::getNodeDofs	(	dof_id_type	node_id,
		std::vector< dof_id_type > &	dofs
	)

protectedinherited

Definition at line 2341 of file NonlinearSystemBase.C.

{
  const Node & node = _mesh.nodeRef(node_id);
  unsigned int s = number();
  if (node.has_dofs(s))
  {
    for (unsigned int v = 0; v < nVariables(); v++)
      for (unsigned int c = 0; c < node.n_comp(s, v); c++)
        dofs.push_back(node.dof_number(s, v, c));
  }
}

Referenced by NonlinearSystemBase::findImplicitGeometricCouplingEntries().

◆ 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 1161 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.

88{ return _pc_side; }

SolverSystem::_pc_side

Moose::PCSideType _pc_side

Preconditioning side.

Definition SolverSystem.h:120

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

◆ getPreconditioner()

MoosePreconditioner const * NonlinearSystemBase::getPreconditioner ( ) const

inherited

Definition at line 3713 of file NonlinearSystemBase.C.

{
  return _preconditioner.get();
}

Referenced by ConsoleUtils::outputExecutionInformation().

◆ getPredictor()

Predictor * NonlinearSystemBase::getPredictor ( )

inlineinherited

Definition at line 600 of file NonlinearSystemBase.h.

600{ return _predictor.get(); }

NonlinearSystemBase::_predictor

std::shared_ptr< Predictor > _predictor

If predictor is active, this is non-NULL.

Definition NonlinearSystemBase.h:1034

Referenced by AB2PredictorCorrector::estimateTimeError().

◆ getResidualNonTimeVector()

NumericVector< Number > & NonlinearSystemBase::getResidualNonTimeVector ( )

inherited

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

Definition at line 1045 of file NonlinearSystemBase.C.

{
  if (!_Re_non_time)
  {
    _Re_non_time_tag = _fe_problem.addVectorTag("NONTIME");
 
    // Most applications don't need the expense of ghosting
    libMesh::ParallelType ptype = _need_residual_ghosted ? GHOSTED : PARALLEL;
    _Re_non_time = &addVector(_Re_non_time_tag, false, ptype);
  }
  else if (_need_residual_ghosted && _Re_non_time->type() == PARALLEL)
  {
    const auto vector_name = _subproblem.vectorTagName(_Re_non_time_tag);
 
    // If an application changes its mind, the libMesh API lets us
    // change the vector.
    _Re_non_time = &system().add_vector(vector_name, false, GHOSTED);
  }
 
  return *_Re_non_time;
}

Referenced by PseudoTimestep::currentResidualNorm(), NonlinearSystemBase::NonlinearSystemBase(), and NonlinearSystemBase::residualVector().

◆ getResidualTimeVector()

NumericVector< Number > & NonlinearSystemBase::getResidualTimeVector ( )

inherited

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

Definition at line 1022 of file NonlinearSystemBase.C.

{
  if (!_Re_time)
  {
    _Re_time_tag = _fe_problem.addVectorTag("TIME");
 
    // Most applications don't need the expense of ghosting
    libMesh::ParallelType ptype = _need_residual_ghosted ? GHOSTED : PARALLEL;
    _Re_time = &addVector(_Re_time_tag, false, ptype);
  }
  else if (_need_residual_ghosted && _Re_time->type() == PARALLEL)
  {
    const auto vector_name = _subproblem.vectorTagName(_Re_time_tag);
 
    // If an application changes its mind, the libMesh API lets us
    // change the vector.
    _Re_time = &system().add_vector(vector_name, false, GHOSTED);
  }
 
  return *_Re_time;
}

Referenced by NonlinearSystemBase::residualVector().

◆ getScalarKernelWarehouse()

const MooseObjectTagWarehouse< ScalarKernelBase > & NonlinearSystemBase::getScalarKernelWarehouse ( ) const

inlineinherited

Definition at line 638 of file NonlinearSystemBase.h.

  {
    return _scalar_kernels;
  }

Referenced by ExplicitTimeIntegrator::initialSetup().

◆ 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 147 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;
}

◆ 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 156 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 789 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().

◆ getSNES()

SNES NonlinearSystem::getSNES ( )

overridevirtual

Implements NonlinearSystemBase.

Definition at line 413 of file NonlinearSystem.C.

{
  libMesh::PetscNonlinearSolver<Number> * petsc_solver =
      dynamic_cast<libMesh::PetscNonlinearSolver<Number> *>(nonlinearSolver());
 
  if (petsc_solver)
  {
    const char * snes_prefix = nullptr;
    std::string snes_prefix_str;
    if (system().prefix_with_name())
    {
      snes_prefix_str = system().prefix();
      snes_prefix = snes_prefix_str.c_str();
    }
    return petsc_solver->snes(snes_prefix);
  }
  else
    mooseError("It is not a petsc nonlinear solver");
}

◆ 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 1126 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 1151 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().

◆ getSplit()

std::shared_ptr< Split > NonlinearSystemBase::getSplit ( const std::string & name )

inherited

Retrieves a split by name.

Parameters

name	The name of the split

Definition at line 725 of file NonlinearSystemBase.C.

{
  return _splits.getActiveObject(name);
}

Referenced by FieldSplitPreconditioner::FieldSplitPreconditioner(), Split::setup(), and StaticCondensationFieldSplitPreconditioner::StaticCondensationFieldSplitPreconditioner().

◆ getSplits()

MooseObjectWarehouseBase< Split > & NonlinearSystemBase::getSplits ( )

inlineinherited

Retrieves all splits.

Definition at line 263 of file NonlinearSystemBase.h.

263{ return _splits; }

Referenced by ConsoleUtils::outputExecutionInformation().

◆ 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 1724 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 794 of file SystemBase.h.

  {
    return _var_map.at(var_number);
  }

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

◆ 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 1700 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 1712 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 92 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 102 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 166 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 875 of file SystemBase.h.

875{ return _var_all_dof_indices; }

SystemBase::_var_all_dof_indices

std::vector< dof_id_type > _var_all_dof_indices

Container for the dof indices of a given variable.

Definition SystemBase.h:1109

◆ getVariableNames()

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

inlineinherited

Definition at line 893 of file SystemBase.h.

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

◆ 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 933 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(), 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(), 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 939 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 945 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 963 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];
}

◆ hasDiagSaveIn()

bool NonlinearSystemBase::hasDiagSaveIn ( ) const

inlineinherited

Weather or not the nonlinear system has diagonal Jacobian save-ins.

Definition at line 699 of file NonlinearSystemBase.h.

699{ return _has_diag_save_in || _has_nodalbc_diag_save_in; }

Referenced by NonlinearSystemBase::computeJacobianInternal().

◆ hasMatrix()

virtual bool SystemBase::hasMatrix ( TagID tag ) const

inlinevirtualinherited

Check if the tagged matrix exists in the system.

Reimplemented in DisplacedSystem.

Definition at line 391 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(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeResidualAndJacobian(), NonlinearSystemBase::constraintJacobians(), SystemBase::disassociateMatrixFromTag(), NonlinearSystemBase::enforceNodalConstraintsJacobian(), SystemBase::flushTaggedMatrices(), SystemBase::getMatrix(), SystemBase::getMatrix(), DisplacedSystem::hasMatrix(), MooseVariableScalar::reinit(), SystemBase::removeMatrix(), SubProblem::selectMatrixTagsFromSystem(), Assembly::setCachedJacobian(), NonlinearSystemBase::setMatrixOptions(), and Assembly::zeroCachedJacobian().

◆ hasSaveIn()

bool NonlinearSystemBase::hasSaveIn ( ) const

inlineinherited

Weather or not the nonlinear system has save-ins.

Definition at line 694 of file NonlinearSystemBase.h.

694{ return _has_save_in || _has_nodalbc_save_in; }

Referenced by NonlinearSystemBase::computeResidualTags().

◆ hasScalarVariable()

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

virtualinherited

Definition at line 876 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 1167 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 921 of file SystemBase.h.

921{ 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 851 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 924 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(), 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 312 of file SystemBase.h.

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

◆ haveFieldSplitPreconditioner()

bool NonlinearSystemBase::haveFieldSplitPreconditioner ( ) const

inlineinherited

Definition at line 113 of file NonlinearSystemBase.h.

113{ return _fsp; }

◆ haveFiniteDifferencedPreconditioner()

bool NonlinearSystemBase::haveFiniteDifferencedPreconditioner ( ) const

inlineinherited

Definition at line 109 of file NonlinearSystemBase.h.

  {
    return _use_finite_differenced_preconditioner;
  }

◆ ignoreVariablesForAutoscaling()

void NonlinearSystemBase::ignoreVariablesForAutoscaling ( const std::vector< std::string > & ignore_variables_for_autoscaling )

inlineinherited

Definition at line 742 of file NonlinearSystemBase.h.

  {
    _ignore_variables_for_autoscaling = ignore_variables_for_autoscaling;
  }

◆ initializeObjects()

virtual void SystemBase::initializeObjects ( )

inlinevirtualinherited

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

Definition at line 177 of file SystemBase.h.

177{}

◆ initialResidual()

Real NonlinearSystemBase::initialResidual ( ) const

inherited

The initial residual.

Definition at line 764 of file NonlinearSystemBase.C.

{
  return _initial_residual;
}

Referenced by NonlinearSystemBase::referenceResidual().

◆ initialSetup()

void NonlinearSystemBase::initialSetup ( )

overridevirtualinherited

Setup Functions.

Reimplemented from SystemBase.

Definition at line 279 of file NonlinearSystemBase.C.

{
  TIME_SECTION("nlInitialSetup", 2, "Setting Up Nonlinear System");
 
  SolverSystem::initialSetup();
 
  {
    TIME_SECTION("kernelsInitialSetup", 2, "Setting Up Kernels/BCs/Constraints");
 
    for (THREAD_ID tid = 0; tid < this->numThreads(); tid++)
    {
      _kernels.initialSetup(tid);
      _nodal_kernels.initialSetup(tid);
      _dirac_kernels.initialSetup(tid);
      if (_doing_dg)
        _dg_kernels.initialSetup(tid);
      _interface_kernels.initialSetup(tid);
 
      _element_dampers.initialSetup(tid);
      _nodal_dampers.initialSetup(tid);
      _integrated_bcs.initialSetup(tid);
 
      if (_fe_problem.haveFV())
        for (auto * fv_object : getFVSetupObjects(tid))
          fv_object->initialSetup();
    }
 
    _scalar_kernels.initialSetup();
    _constraints.initialSetup();
    _general_dampers.initialSetup();
    _nodal_bcs.initialSetup();
    _preset_nodal_bcs.residualSetup();
    _ad_preset_nodal_bcs.residualSetup();
 
#ifdef MOOSE_KOKKOS_ENABLED
    _kokkos_kernels.initialSetup();
    _kokkos_nodal_kernels.initialSetup();
    _kokkos_integrated_bcs.initialSetup();
    _kokkos_nodal_bcs.initialSetup();
#endif
  }
 
  {
    TIME_SECTION("mortarSetup", 2, "Initializing Mortar Interfaces");
 
    auto create_mortar_functors = [this](const bool displaced)
    {
      // go over mortar interfaces and construct functors
      const auto & mortar_interfaces = _fe_problem.getMortarInterfaces(displaced);
      for (const auto & [primary_secondary_boundary_pair, interface_config] : mortar_interfaces)
      {
        if (!_constraints.hasActiveMortarConstraints(primary_secondary_boundary_pair, displaced))
          continue;
 
        auto & mortar_constraints =
            _constraints.getActiveMortarConstraints(primary_secondary_boundary_pair, displaced);
 
        auto & subproblem = displaced ? cast_ref<SubProblem &>(*_fe_problem.getDisplacedProblem())
                                      : cast_ref<SubProblem &>(_fe_problem);
 
        auto & mortar_functors =
            displaced ? _displaced_mortar_functors : _undisplaced_mortar_functors;
 
        mortar_functors.emplace(primary_secondary_boundary_pair,
                                ComputeMortarFunctor(mortar_constraints,
                                                     *interface_config.amg,
                                                     subproblem,
                                                     _fe_problem,
                                                     displaced,
                                                     subproblem.assembly(0, number())));
      }
    };
 
    create_mortar_functors(false);
    create_mortar_functors(true);
  }
 
  if (_automatic_scaling)
  {
    if (_off_diagonals_in_auto_scaling)
      _scaling_matrix = std::make_unique<OffDiagonalScalingMatrix<Number>>(_communicator);
    else
      _scaling_matrix = std::make_unique<libMesh::DiagonalMatrix<Number>>(_communicator);
  }
 
  if (_preconditioner)
    _preconditioner->initialSetup();
}

◆ initSolutionState()

void SystemBase::initSolutionState ( )

virtualinherited

Initializes the solution state.

Reimplemented in AuxiliarySystem, DisplacedSystem, and LinearSystem.

Definition at line 1386 of file SystemBase.C.

{
  // Default is the current solution
  unsigned int state = 0;
 
  // Add additional states as required by the variable states requested
  for (const auto & var : getVariables(/* tid = */ 0))
    state = std::max(state, var->oldestSolutionStateRequested());
  for (const auto & var : getScalarVariables(/* tid = */ 0))
    state = std::max(state, var->oldestSolutionStateRequested());
 
  needSolutionState(state, Moose::SolutionIterationType::Time);
 
  _solution_states_initialized = true;
}

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

◆ isArrayVariable()

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

virtualinherited

If a variable is an array variable.

Definition at line 864 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 885 of file SystemBase.C.

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

Referenced by Assembly::initNonlocalCoupling().

◆ jacobianSetup()

void NonlinearSystemBase::jacobianSetup ( )

overridevirtualinherited

Reimplemented from SystemBase.

Definition at line 2962 of file NonlinearSystemBase.C.

{
  SolverSystem::jacobianSetup();
 
  for (THREAD_ID tid = 0; tid < this->numThreads(); tid++)
  {
    _kernels.jacobianSetup(tid);
    _nodal_kernels.jacobianSetup(tid);
    _dirac_kernels.jacobianSetup(tid);
    if (_doing_dg)
      _dg_kernels.jacobianSetup(tid);
    _interface_kernels.jacobianSetup(tid);
    _element_dampers.jacobianSetup(tid);
    _nodal_dampers.jacobianSetup(tid);
    _integrated_bcs.jacobianSetup(tid);
  }
  _scalar_kernels.jacobianSetup();
  _constraints.jacobianSetup();
  _general_dampers.jacobianSetup();
  _nodal_bcs.jacobianSetup();
  _preset_nodal_bcs.jacobianSetup();
  _ad_preset_nodal_bcs.jacobianSetup();
 
#ifdef MOOSE_KOKKOS_ENABLED
  _kokkos_kernels.jacobianSetup();
  _kokkos_nodal_kernels.jacobianSetup();
  _kokkos_integrated_bcs.jacobianSetup();
  _kokkos_nodal_bcs.jacobianSetup();
#endif
 
  // Avoid recursion
  if (this == &_fe_problem.currentNonlinearSystem())
    _fe_problem.jacobianSetup();
}

Referenced by NonlinearSystemBase::computeJacobianInternal().

◆ matrixFromColoring()

virtual bool NonlinearSystem::matrixFromColoring ( ) const

inlineoverrideprivatevirtual

Whether a system matrix is formed from coloring.

This influences things like when to compute time derivatives

Reimplemented from SolverSystem.

Definition at line 104 of file NonlinearSystem.h.

104{ return _use_coloring_finite_difference; }

◆ matrixTagActive()

bool SystemBase::matrixTagActive ( TagID tag ) const

virtualinherited

If or not a matrix tag is active.

Definition at line 1149 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.

100{ 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.

101{ return _mesh; }

◆ mortarConstraints()

void NonlinearSystemBase::mortarConstraints	(	Moose::ComputeType	compute_type,
		const std::set< TagID > &	vector_tags,
		const std::set< TagID > &	matrix_tags
	)

protectedinherited

Do mortar constraint residual/jacobian computations.

Definition at line 4008 of file NonlinearSystemBase.C.

{
  parallel_object_only();
 
  try
  {
    for (auto & map_pr : _undisplaced_mortar_functors)
      map_pr.second(compute_type, vector_tags, matrix_tags);
 
    for (auto & map_pr : _displaced_mortar_functors)
      map_pr.second(compute_type, vector_tags, matrix_tags);
  }
  catch (MetaPhysicL::LogicError &)
  {
    mooseError(
        "We caught a MetaPhysicL error in NonlinearSystemBase::mortarConstraints. This is very "
        "likely due to AD not having a sufficiently large derivative container size. Please run "
        "MOOSE configure with the '--with-derivative-size=<n>' option");
  }
}

Referenced by NonlinearSystemBase::computeJacobianInternal(), NonlinearSystemBase::computeResidualAndJacobianInternal(), and NonlinearSystemBase::computeResidualInternal().

◆ name()

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

virtualinherited

Definition at line 1362 of file SystemBase.C.

{
  return system().name();
}

◆ needBoundaryMaterialOnSide()

bool NonlinearSystemBase::needBoundaryMaterialOnSide	(	BoundaryID	bnd_id,
		THREAD_ID	tid
	)		const

inherited

Indicated whether this system needs material properties on boundaries.

Returns: Boolean if IntegratedBCs are active

Definition at line 3940 of file NonlinearSystemBase.C.

{
  // IntegratedBCs are for now the only objects we consider to be consuming
  // matprops on boundaries.
  if (_integrated_bcs.hasActiveBoundaryObjects(bnd_id, tid))
    for (const auto & bc : _integrated_bcs.getActiveBoundaryObjects(bnd_id, tid))
      if (std::static_pointer_cast<MaterialPropertyInterface>(bc)->getMaterialPropertyCalled())
        return true;
 
  // Thin layer heat transfer in the heat_transfer module is being used on a boundary even though
  // it's an interface kernel. That boundary is external, on both sides of a gap in a mesh
  if (_interface_kernels.hasActiveBoundaryObjects(bnd_id, tid))
    for (const auto & ik : _interface_kernels.getActiveBoundaryObjects(bnd_id, tid))
      if (std::static_pointer_cast<MaterialPropertyInterface>(ik)->getMaterialPropertyCalled())
        return true;
 
  // Because MortarConstraints do not inherit from BoundaryRestrictable, they are not sorted
  // by boundary in the MooseObjectWarehouse. So for now, we return true for all boundaries
  // Note: constraints are not threaded at this time
  if (_constraints.hasActiveObjects(/*tid*/ 0))
    for (const auto & ct : _constraints.getActiveObjects(/*tid*/ 0))
      if (auto mpi = std::dynamic_pointer_cast<MaterialPropertyInterface>(ct);
          mpi && mpi->getMaterialPropertyCalled())
        return true;
  return false;
}

◆ needInterfaceMaterialOnSide()

bool NonlinearSystemBase::needInterfaceMaterialOnSide	(	BoundaryID	bnd_id,
		THREAD_ID	tid
	)		const

inherited

Indicated whether this system needs material properties on interfaces.

Returns: Boolean if IntegratedBCs are active

Definition at line 3968 of file NonlinearSystemBase.C.

{
  // InterfaceKernels are for now the only objects we consider to be consuming matprops on internal
  // boundaries.
  if (_interface_kernels.hasActiveBoundaryObjects(bnd_id, tid))
    for (const auto & ik : _interface_kernels.getActiveBoundaryObjects(bnd_id, tid))
      if (std::static_pointer_cast<MaterialPropertyInterface>(ik)->getMaterialPropertyCalled())
        return true;
  return false;
}

◆ needInternalNeighborSideMaterial()

bool NonlinearSystemBase::needInternalNeighborSideMaterial	(	SubdomainID	subdomain_id,
		THREAD_ID	tid
	)		const

inherited

Indicates whether this system needs material properties on internal sides.

Returns: Boolean if DGKernels are active

Definition at line 3980 of file NonlinearSystemBase.C.

{
  // DGKernels are for now the only objects we consider to be consuming matprops on
  // internal sides.
  if (_dg_kernels.hasActiveBlockObjects(subdomain_id, tid))
    for (const auto & dg : _dg_kernels.getActiveBlockObjects(subdomain_id, tid))
      if (std::static_pointer_cast<MaterialPropertyInterface>(dg)->getMaterialPropertyCalled())
        return true;
  // NOTE:
  // HDG kernels do not require face material properties on internal sides at this time.
  // The idea is to have element locality of HDG for hybridization
  return false;
}

◆ 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 1487 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 900 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 910 of file SystemBase.C.

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

◆ nLinearIterations()

virtual unsigned int NonlinearSystemBase::nLinearIterations ( ) const

inlinevirtualinherited

Return the number of linear iterations.

Reimplemented in NonlinearEigenSystem.

Definition at line 571 of file NonlinearSystemBase.h.

571{ return _n_linear_iters; }

NonlinearSystemBase::_n_linear_iters

unsigned int _n_linear_iters

Definition NonlinearSystemBase.h:1026

Referenced by IterationAdaptiveDT::acceptStep().

◆ nNonlinearIterations()

virtual unsigned int NonlinearSystemBase::nNonlinearIterations ( ) const

inlinevirtualinherited

Return the number of non-linear iterations.

Reimplemented in NonlinearEigenSystem.

Definition at line 566 of file NonlinearSystemBase.h.

566{ return _n_iters; }

NonlinearSystemBase::_n_iters

unsigned int _n_iters

Definition NonlinearSystemBase.h:1025

Referenced by IterationAdaptiveDT::acceptStep().

◆ nonlinearNorm()

Real NonlinearSystemBase::nonlinearNorm ( ) const

inlineinherited

Return the last nonlinear norm.

Returns: A Real containing the last computed residual norm

Definition at line 587 of file NonlinearSystemBase.h.

587{ return _last_nl_rnorm; }

NonlinearSystemBase::_last_nl_rnorm

Real _last_nl_rnorm

Definition NonlinearSystemBase.h:755

Referenced by Console::writeVariableNorms().

◆ nonlinearSolver()

virtual libMesh::NonlinearSolver< Number > * NonlinearSystem::nonlinearSolver ( )

inlineoverridevirtual

Implements NonlinearSystemBase.

Definition at line 60 of file NonlinearSystem.h.

  {
    return _nl_implicit_sys.nonlinear_solver.get();
  }

Referenced by attachPreconditioner(), getSNES(), NonlinearSystem(), and residualAndJacobianTogether().

◆ nonTimeVectorTag()

TagID NonlinearSystemBase::nonTimeVectorTag ( ) const

inlineoverridevirtualinherited

Reimplemented from SystemBase.

Definition at line 711 of file NonlinearSystemBase.h.

711{ return _Re_non_time_tag; }

Referenced by FEProblemBase::addCachedResidualDirectly(), and CrankNicolson::init().

◆ nResidualEvaluations()

unsigned int NonlinearSystemBase::nResidualEvaluations ( ) const

inlineinherited

Return the total number of residual evaluations done so far in this calculation.

Definition at line 576 of file NonlinearSystemBase.h.

576{ return _n_residual_evaluations; }

Referenced by NumResidualEvaluations::getValue().

◆ number()

unsigned int SystemBase::number ( ) const

inherited

Gets the number of this system.

Returns: The number of this system

Definition at line 1157 of file SystemBase.C.

{
  return system().number();
}

◆ numThreads()

THREAD_ID SystemBase::numThreads ( ) const

inherited

Returns: the number of threads the associated application uses (see MooseApp::numThreads())

Definition at line 89 of file SystemBase.C.

89{ return _app.numThreads(); }

MooseApp::numThreads

THREAD_ID numThreads() const

Returns the number of threads this application uses.

Definition MooseApp.h:421

◆ nVariables()

unsigned int SystemBase::nVariables ( ) const

virtualinherited

Get the number of variables in this system.

Returns: the number of variables

Definition at line 891 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().

◆ offDiagonalsInAutoScaling() [1/2]

bool NonlinearSystemBase::offDiagonalsInAutoScaling ( ) const

inlineinherited

Definition at line 747 of file NonlinearSystemBase.h.

747{ return _off_diagonals_in_auto_scaling; }

Referenced by ComputeJacobianForScalingThread::computeOnElement().

◆ offDiagonalsInAutoScaling() [2/2]

void NonlinearSystemBase::offDiagonalsInAutoScaling ( bool off_diagonals_in_auto_scaling )

inlineinherited

Definition at line 748 of file NonlinearSystemBase.h.

  {
    _off_diagonals_in_auto_scaling = off_diagonals_in_auto_scaling;
  }

◆ 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 1403 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().

◆ onTimestepBegin()

void NonlinearSystemBase::onTimestepBegin ( )

inherited

Called at the beginning of the time step.

Definition at line 927 of file NonlinearSystemBase.C.

{
  for (auto & ti : _time_integrators)
    ti->preSolve();
  if (_predictor.get())
    _predictor->timestepSetup();
}

◆ overwriteNodeFace()

void NonlinearSystemBase::overwriteNodeFace ( NumericVector< Number > & soln )

inherited

Called from explicit time stepping to overwrite boundary positions (explicit dynamics).

This will close/assemble the passed-in soln after overwrite

Definition at line 1659 of file NonlinearSystemBase.C.

{
  // Overwrite results from integrator in case we have explicit dynamics contact constraints
  auto & subproblem = _fe_problem.getDisplacedProblem()
                          ? cast_ref<SubProblem &>(*_fe_problem.getDisplacedProblem())
                          : cast_ref<SubProblem &>(_fe_problem);
  const auto & penetration_locators = subproblem.geomSearchData()._penetration_locators;
 
  for (const auto & it : penetration_locators)
  {
    PenetrationLocator & pen_loc = *(it.second);
 
    const auto & secondary_nodes = pen_loc._nearest_node._secondary_nodes;
    const BoundaryID secondary_boundary = pen_loc._secondary_boundary;
    const BoundaryID primary_boundary = pen_loc._primary_boundary;
 
    if (_constraints.hasActiveNodeFaceConstraints(secondary_boundary, true))
    {
      const auto & constraints =
          _constraints.getActiveNodeFaceConstraints(secondary_boundary, true);
      for (const auto i : index_range(secondary_nodes))
      {
        const auto secondary_node_num = secondary_nodes[i];
        const Node & secondary_node = _mesh.nodeRef(secondary_node_num);
 
        if (secondary_node.processor_id() == processor_id())
          if (pen_loc._penetration_info[secondary_node_num])
            for (const auto & nfc : constraints)
            {
              if (!nfc->isExplicitConstraint())
                continue;
 
              // Return if this constraint does not correspond to the primary-secondary pair
              // prepared by the outer loops.
              // This continue statement is required when, e.g. one secondary surface constrains
              // more than one primary surface.
              if (nfc->secondaryBoundary() != secondary_boundary ||
                  nfc->primaryBoundary() != primary_boundary)
                continue;
 
              nfc->overwriteBoundaryVariables(soln, secondary_node);
            }
      }
    }
  }
  soln.close();
}

Referenced by ActuallyExplicitEuler::solve().

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

◆ postAddResidualObject()

virtual void NonlinearSystemBase::postAddResidualObject ( ResidualObject & )

inlineprotectedvirtualinherited

Called after any ResidualObject-derived objects are added to the system.

Reimplemented in NonlinearEigenSystem.

Definition at line 889 of file NonlinearSystemBase.h.

889{}

Referenced by NonlinearSystemBase::addBoundaryCondition(), NonlinearSystemBase::addConstraint(), NonlinearSystemBase::addDGKernel(), NonlinearSystemBase::addDiracKernel(), NonlinearSystemBase::addHDGKernel(), NonlinearSystemBase::addInterfaceKernel(), NonlinearSystemBase::addKernel(), NonlinearSystemBase::addNodalKernel(), and NonlinearSystemBase::addScalarKernel().

◆ postInit()

virtual void SystemBase::postInit ( )

inlinevirtualinherited

Reimplemented in NonlinearEigenSystem.

Definition at line 166 of file SystemBase.h.

166{}

Referenced by NonlinearEigenSystem::postInit().

◆ potentiallySetupFiniteDifferencing()

void NonlinearSystem::potentiallySetupFiniteDifferencing ( )

overridevirtual

Create finite differencing contexts for assembly of the Jacobian and/or approximating the action of the Jacobian on vectors (e.g.

FD and/or MFFD respectively)

Reimplemented from NonlinearSystemBase.

Definition at line 124 of file NonlinearSystem.C.

{
  if (_use_finite_differenced_preconditioner)
  {
    _nl_implicit_sys.nonlinear_solver->fd_residual_object = &_fd_residual_functor;
    setupFiniteDifferencedPreconditioner();
  }
 
  libMesh::PetscNonlinearSolver<Real> & solver =
      cast_ref<libMesh::PetscNonlinearSolver<Real> &>(*_nl_implicit_sys.nonlinear_solver);
  solver.mffd_residual_object = &_fd_residual_functor;
 
  solver.set_snesmf_reuse_base(_fe_problem.useSNESMFReuseBase());
}

Referenced by solve().

◆ 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 1730 of file SystemBase.C.

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

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

◆ preInit()

void NonlinearSystemBase::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 227 of file NonlinearSystemBase.C.

{
  SolverSystem::preInit();
 
  if (_fe_problem.hasDampers())
    setupDampers();
 
  if (_residual_copy.get())
    _residual_copy->init(_sys.n_dofs(), false, SERIAL);
 
#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 258 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 281 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 334 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 326 of file SystemBase.C.

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

Referenced by SubProblem::reinitNeighborFaceRef().

◆ preSMOResidual()

Real NonlinearSystemBase::preSMOResidual ( ) const

inherited

The pre-SMO residual.

Definition at line 755 of file NonlinearSystemBase.C.

{
  if (!shouldEvaluatePreSMOResidual())
    mooseError("pre-SMO residual is requested but not evaluated.");
 
  return _pre_smo_residual;
}

Referenced by Residual::getValue(), and NonlinearSystemBase::referenceResidual().

◆ preSolve()

bool NonlinearSystemBase::preSolve ( )

protectedinherited

Perform some steps to get ready for the solver.

These include

zeroing iteration counters
setting initial solutions
possibly performing automatic scaling
Returns
Whether any exceptions were raised while running this method

Definition at line 4259 of file NonlinearSystemBase.C.

{
  // Clear the iteration counters
  _current_l_its.clear();
  _current_nl_its = 0;
 
  // Initialize the solution vector using a predictor and known values from nodal bcs
  setInitialSolution();
 
  // Now that the initial solution has ben set, potentially perform a residual/Jacobian evaluation
  // to determine variable scaling factors
  if (_automatic_scaling)
  {
    const bool scaling_succeeded = computeScaling();
    if (!scaling_succeeded)
      return false;
  }
 
  convergence().preLoop();
 
  return true;
}

Referenced by NonlinearEigenSystem::solve(), and solve().

◆ printAllVariableNorms()

void NonlinearSystemBase::printAllVariableNorms ( bool state )

inlineinherited

Force the printing of all variable norms after each solve.

Todo:: {Remove after output update

Definition at line 593 of file NonlinearSystemBase.h.

593{ _print_all_var_norms = state; }

NonlinearSystemBase::_print_all_var_norms

bool _print_all_var_norms

Definition NonlinearSystemBase.h:1045

◆ 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 1690 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().

◆ referenceResidual()

Real NonlinearSystemBase::referenceResidual ( ) const

inherited

The reference residual used in relative convergence check.

Definition at line 749 of file NonlinearSystemBase.C.

{
  return usePreSMOResidual() ? preSMOResidual() : initialResidual();
}

Referenced by DefaultNonlinearConvergence::checkConvergence(), and EigenExecutionerBase::inversePowerIteration().

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

virtual void SystemBase::reinit ( )

inlinevirtualinherited

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 in AuxiliarySystem, LinearSystem, and NonlinearEigenSystem.

Definition at line 172 of file SystemBase.h.

172{}

Referenced by NonlinearEigenSystem::reinit().

◆ 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 342 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 368 of file SystemBase.C.

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

Referenced by NonlinearThread::onInterfaceWithHRefinementMismatch(), and SubProblem::reinitElemFaceRef().

◆ reinitIncrementAtNodeForDampers()

void NonlinearSystemBase::reinitIncrementAtNodeForDampers	(	THREAD_ID	tid,
		const std::set< MooseVariable * > &	damped_vars
	)

inherited

Compute the incremental change in variables at nodes for dampers.

Called before we use damping

Parameters

tid	Thread ID
damped_vars	Set of variables for which increment is to be computed

Definition at line 3733 of file NonlinearSystemBase.C.

{
  for (const auto & var : damped_vars)
    var->computeIncrementAtNode(*_increment_vec);
}

Referenced by ComputeNodalDampingThread::onNode().

◆ reinitIncrementAtQpsForDampers()

void NonlinearSystemBase::reinitIncrementAtQpsForDampers	(	THREAD_ID	tid,
		const std::set< MooseVariable * > &	damped_vars
	)

inherited

Compute the incremental change in variables at QPs for dampers.

Called before we use damping

Parameters

tid	Thread ID
damped_vars	Set of variables for which increment is to be computed

Definition at line 3725 of file NonlinearSystemBase.C.

{
  for (const auto & var : damped_vars)
    var->computeIncrementAtQps(*_increment_vec);
}

Referenced by ComputeElemDampingThread::onElement().

◆ reinitLowerD()

void SystemBase::reinitLowerD ( THREAD_ID tid )

virtualinherited

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

Definition at line 392 of file SystemBase.C.

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

Referenced by SubProblem::reinitLowerDElem().

◆ reinitMortarFunctors()

void NonlinearSystemBase::reinitMortarFunctors ( )

inherited

Update the mortar functors if the mesh has changed.

Definition at line 244 of file NonlinearSystemBase.C.

{
  // reinit is called on meshChanged() in FEProblemBase. We could implement meshChanged() instead.
  // Subdomains might have changed
  for (auto & functor : _displaced_mortar_functors)
    functor.second.setupMortarMaterials();
  for (auto & functor : _undisplaced_mortar_functors)
    functor.second.setupMortarMaterials();
}

◆ 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 384 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 376 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 400 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() [1/2]

void NonlinearSystemBase::reinitNodeFace	(	const Node &	secondary_node,
		const BoundaryID	secondary_boundary,
		const PenetrationInfo &	info,
		const bool	displaced
	)

protectedinherited

Reinitialize quantities such as variables, residuals, Jacobians, materials for node-face constraints.

Definition at line 1139 of file NonlinearSystemBase.C.

{
  auto & subproblem = displaced ? cast_ref<SubProblem &>(*_fe_problem.getDisplacedProblem())
                                : cast_ref<SubProblem &>(_fe_problem);
 
  const Elem * primary_elem = info._elem;
  unsigned int primary_side = info._side_num;
  std::vector<Point> points;
  points.push_back(info._closest_point);
 
  // *These next steps MUST be done in this order!*
  // ADL: This is a Chesterton's fence situation. I don't know which calls exactly the above comment
  // is referring to. If I had to guess I would guess just the reinitNodeFace and prepareAssembly
  // calls since the former will size the variable's dof indices and then the latter will resize the
  // residual/Jacobian based off the variable's cached dof indices size
 
  // This reinits the variables that exist on the secondary node
  _fe_problem.reinitNodeFace(&secondary_node, secondary_boundary, 0);
 
  // This will set aside residual and jacobian space for the variables that have dofs on
  // the secondary node
  _fe_problem.prepareAssembly(0);
 
  _fe_problem.setNeighborSubdomainID(primary_elem, 0);
 
  //
  // Reinit material on undisplaced mesh
  //
 
  const Elem * const undisplaced_primary_elem =
      displaced ? _mesh.elemPtr(primary_elem->id()) : primary_elem;
  const Point undisplaced_primary_physical_point =
      [&points, displaced, primary_elem, undisplaced_primary_elem]()
  {
    if (displaced)
    {
      const Point reference_point =
          FEMap::inverse_map(primary_elem->dim(), primary_elem, points[0]);
      return FEMap::map(primary_elem->dim(), undisplaced_primary_elem, reference_point);
    }
    else
      // If our penetration locator is on the reference mesh, then our undisplaced
      // physical point is simply the point coming from the penetration locator
      return points[0];
  }();
 
  _fe_problem.reinitNeighborPhys(
      undisplaced_primary_elem, primary_side, {undisplaced_primary_physical_point}, 0);
  // Stateful material properties are only initialized for neighbor material data for internal faces
  // for discontinuous Galerkin methods or for conforming interfaces for interface kernels. We don't
  // have either of those use cases here where we likely have disconnected meshes
  _fe_problem.reinitMaterialsNeighbor(primary_elem->subdomain_id(), 0, /*swap_stateful=*/false);
 
  // Reinit points for constraint enforcement
  if (displaced)
    subproblem.reinitNeighborPhys(primary_elem, primary_side, points, 0);
}

Referenced by NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::constraintResiduals(), and NonlinearSystemBase::setConstraintSecondaryValues().

◆ reinitNodeFace() [2/2]

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 from SystemBase.

Definition at line 745 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 424 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 435 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 446 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 590 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 1356 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 702 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;
  }
}

◆ residualAndJacobianTogether()

void NonlinearSystem::residualAndJacobianTogether ( )

overridevirtual

Call this method if you want the residual and Jacobian to be computed simultaneously.

Implements NonlinearSystemBase.

Definition at line 434 of file NonlinearSystem.C.

{
  if (_fe_problem.solverParams(number())._type == Moose::ST_JFNK)
    mooseError(
        "Evaluting the residual and Jacobian together does not make sense for a JFNK solve type in "
        "which only function evaluations are required, e.g. there is no need to form a matrix");
 
  nonlinearSolver()->residual_object = nullptr;
  nonlinearSolver()->jacobian = nullptr;
  nonlinearSolver()->residual_and_jacobian_object = &_resid_and_jac_functor;
}

◆ residualCopy()

NumericVector< Number > & NonlinearSystemBase::residualCopy ( )

overridevirtualinherited

Reimplemented from SystemBase.

Definition at line 3580 of file NonlinearSystemBase.C.

{
  if (!_residual_copy.get())
    _residual_copy = NumericVector<Number>::build(_communicator);
 
  return *_residual_copy;
}

◆ residualGhosted()

NumericVector< Number > & NonlinearSystemBase::residualGhosted ( )

overridevirtualinherited

Reimplemented from SystemBase.

Definition at line 3589 of file NonlinearSystemBase.C.

{
  _need_residual_ghosted = true;
  if (!_residual_ghosted)
  {
    // The first time we realize we need a ghosted residual vector,
    // we add it.
    _residual_ghosted = &addVector("residual_ghosted", false, GHOSTED);
 
    // If we've already realized we need time and/or non-time
    // residual vectors, but we haven't yet realized they need to be
    // ghosted, fix that now.
    //
    // If an application changes its mind, the libMesh API lets us
    // change the vector.
    if (_Re_time)
    {
      const auto vector_name = _subproblem.vectorTagName(_Re_time_tag);
      _Re_time = &system().add_vector(vector_name, false, GHOSTED);
    }
    if (_Re_non_time)
    {
      const auto vector_name = _subproblem.vectorTagName(_Re_non_time_tag);
      _Re_non_time = &system().add_vector(vector_name, false, GHOSTED);
    }
  }
  return *_residual_ghosted;
}

◆ residualSetup()

void NonlinearSystemBase::residualSetup ( )

overridevirtualinherited

Reimplemented from SystemBase.

Definition at line 1708 of file NonlinearSystemBase.C.

{
  TIME_SECTION("residualSetup", 3);
 
  SolverSystem::residualSetup();
 
  for (THREAD_ID tid = 0; tid < this->numThreads(); tid++)
  {
    _kernels.residualSetup(tid);
    _nodal_kernels.residualSetup(tid);
    _dirac_kernels.residualSetup(tid);
    if (_doing_dg)
      _dg_kernels.residualSetup(tid);
    _interface_kernels.residualSetup(tid);
    _element_dampers.residualSetup(tid);
    _nodal_dampers.residualSetup(tid);
    _integrated_bcs.residualSetup(tid);
  }
  _scalar_kernels.residualSetup();
  _constraints.residualSetup();
  _general_dampers.residualSetup();
  _nodal_bcs.residualSetup();
  _preset_nodal_bcs.residualSetup();
  _ad_preset_nodal_bcs.residualSetup();
 
#ifdef MOOSE_KOKKOS_ENABLED
  _kokkos_kernels.residualSetup();
  _kokkos_nodal_kernels.residualSetup();
  _kokkos_integrated_bcs.residualSetup();
  _kokkos_nodal_bcs.residualSetup();
#endif
 
  // Avoid recursion
  if (this == &_fe_problem.currentNonlinearSystem())
    _fe_problem.residualSetup();
}

Referenced by NonlinearSystemBase::computeResidualAndJacobianInternal(), and NonlinearSystemBase::computeResidualInternal().

◆ residualVector()

NumericVector< Number > & NonlinearSystemBase::residualVector ( TagID tag )

inherited

Return a residual vector that is associated with the residual tag.

Definition at line 1068 of file NonlinearSystemBase.C.

{
  mooseDeprecated("Please use getVector()");
  switch (tag)
  {
    case 0:
      return getResidualNonTimeVector();
 
    case 1:
      return getResidualTimeVector();
 
    default:
      mooseError("The required residual vector is not available");
  }
}

◆ residualVectorTag()

TagID NonlinearSystemBase::residualVectorTag ( ) const

inlineoverridevirtualinherited

Reimplemented from SystemBase.

Definition at line 712 of file NonlinearSystemBase.h.

712{ return _Re_tag; }

NonlinearSystemBase::_Re_tag

TagID _Re_tag

Used for the residual vector from PETSc.

Definition NonlinearSystemBase.h:938

Referenced by NonlinearSystemBase::computeNodalBCsResidual(), NonlinearSystemBase::computeNodalBCsResidual(), FEProblemBase::computeResidualAndJacobian(), NonlinearSystemBase::computeResidualAndJacobianTags(), FEProblemBase::computeResidualInternal(), NonlinearSystemBase::computeResidualTag(), NonlinearSystemBase::computeResidualTags(), FEProblemBase::computeResidualType(), and FEProblemBase::setResidualNeighbor().

◆ restoreAdditionalStates()

virtual void SystemBase::restoreAdditionalStates ( )

inlineprotectedvirtualinherited

Restore system-owned state not represented by solution vectors.

Default implementation does nothing.

Reimplemented in AuxiliarySystem, and LinearSystem.

Definition at line 1019 of file SystemBase.h.

1019{}

Referenced by SystemBase::restoreStateHistory().

◆ restoreOldSolutions()

void SystemBase::restoreOldSolutions ( )

virtualinherited

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

Definition at line 543 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 1349 of file SystemBase.C.

{
  restoreSolutions();
  restoreAdditionalStates();
}

◆ RHS()

virtual NumericVector< Number > & NonlinearSystem::RHS ( )

inlineoverridevirtual

Implements NonlinearSystemBase.

Definition at line 58 of file NonlinearSystem.h.

58{ return *_nl_implicit_sys.rhs; }

libMesh::NonlinearImplicitSystem::rhs

NumericVector< Number > * rhs

Referenced by computeScalingResidual().

◆ saveOldSolutions()

void SystemBase::saveOldSolutions ( )

virtualinherited

Save the old and older solutions.

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

◆ scalingGroupVariables()

void NonlinearSystemBase::scalingGroupVariables ( const std::vector< std::vector< std::string > > & scaling_group_variables )

inlineinherited

Definition at line 736 of file NonlinearSystemBase.h.

  {
    _scaling_group_variables = scaling_group_variables;
  }

◆ 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 1663 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 1643 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 1637 of file SystemBase.C.

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

Referenced by SubProblem::setActiveFEVariableCoupleableVectorTags().

◆ setConstraintSecondaryValues()

void NonlinearSystemBase::setConstraintSecondaryValues	(	NumericVector< Number > &	solution,
		bool	displaced
	)

inherited

Sets the value of constrained variables in the solution vector.

Definition at line 1201 of file NonlinearSystemBase.C.

{
 
  if (displaced)
    mooseAssert(_fe_problem.getDisplacedProblem(),
                "If we're calling this method with displaced = true, then we better well have a "
                "displaced problem");
  auto & subproblem = displaced ? cast_ref<SubProblem &>(*_fe_problem.getDisplacedProblem())
                                : cast_ref<SubProblem &>(_fe_problem);
  const auto & penetration_locators = subproblem.geomSearchData()._penetration_locators;
 
  bool constraints_applied = false;
 
  for (const auto & it : penetration_locators)
  {
    PenetrationLocator & pen_loc = *(it.second);
 
    std::vector<dof_id_type> & secondary_nodes = pen_loc._nearest_node._secondary_nodes;
 
    BoundaryID secondary_boundary = pen_loc._secondary_boundary;
    BoundaryID primary_boundary = pen_loc._primary_boundary;
 
    if (_constraints.hasActiveNodeFaceConstraints(secondary_boundary, displaced))
    {
      const auto & constraints =
          _constraints.getActiveNodeFaceConstraints(secondary_boundary, displaced);
      std::unordered_set<unsigned int> needed_mat_props;
      for (const auto & constraint : constraints)
      {
        const auto & mp_deps = constraint->getMatPropDependencies();
        needed_mat_props.insert(mp_deps.begin(), mp_deps.end());
      }
      _fe_problem.setActiveMaterialProperties(needed_mat_props, /*tid=*/0);
 
      for (unsigned int i = 0; i < secondary_nodes.size(); i++)
      {
        dof_id_type secondary_node_num = secondary_nodes[i];
        Node & secondary_node = _mesh.nodeRef(secondary_node_num);
 
        if (secondary_node.processor_id() == processor_id())
        {
          if (pen_loc._penetration_info[secondary_node_num])
          {
            PenetrationInfo & info = *pen_loc._penetration_info[secondary_node_num];
 
            reinitNodeFace(secondary_node, secondary_boundary, info, displaced);
 
            for (const auto & nfc : constraints)
            {
              if (nfc->isExplicitConstraint())
                continue;
              // Return if this constraint does not correspond to the primary-secondary pair
              // prepared by the outer loops.
              // This continue statement is required when, e.g. one secondary surface constrains
              // more than one primary surface.
              if (nfc->secondaryBoundary() != secondary_boundary ||
                  nfc->primaryBoundary() != primary_boundary)
                continue;
 
              if (nfc->shouldApply())
              {
                constraints_applied = true;
                nfc->computeSecondaryValue(solution);
              }
 
              if (nfc->hasWritableCoupledVariables())
              {
                Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
                for (auto * var : nfc->getWritableCoupledVariables())
                {
                  if (var->isNodalDefined())
                    var->insert(_fe_problem.getAuxiliarySystem().solution());
                }
              }
            }
          }
        }
      }
    }
  }
 
  // go over NodeELemConstraints
  std::set<dof_id_type> unique_secondary_node_ids;
 
  for (const auto & secondary_id : _mesh.meshSubdomains())
  {
    for (const auto & primary_id : _mesh.meshSubdomains())
    {
      if (_constraints.hasActiveNodeElemConstraints(secondary_id, primary_id, displaced))
      {
        const auto & constraints =
            _constraints.getActiveNodeElemConstraints(secondary_id, primary_id, displaced);
 
        // get unique set of ids of all nodes on current block
        unique_secondary_node_ids.clear();
        const MeshBase & meshhelper = _mesh.getMesh();
        for (const auto & elem : as_range(meshhelper.active_subdomain_elements_begin(secondary_id),
                                          meshhelper.active_subdomain_elements_end(secondary_id)))
        {
          for (auto & n : elem->node_ref_range())
            unique_secondary_node_ids.insert(n.id());
        }
 
        for (auto secondary_node_id : unique_secondary_node_ids)
        {
          Node & secondary_node = _mesh.nodeRef(secondary_node_id);
 
          // check if secondary node is on current processor
          if (secondary_node.processor_id() == processor_id())
          {
            // This reinits the variables that exist on the secondary node
            _fe_problem.reinitNodeFace(&secondary_node, secondary_id, 0);
 
            // This will set aside residual and jacobian space for the variables that have dofs
            // on the secondary node
            _fe_problem.prepareAssembly(0);
 
            for (const auto & nec : constraints)
            {
              if (nec->shouldApply())
              {
                constraints_applied = true;
                nec->computeSecondaryValue(solution);
              }
            }
          }
        }
      }
    }
  }
 
  // See if constraints were applied anywhere
  _communicator.max(constraints_applied);
 
  if (constraints_applied)
  {
    solution.close();
    update();
  }
}

Referenced by NonlinearSystemBase::setInitialSolution().

◆ setConvergenceName()

void NonlinearSystemBase::setConvergenceName ( const ConvergenceName & convergence_name )

inlineinherited

Sets the name of the associated Convergence object.

Definition at line 778 of file NonlinearSystemBase.h.

  {
    _convergence_name = convergence_name;
  }

◆ setInitialResidual()

void NonlinearSystemBase::setInitialResidual ( Real r )

inherited

Record the initial residual (for later relative convergence check)

Definition at line 770 of file NonlinearSystemBase.C.

{
  _initial_residual = r;
}

Referenced by DefaultNonlinearConvergence::checkConvergence().

◆ setInitialSolution()

void NonlinearSystemBase::setInitialSolution ( )

inherited

Definition at line 936 of file NonlinearSystemBase.C.

{
  deactivateAllMatrixTags();
 
  NumericVector<Number> & initial_solution(solution());
  if (_predictor.get())
  {
    if (_predictor->shouldApply())
    {
      TIME_SECTION("applyPredictor", 2, "Applying Predictor");
 
      _predictor->apply(initial_solution);
      _fe_problem.predictorCleanup(initial_solution);
    }
    else
      _console << " Skipping predictor this step" << std::endl;
  }
 
  // do nodal BC
  {
    TIME_SECTION("initialBCs", 2, "Applying BCs To Initial Condition");
 
    const ConstBndNodeRange & bnd_nodes = _fe_problem.getCurrentAlgebraicBndNodeRange();
    for (const auto & bnode : bnd_nodes)
    {
      BoundaryID boundary_id = bnode->_bnd_id;
      Node * node = bnode->_node;
 
      if (node->processor_id() == processor_id())
      {
        bool has_preset_nodal_bcs = _preset_nodal_bcs.hasActiveBoundaryObjects(boundary_id);
        bool has_ad_preset_nodal_bcs = _ad_preset_nodal_bcs.hasActiveBoundaryObjects(boundary_id);
 
        // reinit variables in nodes
        if (has_preset_nodal_bcs || has_ad_preset_nodal_bcs)
          _fe_problem.reinitNodeFace(node, boundary_id, 0);
 
        if (has_preset_nodal_bcs)
        {
          const auto & preset_bcs = _preset_nodal_bcs.getActiveBoundaryObjects(boundary_id);
          for (const auto & preset_bc : preset_bcs)
            preset_bc->computeValue(initial_solution);
        }
        if (has_ad_preset_nodal_bcs)
        {
          const auto & preset_bcs_res = _ad_preset_nodal_bcs.getActiveBoundaryObjects(boundary_id);
          for (const auto & preset_bc : preset_bcs_res)
            preset_bc->computeValue(initial_solution);
        }
      }
    }
  }
 
#ifdef MOOSE_KOKKOS_ENABLED
  if (_kokkos_preset_nodal_bcs.hasObjects())
    setKokkosInitialSolution();
#endif
 
  _sys.solution->close();
  update();
 
  // Set constraint secondary values
  setConstraintSecondaryValues(initial_solution, false);
 
  if (_fe_problem.getDisplacedProblem())
    setConstraintSecondaryValues(initial_solution, true);
}

Referenced by NonlinearSystemBase::preSolve().

◆ setKokkosInitialSolution()

void NonlinearSystemBase::setKokkosInitialSolution ( )

inherited

Referenced by NonlinearSystemBase::setInitialSolution().

◆ setMatrixOptions()

void NonlinearSystemBase::setMatrixOptions ( const std::set< TagID > & tags )

protectedinherited

Set the PETSc options used for assembling the matrices of the given tags.

Parameters

tags	The matrix tags

Definition at line 2998 of file NonlinearSystemBase.C.

{
  for (auto tag : tags)
  {
    if (!hasMatrix(tag))
      continue;
 
    auto & jacobian = getMatrix(tag);
    // Necessary for speed
    if (auto petsc_matrix = dynamic_cast<PetscMatrix<Number> *>(&jacobian))
    {
      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 (_fe_problem.ignoreZerosInJacobian())
        LibmeshPetscCall(MatSetOption(
            cast_ref<PetscMatrix<Number> &>(jacobian).mat(), MAT_IGNORE_ZERO_ENTRIES, PETSC_TRUE));
    }
  }
}

Referenced by NonlinearSystemBase::computeJacobianInternal(), and NonlinearSystemBase::computeResidualAndJacobianInternal().

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

◆ setPreconditioner()

void NonlinearSystemBase::setPreconditioner ( std::shared_ptr< MoosePreconditioner > pc )

inherited

Sets a preconditioner.

Parameters

pc	The preconditioner to be set

Definition at line 3704 of file NonlinearSystemBase.C.

{
  if (_preconditioner.get() != nullptr)
    mooseError("More than one active Preconditioner detected");
 
  _preconditioner = pc;
}

Referenced by SetupPreconditionerAction::act().

◆ setPredictor()

void NonlinearSystemBase::setPredictor ( std::shared_ptr< Predictor > predictor )

inherited

Definition at line 1005 of file NonlinearSystemBase.C.

{
  _predictor = predictor;
}

Referenced by SetupPredictorAction::act().

◆ setPreSMOResidual()

void NonlinearSystemBase::setPreSMOResidual ( bool use )

inlineinherited

Set whether to evaluate the pre-SMO residual and use it in the subsequent relative convergence checks.

If set to true, an additional residual evaluation is performed before any solution-modifying object is executed, and before the initial (0-th nonlinear iteration) residual evaluation. Such residual is referred to as the pre-SMO residual. If the pre-SMO residual is evaluated, it is used in the subsequent relative convergence checks.

If set to false, no residual evaluation takes place before the initial residual evaluation, and the initial residual is used in the subsequent relative convergence checks. This mode is recommended for performance-critical code as it avoids the additional pre-SMO residual evaluation.

Definition at line 287 of file NonlinearSystemBase.h.

287{ _use_pre_smo_residual = use; }

NonlinearSystemBase::_use_pre_smo_residual

bool _use_pre_smo_residual

Whether to use the pre-SMO initial residual in the relative convergence check.

Definition NonlinearSystemBase.h:1043

Referenced by FEProblemSolve::FEProblemSolve().

◆ setPreviousNewtonSolution()

void NonlinearSystemBase::setPreviousNewtonSolution ( const NumericVector< Number > & soln )

virtualinherited

Definition at line 4001 of file NonlinearSystemBase.C.

{
  if (hasVector(Moose::PREVIOUS_NL_SOLUTION_TAG))
    getVector(Moose::PREVIOUS_NL_SOLUTION_TAG) = soln;
}

Referenced by FEProblemBase::computePostCheck().

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

◆ setSolutionUDot()

void NonlinearSystemBase::setSolutionUDot ( const NumericVector< Number > & udot )

virtualinherited

Set transient term used by residual and Jacobian evaluation.

Parameters

udot	transient term

Note: If the calling sequence for residual evaluation was changed, this could become an explicit argument.

Definition at line 3680 of file NonlinearSystemBase.C.

{
  *_u_dot = u_dot;
}

◆ setSolutionUDotDot()

void NonlinearSystemBase::setSolutionUDotDot ( const NumericVector< Number > & udotdot )

virtualinherited

Set transient term used by residual and Jacobian evaluation.

Parameters

udotdot transient term

Note: If the calling sequence for residual evaluation was changed, this could become an explicit argument.

Definition at line 3686 of file NonlinearSystemBase.C.

{
  *_u_dotdot = u_dotdot;
}

◆ setSolutionUDotDotOld()

void NonlinearSystemBase::setSolutionUDotDotOld ( const NumericVector< Number > & u_dotdot_old )

virtualinherited

Definition at line 3698 of file NonlinearSystemBase.C.

{
  *_u_dotdot_old = u_dotdot_old;
}

◆ setSolutionUDotOld()

void NonlinearSystemBase::setSolutionUDotOld ( const NumericVector< Number > & u_dot_old )

virtualinherited

Definition at line 3692 of file NonlinearSystemBase.C.

{
  *_u_dot_old = u_dot_old;
}

◆ setupColoringFiniteDifferencedPreconditioner()

void NonlinearSystem::setupColoringFiniteDifferencedPreconditioner ( )

private

According to the nonzero pattern provided in the matrix, a graph is constructed.

A coloring algorithm is applied to the graph. The graph is partitioned into several independent subgraphs (colors), and a finte difference method is applied color-by-color to form a preconditioning matrix. If the number of colors is small, this method is much faster than the standard FD. But there is an issue. If the matrix provided by users does not represent the actual structure of the true Jacobian, the matrix computed via coloring could be wrong or inaccurate. In this case, users should switch to the standard finite difference method.

Definition at line 276 of file NonlinearSystem.C.

{
  // Make sure that libMesh isn't going to override our preconditioner
  _nl_implicit_sys.nonlinear_solver->jacobian = nullptr;
 
  libMesh::PetscNonlinearSolver<Number> & petsc_nonlinear_solver =
      dynamic_cast<libMesh::PetscNonlinearSolver<Number> &>(*_nl_implicit_sys.nonlinear_solver);
 
  // Pointer to underlying PetscMatrix type
  PetscMatrix<Number> * petsc_mat =
      dynamic_cast<PetscMatrix<Number> *>(&_nl_implicit_sys.get_system_matrix());
 
  Moose::compute_jacobian(*_nl_implicit_sys.current_local_solution, *petsc_mat, _nl_implicit_sys);
 
  if (!petsc_mat)
    mooseError("Could not convert to Petsc matrix.");
 
  petsc_mat->close();
 
  ISColoring iscoloring;
 
  // PETSc 3.5.x
  MatColoring matcoloring;
  LibmeshPetscCallA(_communicator.get(), MatColoringCreate(petsc_mat->mat(), &matcoloring));
  LibmeshPetscCallA(_communicator.get(), MatColoringSetType(matcoloring, MATCOLORINGLF));
  LibmeshPetscCallA(_communicator.get(), MatColoringSetFromOptions(matcoloring));
  LibmeshPetscCallA(_communicator.get(), MatColoringApply(matcoloring, &iscoloring));
  LibmeshPetscCallA(_communicator.get(), MatColoringDestroy(&matcoloring));
 
  LibmeshPetscCallA(_communicator.get(),
                    MatFDColoringCreate(petsc_mat->mat(), iscoloring, &_fdcoloring));
  LibmeshPetscCallA(_communicator.get(), MatFDColoringSetFromOptions(_fdcoloring));
  // clang-format off
#if PETSC_VERSION_LESS_THAN(3, 24, 0)
  LibmeshPetscCallA(_communicator.get(),
                    MatFDColoringSetFunction(_fdcoloring,
                                             (PetscErrorCode(*)(void))(void (*)(void))
                                             &libMesh::libmesh_petsc_snes_fd_residual,
                                             &petsc_nonlinear_solver));
#else
  LibmeshPetscCallA(_communicator.get(),
                    MatFDColoringSetFunction(_fdcoloring,
                                             (MatFDColoringFn*)
                                             &libMesh::libmesh_petsc_snes_fd_residual,
                                             &petsc_nonlinear_solver));
#endif
  // clang-format on
  LibmeshPetscCallA(_communicator.get(),
                    MatFDColoringSetUp(petsc_mat->mat(), iscoloring, _fdcoloring));
  LibmeshPetscCallA(_communicator.get(),
                    SNESSetJacobian(petsc_nonlinear_solver.snes(),
                                    petsc_mat->mat(),
                                    petsc_mat->mat(),
                                    SNESComputeJacobianDefaultColor,
                                    _fdcoloring));
  // PETSc >=3.3.0
  LibmeshPetscCallA(_communicator.get(), ISColoringDestroy(&iscoloring));
}

Referenced by setupFiniteDifferencedPreconditioner().

◆ setupDampers()

void NonlinearSystemBase::setupDampers ( )

inherited

Setup damping stuff (called before we actually start)

Definition at line 3719 of file NonlinearSystemBase.C.

{
  _increment_vec = &_sys.add_vector("u_increment", true, GHOSTED);
}

Referenced by NonlinearSystemBase::preInit().

◆ setupDM()

void NonlinearSystemBase::setupDM ( )

inherited

Setup the PETSc DM object (when appropriate)

Definition at line 441 of file NonlinearSystemBase.C.

{
  if (_fsp)
    _fsp->setupDM();
}

Referenced by FEProblemBase::solve().

◆ setupFiniteDifferencedPreconditioner()

void NonlinearSystem::setupFiniteDifferencedPreconditioner ( )

overridevirtual

Implements NonlinearSystemBase.

Definition at line 233 of file NonlinearSystem.C.

{
  std::shared_ptr<FiniteDifferencePreconditioner> fdp =
      std::dynamic_pointer_cast<FiniteDifferencePreconditioner>(_preconditioner);
  if (!fdp)
    mooseError("Did not setup finite difference preconditioner, and please add a preconditioning "
               "block with type = fdp");
 
  if (fdp->finiteDifferenceType() == "coloring")
  {
    _use_coloring_finite_difference = true;
    setupColoringFiniteDifferencedPreconditioner();
  }
 
  else if (fdp->finiteDifferenceType() == "standard")
  {
    _use_coloring_finite_difference = false;
    setupStandardFiniteDifferencedPreconditioner();
  }
  else
    mooseError("Unknown finite difference type");
}

Referenced by potentiallySetupFiniteDifferencing().

◆ setupScalingData()

void NonlinearSystemBase::setupScalingData ( )

privateinherited

Setup group scaling containers.

Definition at line 4032 of file NonlinearSystemBase.C.

{
  if (_auto_scaling_initd)
    return;
 
  // Want the libMesh count of variables, not MOOSE, e.g. I don't care about array variable counts
  const auto n_vars = system().n_vars();
 
  if (_scaling_group_variables.empty())
  {
    _var_to_group_var.reserve(n_vars);
    _num_scaling_groups = n_vars;
 
    for (const auto var_number : make_range(n_vars))
      _var_to_group_var.emplace(var_number, var_number);
  }
  else
  {
    std::set<unsigned int> var_numbers, var_numbers_covered, var_numbers_not_covered;
    for (const auto var_number : make_range(n_vars))
      var_numbers.insert(var_number);
 
    _num_scaling_groups = _scaling_group_variables.size();
 
    for (const auto group_index : index_range(_scaling_group_variables))
      for (const auto & var_name : _scaling_group_variables[group_index])
      {
        if (!hasVariable(var_name) && !hasScalarVariable(var_name))
          mooseError("'",
                     var_name,
                     "', provided to the 'scaling_group_variables' parameter, does not exist in "
                     "the nonlinear system.");
 
        const MooseVariableBase & var =
            hasVariable(var_name) ? cast_ref<MooseVariableBase &>(getVariable(0, var_name))
                                  : cast_ref<MooseVariableBase &>(getScalarVariable(0, var_name));
        auto map_pair = _var_to_group_var.emplace(var.number(), group_index);
        if (!map_pair.second)
          mooseError("Variable ", var_name, " is contained in multiple scaling grouplings");
        var_numbers_covered.insert(var.number());
      }
 
    std::set_difference(var_numbers.begin(),
                        var_numbers.end(),
                        var_numbers_covered.begin(),
                        var_numbers_covered.end(),
                        std::inserter(var_numbers_not_covered, var_numbers_not_covered.begin()));
 
    _num_scaling_groups = _scaling_group_variables.size() + var_numbers_not_covered.size();
 
    auto index = static_cast<unsigned int>(_scaling_group_variables.size());
    for (auto var_number : var_numbers_not_covered)
      _var_to_group_var.emplace(var_number, index++);
  }
 
  _variable_autoscaled.resize(n_vars, true);
  const auto & number_to_var_map = _vars[0].numberToVariableMap();
 
  if (_ignore_variables_for_autoscaling.size())
    for (const auto i : index_range(_variable_autoscaled))
      if (std::find(_ignore_variables_for_autoscaling.begin(),
                    _ignore_variables_for_autoscaling.end(),
                    libmesh_map_find(number_to_var_map, i)->name()) !=
          _ignore_variables_for_autoscaling.end())
        _variable_autoscaled[i] = false;
 
  _auto_scaling_initd = true;
}

Referenced by NonlinearSystemBase::computeScaling().

◆ setupStandardFiniteDifferencedPreconditioner()

void NonlinearSystem::setupStandardFiniteDifferencedPreconditioner ( )

private

Form preconditioning matrix via a standard finite difference method column-by-column.

This method computes both diagonal and off-diagonal entrices regardless of the structure pattern of the Jacobian matrix.

Definition at line 257 of file NonlinearSystem.C.

{
  // Make sure that libMesh isn't going to override our preconditioner
  _nl_implicit_sys.nonlinear_solver->jacobian = nullptr;
 
  libMesh::PetscNonlinearSolver<Number> * petsc_nonlinear_solver =
      cast_ptr<libMesh::PetscNonlinearSolver<Number> *>(_nl_implicit_sys.nonlinear_solver.get());
 
  PetscMatrix<Number> * petsc_mat =
      cast_ptr<PetscMatrix<Number> *>(&_nl_implicit_sys.get_system_matrix());
 
  LibmeshPetscCall(SNESSetJacobian(petsc_nonlinear_solver->snes(),
                                   petsc_mat->mat(),
                                   petsc_mat->mat(),
                                   SNESComputeJacobianDefault,
                                   nullptr));
}

Referenced by setupFiniteDifferencedPreconditioner().

◆ 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 188 of file SystemBase.C.

{
  AllLocalDofIndicesThread aldit(_subproblem, {var_name});
  const ConstElemRange & elem_range = *_mesh.getActiveLocalElementRange();
  Threads::parallel_reduce(elem_range, aldit, numThreads());
 
  // 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 138 of file SystemBase.h.

138{ _verbose = verbose; }

Referenced by Executioner::Executioner().

◆ shouldEvaluatePreSMOResidual()

bool NonlinearSystemBase::shouldEvaluatePreSMOResidual ( ) const

inherited

We offer the option to check convergence against the pre-SMO residual.

This method handles the logic as to whether we should perform such residual evaluation.

Returns: A boolean indicating whether we should evaluate the pre-SMO residual.

Definition at line 731 of file NonlinearSystemBase.C.

{
  if (_fe_problem.solverParams(number())._type == Moose::ST_LINEAR)
    return false;
 
  // The legacy behavior (#10464) _always_ performs the pre-SMO residual evaluation
  // regardless of whether it is needed.
  //
  // This is not ideal and has been fixed by #23472. This legacy option ensures a smooth transition
  // to the new behavior. Modules and Apps that want to migrate to the new behavior should set this
  // parameter to false.
  if (_app.parameters().get<bool>("use_legacy_initial_residual_evaluation_behavior"))
    return true;
 
  return _use_pre_smo_residual;
}

Referenced by NonlinearSystemBase::preSMOResidual(), and solve().

◆ sizeVariableMatrixData()

void SystemBase::sizeVariableMatrixData ( )

inherited

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

Definition at line 1736 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 1003 of file SystemBase.h.

1003{ _skip_next_solution_to_old_copy = true; }

◆ solution() [1/2]

NumericVector< Number > & SystemBase::solution ( )

inlineinherited

Definition at line 215 of file SystemBase.h.

215{ return solutionState(0); }

◆ solution() [2/2]

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

inlineinherited

Definition at line 218 of file SystemBase.h.

218{ 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 216 of file SystemBase.h.

216{ 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 219 of file SystemBase.h.

219{ return solutionState(1); }

◆ solutionOlder() [1/2]

NumericVector< Number > & SystemBase::solutionOlder ( )

inlineinherited

Definition at line 217 of file SystemBase.h.

217{ 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 220 of file SystemBase.h.

220{ return solutionState(2); }

◆ solutionPreviousNewton() [1/2]

NumericVector< Number > * SystemBase::solutionPreviousNewton ( )

virtualinherited

Reimplemented in DisplacedSystem.

Definition at line 1368 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 1377 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 1469 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 1439 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 1478 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 929 of file SystemBase.h.

929{ return _solution_states_initialized; }

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

◆ solutionUDot() [1/2]

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

inlinevirtualinherited

Reimplemented in DisplacedSystem.

Definition at line 292 of file SystemBase.h.

292{ return _u_dot; }

◆ solutionUDot() [2/2]

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

inlinevirtualinherited

Reimplemented in DisplacedSystem.

Definition at line 296 of file SystemBase.h.

296{ return _u_dot; }

◆ solutionUDotDot() [1/2]

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

inlinevirtualinherited

Reimplemented in DisplacedSystem.

Definition at line 293 of file SystemBase.h.

293{ 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 297 of file SystemBase.h.

297{ return _u_dotdot; }

◆ solutionUDotDotOld() [1/2]

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

inlinevirtualinherited

Reimplemented in DisplacedSystem.

Definition at line 295 of file SystemBase.h.

295{ 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 299 of file SystemBase.h.

299{ return _u_dotdot_old; }

◆ solutionUDotOld() [1/2]

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

inlinevirtualinherited

Reimplemented in DisplacedSystem.

Definition at line 294 of file SystemBase.h.

294{ 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 298 of file SystemBase.h.

298{ return _u_dot_old; }

◆ solve()

void NonlinearSystem::solve ( )

overridevirtual

Solve the system (using libMesh magic)

Implements NonlinearSystemBase.

Definition at line 140 of file NonlinearSystem.C.

{
  // Only attach the postcheck function to the solver if we actually
  // have dampers or if the FEProblemBase needs to update the solution,
  // which is also done during the linesearch postcheck.  It doesn't
  // hurt to do this multiple times, it is just setting a pointer.
  if (_fe_problem.hasDampers() || _fe_problem.shouldUpdateSolution() ||
      _fe_problem.needsPreviousNewtonIteration())
    _nl_implicit_sys.nonlinear_solver->postcheck = Moose::compute_postcheck;
 
  if (shouldEvaluatePreSMOResidual())
  {
    TIME_SECTION("nlPreSMOResidual", 3, "Computing Pre-SMO Residual");
    // Calculate the pre-SMO residual for use in the convergence criterion.
    _computing_pre_smo_residual = true;
    _fe_problem.computeResidualSys(_nl_implicit_sys, *_current_solution, *_nl_implicit_sys.rhs);
    _computing_pre_smo_residual = false;
    _nl_implicit_sys.rhs->close();
    _pre_smo_residual = _nl_implicit_sys.rhs->l2_norm();
    _console << " * Nonlinear |R| = "
             << Console::outputNorm(std::numeric_limits<Real>::max(), _pre_smo_residual)
             << " (Before preset BCs, predictors, correctors, and constraints)\n";
    _console << std::flush;
  }
 
  const bool presolve_succeeded = preSolve();
  if (!presolve_succeeded)
    return;
 
  potentiallySetupFiniteDifferencing();
 
  const bool time_integrator_solve = std::any_of(_time_integrators.begin(),
                                                 _time_integrators.end(),
                                                 [](auto & ti) { return ti->overridesSolve(); });
  if (time_integrator_solve)
    mooseAssert(_time_integrators.size() == 1,
                "If solve is overridden, then there must be only one time integrator");
 
  if (time_integrator_solve)
    _time_integrators.front()->solve();
  else
    system().solve();
 
  for (auto & ti : _time_integrators)
  {
    if (!ti->overridesSolve())
      ti->setNumIterationsLastSolve();
    ti->postSolve();
  }
 
  if (!_time_integrators.empty())
  {
    _n_iters = _time_integrators.front()->getNumNonlinearIterations();
    _n_linear_iters = _time_integrators.front()->getNumLinearIterations();
  }
  else
  {
    _n_iters = _nl_implicit_sys.n_nonlinear_iterations();
    _n_linear_iters = _nl_implicit_sys.nonlinear_solver->get_total_linear_iterations();
  }
 
  // store info about the solve
  _final_residual = _nl_implicit_sys.final_nonlinear_residual();
 
  // determine whether solution invalid occurs in the converged solution
  checkInvalidSolution();
 
  if (_use_coloring_finite_difference)
    LibmeshPetscCall(MatFDColoringDestroy(&_fdcoloring));
}

◆ stopSolve()

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

overridevirtual

Quit the current solve as soon as possible.

Implements SolverSystem.

Definition at line 212 of file NonlinearSystem.C.

{
  libMesh::PetscNonlinearSolver<Real> & solver =
      cast_ref<libMesh::PetscNonlinearSolver<Real> &>(*sys().nonlinear_solver);
 
  if (exec_flag == EXEC_LINEAR || exec_flag == EXEC_POSTCHECK)
  {
    LibmeshPetscCall(SNESSetFunctionDomainError(solver.snes()));
 
    // Clean up by getting vectors into a valid state for a
    // (possible) subsequent solve.
    closeTaggedVectors(vector_tags_to_close);
  }
  else if (exec_flag == EXEC_NONLINEAR)
    LibmeshPetscCall(SNESSetJacobianDomainError(solver.snes()));
  else
    mooseError("Unsupported execute flag: ", Moose::stringify(exec_flag));
}

◆ subdomainSetup() [1/2]

void SystemBase::subdomainSetup ( )

virtualinherited

Reimplemented from SystemBase.

Definition at line 935 of file SystemBase.C.

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

◆ subdomainSetup() [2/2]

void NonlinearSystemBase::subdomainSetup	(	SubdomainID	subdomain,
		THREAD_ID	tid
	)

virtualinherited

Called from assembling when we hit a new subdomain.

Parameters

subdomain	ID of the new subdomain
tid	Thread ID

Definition at line 1011 of file NonlinearSystemBase.C.

{
  SolverSystem::subdomainSetup();
 
  _kernels.subdomainSetup(subdomain, tid);
  _nodal_kernels.subdomainSetup(subdomain, tid);
  _element_dampers.subdomainSetup(subdomain, tid);
  _nodal_dampers.subdomainSetup(subdomain, tid);
}

◆ subproblem() [1/2]

SubProblem & SystemBase::subproblem ( )

inlineinherited

Definition at line 102 of file SystemBase.h.

102{ 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.

103{ return _subproblem; }

◆ sys()

virtual libMesh::NonlinearImplicitSystem & NonlinearSystem::sys ( )

inlinevirtual

Definition at line 67 of file NonlinearSystem.h.

67{ return _nl_implicit_sys; }

Referenced by MooseEigenSystem::buildSystemDoFIndices(), and stopSolve().

◆ system() [1/2]

virtual const libMesh::System & NonlinearSystemBase::system ( ) const

inlineoverridevirtualinherited

Implements SystemBase.

Definition at line 702 of file NonlinearSystemBase.h.

702{ return _sys; }

◆ system() [2/2]

virtual libMesh::System & NonlinearSystemBase::system ( )

inlineoverridevirtualinherited

Get the reference to the libMesh system.

Implements SystemBase.

Definition at line 701 of file NonlinearSystemBase.h.

701{ return _sys; }

Referenced by PhysicsBasedPreconditioner::addSystem(), PhysicsBasedPreconditioner::apply(), DefaultNonlinearConvergence::checkPetscToleranceOverrides(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeResidualAndJacobian(), NonlinearSystemBase::computeScaling(), PseudoTimestep::currentResidualNorm(), VariableResidual::execute(), NonlinearSystemBase::getResidualNonTimeVector(), NonlinearSystemBase::getResidualTimeVector(), getSNES(), ExplicitTimeIntegrator::initialSetup(), ActivateElementsUserObjectBase::initSolutions(), EigenExecutionerBase::inversePowerIteration(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), EigenExecutionerBase::nonlinearSolve(), Moose::PetscSupport::petscSetDefaults(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), ComputeJacobianThread::postElement(), NonlinearSystemBase::residualGhosted(), Moose::PetscSupport::setLineSearchFromParams(), DefaultNonlinearConvergence::setNonlinearSystemParameters(), PhysicsBasedPreconditioner::setup(), NonlinearSystemBase::setupScalingData(), SingleMatrixPreconditioner::SingleMatrixPreconditioner(), NonlinearEigenSystem::solve(), solve(), AStableDirk4::solve(), ExplicitRK2::solve(), ExplicitTVDRK2::solve(), ImplicitMidpoint::solve(), LStableDirk2::solve(), LStableDirk3::solve(), LStableDirk4::solve(), FieldSplitPreconditioner::system(), NonlinearSystemBase::turnOffJacobian(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), and Console::writeVariableNorms().

◆ systemMatrixTag()

TagID NonlinearSystemBase::systemMatrixTag ( ) const

inlineoverridevirtualinherited

Return the Matrix Tag ID for System.

Reimplemented from SystemBase.

Definition at line 713 of file NonlinearSystemBase.h.

713{ return _Ke_system_tag; }

NonlinearSystemBase::_Ke_system_tag

TagID _Ke_system_tag

Tag for system contribution Jacobian.

Definition NonlinearSystemBase.h:944

Referenced by NonlinearSystemBase::addImplicitGeometricCouplingEntries(), NonlinearSystemBase::computeJacobian(), FEProblemBase::computeJacobianInternal(), NonlinearSystemBase::computeJacobianInternal(), FEProblemBase::computeResidualAndJacobian(), NonlinearSystemBase::constraintJacobians(), and NonlinearSystemBase::enforceNodalConstraintsJacobian().

◆ 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() ? section_name : _prefix + "::" + section_name;
}

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

◆ timeKernelVariableNames()

std::vector< std::string > NonlinearSystemBase::timeKernelVariableNames ( )

overridevirtualinherited

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

Implements SolverSystem.

Definition at line 3928 of file NonlinearSystemBase.C.

{
  std::vector<std::string> variable_names;
  const auto & time_kernels = _kernels.getVectorTagObjectWarehouse(timeVectorTag(), 0);
  if (time_kernels.hasActiveObjects())
    for (const auto & kernel : time_kernels.getObjects())
      variable_names.push_back(kernel->variable().name());
 
  return variable_names;
}

◆ timestepSetup()

void NonlinearSystemBase::timestepSetup ( )

overridevirtualinherited

Reimplemented from SystemBase.

Definition at line 369 of file NonlinearSystemBase.C.

{
  SolverSystem::timestepSetup();
 
  for (THREAD_ID tid = 0; tid < this->numThreads(); tid++)
  {
    _kernels.timestepSetup(tid);
    _nodal_kernels.timestepSetup(tid);
    _dirac_kernels.timestepSetup(tid);
    if (_doing_dg)
      _dg_kernels.timestepSetup(tid);
    _interface_kernels.timestepSetup(tid);
    _element_dampers.timestepSetup(tid);
    _nodal_dampers.timestepSetup(tid);
    _integrated_bcs.timestepSetup(tid);
 
    if (_fe_problem.haveFV())
      for (auto * fv_object : getFVSetupObjects(tid))
        fv_object->timestepSetup();
  }
  _scalar_kernels.timestepSetup();
  _constraints.timestepSetup();
  _general_dampers.timestepSetup();
  _nodal_bcs.timestepSetup();
  _preset_nodal_bcs.timestepSetup();
  _ad_preset_nodal_bcs.timestepSetup();
 
#ifdef MOOSE_KOKKOS_ENABLED
  _kokkos_kernels.timestepSetup();
  _kokkos_nodal_kernels.timestepSetup();
  _kokkos_integrated_bcs.timestepSetup();
  _kokkos_nodal_bcs.timestepSetup();
#endif
}

◆ timeVectorTag()

TagID NonlinearSystemBase::timeVectorTag ( ) const

inlineoverridevirtualinherited

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 from SystemBase.

Definition at line 710 of file NonlinearSystemBase.h.

710{ return _Re_time_tag; }

Referenced by FEProblemBase::addCachedResidualDirectly(), NonlinearSystemBase::containsTimeKernel(), and NonlinearSystemBase::timeKernelVariableNames().

◆ turnOffJacobian()

void NonlinearSystemBase::turnOffJacobian ( )

virtualinherited

Turn off the Jacobian (must be called before equation system initialization)

Reimplemented in NonlinearEigenSystem.

Definition at line 255 of file NonlinearSystemBase.C.

{
  system().set_basic_system_only();
  nonlinearSolver()->jacobian = NULL;
}

◆ update()

void SystemBase::update ( )

inherited

Update the system (doing libMesh magic)

Definition at line 1243 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().

◆ updateActive()

void NonlinearSystemBase::updateActive ( THREAD_ID tid )

inherited

Update active objects of Warehouses owned by NonlinearSystemBase.

Definition at line 3414 of file NonlinearSystemBase.C.

{
  _element_dampers.updateActive(tid);
  _nodal_dampers.updateActive(tid);
  _integrated_bcs.updateActive(tid);
  _dg_kernels.updateActive(tid);
  _interface_kernels.updateActive(tid);
  _dirac_kernels.updateActive(tid);
  _kernels.updateActive(tid);
  _nodal_kernels.updateActive(tid);
 
  if (tid == 0)
  {
    _general_dampers.updateActive();
    _nodal_bcs.updateActive();
    _preset_nodal_bcs.updateActive();
    _ad_preset_nodal_bcs.updateActive();
    _splits.updateActive();
    _constraints.updateActive();
    _scalar_kernels.updateActive();
 
#ifdef MOOSE_KOKKOS_ENABLED
    _kokkos_kernels.updateActive();
    _kokkos_nodal_kernels.updateActive();
    _kokkos_integrated_bcs.updateActive();
    _kokkos_nodal_bcs.updateActive();
    _kokkos_preset_nodal_bcs.updateActive();
#endif
  }
}

◆ useFieldSplitPreconditioner()

void NonlinearSystemBase::useFieldSplitPreconditioner ( FieldSplitPreconditionerBase * fsp )

inlineinherited

If called with a non-null object true this system will use a field split preconditioner matrix.

Definition at line 500 of file NonlinearSystemBase.h.

500{ _fsp = fsp; }

◆ useFiniteDifferencedPreconditioner()

void NonlinearSystemBase::useFiniteDifferencedPreconditioner ( bool use = true )

inlineinherited

If called with true this system will use a finite differenced form of the Jacobian as the preconditioner.

Definition at line 492 of file NonlinearSystemBase.h.

  {
    _use_finite_differenced_preconditioner = use;
  }

Referenced by FiniteDifferencePreconditioner::FiniteDifferencePreconditioner().

◆ usePreSMOResidual()

const bool & NonlinearSystemBase::usePreSMOResidual ( ) const

inlineinherited

Whether we are using pre-SMO residual in relative convergence checks.

Definition at line 290 of file NonlinearSystemBase.h.

290{ return _use_pre_smo_residual; }

Referenced by Console::outputSystemInformation(), and NonlinearSystemBase::referenceResidual().

◆ 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 787 of file SystemBase.h.

787{ return _vars[tid]; }

Referenced by NonlinearSystemBase::checkKernelCoverage(), and 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 957 of file SystemBase.h.

957{ return _var_kind; }

SystemBase::_var_kind

Moose::VarKindType _var_kind

default kind of variables in this system

Definition SystemBase.h:1083

Referenced by Coupleable::coupled().

◆ zeroTaggedVector()

void SystemBase::zeroTaggedVector ( const TagID tag )

inherited

Zero vector with the given tag.

Definition at line 676 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 695 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 202 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, numThreads());
 
    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 237 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 231 of file SystemBase.C.

{
  zeroVariables(_vars_to_be_zeroed_on_residual);
}

◆ zeroVectorForResidual()

void NonlinearSystemBase::zeroVectorForResidual ( const std::string & vector_name )

inherited

Definition at line 776 of file NonlinearSystemBase.C.

{
  for (unsigned int i = 0; i < _vecs_to_zero_for_residual.size(); ++i)
    if (vector_name == _vecs_to_zero_for_residual[i])
      return;
 
  _vecs_to_zero_for_residual.push_back(vector_name);
}

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 1070 of file SystemBase.h.

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

◆ _ad_preset_nodal_bcs

MooseObjectWarehouse<ADDirichletBCBase> NonlinearSystemBase::_ad_preset_nodal_bcs

protectedinherited

Definition at line 960 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::addBoundaryCondition(), NonlinearSystemBase::customSetup(), NonlinearSystemBase::initialSetup(), NonlinearSystemBase::jacobianSetup(), NonlinearSystemBase::residualSetup(), NonlinearSystemBase::setInitialSolution(), NonlinearSystemBase::timestepSetup(), and NonlinearSystemBase::updateActive().

◆ _add_implicit_geometric_coupling_entries_to_jacobian

bool NonlinearSystemBase::_add_implicit_geometric_coupling_entries_to_jacobian

protectedinherited

Whether or not to add implicit geometric couplings to the Jacobian for FDP.

Definition at line 1009 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::addImplicitGeometricCouplingEntriesToJacobian(), NonlinearSystemBase::augmentSparsity(), and NonlinearSystemBase::computeJacobianInternal().

◆ _app

MooseApp& SystemBase::_app

protectedinherited

Definition at line 1033 of file SystemBase.h.

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

◆ _assemble_constraints_separately

bool NonlinearSystemBase::_assemble_constraints_separately

protectedinherited

Whether or not to assemble the residual and Jacobian after the application of each constraint.

Definition at line 1012 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::assembleConstraintsSeparately(), NonlinearSystemBase::constraintJacobians(), and NonlinearSystemBase::constraintResiduals().

◆ _auto_scaling_initd

bool NonlinearSystemBase::_auto_scaling_initd

privateinherited

Whether we've initialized the automatic scaling data structures.

Definition at line 1124 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::computeScaling(), and NonlinearSystemBase::setupScalingData().

◆ _automatic_scaling

bool SystemBase::_automatic_scaling

protectedinherited

Whether to automatically scale the variables.

Definition at line 1100 of file SystemBase.h.

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

◆ _compute_scaling_once

bool NonlinearSystemBase::_compute_scaling_once

protectedinherited

Whether the scaling factors should only be computed once at the beginning of the simulation through an extra Jacobian evaluation.

If this is set to false, then the scaling factors will be computed during an extra Jacobian evaluation at the beginning of every time step.

Definition at line 1067 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::computeScaling(), NonlinearSystemBase::computeScalingOnce(), and NonlinearSystemBase::computeScalingOnce().

◆ _computed_scaling

bool NonlinearSystemBase::_computed_scaling

protectedinherited

Flag used to indicate whether we have already computed the scaling Jacobian.

Definition at line 1062 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::computedScalingJacobian(), and NonlinearSystemBase::computeScaling().

◆ _computing_pre_smo_residual

bool NonlinearSystemBase::_computing_pre_smo_residual

protectedinherited

Definition at line 1036 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::computingPreSMOResidual(), and solve().

◆ _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.

◆ _constraints

ConstraintWarehouse NonlinearSystemBase::_constraints

protectedinherited

Constraints storage object.

Definition at line 993 of file NonlinearSystemBase.h.

◆ _convergence_name

ConvergenceName NonlinearSystemBase::_convergence_name

privateinherited

Associated convergence object name.

Definition at line 1133 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::convergence(), and NonlinearSystemBase::setConvergenceName().

◆ _current_l_its

std::vector<unsigned int> NonlinearSystemBase::_current_l_its

inherited

Definition at line 756 of file NonlinearSystemBase.h.

Referenced by SolutionHistory::output(), and NonlinearSystemBase::preSolve().

◆ _current_nl_its

unsigned int NonlinearSystemBase::_current_nl_its

inherited

Definition at line 757 of file NonlinearSystemBase.h.

Referenced by DefaultNonlinearConvergence::checkConvergence(), SolutionHistory::output(), and NonlinearSystemBase::preSolve().

◆ _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(), computeScalingJacobian(), NonlinearEigenSystem::computeScalingResidual(), computeScalingResidual(), SolverSystem::currentSolution(), LinearSystem::initialSetup(), SolverSystem::preInit(), LinearSystem::reinit(), SolverSystem::restoreSolutions(), SolverSystem::serializeSolution(), SolverSystem::setSolution(), and solve().

◆ _debugging_residuals

bool NonlinearSystemBase::_debugging_residuals

protectedinherited

true if debugging residuals

Definition at line 1017 of file NonlinearSystemBase.h.

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

◆ _dg_kernels

MooseObjectTagWarehouse<DGKernelBase> NonlinearSystemBase::_dg_kernels

protectedinherited

Definition at line 951 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::addDGKernel(), NonlinearSystemBase::checkKernelCoverage(), NonlinearSystemBase::customSetup(), NonlinearSystemBase::getDGKernelWarehouse(), NonlinearSystemBase::initialSetup(), NonlinearSystemBase::jacobianSetup(), NonlinearSystemBase::needInternalNeighborSideMaterial(), NonlinearSystemBase::residualSetup(), NonlinearSystemBase::timestepSetup(), and NonlinearSystemBase::updateActive().

◆ _dirac_kernels

MooseObjectTagWarehouse<DiracKernelBase> NonlinearSystemBase::_dirac_kernels

protectedinherited

Dirac Kernel storage for each thread.

Definition at line 975 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::addDiracKernel(), NonlinearSystemBase::computeDiracContributions(), NonlinearSystemBase::customSetup(), NonlinearSystemBase::getDiracKernelWarehouse(), NonlinearSystemBase::initialSetup(), NonlinearSystemBase::jacobianSetup(), NonlinearSystemBase::residualSetup(), NonlinearSystemBase::timestepSetup(), and NonlinearSystemBase::updateActive().

◆ _displaced_mortar_functors

std::unordered_map<std::pair<BoundaryID, BoundaryID>, ComputeMortarFunctor> NonlinearSystemBase::_displaced_mortar_functors

privateinherited

Functors for computing displaced mortar constraints.

Definition at line 1118 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::initialSetup(), NonlinearSystemBase::mortarConstraints(), and NonlinearSystemBase::reinitMortarFunctors().

◆ _doing_dg

bool NonlinearSystemBase::_doing_dg

protectedinherited

true if DG is active (optimization reasons)

Definition at line 1020 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::addDGKernel(), NonlinearSystemBase::customSetup(), NonlinearSystemBase::doingDG(), NonlinearSystemBase::initialSetup(), NonlinearSystemBase::jacobianSetup(), NonlinearSystemBase::residualSetup(), and NonlinearSystemBase::timestepSetup().

◆ _du_dot_du

Number NonlinearSystemBase::_du_dot_du

protectedinherited

\( {du^dot}\over{du} \)

Definition at line 916 of file NonlinearSystemBase.h.

◆ _du_dotdot_du

Number NonlinearSystemBase::_du_dotdot_du

protectedinherited

\( {du^dotdot}\over{du} \)

Definition at line 918 of file NonlinearSystemBase.h.

◆ _element_dampers

MooseObjectWarehouse<ElementDamper> NonlinearSystemBase::_element_dampers

protectedinherited

Element Dampers for each thread.

Definition at line 978 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::addDamper(), NonlinearSystemBase::computeDamping(), NonlinearSystemBase::customSetup(), NonlinearSystemBase::getElementDamperWarehouse(), NonlinearSystemBase::initialSetup(), NonlinearSystemBase::jacobianSetup(), NonlinearSystemBase::residualSetup(), NonlinearSystemBase::subdomainSetup(), NonlinearSystemBase::timestepSetup(), and NonlinearSystemBase::updateActive().

◆ _factory

Factory& SystemBase::_factory

protectedinherited

Definition at line 1034 of file SystemBase.h.

◆ _fd_residual_functor

ComputeFDResidualFunctor NonlinearSystem::_fd_residual_functor

protected

Definition at line 81 of file NonlinearSystem.h.

Referenced by potentiallySetupFiniteDifferencing().

◆ _fdcoloring

MatFDColoring NonlinearSystemBase::_fdcoloring

protectedinherited

Definition at line 1003 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::destroyColoring(), setupColoringFiniteDifferencedPreconditioner(), and solve().

◆ _fe_problem

FEProblemBase& SystemBase::_fe_problem

protectedinherited

the governing finite element/volume problem

Definition at line 1031 of file SystemBase.h.

◆ _final_residual

Real NonlinearSystemBase::_final_residual

protectedinherited

Definition at line 1031 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::finalNonlinearResidual(), NonlinearEigenSystem::finalNonlinearResidual(), NonlinearEigenSystem::solve(), and solve().

◆ _fsp

FieldSplitPreconditionerBase* NonlinearSystemBase::_fsp

protectedinherited

The field split preconditioner if this sytem is using one.

Definition at line 1006 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::getFieldSplitPreconditioner(), NonlinearSystemBase::haveFieldSplitPreconditioner(), NonlinearSystemBase::setupDM(), and NonlinearSystemBase::useFieldSplitPreconditioner().

◆ _general_dampers

MooseObjectWarehouse<GeneralDamper> NonlinearSystemBase::_general_dampers

protectedinherited

General Dampers.

Definition at line 984 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::addDamper(), NonlinearSystemBase::computeDamping(), NonlinearSystemBase::customSetup(), NonlinearSystemBase::initialSetup(), NonlinearSystemBase::jacobianSetup(), NonlinearSystemBase::residualSetup(), NonlinearSystemBase::timestepSetup(), and NonlinearSystemBase::updateActive().

◆ _has_diag_save_in

bool NonlinearSystemBase::_has_diag_save_in

protectedinherited

If there is any Kernel or IntegratedBC having diag_save_in.

Definition at line 1051 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::addBoundaryCondition(), NonlinearSystemBase::addDGKernel(), MooseEigenSystem::addKernel(), NonlinearSystemBase::addKernel(), NonlinearSystemBase::addNodalKernel(), NonlinearSystemBase::computeNodalBCsJacobian(), and NonlinearSystemBase::hasDiagSaveIn().

◆ _has_nodalbc_diag_save_in

bool NonlinearSystemBase::_has_nodalbc_diag_save_in

protectedinherited

If there is a nodal BC having diag_save_in.

Definition at line 1057 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::addBoundaryCondition(), NonlinearSystemBase::computeJacobianInternal(), and NonlinearSystemBase::hasDiagSaveIn().

◆ _has_nodalbc_save_in

bool NonlinearSystemBase::_has_nodalbc_save_in

protectedinherited

If there is a nodal BC having save_in.

Definition at line 1054 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::addBoundaryCondition(), NonlinearSystemBase::computeResidualTags(), and NonlinearSystemBase::hasSaveIn().

◆ _has_save_in

bool NonlinearSystemBase::_has_save_in

protectedinherited

If there is any Kernel or IntegratedBC having save_in.

Definition at line 1048 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::addBoundaryCondition(), NonlinearSystemBase::addDGKernel(), MooseEigenSystem::addKernel(), NonlinearSystemBase::addKernel(), NonlinearSystemBase::addNodalKernel(), NonlinearSystemBase::computeNodalBCsResidual(), and NonlinearSystemBase::hasSaveIn().

◆ _hybridized_kernels

MooseObjectTagWarehouse<HDGKernel> NonlinearSystemBase::_hybridized_kernels

protectedinherited

Definition at line 949 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::addHDGKernel(), and NonlinearSystemBase::getHDGKernelWarehouse().

◆ _ignore_variables_for_autoscaling

std::vector<std::string> NonlinearSystemBase::_ignore_variables_for_autoscaling

protectedinherited

A container for variables that do not partipate in autoscaling.

Definition at line 1083 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::ignoreVariablesForAutoscaling(), and NonlinearSystemBase::setupScalingData().

◆ _increment_vec

NumericVector<Number>* NonlinearSystemBase::_increment_vec

protectedinherited

increment vector

Definition at line 996 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::computeDamping(), NonlinearSystemBase::reinitIncrementAtNodeForDampers(), NonlinearSystemBase::reinitIncrementAtQpsForDampers(), and NonlinearSystemBase::setupDampers().

◆ _initial_residual

Real NonlinearSystemBase::_initial_residual

protectedinherited

The initial (i.e., 0th nonlinear iteration) residual, see setPreSMOResidual for a detailed explanation.

Definition at line 1041 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::initialResidual(), and NonlinearSystemBase::setInitialResidual().

◆ _integrated_bcs

MooseObjectTagWarehouse<IntegratedBCBase> NonlinearSystemBase::_integrated_bcs

protectedinherited

BoundaryCondition Warhouses

Definition at line 957 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::addBoundaryCondition(), NonlinearSystemBase::checkKernelCoverage(), NonlinearSystemBase::customSetup(), NonlinearSystemBase::getIntegratedBCWarehouse(), NonlinearSystemBase::getIntegratedBCWarehouse(), NonlinearSystemBase::initialSetup(), NonlinearSystemBase::jacobianSetup(), NonlinearSystemBase::needBoundaryMaterialOnSide(), NonlinearSystemBase::residualSetup(), NonlinearSystemBase::timestepSetup(), and NonlinearSystemBase::updateActive().

◆ _interface_kernels

MooseObjectTagWarehouse<InterfaceKernelBase> NonlinearSystemBase::_interface_kernels

protectedinherited

Definition at line 952 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::addInterfaceKernel(), NonlinearSystemBase::customSetup(), NonlinearSystemBase::getInterfaceKernelWarehouse(), NonlinearSystemBase::initialSetup(), NonlinearSystemBase::jacobianSetup(), NonlinearSystemBase::needBoundaryMaterialOnSide(), NonlinearSystemBase::needInterfaceMaterialOnSide(), NonlinearSystemBase::residualSetup(), NonlinearSystemBase::timestepSetup(), and NonlinearSystemBase::updateActive().

◆ _Ke_non_time_tag

TagID NonlinearSystemBase::_Ke_non_time_tag

protectedinherited

Tag for non-time contribution Jacobian.

Definition at line 941 of file NonlinearSystemBase.h.

◆ _Ke_system_tag

TagID NonlinearSystemBase::_Ke_system_tag

protectedinherited

Tag for system contribution Jacobian.

Definition at line 944 of file NonlinearSystemBase.h.

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

◆ _kernels

MooseObjectTagWarehouse<KernelBase> NonlinearSystemBase::_kernels

protectedinherited

Kernel Storage

Definition at line 948 of file NonlinearSystemBase.h.

◆ _kokkos_integrated_bcs

MooseObjectTagWarehouse<ResidualObject> NonlinearSystemBase::_kokkos_integrated_bcs

protectedinherited

Definition at line 967 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::customSetup(), NonlinearSystemBase::getKokkosIntegratedBCWarehouse(), NonlinearSystemBase::initialSetup(), NonlinearSystemBase::jacobianSetup(), NonlinearSystemBase::residualSetup(), NonlinearSystemBase::timestepSetup(), and NonlinearSystemBase::updateActive().

◆ _kokkos_kernels

MooseObjectTagWarehouse<ResidualObject> NonlinearSystemBase::_kokkos_kernels

protectedinherited

Kokkos residual object warhouses

Definition at line 966 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::checkKernelCoverage(), NonlinearSystemBase::customSetup(), NonlinearSystemBase::getKokkosKernelWarehouse(), NonlinearSystemBase::initialSetup(), NonlinearSystemBase::jacobianSetup(), NonlinearSystemBase::residualSetup(), NonlinearSystemBase::timestepSetup(), and NonlinearSystemBase::updateActive().

◆ _kokkos_nodal_bcs

MooseObjectTagWarehouse<ResidualObject> NonlinearSystemBase::_kokkos_nodal_bcs

protectedinherited

Definition at line 968 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::customSetup(), NonlinearSystemBase::getKokkosNodalBCWarehouse(), NonlinearSystemBase::initialSetup(), NonlinearSystemBase::jacobianSetup(), NonlinearSystemBase::residualSetup(), NonlinearSystemBase::timestepSetup(), and NonlinearSystemBase::updateActive().

◆ _kokkos_nodal_kernels

MooseObjectTagWarehouse<ResidualObject> NonlinearSystemBase::_kokkos_nodal_kernels

protectedinherited

Definition at line 970 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::checkKernelCoverage(), NonlinearSystemBase::customSetup(), NonlinearSystemBase::getKokkosNodalKernelWarehouse(), NonlinearSystemBase::initialSetup(), NonlinearSystemBase::jacobianSetup(), NonlinearSystemBase::residualSetup(), NonlinearSystemBase::timestepSetup(), and NonlinearSystemBase::updateActive().

◆ _kokkos_preset_nodal_bcs

MooseObjectWarehouse<ResidualObject> NonlinearSystemBase::_kokkos_preset_nodal_bcs

protectedinherited

Definition at line 969 of file NonlinearSystemBase.h.

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

◆ _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().

◆ _last_nl_rnorm

Real NonlinearSystemBase::_last_nl_rnorm

inherited

Definition at line 755 of file NonlinearSystemBase.h.

Referenced by DefaultNonlinearConvergence::checkConvergence(), and NonlinearSystemBase::nonlinearNorm().

◆ _matrix_tag_active_flags

std::vector<bool> SystemBase::_matrix_tag_active_flags

protectedinherited

Active flags for tagged matrices.

Definition at line 1072 of file SystemBase.h.

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

◆ _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 1088 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 1091 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 1045 of file SystemBase.h.

Referenced by SystemBase::getMaxVariableNumber().

◆ _mesh

MooseMesh& SystemBase::_mesh

protectedinherited

◆ _n_iters

unsigned int NonlinearSystemBase::_n_iters

protectedinherited

Definition at line 1025 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::nNonlinearIterations(), NonlinearEigenSystem::nNonlinearIterations(), NonlinearEigenSystem::solve(), and solve().

◆ _n_linear_iters

unsigned int NonlinearSystemBase::_n_linear_iters

protectedinherited

Definition at line 1026 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::nLinearIterations(), NonlinearEigenSystem::nLinearIterations(), NonlinearEigenSystem::solve(), and solve().

◆ _n_residual_evaluations

unsigned int NonlinearSystemBase::_n_residual_evaluations

protectedinherited

Total number of residual evaluations that have been performed.

Definition at line 1029 of file NonlinearSystemBase.h.

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

◆ _name

std::string SystemBase::_name

protectedinherited

The name of this system.

Definition at line 1038 of file SystemBase.h.

◆ _need_residual_ghosted

bool NonlinearSystemBase::_need_residual_ghosted

protectedinherited

Whether or not a ghosted copy of the residual needs to be made.

Definition at line 1015 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::computeResidualInternal(), NonlinearSystemBase::computeResidualTags(), NonlinearSystemBase::constraintResiduals(), NonlinearSystemBase::getResidualNonTimeVector(), NonlinearSystemBase::getResidualTimeVector(), and NonlinearSystemBase::residualGhosted().

◆ _nl_implicit_sys

libMesh::NonlinearImplicitSystem& NonlinearSystem::_nl_implicit_sys

protected

Definition at line 79 of file NonlinearSystem.h.

Referenced by computeScalingJacobian(), computeScalingResidual(), converged(), getCurrentNonlinearIterationNumber(), nonlinearSolver(), NonlinearSystem(), potentiallySetupFiniteDifferencing(), RHS(), setupColoringFiniteDifferencedPreconditioner(), setupStandardFiniteDifferencedPreconditioner(), solve(), and sys().

◆ _nl_matrix_tags

std::set<TagID> NonlinearSystemBase::_nl_matrix_tags

protectedinherited

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

Definition at line 927 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::computeJacobian(), and NonlinearSystemBase::computeJacobianBlocks().

◆ _nl_residual_functor

ComputeResidualFunctor NonlinearSystem::_nl_residual_functor

protected

Definition at line 80 of file NonlinearSystem.h.

Referenced by NonlinearSystem().

◆ _nl_vector_tags

std::set<TagID> NonlinearSystemBase::_nl_vector_tags

protectedinherited

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

Definition at line 924 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::computeNodalBCsResidual(), and NonlinearSystemBase::computeResidualTag().

◆ _nodal_bcs

MooseObjectTagWarehouse<NodalBCBase> NonlinearSystemBase::_nodal_bcs

protectedinherited

Definition at line 958 of file NonlinearSystemBase.h.

◆ _nodal_dampers

MooseObjectWarehouse<NodalDamper> NonlinearSystemBase::_nodal_dampers

protectedinherited

Nodal Dampers for each thread.

Definition at line 981 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::addDamper(), NonlinearSystemBase::computeDamping(), NonlinearSystemBase::customSetup(), NonlinearSystemBase::getNodalDamperWarehouse(), NonlinearSystemBase::initialSetup(), NonlinearSystemBase::jacobianSetup(), NonlinearSystemBase::residualSetup(), NonlinearSystemBase::subdomainSetup(), NonlinearSystemBase::timestepSetup(), and NonlinearSystemBase::updateActive().

◆ _nodal_kernels

MooseObjectTagWarehouse<NodalKernelBase> NonlinearSystemBase::_nodal_kernels

protectedinherited

NodalKernels for each thread.

Definition at line 987 of file NonlinearSystemBase.h.

◆ _num_residual_evaluations

unsigned int NonlinearSystemBase::_num_residual_evaluations

inherited

Definition at line 597 of file NonlinearSystemBase.h.

◆ _num_scaling_groups

std::size_t NonlinearSystemBase::_num_scaling_groups

privateinherited

The number of scaling groups.

Definition at line 1130 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::computeScaling(), and NonlinearSystemBase::setupScalingData().

◆ _numbered_vars

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

protectedinherited

Map variable number to its pointer.

Definition at line 1097 of file SystemBase.h.

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

◆ _off_diagonals_in_auto_scaling

bool NonlinearSystemBase::_off_diagonals_in_auto_scaling

protectedinherited

Whether to include off diagonals when determining automatic scaling factors.

Definition at line 1086 of file NonlinearSystemBase.h.

Referenced by computeScalingJacobian(), NonlinearSystemBase::initialSetup(), NonlinearSystemBase::offDiagonalsInAutoScaling(), and NonlinearSystemBase::offDiagonalsInAutoScaling().

◆ _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().

◆ _pre_smo_residual

Real NonlinearSystemBase::_pre_smo_residual

protectedinherited

The pre-SMO residual, see setPreSMOResidual for a detailed explanation.

Definition at line 1039 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::preSMOResidual(), and solve().

◆ _preconditioner

std::shared_ptr<MoosePreconditioner> NonlinearSystemBase::_preconditioner

protectedinherited

Preconditioner.

Definition at line 998 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::getPreconditioner(), NonlinearSystemBase::initialSetup(), NonlinearSystemBase::setPreconditioner(), and setupFiniteDifferencedPreconditioner().

◆ _predictor

std::shared_ptr<Predictor> NonlinearSystemBase::_predictor

protectedinherited

If predictor is active, this is non-NULL.

Definition at line 1034 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::getPredictor(), NonlinearSystemBase::onTimestepBegin(), NonlinearSystemBase::setInitialSolution(), and NonlinearSystemBase::setPredictor().

◆ _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().

◆ _preset_nodal_bcs

MooseObjectWarehouse<DirichletBCBase> NonlinearSystemBase::_preset_nodal_bcs

protectedinherited

Definition at line 959 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::addBoundaryCondition(), NonlinearSystemBase::customSetup(), NonlinearSystemBase::initialSetup(), NonlinearSystemBase::jacobianSetup(), NonlinearSystemBase::residualSetup(), NonlinearSystemBase::setInitialSolution(), NonlinearSystemBase::timestepSetup(), and NonlinearSystemBase::updateActive().

◆ _print_all_var_norms

bool NonlinearSystemBase::_print_all_var_norms

protectedinherited

Definition at line 1045 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::printAllVariableNorms().

◆ _Re_non_time

NumericVector<Number>* NonlinearSystemBase::_Re_non_time

protectedinherited

residual vector for non-time contributions

Definition at line 935 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::computeNodalBCsResidual(), NonlinearSystemBase::computeResidualAndJacobianTags(), NonlinearSystemBase::computeResidualInternal(), NonlinearSystemBase::computeResidualTags(), NonlinearSystemBase::getResidualNonTimeVector(), and NonlinearSystemBase::residualGhosted().

◆ _Re_non_time_tag

TagID NonlinearSystemBase::_Re_non_time_tag

protectedinherited

Tag for non-time contribution residual.

Definition at line 933 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::getResidualNonTimeVector(), NonlinearSystemBase::nonTimeVectorTag(), and NonlinearSystemBase::residualGhosted().

◆ _Re_tag

TagID NonlinearSystemBase::_Re_tag

protectedinherited

Used for the residual vector from PETSc.

Definition at line 938 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::NonlinearSystemBase(), and NonlinearSystemBase::residualVectorTag().

◆ _Re_time

NumericVector<Number>* NonlinearSystemBase::_Re_time

protectedinherited

residual vector for time contributions

Definition at line 930 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::computeNodalBCsResidual(), NonlinearSystemBase::getResidualTimeVector(), and NonlinearSystemBase::residualGhosted().

◆ _Re_time_tag

TagID NonlinearSystemBase::_Re_time_tag

protectedinherited

Tag for time contribution residual.

Definition at line 921 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::getResidualTimeVector(), NonlinearSystemBase::residualGhosted(), and NonlinearSystemBase::timeVectorTag().

◆ _resid_and_jac_functor

ComputeResidualAndJacobian NonlinearSystem::_resid_and_jac_functor

protected

Definition at line 82 of file NonlinearSystem.h.

Referenced by residualAndJacobianTogether().

◆ _resid_vs_jac_scaling_param

Real NonlinearSystemBase::_resid_vs_jac_scaling_param

protectedinherited

The param that indicates the weighting of the residual vs the Jacobian in determining variable scaling parameters.

A value of 1 indicates pure residual-based scaling. A value of 0 indicates pure Jacobian-based scaling

Definition at line 1072 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::autoScalingParam(), and NonlinearSystemBase::computeScaling().

◆ _residual_copy

std::unique_ptr<NumericVector<Number> > NonlinearSystemBase::_residual_copy

protectedinherited

Copy of the residual vector, or nullptr if a copy is not needed.

Definition at line 913 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::computeResidualInternal(), NonlinearSystemBase::preInit(), and NonlinearSystemBase::residualCopy().

◆ _residual_ghosted

NumericVector<Number>* NonlinearSystemBase::_residual_ghosted

protectedinherited

ghosted form of the residual

Definition at line 910 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::computeResidualInternal(), NonlinearSystemBase::computeResidualTags(), NonlinearSystemBase::constraintResiduals(), and NonlinearSystemBase::residualGhosted().

◆ _saved_dot_old

NumericVector<Real>* SystemBase::_saved_dot_old

protectedinherited

Definition at line 1079 of file SystemBase.h.

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

◆ _saved_dotdot_old

NumericVector<Real>* SystemBase::_saved_dotdot_old

protectedinherited

Definition at line 1080 of file SystemBase.h.

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

◆ _saved_old

NumericVector<Real>* SystemBase::_saved_old

protectedinherited

Definition at line 1075 of file SystemBase.h.

◆ _saved_older

NumericVector<Real>* SystemBase::_saved_older

protectedinherited

Definition at line 1076 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 1145 of file SystemBase.h.

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

◆ _scalar_kernels

MooseObjectTagWarehouse<ScalarKernelBase> NonlinearSystemBase::_scalar_kernels

protectedinherited

Definition at line 950 of file NonlinearSystemBase.h.

◆ _scaling_group_variables

std::vector<std::vector<std::string> > NonlinearSystemBase::_scaling_group_variables

protectedinherited

A container of variable groupings that can be used in scaling calculations.

This can be useful for simulations in which vector-like variables are split into invidual scalar-field components like for solid/fluid mechanics

Definition at line 1077 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::scalingGroupVariables(), and NonlinearSystemBase::setupScalingData().

◆ _scaling_matrix

std::unique_ptr<libMesh::DiagonalMatrix<Number> > NonlinearSystemBase::_scaling_matrix

protectedinherited

A diagonal matrix used for computing scaling.

Definition at line 1089 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::computeScaling(), NonlinearEigenSystem::computeScalingJacobian(), computeScalingJacobian(), and NonlinearSystemBase::initialSetup().

◆ _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 1113 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 1147 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> *> NonlinearSystemBase::_solution_state

privateinherited

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

Definition at line 1121 of file NonlinearSystemBase.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 1143 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 1106 of file SystemBase.h.

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

◆ _splits

MooseObjectWarehouseBase<Split> NonlinearSystemBase::_splits

protectedinherited

Decomposition splits.

Definition at line 990 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::addSplit(), NonlinearSystemBase::getSplit(), NonlinearSystemBase::getSplits(), and NonlinearSystemBase::updateActive().

◆ _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 1028 of file SystemBase.h.

Referenced by SystemBase::activateAllMatrixTags(), SystemBase::addMatrix(), 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

libMesh::System& NonlinearSystemBase::_sys

inherited

Definition at line 753 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::NonlinearSystemBase(), NonlinearSystemBase::preInit(), NonlinearSystemBase::setInitialSolution(), NonlinearSystemBase::setupDampers(), NonlinearSystemBase::system(), and NonlinearSystemBase::system().

◆ _tagged_matrices

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

protectedinherited

Tagged matrices (pointer)

Definition at line 1068 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 1066 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 1094 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 solve().

◆ _u_dot

NumericVector<Number>* SystemBase::_u_dot

protectedinherited

solution vector for u^dot

Definition at line 1051 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 1056 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 1053 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 1058 of file SystemBase.h.

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

◆ _undisplaced_mortar_functors

std::unordered_map<std::pair<BoundaryID, BoundaryID>, ComputeMortarFunctor> NonlinearSystemBase::_undisplaced_mortar_functors

privateinherited

Functors for computing undisplaced mortar constraints.

Definition at line 1114 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::initialSetup(), NonlinearSystemBase::mortarConstraints(), and NonlinearSystemBase::reinitMortarFunctors().

◆ _use_coloring_finite_difference

bool NonlinearSystem::_use_coloring_finite_difference

private

Definition at line 106 of file NonlinearSystem.h.

Referenced by matrixFromColoring(), setupFiniteDifferencedPreconditioner(), and solve().

◆ _use_finite_differenced_preconditioner

bool NonlinearSystemBase::_use_finite_differenced_preconditioner

protectedinherited

Whether or not to use a finite differenced preconditioner.

Definition at line 1001 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::haveFiniteDifferencedPreconditioner(), potentiallySetupFiniteDifferencing(), and NonlinearSystemBase::useFiniteDifferencedPreconditioner().

◆ _use_pre_smo_residual

bool NonlinearSystemBase::_use_pre_smo_residual

protectedinherited

Whether to use the pre-SMO initial residual in the relative convergence check.

Definition at line 1043 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::setPreSMOResidual(), NonlinearSystemBase::shouldEvaluatePreSMOResidual(), and NonlinearSystemBase::usePreSMOResidual().

◆ _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 1109 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 1083 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 1043 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 1085 of file SystemBase.h.

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

◆ _var_to_group_var

std::unordered_map<unsigned int, unsigned int> NonlinearSystemBase::_var_to_group_var

privateinherited

A map from variable index to group variable index and it's associated (inverse) scaling factor.

Definition at line 1127 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::computeScaling(), and NonlinearSystemBase::setupScalingData().

◆ _variable_autoscaled

std::vector<bool> NonlinearSystemBase::_variable_autoscaled

protectedinherited

Container to hold flag if variable is to participate in autoscaling.

Definition at line 1080 of file NonlinearSystemBase.h.

Referenced by NonlinearSystemBase::computeScaling(), and NonlinearSystemBase::setupScalingData().

◆ _vars

std::vector<VariableWarehouse> SystemBase::_vars

protectedinherited

Variable warehouses (one for each thread)

Definition at line 1041 of file SystemBase.h.

◆ _vars_to_be_zeroed_on_jacobian

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

protectedinherited

Definition at line 1048 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 1047 of file SystemBase.h.

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

◆ _vecs_to_zero_for_residual

std::vector<std::string> NonlinearSystemBase::_vecs_to_zero_for_residual

protectedinherited

vectors that will be zeroed before a residual computation

Definition at line 1023 of file NonlinearSystemBase.h.

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

◆ _verbose

bool SystemBase::_verbose

protectedinherited

True if printing out additional information.

Definition at line 1103 of file SystemBase.h.

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

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

include/systems/NonlinearSystem.h
src/systems/NonlinearSystem.C

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ NonlinearSystem()

◆ ~NonlinearSystem()

Member Function Documentation

◆ activateAllMatrixTags()

◆ addBoundaryCondition()

◆ addConstraint()

◆ addDamper()

◆ addDGKernel()

◆ addDiracKernel()

◆ addDotVectors()

◆ addHDGKernel()

◆ addImplicitGeometricCouplingEntries()

◆ addImplicitGeometricCouplingEntriesToJacobian()

◆ addInterfaceKernel()

◆ addKernel()

◆ addKokkosBoundaryCondition()

◆ addKokkosKernel()

◆ addKokkosNodalKernel()

◆ addMatrix()

◆ addNodalKernel()

◆ addScalarKernel()

◆ addSplit()

◆ addTimeIntegrator()

◆ addVariable()

◆ addVariableToCopy()

◆ addVariableToZeroOnJacobian()

◆ addVariableToZeroOnResidual()

◆ addVector() [1/2]

◆ addVector() [2/2]

◆ advanceStateHistory()

◆ applyFixedPointRelaxation()

◆ applyScalingFactors()

◆ assembleConstraintsSeparately()

◆ assignMaxVarNDofsPerElem()

◆ assignMaxVarNDofsPerNode()

◆ associateMatrixToTag()

◆ associateVectorToTag()

◆ attachPreconditioner()

◆ augmentSendList()

◆ augmentSparsity()

◆ automaticScaling() [1/2]

◆ automaticScaling() [2/2]

◆ autoScalingParam()

◆ checkInvalidSolution()

◆ checkKernelCoverage()

◆ clearAllDofIndices()

◆ closeTaggedMatrices()

◆ closeTaggedVector()

◆ closeTaggedVectors()

◆ compute()

◆ computeDamping()

◆ computeDiracContributions()

◆ computedScalingJacobian()

◆ computeJacobian() [1/2]

◆ computeJacobian() [2/2]

◆ computeJacobianBlocks() [1/2]

◆ computeJacobianBlocks() [2/2]

◆ computeJacobianInternal()

◆ computeJacobianTags()

◆ computeKokkosJacobian()

◆ computeKokkosNodalBCsResidual()

◆ computeKokkosResidual()

◆ computeKokkosResidualAndJacobian()

◆ computeNodalBCsJacobian()

◆ computeNodalBCsResidual() [1/3]

◆ computeNodalBCsResidual() [2/3]

◆ computeNodalBCsResidual() [3/3]

◆ computeNodalBCsResidualAndJacobian()

◆ computeResidual()

◆ computeResidualAndJacobianInternal()

◆ computeResidualAndJacobianTags()