NonlinearSystemBase Class Reference

Nonlinear system to be solved. More...

#include <NonlinearSystemBase.h>

Inheritance diagram for NonlinearSystemBase:

Public Member Functions
	NonlinearSystemBase (FEProblemBase &problem, System &sys, const std::string &name)
virtual	~NonlinearSystemBase ()
virtual void	init () override
	Initialize the system. More...
void	turnOffJacobian ()
	Turn off the Jacobian (must be called before equation system initialization) More...
virtual void	addExtraVectors () override
	Method called during initialSetup to add extra system vector if they are required by the simulation. More...
virtual void	solve () override=0
	Solve the system (using libMesh magic) More...
virtual void	restoreSolutions () override
	Restore current solutions (call after your solve failed) More...
virtual void	stopSolve ()=0
	Quit the current solve as soon as possible. More...
virtual NonlinearSolver< Number > *	nonlinearSolver ()=0
virtual unsigned int	getCurrentNonlinearIterationNumber ()=0
virtual bool	computingInitialResidual ()
	Returns true if this system is currently computing the initial residual for a solve. More...
virtual void	initialSetup ()
virtual void	timestepSetup ()
virtual void	setupFiniteDifferencedPreconditioner ()=0
void	setupFieldDecomposition ()
bool	haveFiniteDifferencedPreconditioner () const
bool	haveFieldSplitPreconditioner () const
virtual bool	converged ()=0
	Returns the convergence state. More...
void	addTimeIntegrator (const std::string &type, const std::string &name, InputParameters parameters) override
	Add a time integrator. More...
void	addDotVectors ()
	Add u_dot, u_dotdot, u_dot_old and u_dotdot_old vectors if requested by the time integrator. More...
virtual void	addKernel (const std::string &kernel_name, const std::string &name, InputParameters parameters)
	Adds a kernel. More...
virtual void	addNodalKernel (const std::string &kernel_name, const std::string &name, InputParameters parameters)
	Adds a NodalKernel. More...
void	addScalarKernel (const std::string &kernel_name, const std::string &name, InputParameters parameters)
	Adds a scalar kernel. More...
void	addBoundaryCondition (const std::string &bc_name, const std::string &name, InputParameters parameters)
	Adds a boundary condition. More...
void	addConstraint (const std::string &c_name, const std::string &name, InputParameters parameters)
	Adds a Constraint. More...
void	addDiracKernel (const std::string &kernel_name, const std::string &name, InputParameters parameters)
	Adds a Dirac kernel. More...
void	addDGKernel (std::string dg_kernel_name, const std::string &name, InputParameters parameters)
	Adds a DG kernel. More...
void	addInterfaceKernel (std::string interface_kernel_name, const std::string &name, InputParameters parameters)
	Adds an interface kernel. More...
void	addDamper (const std::string &damper_name, const std::string &name, InputParameters parameters)
	Adds a damper. More...
void	addSplit (const std::string &split_name, const std::string &name, InputParameters parameters)
	Adds a split. More...
std::shared_ptr< Split >	getSplit (const std::string &name)
	Retrieves a split by name. More...
void	zeroVectorForResidual (const std::string &vector_name)
void	setInitialSolution ()
void	setConstraintSlaveValues (NumericVector< Number > &solution, bool displaced)
	Sets the value of constrained variables in the solution vector. More...
void	constraintResiduals (NumericVector< Number > &residual, bool displaced)
	Add residual contributions from Constraints. More...
void	computeResidualTag (NumericVector< Number > &residual, TagID tag_id)
	Computes residual for a given tag. More...
void	computeResidualTags (const std::set< TagID > &tags)
	Form multiple tag-associated residual vectors for all the given tags. More...
void	computeResidual (NumericVector< Number > &residual, TagID tag_id)
	Form a residual vector for a given tag. More...
void	findImplicitGeometricCouplingEntries (GeometricSearchData &geom_search_data, std::map< dof_id_type, std::vector< dof_id_type >> &graph)
	Finds the implicit sparsity graph between geometrically related dofs. More...
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. More...
void	constraintJacobians (bool displaced)
	Add jacobian contributions from Constraints. More...
void	setVariableGlobalDoFs (const std::string &var_name)
	set all the global dof indices for a nonlinear variable More...
const std::vector< dof_id_type > &	getVariableGlobalDoFs ()
void	computeJacobianTags (const std::set< TagID > &tags)
	Computes multiple (tag associated) Jacobian matricese. More...
void	computeJacobian (SparseMatrix< Number > &jacobian, const std::set< TagID > &tags)
	Associate jacobian to systemMatrixTag, and then form a matrix for all the tags. More...
void	computeJacobian (SparseMatrix< Number > &jacobian)
	Take all tags in the system, and form a matrix for all tags in the system. More...
void	computeJacobianBlocks (std::vector< JacobianBlock *> &blocks)
	Computes several Jacobian blocks simultaneously, summing their contributions into smaller preconditioning matrices. More...
void	computeJacobianBlocks (std::vector< JacobianBlock *> &blocks, const std::set< TagID > &tags)
Real	computeDamping (const NumericVector< Number > &solution, const NumericVector< Number > &update)
	Compute damping. More...
void	computeTimeDerivatives ()
	Computes the time derivative vector. More...
void	onTimestepBegin ()
	Called at the beginning of the time step. More...
virtual void	subdomainSetup (SubdomainID subdomain, THREAD_ID tid)
	Called from assembling when we hit a new subdomain. More...
virtual void	setSolution (const NumericVector< Number > &soln)
void	updateActive (THREAD_ID tid)
	Update active objects of Warehouses owned by NonlinearSystemBase. More...
virtual void	setSolutionUDot (const NumericVector< Number > &udot)
	Set transient term used by residual and Jacobian evaluation. More...
virtual void	setSolutionUDotDot (const NumericVector< Number > &udotdot)
	Set transient term used by residual and Jacobian evaluation. More...
virtual NumericVector< Number > *	solutionUDot () override
virtual NumericVector< Number > *	solutionUDotDot () override
NumericVector< Number > &	getResidualTimeVector ()
	Return a numeric vector that is associated with the time tag. More...
NumericVector< Number > &	getResidualNonTimeVector ()
	Return a numeric vector that is associated with the nontime tag. More...
NumericVector< Number > &	residualVector (TagID tag)
	Return a residual vector that is associated with the residual tag. More...
virtual const NumericVector< Number > *&	currentSolution () override
	The solution vector that is currently being operated on. More...
virtual void	serializeSolution ()
virtual NumericVector< Number > &	serializedSolution () override
	Returns a reference to a serialized version of the solution vector for this subproblem. More...
virtual NumericVector< Number > &	residualCopy () override
virtual NumericVector< Number > &	residualGhosted () override
virtual NumericVector< Number > &	RHS ()=0
virtual void	augmentSparsity (SparsityPattern::Graph &sparsity, std::vector< dof_id_type > &n_nz, std::vector< dof_id_type > &n_oz) override
	Will modify the sparsity pattern to add logical geometric connections. More...
void	setPreconditioner (std::shared_ptr< MoosePreconditioner > pc)
	Sets a preconditioner. More...
void	useFiniteDifferencedPreconditioner (bool use=true)
	If called with true this system will use a finite differenced form of the Jacobian as the preconditioner. More...
void	setDecomposition (const std::vector< std::string > &decomposition)
	If called with a single string, it is used as the name of a the top-level decomposition split. More...
void	useFieldSplitPreconditioner (bool use=true)
	If called with true this system will use a field split preconditioner matrix. More...
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. More...
void	assembleConstraintsSeparately (bool separately=true)
	Indicates whether to assemble residual and Jacobian after each constraint application. More...
void	setupDampers ()
	Setup damping stuff (called before we actually start) More...
void	reinitIncrementAtQpsForDampers (THREAD_ID tid, const std::set< MooseVariable *> &damped_vars)
	Compute the incremental change in variables at QPs for dampers. More...
void	reinitIncrementAtNodeForDampers (THREAD_ID tid, const std::set< MooseVariable *> &damped_vars)
	Compute the incremental change in variables at nodes for dampers. More...
unsigned int	nNonlinearIterations () const
	Return the number of non-linear iterations. More...
unsigned int	nLinearIterations () const
	Return the number of linear iterations. More...
unsigned int	nResidualEvaluations () const
	Return the total number of residual evaluations done so far in this calculation. More...
Real	finalNonlinearResidual () const
	Return the final nonlinear residual. More...
Real	nonlinearNorm () const
	Return the last nonlinear norm. More...
void	printAllVariableNorms (bool state)
	Force the printing of all variable norms after each solve. More...
void	debuggingResiduals (bool state)
void	setPredictor (std::shared_ptr< Predictor > predictor)
Predictor *	getPredictor ()
void	setPCSide (MooseEnum pcs)
Moose::PCSideType	getPCSide ()
void	setMooseKSPNormType (MooseEnum kspnorm)
Moose::MooseKSPNormType	getMooseKSPNormType ()
bool	needBoundaryMaterialOnSide (BoundaryID bnd_id, THREAD_ID tid) const
	Indicated whether this system needs material properties on boundaries. More...
bool	needSubdomainMaterialOnSide (SubdomainID subdomain_id, THREAD_ID tid) const
	Indicates whether this system needs material properties on internal sides. More...
bool	doingDG () const
	Getter for _doing_dg. More...
bool	hasSaveIn () const
	Weather or not the nonlinear system has save-ins. More...
bool	hasDiagSaveIn () const
	Weather or not the nonlinear system has diagonal Jacobian save-ins. More...
virtual NumericVector< Number > &	solution () override
virtual System &	system () override
	Get the reference to the libMesh system. More...
virtual const System &	system () const override
virtual NumericVector< Number > *	solutionUDotOld () override
virtual NumericVector< Number > *	solutionUDotDotOld () override
virtual NumericVector< Number > *	solutionPreviousNewton () 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)
virtual TagID	timeVectorTag () override
	Ideally, we should not need this API. More...
virtual TagID	nonTimeVectorTag () override
virtual TagID	residualVectorTag () override
virtual TagID	systemMatrixTag () override
	Return the Matrix Tag ID for System. More...
virtual void	addTimeIntegrator (const std::string &, const std::string &, InputParameters)
virtual void	addTimeIntegrator (std::shared_ptr< TimeIntegrator >)
virtual unsigned int	number () const
	Gets the number of this system. More...
virtual MooseMesh &	mesh ()
virtual SubProblem &	subproblem ()
virtual DofMap &	dofMap ()
	Gets the dof map. More...
virtual void	initializeObjects ()
	Called only once, just before the solve begins so objects can do some precalculations. More...
virtual void	update ()
	Update the system (doing libMesh magic) More...
virtual void	copyOldSolutions ()
	Shifts the solutions backwards in time. More...
virtual NumericVector< Number > &	solutionOld ()=0
virtual NumericVector< Number > &	solutionOlder ()=0
virtual Number &	duDotDu ()
virtual Number &	duDotDotDu ()
virtual void	saveOldSolutions ()
	Save the old and older solutions. More...
virtual void	restoreOldSolutions ()
	Restore the old and older solutions when the saved solutions present. More...
bool	hasVector (const std::string &tag_name) const
	Check if the named vector exists in the system. More...
virtual bool	hasVector (TagID tag_id)
	Check if the tagged vector exists in the system. More...
virtual TagID	timeMatrixTag ()
	Return the Matrix Tag ID for Time. More...
virtual NumericVector< Number > &	getVector (const std::string &name)
	Get a raw NumericVector. More...
virtual NumericVector< Number > &	getVector (TagID tag)
	Get a raw NumericVector. More...
virtual void	associateVectorToTag (NumericVector< Number > &vec, TagID tag)
	Associate a vector for a given tag. More...
virtual void	disassociateVectorFromTag (NumericVector< Number > &vec, TagID tag)
	Associate a vector for a given tag. More...
virtual void	disassociateAllTaggedVectors ()
	Disassociate all vectors, and then hasVector() will return false. More...
virtual bool	hasMatrix (TagID tag)
	Check if the tagged matrix exists in the system. More...
virtual SparseMatrix< Number > &	getMatrix (TagID tag)
	Get a raw SparseMatrix. More...
virtual void	activeAllMatrixTags ()
	Make all exsiting matrices ative. More...
virtual void	activeMatrixTag (TagID tag)
	Active a matrix for tag. More...
virtual bool	matrixTagActive (TagID tag)
	If or not a matrix tag is active. More...
virtual void	deactiveMatrixTag (TagID tag)
	deactive a matrix for tag More...
virtual void	deactiveAllMatrixTags ()
	Make matrices inactive. More...
void	closeTaggedMatrices (const std::set< TagID > &tags)
	Close all matrices associated the tags. More...
virtual void	associateMatrixToTag (SparseMatrix< Number > &matrix, TagID tag)
	associate a matirx to a tag More...
virtual void	disassociateMatrixFromTag (SparseMatrix< Number > &matrix, TagID tag)
	disassociate a matirx from a tag More...
virtual void	disassociateAllTaggedMatrices ()
	Clear all tagged matrices. More...
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. More...
virtual void	addVariable (const std::string &var_name, const FEType &type, Real scale_factor, const std::set< SubdomainID > *const active_subdomains=NULL)
	Adds a variable to the system. More...
virtual bool	isScalarVariable (unsigned int var_name) const
MooseVariableFEBase &	getVariable (THREAD_ID tid, const std::string &var_name)
	Gets a reference to a variable of with specified name. More...
MooseVariableFEBase &	getVariable (THREAD_ID tid, unsigned int var_number)
	Gets a reference to a variable with specified number. More...
template<typename T >
MooseVariableFE< T > &	getFieldVariable (THREAD_ID tid, const std::string &var_name)
	Gets a reference to a variable of with specified name. More...
template<typename T >
MooseVariableFE< T > &	getFieldVariable (THREAD_ID tid, unsigned int var_number)
	Gets a reference to a variable with specified number. More...
virtual MooseVariableScalar &	getScalarVariable (THREAD_ID tid, const std::string &var_name)
	Gets a reference to a scalar variable with specified number. More...
virtual MooseVariableScalar &	getScalarVariable (THREAD_ID tid, unsigned int var_number)
	Gets a reference to a variable with specified number. More...
virtual const std::set< SubdomainID > *	getVariableBlocks (unsigned int var_number)
	Get the block where a variable of this system is defined. More...
virtual unsigned int	nVariables () const
	Get the number of variables in this system. More...
size_t	getMaxVarNDofsPerElem ()
	Gets the maximum number of dofs used by any one variable on any one element. More...
size_t	getMaxVarNDofsPerNode ()
	Gets the maximum number of dofs used by any one variable on any one node. More...
void	assignMaxVarNDofsPerElem (const size_t &max_dofs)
	assign the maximum element dofs More...
void	assignMaxVarNDofsPerNode (const size_t &max_dofs)
	assign the maximum node dofs More...
virtual void	addVariableToZeroOnResidual (std::string var_name)
	Adds this variable to the list of variables to be zeroed during each residual evaluation. More...
virtual void	addVariableToZeroOnJacobian (std::string var_name)
	Adds this variable to the list of variables to be zeroed during each Jacobian evaluation. More...
virtual void	zeroVariables (std::vector< std::string > &vars_to_be_zeroed)
	Zero out the solution for the list of variables passed in. More...
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() More...
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() More...
virtual Order	getMinQuadratureOrder ()
	Get minimal quadrature order needed for integrating variables in this system. More...
virtual void	prepare (THREAD_ID tid)
	Prepare the system for use. More...
virtual void	prepareFace (THREAD_ID tid, bool resize_data)
	Prepare the system for use on sides. More...
virtual void	prepareNeighbor (THREAD_ID tid)
	Prepare the system for use. More...
virtual void	reinitElem (const Elem *elem, THREAD_ID tid)
	Reinit an element assembly info. More...
virtual void	reinitElemFace (const Elem *elem, unsigned int side, BoundaryID bnd_id, THREAD_ID tid)
	Reinit assembly info for a side of an element. More...
virtual void	reinitNeighborFace (const Elem *elem, unsigned int side, BoundaryID bnd_id, THREAD_ID tid)
	Compute the values of the variables at all the current points. More...
virtual void	reinitNeighbor (const Elem *elem, THREAD_ID tid)
	Compute the values of the variables at all the current points. More...
virtual void	reinitNode (const Node *node, THREAD_ID tid)
	Reinit nodal assembly info. More...
virtual void	reinitNodeFace (const Node *node, BoundaryID bnd_id, THREAD_ID tid)
	Reinit nodal assembly info on a face. More...
virtual void	reinitNodes (const std::vector< dof_id_type > &nodes, THREAD_ID tid)
	Reinit variables at a set of nodes. More...
virtual void	reinitNodesNeighbor (const std::vector< dof_id_type > &nodes, THREAD_ID tid)
	Reinit variables at a set of neighbor nodes. More...
virtual void	reinitScalars (THREAD_ID tid)
	Reinit scalar varaibles. More...
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. More...
const std::vector< MooseVariableFEBase * > &	getVariables (THREAD_ID tid)
const std::vector< MooseVariableScalar * > &	getScalarVariables (THREAD_ID tid)
const std::set< SubdomainID > &	getSubdomainsForVar (unsigned int var_number) const
virtual void	removeVector (const std::string &name)
	Remove a vector from the system with the given name. More...
virtual void	removeVector (TagID tag_id)
	Remove a solution length vector from the system with the specified TagID. More...
virtual NumericVector< Number > &	addVector (const std::string &vector_name, const bool project, const ParallelType type)
	Adds a solution length vector to the system. More...
NumericVector< Number > &	addVector (TagID tag, const bool project, const ParallelType type)
	Adds a solution length vector to the system with the specified TagID. More...
virtual void	closeTaggedVectors (const std::set< TagID > &tags)
	Close all vectors for given tags. More...
virtual void	zeroTaggedVectors (const std::set< TagID > &tags)
	Zero all vectors for given tags. More...
virtual SparseMatrix< Number > &	addMatrix (TagID)
	Adds a jacobian sized vector. More...
virtual void	removeMatrix (TagID)
	Removes a jacobian sized vector. More...
virtual const std::string &	name () const
virtual void	addScalarVariable (const std::string &var_name, Order order, Real scale_factor, const std::set< SubdomainID > *const active_subdomains=NULL)
	Adds a scalar variable. More...
const std::vector< VariableName > &	getVariableNames () const
virtual void	computeVariables (const NumericVector< Number > &)
void	copyVars (ExodusII_IO &io)
virtual void	copySolutionsBackwards ()
	Copy current solution into old and older. More...
virtual void	addTimeIntegrator (std::shared_ptr< TimeIntegrator >)
TimeIntegrator *	getTimeIntegrator ()
std::shared_ptr< TimeIntegrator >	getSharedTimeIntegrator ()
void	checkKernelCoverage (const std::set< SubdomainID > &mesh_subdomains) const
bool	containsTimeKernel ()
MooseObjectTagWarehouse< KernelBase > &	getKernelWarehouse ()
	Access functions to Warehouses from outside NonlinearSystemBase. More...
MooseObjectTagWarehouse< KernelBase > &	getADJacobianKernelWarehouse ()
MooseObjectTagWarehouse< DGKernelBase > &	getDGKernelWarehouse ()
MooseObjectTagWarehouse< InterfaceKernel > &	getInterfaceKernelWarehouse ()
MooseObjectTagWarehouse< DiracKernel > &	getDiracKernelWarehouse ()
MooseObjectTagWarehouse< IntegratedBCBase > &	getIntegratedBCWarehouse ()
const MooseObjectWarehouse< ElementDamper > &	getElementDamperWarehouse () const
const MooseObjectWarehouse< NodalDamper > &	getNodalDamperWarehouse () const
const ConstraintWarehouse &	getConstraintWarehouse () const
virtual bool	hasVariable (const std::string &var_name) const
	Query a system for a variable. More...
virtual bool	hasScalarVariable (const std::string &var_name) const

Public Attributes
unsigned int	_num_residual_evaluations
FEProblemBase &	_fe_problem
System &	_sys
Real	_last_rnorm
Real	_last_nl_rnorm
Real	_l_abs_step_tol
Real	_initial_residual_before_preset_bcs
Real	_initial_residual_after_preset_bcs
std::vector< unsigned int >	_current_l_its
unsigned int	_current_nl_its
bool	_compute_initial_residual_before_preset_bcs
const ConsoleStream	_console
	An instance of helper class to write streams to the Console objects. More...

Protected Member Functions
void	computeResidualInternal (const std::set< TagID > &tags)
	Compute the residual for a given tag. More...
void	computeNodalBCs (NumericVector< Number > &residual)
	Enforces nodal boundary conditions. More...
void	computeNodalBCs (NumericVector< Number > &residual, const std::set< TagID > &tags)
	Form a residual for BCs that at least has one of the given tags. More...
void	computeNodalBCs (const std::set< TagID > &tags)
	Form multiple tag-associated residual vectors for the given tags. More...
void	computeJacobianInternal (const std::set< TagID > &tags)
	Form multiple matrices for all the tags. More...
void	computeDiracContributions (const std::set< TagID > &tags, bool is_jacobian)
void	computeScalarKernelsJacobians (const std::set< TagID > &tags)
void	enforceNodalConstraintsResidual (NumericVector< Number > &residual)
	Enforce nodal constraints. More...
void	enforceNodalConstraintsJacobian ()
void	getNodeDofs (dof_id_type node_id, std::vector< dof_id_type > &dofs)
PerfID	registerTimedSection (const std::string &section_name, const unsigned int level)
	Call to register a named section for timing. More...

Protected Attributes
const NumericVector< Number > *	_current_solution
	solution vector from nonlinear solver More...
NumericVector< Number > *	_residual_ghosted
	ghosted form of the residual More...
NumericVector< Number > &	_serialized_solution
	Serialized version of the solution vector. More...
NumericVector< Number > *	_solution_previous_nl
	Solution vector of the previous nonlinear iterate. More...
NumericVector< Number > &	_residual_copy
	Copy of the residual vector. More...
NumericVector< Number > *	_u_dot
	solution vector for u^dot More...
NumericVector< Number > *	_u_dotdot
	solution vector for u^dotdot More...
NumericVector< Number > *	_u_dot_old
	old solution vector for u^dot More...
NumericVector< Number > *	_u_dotdot_old
	old solution vector for u^dotdot More...
Number	_du_dot_du
	\( {du^dot}\over{du} \) More...
Number	_du_dotdot_du
	\( {du^dotdot}\over{du} \) More...
TagID	_Re_time_tag
	Tag for time contribution residual. More...
std::set< TagID >	_nl_vector_tags
	Vector tags to temporarily store all tags associated with the current system. More...
std::set< TagID >	_nl_matrix_tags
	Matrix tags to temporarily store all tags associated with the current system. More...
NumericVector< Number > *	_Re_time
	residual vector for time contributions More...
TagID	_Re_non_time_tag
	Tag for non-time contribution residual. More...
NumericVector< Number > *	_Re_non_time
	residual vector for non-time contributions More...
TagID	_Re_tag
	Used for the residual vector from PETSc. More...
TagID	_Ke_non_time_tag
	Tag for non-time contribution Jacobian. More...
TagID	_Ke_system_tag
	Tag for system contribution Jacobian. More...
MooseObjectTagWarehouse< DiracKernel >	_dirac_kernels
	Dirac Kernel storage for each thread. More...
MooseObjectWarehouse< ElementDamper >	_element_dampers
	Element Dampers for each thread. More...
MooseObjectWarehouse< NodalDamper >	_nodal_dampers
	Nodal Dampers for each thread. More...
MooseObjectWarehouse< GeneralDamper >	_general_dampers
	General Dampers. More...
MooseObjectTagWarehouse< NodalKernel >	_nodal_kernels
	NodalKernels for each thread. More...
MooseObjectWarehouseBase< Split >	_splits
	Decomposition splits. More...
ConstraintWarehouse	_constraints
	Constraints storage object. More...
NumericVector< Number > *	_increment_vec
	increment vector More...
std::shared_ptr< MoosePreconditioner >	_preconditioner
	Preconditioner. More...
Moose::PCSideType	_pc_side
	Preconditioning side. More...
Moose::MooseKSPNormType	_ksp_norm
	KSP norm type. More...
bool	_use_finite_differenced_preconditioner
	Whether or not to use a finite differenced preconditioner. More...
MatFDColoring	_fdcoloring
bool	_have_decomposition
	Whether or not the system can be decomposed into splits. More...
std::string	_decomposition_split
	Name of the top-level split of the decomposition. More...
bool	_use_field_split_preconditioner
	Whether or not to use a FieldSplitPreconditioner matrix based on the decomposition. More...
bool	_add_implicit_geometric_coupling_entries_to_jacobian
	Whether or not to add implicit geometric couplings to the Jacobian for FDP. More...
bool	_assemble_constraints_separately
	Whether or not to assemble the residual and Jacobian after the application of each constraint. More...
bool	_need_serialized_solution
	Whether or not a copy of the residual needs to be made. More...
bool	_need_residual_copy
	Whether or not a copy of the residual needs to be made. More...
bool	_need_residual_ghosted
	Whether or not a ghosted copy of the residual needs to be made. More...
bool	_debugging_residuals
	true if debugging residuals More...
bool	_doing_dg
	true if DG is active (optimization reasons) More...
std::vector< std::string >	_vecs_to_zero_for_residual
	vectors that will be zeroed before a residual computation More...
unsigned int	_n_iters
unsigned int	_n_linear_iters
unsigned int	_n_residual_evaluations
	Total number of residual evaluations that have been performed. More...
Real	_final_residual
std::shared_ptr< Predictor >	_predictor
	If predictor is active, this is non-NULL. More...
bool	_computing_initial_residual
bool	_print_all_var_norms
bool	_has_save_in
	If there is any Kernel or IntegratedBC having save_in. More...
bool	_has_diag_save_in
	If there is any Kernel or IntegratedBC having diag_save_in. More...
bool	_has_nodalbc_save_in
	If there is a nodal BC having save_in. More...
bool	_has_nodalbc_diag_save_in
	If there is a nodal BC having diag_save_in. More...
std::vector< dof_id_type >	_var_all_dof_indices
PerfID	_compute_residual_tags_timer
	Timers. More...
PerfID	_compute_residual_internal_timer
PerfID	_kernels_timer
PerfID	_scalar_kernels_timer
PerfID	_nodal_kernels_timer
PerfID	_nodal_kernel_bcs_timer
PerfID	_nodal_bcs_timer
PerfID	_compute_jacobian_tags_timer
PerfID	_compute_jacobian_blocks_timer
PerfID	_compute_dampers_timer
PerfID	_compute_dirac_timer
SubProblem &	_subproblem
MooseApp &	_app
Factory &	_factory
MooseMesh &	_mesh
std::string	_name
	The name of this system. More...
std::vector< VariableWarehouse >	_vars
	Variable warehouses (one for each thread) More...
std::map< unsigned int, std::set< SubdomainID > >	_var_map
	Map of variables (variable id -> array of subdomains where it lives) More...
std::vector< std::string >	_vars_to_be_zeroed_on_residual
std::vector< std::string >	_vars_to_be_zeroed_on_jacobian
std::vector< NumericVector< Number > * >	_tagged_vectors
	Tagged vectors (pointer) More...
std::vector< SparseMatrix< Number > * >	_tagged_matrices
	Tagged matrices (pointer) More...
std::vector< bool >	_matrix_tag_active_flags
	Active flags for tagged matrices. More...
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 More...
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. More...
size_t	_max_var_n_dofs_per_node
	Maximum number of dofs for any one variable on any one node. More...
std::shared_ptr< TimeIntegrator >	_time_integrator
	Time integrator. More...
const InputParameters *	_pg_params
	Params. More...
PerfGraph &	_perf_graph
	The performance graph to add to. More...
std::string	_prefix
	A prefix to use for all sections. More...
MooseObjectTagWarehouse< KernelBase >	_kernels
MooseObjectTagWarehouse< KernelBase >	_ad_jacobian_kernels
MooseObjectTagWarehouse< ScalarKernel >	_scalar_kernels
MooseObjectTagWarehouse< DGKernelBase >	_dg_kernels
MooseObjectTagWarehouse< InterfaceKernel >	_interface_kernels
MooseObjectTagWarehouse< IntegratedBCBase >	_integrated_bcs
MooseObjectTagWarehouse< NodalBCBase >	_nodal_bcs
MooseObjectWarehouse< PresetNodalBC >	_preset_nodal_bcs

Detailed Description

Nonlinear system to be solved.

It is a part of FEProblemBase ;-)

Definition at line 58 of file NonlinearSystemBase.h.

Constructor & Destructor Documentation

NonlinearSystemBase()

EXTERN_C_END NonlinearSystemBase::NonlinearSystemBase	(	FEProblemBase &	problem,
		System &	sys,
		const std::string &	name
	)

Definition at line 98 of file NonlinearSystemBase.C.

  : SystemBase(fe_problem, name, Moose::VAR_NONLINEAR),
    ConsoleStreamInterface(fe_problem.getMooseApp()),
    PerfGraphInterface(fe_problem.getMooseApp().perfGraph(), "NonlinearSystemBase"),
    _fe_problem(fe_problem),
    _sys(sys),
    _last_rnorm(0.),
    _last_nl_rnorm(0.),
    _l_abs_step_tol(1e-10),
    _initial_residual_before_preset_bcs(0.),
    _initial_residual_after_preset_bcs(0.),
    _current_nl_its(0),
    _compute_initial_residual_before_preset_bcs(true),
    _current_solution(NULL),
    _residual_ghosted(NULL),
    _serialized_solution(*NumericVector<Number>::build(_communicator).release()),
    _solution_previous_nl(NULL),
    _residual_copy(*NumericVector<Number>::build(_communicator).release()),
    _u_dot(NULL),
    _u_dotdot(NULL),
    _u_dot_old(NULL),
    _u_dotdot_old(NULL),
    _Re_time_tag(-1),
    _Re_time(NULL),
    _Re_non_time_tag(-1),
    _Re_non_time(NULL),
    _scalar_kernels(/*threaded=*/false),
    _nodal_bcs(/*threaded=*/false),
    _preset_nodal_bcs(/*threaded=*/false),
    _splits(/*threaded=*/false),
    _increment_vec(NULL),
    _pc_side(Moose::PCS_DEFAULT),
    _ksp_norm(Moose::KSPN_UNPRECONDITIONED),
    _use_finite_differenced_preconditioner(false),
    _have_decomposition(false),
    _use_field_split_preconditioner(false),
    _add_implicit_geometric_coupling_entries_to_jacobian(false),
    _assemble_constraints_separately(false),
    _need_serialized_solution(false),
    _need_residual_copy(false),
    _need_residual_ghosted(false),
    _debugging_residuals(false),
    _doing_dg(false),
    _n_iters(0),
    _n_linear_iters(0),
    _n_residual_evaluations(0),
    _final_residual(0.),
    _computing_initial_residual(false),
    _print_all_var_norms(false),
    _has_save_in(false),
    _has_diag_save_in(false),
    _has_nodalbc_save_in(false),
    _has_nodalbc_diag_save_in(false),
    _compute_residual_tags_timer(registerTimedSection("computeResidualTags", 5)),
    _compute_residual_internal_timer(registerTimedSection("computeResidualInternal", 3)),
    _kernels_timer(registerTimedSection("Kernels", 3)),
    _scalar_kernels_timer(registerTimedSection("ScalarKernels", 3)),
    _nodal_kernels_timer(registerTimedSection("NodalKernels", 3)),
    _nodal_kernel_bcs_timer(registerTimedSection("NodalKernelBCs", 3)),
    _nodal_bcs_timer(registerTimedSection("NodalBCs", 3)),
    _compute_jacobian_tags_timer(registerTimedSection("computeJacobianTags", 5)),
    _compute_jacobian_blocks_timer(registerTimedSection("computeJacobianBlocks", 3)),
    _compute_dampers_timer(registerTimedSection("computeDampers", 3)),
    _compute_dirac_timer(registerTimedSection("computeDirac", 3))
{
  getResidualNonTimeVector();
  // Don't need to add the matrix - it already exists (for now)
  _Ke_system_tag = _fe_problem.addMatrixTag("SYSTEM");

  // The time matrix tag is not normally used - but must be added to the system
  // in case it is so that objects can have 'time' in their matrix tags by default
  _fe_problem.addMatrixTag("TIME");

  _Re_tag = _fe_problem.addVectorTag("RESIDUAL");
}

~NonlinearSystemBase()

NonlinearSystemBase::~NonlinearSystemBase ( )

virtual

Definition at line 176 of file NonlinearSystemBase.C.

{
  delete &_serialized_solution;
  delete &_residual_copy;
}

Member Function Documentation

activeAllMatrixTags()

void SystemBase::activeAllMatrixTags ( )

virtualinherited

Make all exsiting matrices ative.

Definition at line 865 of file SystemBase.C.

Referenced by computeJacobianInternal(), and computeResidualTags().

{
  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++)
    if (hasMatrix(tag))
      _matrix_tag_active_flags[tag] = true;
    else
      _matrix_tag_active_flags[tag] = false;
}

activeMatrixTag()

void SystemBase::activeMatrixTag ( TagID  tag )

virtualinherited

Active a matrix for tag.

Definition at line 830 of file SystemBase.C.

{
  mooseAssert(_subproblem.matrixTagExists(tag),
              "Cannot active Matrix with matrix_tag : " << tag << "that does not exist");

  if (_matrix_tag_active_flags.size() < tag + 1)
    _matrix_tag_active_flags.resize(tag + 1);

  _matrix_tag_active_flags[tag] = true;
}

addBoundaryCondition()

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

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

  // Active BoundaryIDs for the object
  const std::set<BoundaryID> & boundary_ids = bc->boundaryIDs();
  _vars[tid].addBoundaryVar(boundary_ids, &bc->variable());

  // 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)
  {
    _nodal_bcs.addObject(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;

    // PresetNodalBC
    std::shared_ptr<PresetNodalBC> pnbc = std::dynamic_pointer_cast<PresetNodalBC>(bc);
    if (pnbc)
      _preset_nodal_bcs.addObject(pnbc);
  }

  // IntegratedBCBase
  else if (ibc)
  {
    _integrated_bcs.addObject(ibc, tid);
    _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 < libMesh::n_threads(); tid++)
    {
      // Create the object
      bc = _factory.create<BoundaryCondition>(bc_name, name, parameters, tid);

      // Active BoundaryIDs for the object
      const std::set<BoundaryID> & boundary_ids = bc->boundaryIDs();
      _vars[tid].addBoundaryVar(boundary_ids, &bc->variable());

      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
	)

Adds a Constraint.

Parameters

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

Definition at line 454 of file NonlinearSystemBase.C.

{
  std::shared_ptr<Constraint> constraint = _factory.create<Constraint>(c_name, name, parameters);
  _constraints.addObject(constraint);

  if (constraint && constraint->addCouplingEntriesToJacobian())
    addImplicitGeometricCouplingEntriesToJacobian(true);
}

addDamper()

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

Adds a damper.

Parameters

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

Definition at line 516 of file NonlinearSystemBase.C.

{
  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); ++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
	)

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 479 of file NonlinearSystemBase.C.

{
  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); ++tid)
  {
    auto dg_kernel = _factory.create<DGKernelBase>(dg_kernel_name, name, parameters, tid);
    _dg_kernels.addObject(dg_kernel, tid);
  }

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

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 466 of file NonlinearSystemBase.C.

{
  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
  {
    std::shared_ptr<DiracKernel> kernel =
        _factory.create<DiracKernel>(kernel_name, name, parameters, tid);
    _dirac_kernels.addObject(kernel, tid);
  }
}

addDotVectors()

void NonlinearSystemBase::addDotVectors

(

)

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

Definition at line 217 of file NonlinearSystemBase.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);
}

addExtraVectors()

void NonlinearSystemBase::addExtraVectors ( )

overridevirtual

Method called during initialSetup to add extra system vector if they are required by the simulation.

Reimplemented from SystemBase.

Definition at line 237 of file NonlinearSystemBase.C.

{
  if (_fe_problem.needsPreviousNewtonIteration())
    _solution_previous_nl = &addVector("u_previous_newton", true, GHOSTED);
}

addImplicitGeometricCouplingEntries()

void NonlinearSystemBase::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.

near each other across a gap).

Definition at line 1657 of file NonlinearSystemBase.C.

Referenced by computeJacobianInternal().

{
  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::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 std::vector<dof_id_type> & row = it.second;

    for (const auto & coupled_dof : row)
      jacobian.add(dof, coupled_dof, 0);
  }
}

addImplicitGeometricCouplingEntriesToJacobian()

void NonlinearSystemBase::addImplicitGeometricCouplingEntriesToJacobian ( bool  add = true )

inline

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 432 of file NonlinearSystemBase.h.

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

  {
    _add_implicit_geometric_coupling_entries_to_jacobian = add;
  }

addInterfaceKernel()

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

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 498 of file NonlinearSystemBase.C.

{
  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); ++tid)
  {
    std::shared_ptr<InterfaceKernel> interface_kernel =
        _factory.create<InterfaceKernel>(interface_kernel_name, name, parameters, tid);

    const std::set<BoundaryID> & boundary_ids = interface_kernel->boundaryIDs();
    _vars[tid].addBoundaryVar(boundary_ids, &interface_kernel->variable());

    _interface_kernels.addObject(interface_kernel, tid);
    _vars[tid].addBoundaryVars(boundary_ids, interface_kernel->getCoupledVars());
  }
}

addKernel()

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

virtual

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 334 of file NonlinearSystemBase.C.

{
  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); 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);
    if (std::dynamic_pointer_cast<ADKernel<JACOBIAN>>(kernel) ||
        std::dynamic_pointer_cast<ADVectorKernel<JACOBIAN>>(kernel))
      _ad_jacobian_kernels.addObject(kernel, tid);
    else
      _kernels.addObject(kernel, tid);
  }

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

addMatrix()

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

inlinevirtualinherited

Adds a jacobian sized vector.

Parameters

tag_name

The name of the tag

Reimplemented in NonlinearSystem.

Definition at line 642 of file SystemBase.h.

  {
    mooseError("Adding a matrix is not supported for this type of system!");
  }

addNodalKernel()

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

virtual

Adds a NodalKernel.

Parameters

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

Definition at line 357 of file NonlinearSystemBase.C.

{
  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
  {
    // Create the kernel object via the factory and add to the warehouse
    std::shared_ptr<NodalKernel> kernel =
        _factory.create<NodalKernel>(kernel_name, name, parameters, tid);
    _nodal_kernels.addObject(kernel, tid);
  }

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

addScalarKernel()

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

Adds a scalar kernel.

Parameters

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

Definition at line 376 of file NonlinearSystemBase.C.

{
  std::shared_ptr<ScalarKernel> kernel =
      _factory.create<ScalarKernel>(kernel_name, name, parameters);
  _scalar_kernels.addObject(kernel);
}

addScalarVariable()

void SystemBase::addScalarVariable ( const std::string &  var_name, Order  order, Real  scale_factor, const std::set< SubdomainID > *const  active_subdomains = NULL  )

virtualinherited

Adds a scalar variable.

Parameters

var_name	The name of the variable
order	The order of the variable
scale_factor	The scaling factor to be used with this scalar variable

Definition at line 628 of file SystemBase.C.

Referenced by DisplacedProblem::addAuxScalarVariable(), and DisplacedProblem::addScalarVariable().

{
  FEType type(order, SCALAR);
  unsigned int var_num = system().add_variable(var_name, type, active_subdomains);
  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
  {
    // FIXME: we cannot refer fetype in libMesh at this point, so we will just make a copy in
    // MooseVariableBase.
    MooseVariableScalar * var =
        new MooseVariableScalar(var_num, type, *this, _subproblem.assembly(tid), _var_kind, tid);
    var->scalingFactor(scale_factor);
    _vars[tid].add(var_name, var);
  }
  if (active_subdomains == nullptr)
    _var_map[var_num] = std::set<SubdomainID>();
  else
    for (const auto subdomain_id : *active_subdomains)
      _var_map[var_num].insert(subdomain_id);
}

addSplit()

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

Adds a split.

Parameters

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

Definition at line 544 of file NonlinearSystemBase.C.

{
  std::shared_ptr<Split> split = _factory.create<Split>(split_name, name, parameters);
  _splits.addObject(split);
}

addTimeIntegrator() [1/4]

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

overridevirtual

Add a time integrator.

Parameters

type	Type of the integrator
name	The name of the integrator
parameters	Integrator params

Reimplemented from SystemBase.

Definition at line 323 of file NonlinearSystemBase.C.

{
  parameters.set<SystemBase *>("_sys") = this;

  std::shared_ptr<TimeIntegrator> ti = _factory.create<TimeIntegrator>(type, name, parameters);
  _time_integrator = ti;
}

addTimeIntegrator() [2/4]

virtual void SystemBase::addTimeIntegrator

inline

Definition at line 681 of file SystemBase.h.

  {
  }

addTimeIntegrator() [3/4]

virtual void SystemBase::addTimeIntegrator

inline

Definition at line 687 of file SystemBase.h.

{}

addTimeIntegrator() [4/4]

virtual void SystemBase::addTimeIntegrator ( std::shared_ptr< TimeIntegrator >  )

inlinevirtualinherited

Reimplemented in DisplacedSystem.

Definition at line 687 of file SystemBase.h.

{}

addVariable()

void SystemBase::addVariable ( const std::string &  var_name, const FEType &  type, Real  scale_factor, const std::set< SubdomainID > *const  active_subdomains = NULL  )

virtualinherited

Adds a variable to the system.

Parameters

var_name	name of the variable
type	FE type of the variable
scale_factor	the scaling factor for the variable
active_subdomains	a list of subdomain ids this variable is active on

Reimplemented in AuxiliarySystem.

Definition at line 597 of file SystemBase.C.

Referenced by DisplacedProblem::addAuxVariable(), AuxiliarySystem::addVariable(), and DisplacedProblem::addVariable().

{
  unsigned int var_num = system().add_variable(var_name, type, active_subdomains);
  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
  {
    // FIXME: we cannot refer fetype in libMesh at this point, so we will just make a copy in
    // MooseVariableBase.
    MooseVariableBase * var;
    if (type == FEType(0, MONOMIAL))
      var = new MooseVariableConstMonomial(
          var_num, type, *this, _subproblem.assembly(tid), _var_kind, tid);
    else if (type == FEType(FIRST, NEDELEC_ONE) || type.family == LAGRANGE_VEC)
      var =
          new VectorMooseVariable(var_num, type, *this, _subproblem.assembly(tid), _var_kind, tid);
    else
      var = new MooseVariable(var_num, type, *this, _subproblem.assembly(tid), _var_kind, tid);

    var->scalingFactor(scale_factor);
    _vars[tid].add(var_name, var);
  }
  if (active_subdomains == nullptr)
    _var_map[var_num] = std::set<SubdomainID>();
  else
    for (const auto subdomain_id : *active_subdomains)
      _var_map[var_num].insert(subdomain_id);
}

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

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

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

Referenced by DisplacedSystem::addVariableToZeroOnJacobian(), ADIntegratedBCTempl< T, compute_stage >::ADIntegratedBCTempl(), ADKernelTempl< T, compute_stage >::ADKernelTempl(), DGKernelBase::DGKernelBase(), IntegratedBC::IntegratedBC(), InterfaceKernel::InterfaceKernel(), Kernel::Kernel(), NodalBC::NodalBC(), and NodalKernel::NodalKernel().

{
  _vars_to_be_zeroed_on_jacobian.push_back(var_name);
}

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

Referenced by DisplacedSystem::addVariableToZeroOnResidual(), ADIntegratedBCTempl< T, compute_stage >::ADIntegratedBCTempl(), ADKernelTempl< T, compute_stage >::ADKernelTempl(), DGKernelBase::DGKernelBase(), IntegratedBC::IntegratedBC(), InterfaceKernel::InterfaceKernel(), Kernel::Kernel(), NodalBC::NodalBC(), and NodalKernel::NodalKernel().

{
  _vars_to_be_zeroed_on_residual.push_back(var_name);
}

addVector() [1/2]

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

virtualinherited

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.

Reimplemented in AuxiliarySystem.

Definition at line 526 of file SystemBase.C.

Referenced by ActuallyExplicitEuler::ActuallyExplicitEuler(), addDotVectors(), addExtraVectors(), AStableDirk4::AStableDirk4(), MultiApp::createApp(), getResidualNonTimeVector(), getResidualTimeVector(), FEProblemBase::initNullSpaceVectors(), LStableDirk3::LStableDirk3(), LStableDirk4::LStableDirk4(), PicardSolve::PicardSolve(), residualGhosted(), and SystemBase::saveOldSolutions().

{
  if (hasVector(vector_name))
    return getVector(vector_name);

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

addVector() [2/2]

NumericVector< Number > & SystemBase::addVector ( TagID  tag, const bool  project, const 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 536 of file SystemBase.C.

{
  if (!_subproblem.vectorTagExists(tag))
    mooseError("Cannot add a tagged vector with vector_tag, ",
               tag,
               ", that tag does not exist in System ",
               name());

  if (hasVector(tag))
    return getVector(tag);

  auto vector_name = _subproblem.vectorTagName(tag);

  NumericVector<Number> & vec = system().add_vector(vector_name, project, type);

  if (_tagged_vectors.size() < tag + 1)
    _tagged_vectors.resize(tag + 1);

  _tagged_vectors[tag] = &vec;

  return vec;
}

assembleConstraintsSeparately()

void NonlinearSystemBase::assembleConstraintsSeparately ( bool  separately = true )

inline

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 442 of file NonlinearSystemBase.h.

  {
    _assemble_constraints_separately = separately;
  }

assignMaxVarNDofsPerElem()

void SystemBase::assignMaxVarNDofsPerElem ( const size_t &  max_dofs )

inlineinherited

assign the maximum element dofs

Definition at line 425 of file SystemBase.h.

{ _max_var_n_dofs_per_elem = max_dofs; }

assignMaxVarNDofsPerNode()

void SystemBase::assignMaxVarNDofsPerNode ( const size_t &  max_dofs )

inlineinherited

assign the maximum node dofs

Definition at line 430 of file SystemBase.h.

{ _max_var_n_dofs_per_node = max_dofs; }

associateMatrixToTag()

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

virtualinherited

associate a matirx to a tag

Reimplemented in DisplacedSystem.

Definition at line 803 of file SystemBase.C.

Referenced by DisplacedSystem::associateMatrixToTag(), and computeJacobian().

{
  mooseAssert(_subproblem.matrixTagExists(tag),
              "Cannot associate Matrix with matrix_tag : " << tag << "that does not exist");

  if (_tagged_matrices.size() < tag + 1)
    _tagged_matrices.resize(tag + 1);

  _tagged_matrices[tag] = &matrix;
}

associateVectorToTag()

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

virtualinherited

Associate a vector for a given tag.

Reimplemented in DisplacedSystem.

Definition at line 749 of file SystemBase.C.

Referenced by DisplacedSystem::associateVectorToTag(), computeNodalBCs(), and computeResidualTag().

{
  mooseAssert(_subproblem.vectorTagExists(tag),
              "You can't associate a tag that does not exist " << tag);
  if (_tagged_vectors.size() < tag + 1)
    _tagged_vectors.resize(tag + 1);

  _tagged_vectors[tag] = &vec;
}

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

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

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

augmentSparsity()

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

overridevirtual

Will modify the sparsity pattern to add logical geometric connections.

Implements SystemBase.

Definition at line 2785 of file NonlinearSystemBase.C.

{
  if (_add_implicit_geometric_coupling_entries_to_jacobian)
  {
    _fe_problem.updateGeomSearch();

    std::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 std::vector<dof_id_type> & 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]++;
        }
      }
    }
  }
}

checkKernelCoverage()

void NonlinearSystemBase::checkKernelCoverage

(

const std::set< SubdomainID > &

mesh_subdomains

)

const

System Integrity Checks

Definition at line 2935 of file NonlinearSystemBase.C.

{
  // Check kernel coverage of subdomains (blocks) in your mesh
  std::set<SubdomainID> input_subdomains;
  std::set<std::string> kernel_variables;

  bool global_kernels_exist = _kernels.hasActiveBlockObjects(Moose::ANY_BLOCK_ID);
  global_kernels_exist |= _scalar_kernels.hasActiveObjects();
  global_kernels_exist |= _nodal_kernels.hasActiveObjects();

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

  if (!global_kernels_exist)
  {
    std::set<SubdomainID> difference;
    std::set_difference(mesh_subdomains.begin(),
                        mesh_subdomains.end(),
                        input_subdomains.begin(),
                        input_subdomains.end(),
                        std::inserter(difference, difference.end()));

    if (!difference.empty())
    {
      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_ids.str());
    }
  }

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

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

closeTaggedMatrices()

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

inherited

Close all matrices associated the tags.

Definition at line 795 of file SystemBase.C.

Referenced by computeJacobianInternal().

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

closeTaggedVectors()

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

virtualinherited

Close all vectors for given tags.

Definition at line 560 of file SystemBase.C.

Referenced by computeResidualTags().

{
  for (auto & tag : tags)
  {
    mooseAssert(_subproblem.vectorTagExists(tag), "Tag: " << tag << " does not exsit");
    getVector(tag).close();
  }
}

computeDamping()

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

Compute damping.

Parameters

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

Returns

returns The damping factor

Definition at line 2676 of file NonlinearSystemBase.C.

{
  // Default to no damping
  Real damping = 1.0;
  bool has_active_dampers = false;

  if (_element_dampers.hasActiveObjects())
  {
    TIME_SECTION(_compute_dampers_timer);

    has_active_dampers = true;
    *_increment_vec = update;
    ComputeElemDampingThread cid(_fe_problem);
    Threads::parallel_reduce(*_mesh.getActiveLocalElementRange(), cid);
    damping = std::min(cid.damping(), damping);
  }

  if (_nodal_dampers.hasActiveObjects())
  {
    TIME_SECTION(_compute_dampers_timer);

    has_active_dampers = true;
    *_increment_vec = update;
    ComputeNodalDampingThread cndt(_fe_problem);
    Threads::parallel_reduce(*_mesh.getLocalNodeRange(), cndt);
    damping = std::min(cndt.damping(), damping);
  }

  if (_general_dampers.hasActiveObjects())
  {
    TIME_SECTION(_compute_dampers_timer);

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

  _communicator.min(damping);

  if (has_active_dampers && damping < 1.0)
    _console << " Damping factor: " << damping << "\n";

  return damping;
}

computeDiracContributions()

void NonlinearSystemBase::computeDiracContributions ( const std::set< TagID > &  tags, bool  is_jacobian  )

protected

Definition at line 2735 of file NonlinearSystemBase.C.

Referenced by computeJacobianInternal(), and computeResidualInternal().

{
  _fe_problem.clearDiracInfo();

  std::set<const Elem *> dirac_elements;

  if (_dirac_kernels.hasActiveObjects())
  {
    TIME_SECTION(_compute_dirac_timer);

    // TODO: Need a threading fix... but it's complicated!
    for (THREAD_ID tid = 0; tid < libMesh::n_threads(); ++tid)
    {
      const auto & dkernels = _dirac_kernels.getActiveObjects(tid);
      for (const auto & dkernel : dkernels)
      {
        dkernel->clearPoints();
        dkernel->addPoints();
      }
    }

    ComputeDiracThread cd(_fe_problem, tags, is_jacobian);

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

computeJacobian() [1/2]

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

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

Definition at line 2508 of file NonlinearSystemBase.C.

Referenced by computeJacobian().

{
  associateMatrixToTag(jacobian, systemMatrixTag());

  computeJacobianTags(tags);

  disassociateMatrixFromTag(jacobian, systemMatrixTag());
}

computeJacobian() [2/2]

void NonlinearSystemBase::computeJacobian

(

SparseMatrix< Number > &

jacobian

)

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

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

computeJacobianBlocks() [1/2]

void NonlinearSystemBase::computeJacobianBlocks

(

std::vector< JacobianBlock *> &

blocks

)

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

computeJacobianBlocks() [2/2]

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

Definition at line 2549 of file NonlinearSystemBase.C.

{
  TIME_SECTION(_compute_jacobian_blocks_timer);

  FloatingPointExceptionGuard fpe_guard(_app);

  for (unsigned int i = 0; i < blocks.size(); i++)
  {
    SparseMatrix<Number> & jacobian = blocks[i]->_jacobian;

#ifdef LIBMESH_HAVE_PETSC
// Necessary for speed
#if PETSC_VERSION_LESS_THAN(3, 0, 0)
    MatSetOption(static_cast<PetscMatrix<Number> &>(jacobian).mat(), MAT_KEEP_ZEROED_ROWS);
#elif PETSC_VERSION_LESS_THAN(3, 1, 0)
    // In Petsc 3.0.0, MatSetOption has three args...the third arg
    // determines whether the option is set (true) or unset (false)
    MatSetOption(
        static_cast<PetscMatrix<Number> &>(jacobian).mat(), MAT_KEEP_ZEROED_ROWS, PETSC_TRUE);
#else
    MatSetOption(static_cast<PetscMatrix<Number> &>(jacobian).mat(),
                 MAT_KEEP_NONZERO_PATTERN, // This is changed in 3.1
                 PETSC_TRUE);
#endif
#if PETSC_VERSION_LESS_THAN(3, 3, 0)
#else
    if (!_fe_problem.errorOnJacobianNonzeroReallocation())
      MatSetOption(static_cast<PetscMatrix<Number> &>(jacobian).mat(),
                   MAT_NEW_NONZERO_ALLOCATION_ERR,
                   PETSC_FALSE);
#endif

#endif

    jacobian.zero();
  }

  for (unsigned int tid = 0; tid < libMesh::n_threads(); tid++)
    _fe_problem.reinitScalars(tid);

  PARALLEL_TRY
  {
    ConstElemRange & elem_range = *_mesh.getActiveLocalElementRange();
    ComputeJacobianBlocksThread cjb(_fe_problem, blocks, tags);
    Threads::parallel_reduce(elem_range, cjb);
  }
  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
    {
      ConstBndNodeRange & bnd_nodes = *_mesh.getBoundaryNodeRange();
      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 )

protected

Form multiple matrices for all the tags.

Users should not call this func directly.

Definition at line 2197 of file NonlinearSystemBase.C.

Referenced by computeJacobianTags().

{
  // Make matrix ready to use
  activeAllMatrixTags();

  for (auto tag : tags)
  {
    if (!hasMatrix(tag))
      continue;

    auto & jacobian = getMatrix(tag);
#ifdef LIBMESH_HAVE_PETSC
// Necessary for speed
#if PETSC_VERSION_LESS_THAN(3, 0, 0)
    MatSetOption(static_cast<PetscMatrix<Number> &>(jacobian).mat(), MAT_KEEP_ZEROED_ROWS);
#elif PETSC_VERSION_LESS_THAN(3, 1, 0)
    // In Petsc 3.0.0, MatSetOption has three args...the third arg
    // determines whether the option is set (true) or unset (false)
    MatSetOption(
        static_cast<PetscMatrix<Number> &>(jacobian).mat(), MAT_KEEP_ZEROED_ROWS, PETSC_TRUE);
#else
    MatSetOption(static_cast<PetscMatrix<Number> &>(jacobian).mat(),
                 MAT_KEEP_NONZERO_PATTERN, // This is changed in 3.1
                 PETSC_TRUE);
#endif
#if PETSC_VERSION_LESS_THAN(3, 3, 0)
#else
    if (!_fe_problem.errorOnJacobianNonzeroReallocation())
      MatSetOption(static_cast<PetscMatrix<Number> &>(jacobian).mat(),
                   MAT_NEW_NONZERO_ALLOCATION_ERR,
                   PETSC_FALSE);
#endif

#endif
  }
  // jacobianSetup /////
  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
  {
    _kernels.jacobianSetup(tid);
    _ad_jacobian_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();

  // reinit scalar variables
  for (unsigned int tid = 0; tid < libMesh::n_threads(); tid++)
    _fe_problem.reinitScalars(tid);

  PARALLEL_TRY
  {
    ConstElemRange & elem_range = *_mesh.getActiveLocalElementRange();
    switch (_fe_problem.coupling())
    {
      case Moose::COUPLING_DIAG:
      {
        ComputeJacobianThread cj(_fe_problem, tags);
        Threads::parallel_reduce(elem_range, cj);

        unsigned int n_threads = libMesh::n_threads();
        for (unsigned int i = 0; i < n_threads;
             i++) // Add any Jacobian contributions still hanging around
          _fe_problem.addCachedJacobian(i);

        // Block restricted Nodal Kernels
        if (_nodal_kernels.hasActiveBlockObjects())
        {
          ComputeNodalKernelJacobiansThread cnkjt(_fe_problem, _nodal_kernels, tags);
          ConstNodeRange & range = *_mesh.getLocalNodeRange();
          Threads::parallel_reduce(range, cnkjt);

          unsigned int n_threads = libMesh::n_threads();
          for (unsigned int i = 0; i < n_threads;
               i++) // Add any cached jacobians that might be hanging around
            _fe_problem.assembly(i).addCachedJacobianContributions();
        }

        // Boundary restricted Nodal Kernels
        if (_nodal_kernels.hasActiveBoundaryObjects())
        {
          ComputeNodalKernelBCJacobiansThread cnkjt(_fe_problem, _nodal_kernels, tags);
          ConstBndNodeRange & bnd_range = *_mesh.getBoundaryNodeRange();

          Threads::parallel_reduce(bnd_range, cnkjt);
          unsigned int n_threads = libMesh::n_threads();
          for (unsigned int i = 0; i < n_threads;
               i++) // Add any cached jacobians that might be hanging around
            _fe_problem.assembly(i).addCachedJacobianContributions();
        }
      }
      break;

      default:
      case Moose::COUPLING_CUSTOM:
      {
        ComputeFullJacobianThread cj(_fe_problem, tags);
        Threads::parallel_reduce(elem_range, cj);
        unsigned int n_threads = libMesh::n_threads();

        for (unsigned int i = 0; i < n_threads; i++)
          _fe_problem.addCachedJacobian(i);

        // Block restricted Nodal Kernels
        if (_nodal_kernels.hasActiveBlockObjects())
        {
          ComputeNodalKernelJacobiansThread cnkjt(_fe_problem, _nodal_kernels, tags);
          ConstNodeRange & range = *_mesh.getLocalNodeRange();
          Threads::parallel_reduce(range, cnkjt);

          unsigned int n_threads = libMesh::n_threads();
          for (unsigned int i = 0; i < n_threads;
               i++) // Add any cached jacobians that might be hanging around
            _fe_problem.assembly(i).addCachedJacobianContributions();
        }

        // Boundary restricted Nodal Kernels
        if (_nodal_kernels.hasActiveBoundaryObjects())
        {
          ComputeNodalKernelBCJacobiansThread cnkjt(_fe_problem, _nodal_kernels, tags);
          ConstBndNodeRange & bnd_range = *_mesh.getBoundaryNodeRange();

          Threads::parallel_reduce(bnd_range, cnkjt);

          unsigned int n_threads = libMesh::n_threads();
          for (unsigned int i = 0; i < n_threads;
               i++) // Add any cached jacobians that might be hanging around
            _fe_problem.assembly(i).addCachedJacobianContributions();
        }
      }
      break;
    }

    computeDiracContributions(tags, true);

    computeScalarKernelsJacobians(tags);

    static bool first = true;

    // This adds zeroes into geometric coupling entries to ensure they stay in the matrix
    if (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;

  closeTaggedMatrices(tags);

  // Have no idea how to have constraints work
  // with the tag system
  PARALLEL_TRY
  {
    // Add in Jacobian contributions from Constraints
    if (_fe_problem._has_constraints)
    {
      // Nodal Constraints
      enforceNodalConstraintsJacobian();

      // Undisplaced Constraints
      constraintJacobians(false);

      // Displaced Constraints
      if (_fe_problem.getDisplacedProblem())
        constraintJacobians(true);
    }
  }
  PARALLEL_CATCH;
  if (_fe_problem._has_constraints)
    closeTaggedMatrices(tags);

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

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

    // 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_NONLINEAR)
              var_set.insert(coupled_var->number());

          var_set.insert(bc->variable().number());
        }
      }
    }

    // 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.
    std::vector<std::pair<MooseVariableFEBase *, MooseVariableFEBase *>> & coupling_entries =
        _fe_problem.couplingEntries(/*_tid=*/0);

    // Compute Jacobians for NodalBCBases
    ConstBndNodeRange & bnd_nodes = *_mesh.getBoundaryNodeRange();
    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);
          }
        }
      }
    } // end loop over boundary nodes

    // Set the cached NodalBCBase values in the Jacobian matrix
    _fe_problem.assembly(0).setCachedJacobianContributions();
  }
  PARALLEL_CATCH;

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

computeJacobianTags()

void NonlinearSystemBase::computeJacobianTags

(

const std::set< TagID > &

tags

)

Computes multiple (tag associated) Jacobian matricese.

Definition at line 2518 of file NonlinearSystemBase.C.

Referenced by computeJacobian().

{
  TIME_SECTION(_compute_jacobian_tags_timer);

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

computeNodalBCs() [1/3]

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

protected

Enforces nodal boundary conditions.

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

Definition at line 1457 of file NonlinearSystemBase.C.

Referenced by computeNodalBCs(), and computeResidualTags().

{
  _nl_vector_tags.clear();

  auto & tags = _fe_problem.getVectorTags();
  for (auto & tag : tags)
    _nl_vector_tags.insert(tag.second);

  associateVectorToTag(residual, residualVectorTag());
  computeNodalBCs(residual, _nl_vector_tags);
  disassociateVectorFromTag(residual, residualVectorTag());
}

computeNodalBCs() [2/3]

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

protected

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

Definition at line 1471 of file NonlinearSystemBase.C.

{
  associateVectorToTag(residual, residualVectorTag());

  computeNodalBCs(tags);

  disassociateVectorFromTag(residual, residualVectorTag());
}

computeNodalBCs() [3/3]

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

protected

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

Definition at line 1481 of file NonlinearSystemBase.C.

{
  // 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();

  PARALLEL_TRY
  {
    ConstBndNodeRange & bnd_nodes = *_mesh.getBoundaryNodeRange();

    if (!bnd_nodes.empty())
    {
      TIME_SECTION(_nodal_bcs_timer);

      MooseObjectWarehouse<NodalBCBase> * nbc_warehouse;

      // Select nodal kernels
      if (tags.size() == _fe_problem.numVectorTags() || !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));

      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 (nbc_warehouse->hasActiveBoundaryObjects(boundary_id))
          {
            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();
}

computeResidual()

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

Form a residual vector for a given tag.

Definition at line 584 of file NonlinearSystemBase.C.

{
  mooseDeprecated(" Please use computeResidualTag");

  computeResidualTag(residual, tag_id);
}

computeResidualInternal()

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

protected

Compute the residual for a given tag.

Parameters

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

Definition at line 1277 of file NonlinearSystemBase.C.

Referenced by computeResidualTags().

{
  TIME_SECTION(_compute_residual_internal_timer);

  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); 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();

  // reinit scalar variables
  for (unsigned int tid = 0; tid < libMesh::n_threads(); tid++)
    _fe_problem.reinitScalars(tid);

  // residual contributions from the domain
  PARALLEL_TRY
  {
    TIME_SECTION(_kernels_timer);

    ConstElemRange & elem_range = *_mesh.getActiveLocalElementRange();

    ComputeResidualThread cr(_fe_problem, tags);

    Threads::parallel_reduce(elem_range, cr);

    unsigned int n_threads = libMesh::n_threads();
    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(_scalar_kernels_timer);

      MooseObjectWarehouse<ScalarKernel> * 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())
        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(_nodal_kernels_timer);

      ComputeNodalKernelsThread cnk(_fe_problem, _nodal_kernels, tags);

      ConstNodeRange & range = *_mesh.getLocalNodeRange();

      if (range.begin() != range.end())
      {
        _fe_problem.reinitNode(*range.begin(), 0);

        Threads::parallel_reduce(range, cnk);

        unsigned int n_threads = libMesh::n_threads();
        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 boundary NodalKernels
  PARALLEL_TRY
  {
    if (_nodal_kernels.hasActiveBoundaryObjects())
    {
      TIME_SECTION(_nodal_kernel_bcs_timer);

      ComputeNodalKernelBcsThread cnk(_fe_problem, _nodal_kernels, tags);

      ConstBndNodeRange & bnd_node_range = *_mesh.getBoundaryNodeRange();

      Threads::parallel_reduce(bnd_node_range, cnk);

      unsigned int n_threads = libMesh::n_threads();
      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 (_need_residual_copy)
  {
    _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, false); }
  PARALLEL_CATCH;

  if (_fe_problem._has_constraints)
  {
    PARALLEL_TRY { enforceNodalConstraintsResidual(*_Re_non_time); }
    PARALLEL_CATCH;
    _Re_non_time->close();
  }

  // Add in Residual contributions from 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();
  }
}

computeResidualTag()

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

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 569 of file NonlinearSystemBase.C.

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

{

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

computeResidualTags()

void NonlinearSystemBase::computeResidualTags

(

const std::set< TagID > &

tags

)

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

Definition at line 592 of file NonlinearSystemBase.C.

Referenced by computeResidualTag().

{
  TIME_SECTION(_compute_residual_tags_timer);

  bool required_residual = tags.find(residualVectorTag()) == tags.end() ? false : true;

  _n_residual_evaluations++;

  // not suppose to do anythin on matrix
  deactiveAllMatrixTags();

  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_integrator)
        _time_integrator->postResidual(residual);
      else
        residual += *_Re_non_time;
      residual.close();
    }
    computeNodalBCs(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
  activeAllMatrixTags();
}

computeScalarKernelsJacobians()

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

protected

Definition at line 2153 of file NonlinearSystemBase.C.

Referenced by computeJacobianInternal().

{
  MooseObjectWarehouse<ScalarKernel> * 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);

    bool have_scalar_contributions = false;
    for (const auto & kernel : scalars)
    {
      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();
  }
}

computeTimeDerivatives()

void NonlinearSystemBase::computeTimeDerivatives

(

)

Computes the time derivative vector.

Definition at line 764 of file NonlinearSystemBase.C.

{
  if (_time_integrator)
  {
    _time_integrator->preStep();
    _time_integrator->computeTimeDerivatives();
  }
}

computeVariables()

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

inlinevirtualinherited

Definition at line 672 of file SystemBase.h.

{}

computingInitialResidual()

virtual bool NonlinearSystemBase::computingInitialResidual ( )

inlinevirtual

Returns true if this system is currently computing the initial residual for a solve.

Returns

Whether or not we are currently computing the initial residual.

Definition at line 90 of file NonlinearSystemBase.h.

{ return _computing_initial_residual; }

constraintJacobians()

void NonlinearSystemBase::constraintJacobians

(

bool

displaced

)

Add jacobian contributions from Constraints.

Parameters

jacobian	reference to the Jacobian matrix
displaced	Controls whether to do the displaced Constraints or non-displaced

Definition at line 1681 of file NonlinearSystemBase.C.

Referenced by computeJacobianInternal().

{
  if (!hasMatrix(systemMatrixTag()))
    mooseError("A system matrix is required");

  auto & jacobian = getMatrix(systemMatrixTag());

#if PETSC_VERSION_LESS_THAN(3, 3, 0)
#else
  if (!_fe_problem.errorOnJacobianNonzeroReallocation())
    MatSetOption(static_cast<PetscMatrix<Number> &>(jacobian).mat(),
                 MAT_NEW_NONZERO_ALLOCATION_ERR,
                 PETSC_FALSE);
  if (_fe_problem.ignoreZerosInJacobian())
    MatSetOption(
        static_cast<PetscMatrix<Number> &>(jacobian).mat(), MAT_IGNORE_ZERO_ENTRIES, PETSC_TRUE);
#endif

  std::vector<numeric_index_type> zero_rows;
  std::map<std::pair<unsigned int, unsigned int>, PenetrationLocator *> * penetration_locators =
      NULL;

  if (!displaced)
  {
    GeometricSearchData & geom_search_data = _fe_problem.geomSearchData();
    penetration_locators = &geom_search_data._penetration_locators;
  }
  else
  {
    GeometricSearchData & displaced_geom_search_data =
        _fe_problem.getDisplacedProblem()->geomSearchData();
    penetration_locators = &displaced_geom_search_data._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> & slave_nodes = pen_loc._nearest_node._slave_nodes;

    BoundaryID slave_boundary = pen_loc._slave_boundary;

    zero_rows.clear();
    if (_constraints.hasActiveNodeFaceConstraints(slave_boundary, displaced))
    {
      const auto & constraints =
          _constraints.getActiveNodeFaceConstraints(slave_boundary, displaced);

      for (const auto & slave_node_num : slave_nodes)
      {
        Node & slave_node = _mesh.nodeRef(slave_node_num);

        if (slave_node.processor_id() == processor_id())
        {
          if (pen_loc._penetration_info[slave_node_num])
          {
            PenetrationInfo & info = *pen_loc._penetration_info[slave_node_num];

            const Elem * master_elem = info._elem;
            unsigned int master_side = info._side_num;

            // reinit variables at the node
            _fe_problem.reinitNodeFace(&slave_node, slave_boundary, 0);

            _fe_problem.prepareAssembly(0);
            _fe_problem.reinitOffDiagScalars(0);

            std::vector<Point> points;
            points.push_back(info._closest_point);

            // reinit variables on the master element's face at the contact point
            _fe_problem.setNeighborSubdomainID(master_elem, 0);
            _fe_problem.reinitNeighborPhys(master_elem, master_side, points, 0);
            for (const auto & nfc : constraints)
            {
              nfc->_jacobian = &jacobian;

              if (nfc->shouldApply())
              {
                constraints_applied = true;

                nfc->subProblem().prepareShapes(nfc->variable().number(), 0);
                nfc->subProblem().prepareNeighborShapes(nfc->variable().number(), 0);

                nfc->computeJacobian();

                if (nfc->overwriteSlaveJacobian())
                {
                  // Add this variable's dof's row to be zeroed
                  zero_rows.push_back(nfc->variable().nodalDofIndex());
                }

                std::vector<dof_id_type> slave_dofs(1, nfc->variable().nodalDofIndex());

                // Cache the jacobian block for the slave side
                _fe_problem.assembly(0).cacheJacobianBlock(nfc->_Kee,
                                                           slave_dofs,
                                                           nfc->_connected_dof_indices,
                                                           nfc->variable().scalingFactor());

                // Cache the jacobian block for the master side
                if (nfc->addCouplingEntriesToJacobian())
                  _fe_problem.assembly(0).cacheJacobianBlock(
                      nfc->_Kne,
                      nfc->masterVariable().dofIndicesNeighbor(),
                      nfc->_connected_dof_indices,
                      nfc->variable().scalingFactor());

                _fe_problem.cacheJacobian(0);
                if (nfc->addCouplingEntriesToJacobian())
                  _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_NONLINEAR)
                    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()))
                    continue;

                  // Need to zero out the matrices first
                  _fe_problem.prepareAssembly(0);

                  nfc->subProblem().prepareShapes(nfc->variable().number(), 0);
                  nfc->subProblem().prepareNeighborShapes(jvar->number(), 0);

                  nfc->computeOffDiagJacobian(jvar->number());

                  // Cache the jacobian block for the slave side
                  _fe_problem.assembly(0).cacheJacobianBlock(nfc->_Kee,
                                                             slave_dofs,
                                                             nfc->_connected_dof_indices,
                                                             nfc->variable().scalingFactor());

                  // Cache the jacobian block for the master side
                  if (nfc->addCouplingEntriesToJacobian())
                    _fe_problem.assembly(0).cacheJacobianBlock(nfc->_Kne,
                                                               nfc->variable().dofIndicesNeighbor(),
                                                               nfc->_connected_dof_indices,
                                                               nfc->variable().scalingFactor());

                  _fe_problem.cacheJacobian(0);
                  if (nfc->addCouplingEntriesToJacobian())
                    _fe_problem.cacheJacobianNeighbor(0);
                }
              }
            }
          }
        }
      }
    }
    if (_assemble_constraints_separately)
    {
      // See if constraints were applied anywhere
      _communicator.max(constraints_applied);

      if (constraints_applied)
      {
#ifdef LIBMESH_HAVE_PETSC
// Necessary for speed
#if PETSC_VERSION_LESS_THAN(3, 0, 0)
        MatSetOption(static_cast<PetscMatrix<Number> &>(jacobian).mat(), MAT_KEEP_ZEROED_ROWS);
#elif PETSC_VERSION_LESS_THAN(3, 1, 0)
        // In Petsc 3.0.0, MatSetOption has three args...the third arg
        // determines whether the option is set (true) or unset (false)
        MatSetOption(
            static_cast<PetscMatrix<Number> &>(jacobian).mat(), MAT_KEEP_ZEROED_ROWS, PETSC_TRUE);
#else
        MatSetOption(static_cast<PetscMatrix<Number> &>(jacobian).mat(),
                     MAT_KEEP_NONZERO_PATTERN, // This is changed in 3.1
                     PETSC_TRUE);
#endif
#endif

        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)
    {
#ifdef LIBMESH_HAVE_PETSC
// Necessary for speed
#if PETSC_VERSION_LESS_THAN(3, 0, 0)
      MatSetOption(static_cast<PetscMatrix<Number> &>(jacobian).mat(), MAT_KEEP_ZEROED_ROWS);
#elif PETSC_VERSION_LESS_THAN(3, 1, 0)
      // In Petsc 3.0.0, MatSetOption has three args...the third arg
      // determines whether the option is set (true) or unset (false)
      MatSetOption(
          static_cast<PetscMatrix<Number> &>(jacobian).mat(), MAT_KEEP_ZEROED_ROWS, PETSC_TRUE);
#else
      MatSetOption(static_cast<PetscMatrix<Number> &>(jacobian).mat(),
                   MAT_KEEP_NONZERO_PATTERN, // This is changed in 3.1
                   PETSC_TRUE);
#endif
#endif

      jacobian.close();
      jacobian.zero_rows(zero_rows, 0.0);
      jacobian.close();
      _fe_problem.addCachedJacobian(0);
      jacobian.close();
    }
  }

  THREAD_ID tid = 0;
  // go over mortar interfaces
  auto & ifaces = _mesh.getMortarInterfaces();
  for (const auto & iface : ifaces)
  {
    if (_constraints.hasActiveMortarConstraints(iface->_name))
    {
      // MortarConstraint objects
      const auto & face_constraints = _constraints.getActiveMortarConstraints(iface->_name);

      // go over elements on that interface
      const std::vector<Elem *> & elems = iface->_elems;
      for (const auto & elem : elems)
      {
        // for each element process constraints on the
        for (const auto & ffc : face_constraints)
        {
          _fe_problem.setCurrentSubdomainID(elem, tid);
          _fe_problem.prepare(elem, tid);
          _fe_problem.reinitElem(elem, tid);
          ffc->reinit();
          ffc->subProblem().prepareShapes(ffc->variable().number(), tid);
          ffc->computeJacobian();
          _fe_problem.cacheJacobian(tid);

          ffc->reinitSide(Moose::Master);
          ffc->computeJacobianSide(Moose::Master);
          _fe_problem.cacheJacobian(tid);

          ffc->reinitSide(Moose::Slave);
          ffc->computeJacobianSide(Moose::Slave);
          _fe_problem.cacheJacobian(tid);
        }

        _fe_problem.addCachedJacobian(tid);
      }
    }
  }

  // go over element-element constraint interface
  std::map<unsigned int, std::shared_ptr<ElementPairLocator>> * element_pair_locators = nullptr;

  if (!displaced)
  {
    GeometricSearchData & geom_search_data = _fe_problem.geomSearchData();
    element_pair_locators = &geom_search_data._element_pair_locators;
  }
  else
  {
    GeometricSearchData & displaced_geom_search_data =
        _fe_problem.getDisplacedProblem()->geomSearchData();
    element_pair_locators = &displaced_geom_search_data._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);
          _fe_problem.reinitElemPhys(elem1, info._elem1_constraint_q_point, tid);
          _fe_problem.setNeighborSubdomainID(elem2, tid);
          _fe_problem.reinitNeighborPhys(elem2, info._elem2_constraint_q_point, tid);

          ec->subProblem().prepareShapes(ec->variable().number(), tid);
          ec->subProblem().prepareNeighborShapes(ec->variable().number(), tid);

          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_slave_node_ids;
  constraints_applied = false;
  for (const auto & slave_id : _mesh.meshSubdomains())
  {
    for (const auto & master_id : _mesh.meshSubdomains())
    {
      if (_constraints.hasActiveNodeElemConstraints(slave_id, master_id, displaced))
      {
        const auto & constraints =
            _constraints.getActiveNodeElemConstraints(slave_id, master_id, displaced);

        // get unique set of ids of all nodes on current block
        unique_slave_node_ids.clear();
        const MeshBase & meshhelper = _mesh.getMesh();
        for (const auto & elem : as_range(meshhelper.active_subdomain_elements_begin(slave_id),
                                          meshhelper.active_subdomain_elements_end(slave_id)))
        {
          for (auto & n : elem->node_ref_range())
            unique_slave_node_ids.insert(n.id());
        }

        for (auto slave_node_id : unique_slave_node_ids)
        {
          const Node & slave_node = _mesh.nodeRef(slave_node_id);
          // check if slave node is on current processor
          if (slave_node.processor_id() == processor_id())
          {
            // This reinits the variables that exist on the slave node
            _fe_problem.reinitNodeFace(&slave_node, slave_id, 0);

            // This will set aside residual and jacobian space for the variables that have dofs
            // on the slave node
            _fe_problem.prepareAssembly(0);
            _fe_problem.reinitOffDiagScalars(0);

            for (const auto & nec : constraints)
            {
              if (nec->shouldApply())
              {
                constraints_applied = true;

                nec->_jacobian = &jacobian;
                nec->subProblem().prepareShapes(nec->variable().number(), 0);
                nec->subProblem().prepareNeighborShapes(nec->variable().number(), 0);

                nec->computeJacobian();

                if (nec->overwriteSlaveJacobian())
                {
                  // Add this variable's dof's row to be zeroed
                  zero_rows.push_back(nec->variable().nodalDofIndex());
                }

                std::vector<dof_id_type> slave_dofs(1, nec->variable().nodalDofIndex());

                // Cache the jacobian block for the slave side
                _fe_problem.assembly(0).cacheJacobianBlock(nec->_Kee,
                                                           slave_dofs,
                                                           nec->_connected_dof_indices,
                                                           nec->variable().scalingFactor());

                // Cache the jacobian block for the master side
                _fe_problem.assembly(0).cacheJacobianBlock(
                    nec->_Kne,
                    nec->masterVariable().dofIndicesNeighbor(),
                    nec->_connected_dof_indices,
                    nec->variable().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_NONLINEAR)
                    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()))
                    continue;

                  // Need to zero out the matrices first
                  _fe_problem.prepareAssembly(0);

                  nec->subProblem().prepareShapes(nec->variable().number(), 0);
                  nec->subProblem().prepareNeighborShapes(jvar->number(), 0);

                  nec->computeOffDiagJacobian(jvar->number());

                  // Cache the jacobian block for the slave side
                  _fe_problem.assembly(0).cacheJacobianBlock(nec->_Kee,
                                                             slave_dofs,
                                                             nec->_connected_dof_indices,
                                                             nec->variable().scalingFactor());

                  // Cache the jacobian block for the master side
                  _fe_problem.assembly(0).cacheJacobianBlock(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)
  {
#ifdef LIBMESH_HAVE_PETSC
// Necessary for speed
#if PETSC_VERSION_LESS_THAN(3, 0, 0)
    MatSetOption(static_cast<PetscMatrix<Number> &>(jacobian).mat(), MAT_KEEP_ZEROED_ROWS);
#elif PETSC_VERSION_LESS_THAN(3, 1, 0)
    // In Petsc 3.0.0, MatSetOption has three args...the third arg
    // determines whether the option is set (true) or unset (false)
    MatSetOption(
        static_cast<PetscMatrix<Number> &>(jacobian).mat(), MAT_KEEP_ZEROED_ROWS, PETSC_TRUE);
#else
    MatSetOption(static_cast<PetscMatrix<Number> &>(jacobian).mat(),
                 MAT_KEEP_NONZERO_PATTERN, // This is changed in 3.1
                 PETSC_TRUE);
#endif
#endif

    jacobian.close();
    jacobian.zero_rows(zero_rows, 0.0);
    jacobian.close();
    _fe_problem.addCachedJacobian(0);
    jacobian.close();
  }
}

constraintResiduals()

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

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 959 of file NonlinearSystemBase.C.

Referenced by computeResidualInternal().

{
  // Make sure the residual is in a good state
  residual.close();

  std::map<std::pair<unsigned int, unsigned int>, PenetrationLocator *> * penetration_locators =
      NULL;

  if (!displaced)
  {
    GeometricSearchData & geom_search_data = _fe_problem.geomSearchData();
    penetration_locators = &geom_search_data._penetration_locators;
  }
  else
  {
    GeometricSearchData & displaced_geom_search_data =
        _fe_problem.getDisplacedProblem()->geomSearchData();
    penetration_locators = &displaced_geom_search_data._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> & slave_nodes = pen_loc._nearest_node._slave_nodes;

    BoundaryID slave_boundary = pen_loc._slave_boundary;

    if (_constraints.hasActiveNodeFaceConstraints(slave_boundary, displaced))
    {
      const auto & constraints =
          _constraints.getActiveNodeFaceConstraints(slave_boundary, displaced);

      for (unsigned int i = 0; i < slave_nodes.size(); i++)
      {
        dof_id_type slave_node_num = slave_nodes[i];
        Node & slave_node = _mesh.nodeRef(slave_node_num);

        if (slave_node.processor_id() == processor_id())
        {
          if (pen_loc._penetration_info[slave_node_num])
          {
            PenetrationInfo & info = *pen_loc._penetration_info[slave_node_num];

            const Elem * master_elem = info._elem;
            unsigned int master_side = info._side_num;

            // *These next steps MUST be done in this order!*

            // This reinits the variables that exist on the slave node
            _fe_problem.reinitNodeFace(&slave_node, slave_boundary, 0);

            // This will set aside residual and jacobian space for the variables that have dofs on
            // the slave node
            _fe_problem.prepareAssembly(0);

            std::vector<Point> points;
            points.push_back(info._closest_point);

            // reinit variables on the master element's face at the contact point
            _fe_problem.setNeighborSubdomainID(master_elem, 0);
            _fe_problem.reinitNeighborPhys(master_elem, master_side, points, 0);

            for (const auto & nfc : constraints)
              if (nfc->shouldApply())
              {
                constraints_applied = true;
                nfc->computeResidual();

                if (nfc->overwriteSlaveResidual())
                {
                  _fe_problem.setResidual(residual, 0);
                  residual_has_inserted_values = true;
                }
                else
                  _fe_problem.cacheResidual(0);
                _fe_problem.cacheResidualNeighbor(0);
              }
          }
        }
      }
    }
    if (_assemble_constraints_separately)
    {
      // Make sure that slave contribution to master are assembled, and ghosts have been exchanged,
      // as current masters might become slaves on next iteration
      // and will need to contribute their former slaves' contributions
      // to the future masters.
      // 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;
    }
  }

  THREAD_ID tid = 0;
  // go over mortar interfaces
  auto & ifaces = _mesh.getMortarInterfaces();
  for (const auto & iface : ifaces)
  {
    if (_constraints.hasActiveMortarConstraints(iface->_name))
    {
      const auto & face_constraints = _constraints.getActiveMortarConstraints(iface->_name);

      // go over elements on that interface
      const std::vector<Elem *> & elems = iface->_elems;
      for (const auto & elem : elems)
      {
        // for each element process constraints on the
        _fe_problem.setCurrentSubdomainID(elem, tid);
        _fe_problem.prepare(elem, tid);
        _fe_problem.reinitElem(elem, tid);

        for (const auto & ffc : face_constraints)
        {
          ffc->reinit();
          ffc->computeResidual();
        }
        _fe_problem.cacheResidual(tid);

        // evaluate residuals that go into master and slave side
        for (const auto & ffc : face_constraints)
        {
          ffc->reinitSide(Moose::Master);
          ffc->computeResidualSide(Moose::Master);
          _fe_problem.cacheResidual(tid);

          ffc->reinitSide(Moose::Slave);
          ffc->computeResidualSide(Moose::Slave);
          _fe_problem.cacheResidual(tid);
        }
      }
      _fe_problem.addCachedResidual(tid);
    }
  }

  // go over element-element constraint interface
  std::map<unsigned int, std::shared_ptr<ElementPairLocator>> * element_pair_locators = nullptr;

  if (!displaced)
  {
    GeometricSearchData & geom_search_data = _fe_problem.geomSearchData();
    element_pair_locators = &geom_search_data._element_pair_locators;
  }
  else
  {
    GeometricSearchData & displaced_geom_search_data =
        _fe_problem.getDisplacedProblem()->geomSearchData();
    element_pair_locators = &displaced_geom_search_data._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);
          _fe_problem.reinitElemPhys(elem1, info._elem1_constraint_q_point, tid);
          _fe_problem.setNeighborSubdomainID(elem2, tid);
          _fe_problem.reinitNeighborPhys(elem2, info._elem2_constraint_q_point, tid);

          ec->subProblem().prepareShapes(ec->variable().number(), tid);
          ec->subProblem().prepareNeighborShapes(ec->variable().number(), tid);

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

  constraints_applied = false;
  residual_has_inserted_values = false;
  for (const auto & slave_id : _mesh.meshSubdomains())
  {
    for (const auto & master_id : _mesh.meshSubdomains())
    {
      if (_constraints.hasActiveNodeElemConstraints(slave_id, master_id, displaced))
      {
        const auto & constraints =
            _constraints.getActiveNodeElemConstraints(slave_id, master_id, displaced);

        // get unique set of ids of all nodes on current block
        unique_slave_node_ids.clear();
        const MeshBase & meshhelper = _mesh.getMesh();
        for (const auto & elem : as_range(meshhelper.active_subdomain_elements_begin(slave_id),
                                          meshhelper.active_subdomain_elements_end(slave_id)))
        {
          for (auto & n : elem->node_ref_range())
            unique_slave_node_ids.insert(n.id());
        }

        for (auto slave_node_id : unique_slave_node_ids)
        {
          Node & slave_node = _mesh.nodeRef(slave_node_id);
          // check if slave node is on current processor
          if (slave_node.processor_id() == processor_id())
          {
            // This reinits the variables that exist on the slave node
            _fe_problem.reinitNodeFace(&slave_node, slave_id, 0);

            // This will set aside residual and jacobian space for the variables that have dofs
            // on the slave node
            _fe_problem.prepareAssembly(0);

            for (const auto & nec : constraints)
            {
              if (nec->shouldApply())
              {
                constraints_applied = true;
                nec->computeResidual();

                if (nec->overwriteSlaveResidual())
                {
                  _fe_problem.setResidual(residual, 0);
                  residual_has_inserted_values = true;
                }
                else
                  _fe_problem.cacheResidual(0);
                _fe_problem.cacheResidualNeighbor(0);
              }
            }
            _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;
  }
}

containsTimeKernel()

bool NonlinearSystemBase::containsTimeKernel

(

)

Definition at line 2993 of file NonlinearSystemBase.C.

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

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

  return time_kernels.hasActiveObjects();
}

converged()

virtual bool NonlinearSystemBase::converged ( )

pure virtual

Returns the convergence state.

Returns

true if converged, otherwise false

Implemented in NonlinearEigenSystem, NonlinearEigenSystem, NonlinearSystem, and DumpObjectsNonlinearSystem.

Referenced by DT2::step().

copyOldSolutions()

void SystemBase::copyOldSolutions ( )

virtualinherited

Shifts the solutions backwards in time.

Definition at line 1013 of file SystemBase.C.

Referenced by EigenExecutionerBase::inversePowerIteration().

{
  solutionOlder() = solutionOld();
  solutionOld() = *currentSolution();
  if (solutionUDotOld())
    *solutionUDotOld() = *solutionUDot();
  if (solutionUDotDotOld())
    *solutionUDotDotOld() = *solutionUDotDot();
  if (solutionPreviousNewton())
    *solutionPreviousNewton() = *currentSolution();
}

copySolutionsBackwards()

void SystemBase::copySolutionsBackwards ( )

virtualinherited

Copy current solution into old and older.

Definition at line 996 of file SystemBase.C.

{
  system().update();
  solutionOlder() = *currentSolution();
  solutionOld() = *currentSolution();
  if (solutionUDotOld())
    *solutionUDotOld() = *solutionUDot();
  if (solutionUDotDotOld())
    *solutionUDotDotOld() = *solutionUDotDot();
  if (solutionPreviousNewton())
    *solutionPreviousNewton() = *currentSolution();
}

copyVars()

void SystemBase::copyVars ( ExodusII_IO &  io )

inherited

Definition at line 914 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))
    {
      if (getVariable(0, vci._dest_name).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))
    {
      auto rank = comm().rank();
      auto size = comm().size();

      // Read solution on rank 0 only and send data to rank "size - 1" where scalar DOFs are stored
      std::vector<Real> global_values;
      if (rank == 0)
      {
        // Read the scalar value then set that value in the current solution
        io.read_global_variable({vci._source_name}, timestep, global_values);
        if (size > 1)
          comm().send(size - 1, global_values);
      }
      if (rank == size - 1)
      {
        if (size > 1)
          comm().receive(0, global_values);
        const unsigned int var_num = system().variable_number(vci._dest_name);
        system().solution->set(var_num, global_values[0]);
      }
    }
  }

  if (did_copy)
    solution().close();
}

currentSolution()

virtual const NumericVector<Number>*& NonlinearSystemBase::currentSolution ( )

inlineoverridevirtual

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 383 of file NonlinearSystemBase.h.

Referenced by Transient::keepGoing(), DT2::preSolve(), Transient::relativeSolutionDifferenceNorm(), DT2::step(), AB2PredictorCorrector::step(), DisplacedProblem::syncSolutions(), and DisplacedProblem::updateMesh().

{ return _current_solution; }

deactiveAllMatrixTags()

void SystemBase::deactiveAllMatrixTags ( )

virtualinherited

Make matrices inactive.

Definition at line 854 of file SystemBase.C.

Referenced by computeResidualTags(), and setInitialSolution().

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

deactiveMatrixTag()

void SystemBase::deactiveMatrixTag ( TagID  tag )

virtualinherited

deactive a matrix for tag

Definition at line 842 of file SystemBase.C.

{
  mooseAssert(_subproblem.matrixTagExists(tag),
              "Cannot deactivate Matrix with matrix_tag : " << tag << "that does not exist");

  if (_matrix_tag_active_flags.size() < tag + 1)
    _matrix_tag_active_flags.resize(tag + 1);

  _matrix_tag_active_flags[tag] = false;
}

debuggingResiduals()

void NonlinearSystemBase::debuggingResiduals ( bool  state )

inline

Definition at line 504 of file NonlinearSystemBase.h.

{ _debugging_residuals = state; }

disassociateAllTaggedMatrices()

void SystemBase::disasso