AuxiliarySystem Class Reference

A system that holds auxiliary variables. More...

#include <AuxiliarySystem.h>

Inheritance diagram for AuxiliarySystem:

Public Member Functions
	AuxiliarySystem (FEProblemBase &subproblem, const std::string &name)
virtual	~AuxiliarySystem ()
virtual void	init () override
	Initialize the system. More...
virtual void	addExtraVectors () override
	Method called during initialSetup to add extra system vector if they are required by the simulation. More...
virtual void	initialSetup ()
virtual void	timestepSetup ()
virtual void	subdomainSetup ()
virtual void	residualSetup ()
virtual void	jacobianSetup ()
virtual void	updateActive (THREAD_ID tid)
virtual void	addVariable (const std::string &var_name, const FEType &type, Real scale_factor, const std::set< SubdomainID > *const active_subdomains=NULL) override
	Adds a variable to the system. More...
void	addTimeIntegrator (const std::string &type, const std::string &name, InputParameters parameters) override
	Add a time integrator. More...
void	addDotVectors ()
	Adds u_dot, u_dotdot, u_dot_old and u_dotdot_old vectors if requested by the time integrator. More...
void	addKernel (const std::string &kernel_name, const std::string &name, InputParameters parameters)
	Adds an auxiliary kernel. More...
void	addScalarKernel (const std::string &kernel_name, const std::string &name, InputParameters parameters)
	Adds a scalar kernel. More...
virtual void	reinitElem (const Elem *elem, THREAD_ID tid) override
	Reinit an element assembly info. More...
virtual void	reinitElemFace (const Elem *elem, unsigned int side, BoundaryID bnd_id, THREAD_ID tid) override
	Reinit assembly info for a side of an element. More...
virtual const NumericVector< Number > *&	currentSolution () override
	The solution vector that is currently being operated on. More...
virtual NumericVector< Number > *	solutionUDot () override
virtual NumericVector< Number > *	solutionUDotDot () override
virtual void	serializeSolution ()
virtual NumericVector< Number > &	serializedSolution () override
	Returns a reference to a serialized version of the solution vector for this subproblem. More...
virtual void	augmentSparsity (SparsityPattern::Graph &, std::vector< dof_id_type > &, std::vector< dof_id_type > &) override
	Will modify the sparsity pattern to add logical geometric connections. More...
virtual void	compute (ExecFlagType type)
	Compute auxiliary variables. More...
std::set< std::string >	getDependObjects (ExecFlagType type)
	Get a list of dependent UserObjects for this exec type. More...
std::set< std::string >	getDependObjects ()
NumericVector< Number > &	addVector (const std::string &vector_name, const bool project, const ParallelType type) override
	Adds a solution length vector to the system. More...
virtual Order	getMinQuadratureOrder () override
	Get the minimum quadrature order for evaluating elemental auxiliary variables. More...
bool	needMaterialOnSide (BoundaryID bnd_id)
	Indicated whether this system needs material properties on boundaries. More...
virtual NumericVector< Number > &	solution () override
virtual NumericVector< Number > &	solutionOld () override
virtual NumericVector< Number > &	solutionOlder () override
virtual TransientExplicitSystem &	sys ()
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	setPreviousNewtonSolution ()
void	setScalarVariableCoupleableTags (ExecFlagType type)
void	clearScalarVariableCoupleableTags ()
void	computeScalarVars (ExecFlagType type)
void	computeNodalVars (ExecFlagType type)
void	computeNodalVecVars (ExecFlagType type)
void	computeElementalVars (ExecFlagType type)
void	computeElementalVecVars (ExecFlagType type)
template<typename AuxKernelType >
void	computeElementalVarsHelper (const MooseObjectWarehouse< AuxKernelType > &warehouse, const std::vector< std::vector< MooseVariableFEBase *>> &vars, const PerfID timer)
template<typename AuxKernelType >
void	computeNodalVarsHelper (const MooseObjectWarehouse< AuxKernelType > &warehouse, const std::vector< std::vector< MooseVariableFEBase *>> &vars, const PerfID timer)
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	solve ()
	Solve the system (using libMesh magic) More...
virtual void	copyOldSolutions ()
	Shifts the solutions backwards in time. More...
virtual void	restoreSolutions ()
	Restore current solutions (call after your solve failed) More...
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	timeVectorTag ()
	Ideally, we should not need this API. More...
virtual TagID	timeMatrixTag ()
	Return the Matrix Tag ID for Time. More...
virtual TagID	systemMatrixTag ()
	Return the Matrix Tag ID for System. More...
virtual TagID	nonTimeVectorTag ()
virtual TagID	residualVectorTag ()
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 NumericVector< Number > &	residualCopy ()
virtual NumericVector< Number > &	residualGhosted ()
virtual void	augmentSendList (std::vector< dof_id_type > &send_list)
	Will modify the send_list to add all of the extra ghosted dofs for this system. 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 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	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...
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 ()
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
FEProblemBase &	_fe_problem
TransientExplicitSystem &	_sys
const NumericVector< Number > *	_current_solution
	solution vector from nonlinear solver 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...
std::shared_ptr< TimeIntegrator >	_time_integrator
	Time integrator. 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...
bool	_need_serialized_solution
	Whether or not a copy of the residual needs to be made. More...
std::vector< std::vector< MooseVariableFEBase * > >	_nodal_vars
std::vector< std::vector< MooseVariableFEBase * > >	_nodal_std_vars
std::vector< std::vector< MooseVariableFEBase * > >	_nodal_vec_vars
std::vector< std::vector< MooseVariableFEBase * > >	_elem_vars
std::vector< std::vector< MooseVariableFEBase * > >	_elem_std_vars
std::vector< std::vector< MooseVariableFEBase * > >	_elem_vec_vars
ExecuteMooseObjectWarehouse< AuxScalarKernel >	_aux_scalar_storage
ExecuteMooseObjectWarehouse< AuxKernel >	_nodal_aux_storage
ExecuteMooseObjectWarehouse< AuxKernel >	_elemental_aux_storage
ExecuteMooseObjectWarehouse< VectorAuxKernel >	_nodal_vec_aux_storage
ExecuteMooseObjectWarehouse< VectorAuxKernel >	_elemental_vec_aux_storage
const PerfID	_compute_scalar_vars_timer
	Timers. More...
const PerfID	_compute_nodal_vars_timer
const PerfID	_compute_nodal_vec_vars_timer
const PerfID	_compute_elemental_vars_timer
const PerfID	_compute_elemental_vec_vars_timer

Protected Member Functions
PerfID	registerTimedSection (const std::string &section_name, const unsigned int level)
	Call to register a named section for timing. More...

Protected Attributes
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
Real	_du_dot_du
Real	_du_dotdot_du
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...
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...

Friends
class	ComputeIndicatorThread
class	ComputeMarkerThread
class	FlagElementsThread
class	ComputeNodalKernelsThread
class	ComputeNodalKernelBcsThread
class	ComputeNodalKernelJacobiansThread
class	ComputeNodalKernelBCJacobiansThread

Detailed Description

A system that holds auxiliary variables.

Definition at line 41 of file AuxiliarySystem.h.

Constructor & Destructor Documentation

AuxiliarySystem()

AuxiliarySystem::AuxiliarySystem	(	FEProblemBase &	subproblem,
		const std::string &	name
	)

Definition at line 32 of file AuxiliarySystem.C.

  : SystemBase(subproblem, name, Moose::VAR_AUXILIARY),
    PerfGraphInterface(subproblem.getMooseApp().perfGraph(), "AuxiliarySystem"),
    _fe_problem(subproblem),
    _sys(subproblem.es().add_system<TransientExplicitSystem>(name)),
    _current_solution(NULL),
    _serialized_solution(*NumericVector<Number>::build(_fe_problem.comm()).release()),
    _solution_previous_nl(NULL),
    _u_dot(NULL),
    _u_dotdot(NULL),
    _u_dot_old(NULL),
    _u_dotdot_old(NULL),
    _need_serialized_solution(false),
    _aux_scalar_storage(_app.getExecuteOnEnum()),
    _nodal_aux_storage(_app.getExecuteOnEnum()),
    _elemental_aux_storage(_app.getExecuteOnEnum()),
    _nodal_vec_aux_storage(_app.getExecuteOnEnum()),
    _elemental_vec_aux_storage(_app.getExecuteOnEnum()),
    _compute_scalar_vars_timer(registerTimedSection("computeScalarVars", 1)),
    _compute_nodal_vars_timer(registerTimedSection("computeNodalVars", 1)),
    _compute_nodal_vec_vars_timer(registerTimedSection("computeNodalVecVars", 1)),
    _compute_elemental_vars_timer(registerTimedSection("computeElementalVars", 1)),
    _compute_elemental_vec_vars_timer(registerTimedSection("computeElementalVecVars", 1))
{
  _nodal_vars.resize(libMesh::n_threads());
  _nodal_std_vars.resize(libMesh::n_threads());
  _nodal_vec_vars.resize(libMesh::n_threads());
  _elem_vars.resize(libMesh::n_threads());
  _elem_std_vars.resize(libMesh::n_threads());
  _elem_vec_vars.resize(libMesh::n_threads());
}

~AuxiliarySystem()

AuxiliarySystem::~AuxiliarySystem ( )

virtual

Definition at line 64 of file AuxiliarySystem.C.

{ delete &_serialized_solution; }

Member Function Documentation

activeAllMatrixTags()

void SystemBase::activeAllMatrixTags ( )

virtualinherited

Make all exsiting matrices ative.

Definition at line 865 of file SystemBase.C.

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

addDotVectors()

void AuxiliarySystem::addDotVectors

(

)

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

Definition at line 72 of file AuxiliarySystem.C.

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

addExtraVectors()

void AuxiliarySystem::addExtraVectors ( )

overridevirtual

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

Reimplemented from SystemBase.

Definition at line 85 of file AuxiliarySystem.C.

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

addKernel()

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

Adds an auxiliary kernel.

Parameters

kernel_name	The type of the kernel
name	The name of the kernel
parameters	Parameters for this kernel

Definition at line 225 of file AuxiliarySystem.C.

{
  parameters.set<AuxiliarySystem *>("_aux_sys") = this;

  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
  {
    if (parameters.get<std::string>("_moose_base") == "AuxKernel")
    {
      std::shared_ptr<AuxKernel> kernel =
          _factory.create<AuxKernel>(kernel_name, name, parameters, tid);
      if (kernel->isNodal())
        _nodal_aux_storage.addObject(kernel, tid);
      else
        _elemental_aux_storage.addObject(kernel, tid);
    }

    else if (parameters.get<std::string>("_moose_base") == "VectorAuxKernel")
    {
      std::shared_ptr<VectorAuxKernel> kernel =
          _factory.create<VectorAuxKernel>(kernel_name, name, parameters, tid);
      if (kernel->isNodal())
        _nodal_vec_aux_storage.addObject(kernel, tid);
      else
        _elemental_vec_aux_storage.addObject(kernel, tid);
    }
  }
}

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

addScalarKernel()

void AuxiliarySystem::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 256 of file AuxiliarySystem.C.

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

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

addTimeIntegrator() [1/4]

void AuxiliarySystem::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 216 of file AuxiliarySystem.C.

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

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 AuxiliarySystem::addVariable ( const std::string &  var_name, const FEType &  type, Real  scale_factor, const std::set< SubdomainID > *const  active_subdomains = NULL  )

overridevirtual

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

Definition at line 176 of file AuxiliarySystem.C.

{
  SystemBase::addVariable(var_name, type, scale_factor, active_subdomains);
  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
  {
    if (type.family == LAGRANGE_VEC)
    {
      VectorMooseVariable * var = _vars[tid].getFieldVariable<RealVectorValue>(var_name);
      if (var)
      {
        _nodal_vars[tid].push_back(var);
        _nodal_vec_vars[tid].push_back(var);
      }
    }

    else
    {
      MooseVariable * var = _vars[tid].getFieldVariable<Real>(var_name);

      if (var)
      {
        if (var->feType().family == LAGRANGE)
        {
          _nodal_vars[tid].push_back(var);
          _nodal_std_vars[tid].push_back(var);
        }
        else
        {
          _elem_vars[tid].push_back(var);
          _elem_std_vars[tid].push_back(var);
        }
      }
    }
  }
}

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 > & AuxiliarySystem::addVector ( const std::string &  vector_name, const bool  project, const ParallelType  type  )

overridevirtual

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

Definition at line 464 of file AuxiliarySystem.C.

Referenced by addDotVectors(), and addExtraVectors().

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

  NumericVector<Number> * vec = &_sys.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;
}

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 NonlinearSystemBase::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(), NonlinearSystemBase::computeNodalBCs(), and NonlinearSystemBase::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 AuxiliarySystem::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 575 of file AuxiliarySystem.C.

{
}

clearScalarVariableCoupleableTags()

void AuxiliarySystem::clearScalarVariableCoupleableTags

(

)

Definition at line 498 of file AuxiliarySystem.C.

Referenced by computeScalarVars().

{
  _fe_problem.clearActiveScalarVariableCoupleableMatrixTags(0);
  _fe_problem.clearActiveScalarVariableCoupleableVectorTags(0);
}

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 NonlinearSystemBase::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 NonlinearSystemBase::computeResidualTags().

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

compute()

void AuxiliarySystem::compute ( ExecFlagType  type )

virtual

Compute auxiliary variables.

Parameters

type	Time flag of which variables should be computed

Definition at line 322 of file AuxiliarySystem.C.

Referenced by setPreviousNewtonSolution().

{
  // avoid division by dt which might be zero.
  if (_fe_problem.dt() > 0. && _time_integrator)
    _time_integrator->preStep();

  // We need to compute time derivatives every time each kind of the variables is finished, because:
  //
  //  a) the user might want to use the aux variable value somewhere, thus we need to provide the
  //  up-to-date value
  //  b) time integration system works with the whole vectors of solutions, thus we cannot update
  //  only a part of the vector
  //

  if (_vars[0].scalars().size() > 0)
  {
    computeScalarVars(type);
    // compute time derivatives of scalar aux variables _after_ the values were updated
    if (_fe_problem.dt() > 0. && _time_integrator)
      _time_integrator->computeTimeDerivatives();
  }

  if (_vars[0].fieldVariables().size() > 0)
  {
    computeNodalVars(type);
    computeNodalVecVars(type);
    computeElementalVars(type);
    computeElementalVecVars(type);

    // compute time derivatives of nodal aux variables _after_ the values were updated
    if (_fe_problem.dt() > 0. && _time_integrator)
      _time_integrator->computeTimeDerivatives();
  }

  if (_need_serialized_solution)
    serializeSolution();
}

computeElementalVars()

void AuxiliarySystem::computeElementalVars

(

ExecFlagType

type

)

Definition at line 560 of file AuxiliarySystem.C.

Referenced by compute().

{
  const MooseObjectWarehouse<AuxKernel> & elemental = _elemental_aux_storage[type];
  computeElementalVarsHelper<AuxKernel>(elemental, _elem_std_vars, _compute_elemental_vars_timer);
}

computeElementalVarsHelper()

template<typename AuxKernelType >

template void AuxiliarySystem::computeElementalVarsHelper< VectorAuxKernel >	(	const MooseObjectWarehouse< AuxKernelType > &	warehouse,
		const std::vector< std::vector< MooseVariableFEBase *>> &	vars,
		const PerfID	timer
	)

Definition at line 615 of file AuxiliarySystem.C.

{
  if (warehouse.hasActiveBlockObjects())
  {
    TIME_SECTION(timer);

    // Block Elemental AuxKernels
    PARALLEL_TRY
    {
      ConstElemRange & range = *_mesh.getActiveLocalElementRange();
      ComputeElemAuxVarsThread<AuxKernelType> eavt(_fe_problem, warehouse, vars, true);
      Threads::parallel_reduce(range, eavt);

      solution().close();
      _sys.update();
    }
    PARALLEL_CATCH;
  }

  // Boundary Elemental AuxKernels
  if (warehouse.hasActiveBoundaryObjects())
  {
    TIME_SECTION(_compute_elemental_vec_vars_timer);

    PARALLEL_TRY
    {
      ConstBndElemRange & bnd_elems = *_mesh.getBoundaryElementRange();
      ComputeElemAuxBcsThread<AuxKernelType> eabt(_fe_problem, warehouse, vars, true);
      Threads::parallel_reduce(bnd_elems, eabt);

      solution().close();
      _sys.update();
    }
    PARALLEL_CATCH;
  }
}

computeElementalVecVars()

void AuxiliarySystem::computeElementalVecVars

(

ExecFlagType

type

)

Definition at line 567 of file AuxiliarySystem.C.

Referenced by compute().

{
  const MooseObjectWarehouse<VectorAuxKernel> & elemental = _elemental_vec_aux_storage[type];
  computeElementalVarsHelper<VectorAuxKernel>(
      elemental, _elem_vec_vars, _compute_elemental_vec_vars_timer);
}

computeNodalVars()

void AuxiliarySystem::computeNodalVars

(

ExecFlagType

type

)

Definition at line 546 of file AuxiliarySystem.C.

Referenced by compute().

{
  const MooseObjectWarehouse<AuxKernel> & nodal = _nodal_aux_storage[type];
  computeNodalVarsHelper<AuxKernel>(nodal, _nodal_std_vars, _compute_nodal_vars_timer);
}

computeNodalVarsHelper()

template<typename AuxKernelType >

template void AuxiliarySystem::computeNodalVarsHelper< VectorAuxKernel >	(	const MooseObjectWarehouse< AuxKernelType > &	warehouse,
		const std::vector< std::vector< MooseVariableFEBase *>> &	vars,
		const PerfID	timer
	)

Definition at line 657 of file AuxiliarySystem.C.

{
  if (warehouse.hasActiveBlockObjects())
  {
    TIME_SECTION(timer);

    // Block Nodal AuxKernels
    PARALLEL_TRY
    {
      ConstNodeRange & range = *_mesh.getLocalNodeRange();
      ComputeNodalAuxVarsThread<AuxKernelType> navt(_fe_problem, warehouse, vars);
      Threads::parallel_reduce(range, navt);

      solution().close();
      _sys.update();
    }
    PARALLEL_CATCH;
  }

  if (warehouse.hasActiveBoundaryObjects())
  {
    TIME_SECTION(timer);

    // Boundary Nodal AuxKernels
    PARALLEL_TRY
    {
      ConstBndNodeRange & bnd_nodes = *_mesh.getBoundaryNodeRange();
      ComputeNodalAuxBcsThread<AuxKernelType> nabt(_fe_problem, warehouse, vars);
      Threads::parallel_reduce(bnd_nodes, nabt);

      solution().close();
      _sys.update();
    }
    PARALLEL_CATCH;
  }
}

computeNodalVecVars()

void AuxiliarySystem::computeNodalVecVars

(

ExecFlagType

type

)

Definition at line 553 of file AuxiliarySystem.C.

Referenced by compute().

{
  const MooseObjectWarehouse<VectorAuxKernel> & nodal = _nodal_vec_aux_storage[type];
  computeNodalVarsHelper<VectorAuxKernel>(nodal, _nodal_vec_vars, _compute_nodal_vec_vars_timer);
}

computeScalarVars()

void AuxiliarySystem::computeScalarVars

(

ExecFlagType

type

)

Definition at line 505 of file AuxiliarySystem.C.

Referenced by compute().

{
  setScalarVariableCoupleableTags(type);

  // Reference to the current storage container
  const MooseObjectWarehouse<AuxScalarKernel> & storage = _aux_scalar_storage[type];

  if (storage.hasActiveObjects())
  {
    TIME_SECTION(_compute_scalar_vars_timer);

    PARALLEL_TRY
    {
      // FIXME: run multi-threaded
      THREAD_ID tid = 0;
      if (storage.hasActiveObjects())
      {
        _fe_problem.reinitScalars(tid);

        const std::vector<std::shared_ptr<AuxScalarKernel>> & objects =
            storage.getActiveObjects(tid);

        // Call compute() method on all active AuxScalarKernel objects
        for (const auto & obj : objects)
          obj->compute();

        const std::vector<MooseVariableScalar *> & scalar_vars = getScalarVariables(tid);
        for (const auto & var : scalar_vars)
          var->insert(solution());
      }
    }
    PARALLEL_CATCH;

    solution().close();
    _sys.update();
  }

  clearScalarVariableCoupleableTags();
}

computeVariables()

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

inlinevirtualinherited

Definition at line 672 of file SystemBase.h.

{}

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>*& AuxiliarySystem::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 102 of file AuxiliarySystem.h.

Referenced by AB2PredictorCorrector::step(), DisplacedProblem::syncSolutions(), and DisplacedProblem::updateMesh().

  {
    _current_solution = _sys.current_local_solution.get();
    return _current_solution;
  }

deactiveAllMatrixTags()

void SystemBase::deactiveAllMatrixTags ( )

virtualinherited

Make matrices inactive.

Definition at line 854 of file SystemBase.C.

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

disassociateAllTaggedMatrices()

void SystemBase::disassociateAllTaggedMatrices ( )

virtualinherited

Clear all tagged matrices.

Reimplemented in DisplacedSystem.

Definition at line 887 of file SystemBase.C.

Referenced by DisplacedSystem::disassociateAllTaggedMatrices().

{
  for (auto & matrix : _tagged_matrices)
    matrix = nullptr;
}

disassociateAllTaggedVectors()

void SystemBase::disassociateAllTaggedVectors ( )

virtualinherited

Disassociate all vectors, and then hasVector() will return false.

Reimplemented in DisplacedSystem.

Definition at line 774 of file SystemBase.C.

Referenced by DisplacedSystem::disassociateAllTaggedVectors().

{
  for (auto & tagged_vector : _tagged_vectors)
    tagged_vector = nullptr;
}

disassociateMatrixFromTag()

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

virtualinherited

disassociate a matirx from a tag

Reimplemented in DisplacedSystem.

Definition at line 815 of file SystemBase.C.

Referenced by NonlinearSystemBase::computeJacobian(), and DisplacedSystem::disassociateMatrixFromTag().

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

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

  if (_tagged_matrices[tag] != &matrix)
    mooseError("You can not disassociate a matrix from a tag which it was not associated to");

  _tagged_matrices[tag] = nullptr;
}

disassociateVectorFromTag()

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

virtualinherited

Associate a vector for a given tag.

Reimplemented in DisplacedSystem.

Definition at line 760 of file SystemBase.C.

Referenced by NonlinearSystemBase::computeNodalBCs(), NonlinearSystemBase::computeResidualTag(), and DisplacedSystem::disassociateVectorFromTag().

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

  if (_tagged_vectors[tag] != &vec)
    mooseError("You can not disassociate a vector from a tag which it was not associated to");

  _tagged_vectors[tag] = nullptr;
}

dofMap()

DofMap & SystemBase::dofMap ( )

virtualinherited

Gets the dof map.

Definition at line 900 of file SystemBase.C.

Referenced by AddPeriodicBCAction::act(), SystemBase::augmentSendList(), NonlinearSystemBase::augmentSparsity(), AddPeriodicBCAction::autoTranslationBoundaries(), NonlinearSystemBase::findImplicitGeometricCouplingEntries(), DisplacedProblem::init(), Adaptivity::init(), GhostingUserObject::meshChanged(), TableOutput::outputScalarVariables(), Nemesis::outputScalarVariables(), and Exodus::outputScalarVariables().

{
  return system().get_dof_map();
}

duDotDotDu()

virtual Number& SystemBase::duDotDotDu ( )

inlinevirtualinherited

Reimplemented in DisplacedSystem.

Definition at line 159 of file SystemBase.h.

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

{ return _du_dotdot_du; }

duDotDu()

virtual Number& SystemBase::duDotDu ( )

inlinevirtualinherited

Reimplemented in DisplacedSystem.

Definition at line 158 of file SystemBase.h.

Referenced by MooseVariableConstMonomial::computeMonomialNeighborValuesHelper(), MooseVariableConstMonomial::computeMonomialValuesHelper(), DisplacedSystem::duDotDu(), and MooseVariableScalar::reinit().

{ return _du_dot_du; }

getDependObjects() [1/2]

std::set< std::string > AuxiliarySystem::getDependObjects

(

ExecFlagType

type

)

Get a list of dependent UserObjects for this exec type.

Parameters

type	Execution flag type

Returns

a set of dependent user objects

Definition at line 361 of file AuxiliarySystem.C.

{
  std::set<std::string> depend_objects;

  // Elemental AuxKernels
  {
    const std::vector<std::shared_ptr<AuxKernel>> & auxs =
        _elemental_aux_storage[type].getActiveObjects();
    for (const auto & aux : auxs)
    {
      const std::set<std::string> & uo = aux->getDependObjects();
      depend_objects.insert(uo.begin(), uo.end());
    }
  }

  // Elemental VectorAuxKernels
  {
    const std::vector<std::shared_ptr<VectorAuxKernel>> & auxs =
        _elemental_vec_aux_storage[type].getActiveObjects();
    for (const auto & aux : auxs)
    {
      const std::set<std::string> & uo = aux->getDependObjects();
      depend_objects.insert(uo.begin(), uo.end());
    }
  }

  // Nodal AuxKernels
  {
    const std::vector<std::shared_ptr<AuxKernel>> & auxs =
        _nodal_aux_storage[type].getActiveObjects();
    for (const auto & aux : auxs)
    {
      const std::set<std::string> & uo = aux->getDependObjects();
      depend_objects.insert(uo.begin(), uo.end());
    }
  }

  // Nodal VectorAuxKernels
  {
    const std::vector<std::shared_ptr<VectorAuxKernel>> & auxs =
        _nodal_vec_aux_storage[type].getActiveObjects();
    for (const auto & aux : auxs)
    {
      const std::set<std::string> & uo = aux->getDependObjects();
      depend_objects.insert(uo.begin(), uo.end());
    }
  }

  return depend_objects;
}

getDependObjects() [2/2]

std::set< std::string > AuxiliarySystem::getDependObjects

(

)

Definition at line 413 of file AuxiliarySystem.C.

{
  std::set<std::string> depend_objects;

  // Elemental AuxKernels
  {
    const std::vector<std::shared_ptr<AuxKernel>> & auxs =
        _elemental_aux_storage.getActiveObjects();
    for (const auto & aux : auxs)
    {
      const std::set<std::string> & uo = aux->getDependObjects();
      depend_objects.insert(uo.begin(), uo.end());
    }
  }

  // Elemental VectorAuxKernels
  {
    const std::vector<std::shared_ptr<VectorAuxKernel>> & auxs =
        _elemental_vec_aux_storage.getActiveObjects();
    for (const auto & aux : auxs)
    {
      const std::set<std::string> & uo = aux->getDependObjects();
      depend_objects.insert(uo.begin(), uo.end());
    }
  }

  // Nodal AuxKernels
  {
    const std::vector<std::shared_ptr<AuxKernel>> & auxs = _nodal_aux_storage.getActiveObjects();
    for (const auto & aux : auxs)
    {
      const std::set<std::string> & uo = aux->getDependObjects();
      depend_objects.insert(uo.begin(), uo.end());
    }
  }

  // Nodal VectorAuxKernels
  {
    const std::vector<std::shared_ptr<VectorAuxKernel>> & auxs =
        _nodal_vec_aux_storage.getActiveObjects();
    for (const auto & aux : auxs)
    {
      const std::set<std::string> & uo = aux->getDependObjects();
      depend_objects.insert(uo.begin(), uo.end());
    }
  }

  return depend_objects;
}

getFieldVariable() [1/2]

template<typename T >

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

inherited

Gets a reference to a variable of with specified name.

Parameters

tid	Thread id
var_name	variable name

Returns

reference the variable (class)

Definition at line 136 of file SystemBase.C.

Referenced by Assembly::copyFaceShapes(), Assembly::copyNeighborShapes(), Assembly::copyShapes(), DisplacedProblem::getStandardVariable(), and DisplacedProblem::getVectorVariable().

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

getFieldVariable() [2/2]

template<typename T >

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

inherited

Gets a reference to a variable with specified number.

Parameters

tid	Thread id
var_number	libMesh variable number

Returns

reference the variable (class)

Definition at line 143 of file SystemBase.C.

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

getMatrix()

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

virtualinherited

Get a raw SparseMatrix.

Reimplemented in DisplacedSystem.

Definition at line 787 of file SystemBase.C.

Referenced by Assembly::addCachedJacobian(), Assembly::addCachedJacobianContributions(), NonlinearSystemBase::addImplicitGeometricCouplingEntries(), Assembly::addJacobianCoupledVarPair(), Assembly::addJacobianNeighbor(), Assembly::addJacobianNonlocal(), NonlinearSystem::addMatrix(), SystemBase::closeTaggedMatrices(), NonlinearSystemBase::computeJacobianInternal(), NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::enforceNodalConstraintsJacobian(), DisplacedSystem::getMatrix(), MooseVariableScalar::reinit(), Assembly::setCachedJacobianContributions(), and Assembly::zeroCachedJacobianContributions().

{
  mooseAssert(hasMatrix(tag), "Cannot retrieve matrix with matrix_tag: " << tag);

  return *_tagged_matrices[tag];
}

getMaxVarNDofsPerElem()

size_t SystemBase::getMaxVarNDofsPerElem ( )

inlineinherited

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

Returns

The max

Definition at line 413 of file SystemBase.h.

Referenced by Assembly::computeAffineMapAD(), Assembly::computeFaceMap(), and Assembly::computeSinglePointMapAD().

{ return _max_var_n_dofs_per_elem; }

getMaxVarNDofsPerNode()

size_t SystemBase::getMaxVarNDofsPerNode ( )

inlineinherited

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

Returns

The max

Definition at line 420 of file SystemBase.h.

{ return _max_var_n_dofs_per_node; }

getMinQuadratureOrder()

Order AuxiliarySystem::getMinQuadratureOrder ( )

overridevirtual

Get the minimum quadrature order for evaluating elemental auxiliary variables.

Reimplemented from SystemBase.

Definition at line 582 of file AuxiliarySystem.C.

{
  Order order = CONSTANT;
  std::vector<MooseVariableFEBase *> vars = _vars[0].fieldVariables();
  for (const auto & var : vars)
  {
    if (!var->isNodal()) // nodal aux variables do not need quadrature
    {
      FEType fe_type = var->feType();
      if (fe_type.default_quadrature_order() > order)
        order = fe_type.default_quadrature_order();
    }
  }

  return order;
}

getScalarVariable() [1/2]

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

virtualinherited

Gets a reference to a scalar variable with specified number.

Parameters

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

Returns

reference the variable (class)

Definition at line 149 of file SystemBase.C.

Referenced by Assembly::addJacobianOffDiagScalar(), IntegratedBC::computeJacobianBlockScalar(), VectorIntegratedBC::computeJacobianBlockScalar(), ODEKernel::computeOffDiagJacobian(), VectorKernel::computeOffDiagJacobianScalar(), Kernel::computeOffDiagJacobianScalar(), DisplacedProblem::getScalarVariable(), and Assembly::init().

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

getScalarVariable() [2/2]

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

virtualinherited

Gets a reference to a variable with specified number.

Parameters

tid	Thread id
var_number	libMesh variable number

Returns

reference the variable (class)

Definition at line 158 of file SystemBase.C.

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

getScalarVariables()

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

inlineinherited

Definition at line 574 of file SystemBase.h.

Referenced by Assembly::addResidualScalar(), ComputeFullJacobianThread::computeFaceJacobian(), ODEKernel::computeJacobian(), ComputeFullJacobianThread::computeJacobian(), computeScalarVars(), Assembly::init(), ComputeJacobianThread::onElement(), Assembly::prepareOffDiagScalar(), and Assembly::prepareScalar().

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

getSharedTimeIntegrator()

std::shared_ptr<TimeIntegrator> SystemBase::getSharedTimeIntegrator ( )

inlineinherited

Definition at line 691 of file SystemBase.h.

Referenced by DisplacedProblem::DisplacedProblem().

{ return _time_integrator; }

getSubdomainsForVar()

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

inlineinherited

Definition at line 579 of file SystemBase.h.

  {
    return _var_map.at(var_number);
  }

getTimeIntegrator()

TimeIntegrator* SystemBase::getTimeIntegrator ( )

inlineinherited

Definition at line 689 of file SystemBase.h.

Referenced by DT2::computeDT(), Transient::endStep(), AB2PredictorCorrector::estimateTimeError(), MooseVariableFE< Real >::MooseVariableFE(), and Transient::preExecute().

{ return _time_integrator.get(); }

getVariable() [1/2]

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

inherited

Gets a reference to a variable of with specified name.

Parameters

tid	Thread id
var_name	variable name

Returns

reference the variable (class)

Definition at line 105 of file SystemBase.C.

Referenced by Assembly::addJacobianBlock(), Assembly::addJacobianBlockNonlocal(), Assembly::addJacobianNeighbor(), NonlocalIntegratedBC::computeJacobianBlock(), NonlocalIntegratedBC::computeNonlocalOffDiagJacobian(), NonlocalKernel::computeNonlocalOffDiagJacobian(), SystemBase::copyVars(), FieldSplitPreconditioner::FieldSplitPreconditioner(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), EqualValueEmbeddedConstraint::getConnectedDofIndices(), NodeElemConstraint::getConnectedDofIndices(), NodeFaceConstraint::getConnectedDofIndices(), Marker::getMarkerValue(), SubProblem::getVariableHelper(), Assembly::init(), NodalNormalsPreprocessor::initialize(), Assembly::initNonlocalCoupling(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), AddPeriodicBCAction::setPeriodicVars(), SingleMatrixPreconditioner::SingleMatrixPreconditioner(), and UpdateErrorVectorsThread::UpdateErrorVectorsThread().

{
  MooseVariableFEBase * var = dynamic_cast<MooseVariableFEBase *>(_vars[tid].getVariable(var_name));
  if (!var)
  {
    std::stringstream errMsg;
    errMsg << "Variable '" << var_name << "' does not exist in this system" << std::endl;
    throw std::runtime_error(errMsg.str().c_str());
    // mooseError("Variable '" + var_name + "' does not exist in this system");
  }
  return *var;
}

getVariable() [2/2]

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

inherited

Gets a reference to a variable with specified number.

Parameters

tid	Thread id
var_number	libMesh variable number

Returns

reference the variable (class)

Definition at line 119 of file SystemBase.C.

{
  MooseVariableFEBase * var =
      dynamic_cast<MooseVariableFEBase *>(_vars[tid].getVariable(var_number));
  if (!var)
  {
    std::stringstream errMsg;
    errMsg << "Variable '" << Moose::stringify(var_number) << "' does not exist in this system"
           << std::endl;
    throw std::runtime_error(errMsg.str().c_str());
    // mooseError("variable #" + Moose::stringify(var_number) + " does not exist in this system");
  }
  return *var;
}

getVariableBlocks()

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

virtualinherited

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

Parameters

var_number

The number of the variable

Returns

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

Definition at line 168 of file SystemBase.C.

Referenced by PhysicsBasedPreconditioner::addSystem().

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

getVariableNames()

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

inlineinherited

Definition at line 670 of file SystemBase.h.

Referenced by MooseEigenSystem::buildSystemDoFIndices(), NonlinearSystemBase::checkKernelCoverage(), and AddPeriodicBCAction::setPeriodicVars().

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

getVariables()

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

inlineinherited

Definition at line 569 of file SystemBase.h.

Referenced by Assembly::addJacobianOffDiagScalar(), Assembly::addResidual(), Assembly::addResidualNeighbor(), Assembly::cacheResidual(), Assembly::cacheResidualNeighbor(), ComputeFullJacobianThread::computeFaceJacobian(), ComputeFullJacobianThread::computeJacobian(), Assembly::init(), Assembly::initNonlocalCoupling(), Assembly::prepareNeighbor(), Assembly::prepareOffDiagScalar(), Assembly::prepareResidual(), Assembly::setResidual(), and Assembly::setResidualNeighbor().

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

getVector() [1/2]

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

virtualinherited

Get a raw NumericVector.

Get a raw NumericVector with the given name.

Reimplemented in DisplacedSystem.

Definition at line 735 of file SystemBase.C.

Referenced by Assembly::addCachedResiduals(), Assembly::addResidual(), Assembly::addResidualNeighbor(), Assembly::addResidualScalar(), addVector(), SystemBase::addVector(), SystemBase::closeTaggedVectors(), VectorNodalBC::computeResidual(), NodalBC::computeResidual(), NonlinearSystemBase::computeResidualTags(), DisplacedSystem::getVector(), MooseVariableScalar::reinit(), PicardSolve::solve(), PicardSolve::solveStep(), and SystemBase::zeroTaggedVectors().

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

getVector() [2/2]

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

virtualinherited

Get a raw NumericVector.

Reimplemented in DisplacedSystem.

Definition at line 741 of file SystemBase.C.

{
  mooseAssert(hasVector(tag), "Cannot retrieve vector with residual_tag: " << tag);

  return *_tagged_vectors[tag];
}

hasMatrix()

bool SystemBase::hasMatrix ( TagID  tag )

virtualinherited

Check if the tagged matrix exists in the system.

Reimplemented in DisplacedSystem.

Definition at line 781 of file SystemBase.C.

Referenced by SystemBase::activeAllMatrixTags(), Assembly::addCachedJacobian(), Assembly::addCachedJacobianContributions(), NonlinearSystemBase::addImplicitGeometricCouplingEntries(), Assembly::addJacobianCoupledVarPair(), Assembly::addJacobianNeighbor(), Assembly::addJacobianNonlocal(), NonlinearSystem::addMatrix(), Assembly::cacheJacobianBlock(), Assembly::cacheJacobianBlockNonlocal(), Assembly::cacheJacobianContribution(), Assembly::cacheJacobianCoupledVarPair(), Assembly::cacheJacobianNeighbor(), Assembly::cacheJacobianNonlocal(), SystemBase::closeTaggedMatrices(), VectorNodalBC::computeJacobian(), NodalBC::computeJacobian(), NonlinearSystemBase::computeJacobianInternal(), VectorNodalBC::computeOffDiagJacobian(), NodalBC::computeOffDiagJacobian(), NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::enforceNodalConstraintsJacobian(), SystemBase::getMatrix(), DisplacedSystem::hasMatrix(), MooseVariableScalar::reinit(), Assembly::setCachedJacobianContributions(), and Assembly::zeroCachedJacobianContributions().

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

hasScalarVariable()

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

virtualinherited

Definition at line 661 of file SystemBase.C.

Referenced by ComputeFullJacobianThread::computeFaceJacobian(), ComputeFullJacobianThread::computeJacobian(), SystemBase::copyVars(), DisplacedProblem::getScalarVariable(), DisplacedProblem::hasScalarVariable(), and AddPeriodicBCAction::setPeriodicVars().

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

hasVariable()

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

virtualinherited

Query a system for a variable.

Parameters

var_name

name of the variable

Returns

true if the variable exists

Definition at line 652 of file SystemBase.C.

Referenced by ADKernelTempl< T, compute_stage >::ADKernelTempl(), SystemBase::copyVars(), DGKernelBase::DGKernelBase(), FEProblemBase::duplicateVariableCheck(), DisplacedProblem::getStandardVariable(), DisplacedProblem::getSystem(), SubProblem::getVariableHelper(), DisplacedProblem::getVectorVariable(), DisplacedProblem::hasVariable(), InterfaceKernel::InterfaceKernel(), and Kernel::Kernel().

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

hasVector() [1/2]

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

inherited

Check if the named vector exists in the system.

Definition at line 685 of file SystemBase.C.

Referenced by Assembly::addCachedResidual(), Assembly::addCachedResiduals(), Assembly::addResidual(), Assembly::addResidualNeighbor(), Assembly::addResidualScalar(), addVector(), SystemBase::addVector(), Assembly::cacheResidual(), Assembly::cacheResidualNeighbor(), VectorNodalBC::computeResidual(), NodalBC::computeResidual(), NonlinearSystemBase::computeResidualTags(), SystemBase::getVector(), DisplacedSystem::hasVector(), MooseVariableScalar::reinit(), and SystemBase::removeVector().

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

hasVector() [2/2]

bool SystemBase::hasVector ( TagID  tag_id )

virtualinherited

Check if the tagged vector exists in the system.

Reimplemented in DisplacedSystem.

Definition at line 726 of file SystemBase.C.

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

init()

void AuxiliarySystem::init ( )

overridevirtual

Initialize the system.

Reimplemented from SystemBase.

Definition at line 67 of file AuxiliarySystem.C.

{
}

initializeObjects()

virtual void SystemBase::initializeObjects ( )

inlinevirtualinherited

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

Definition at line 126 of file SystemBase.h.

{};

initialSetup()

void AuxiliarySystem::initialSetup ( )

virtual

Definition at line 92 of file AuxiliarySystem.C.

{
  for (unsigned int tid = 0; tid < libMesh::n_threads(); tid++)
  {
    _aux_scalar_storage.sort(tid);
    _aux_scalar_storage.initialSetup(tid);

    _nodal_aux_storage.sort(tid);
    _nodal_aux_storage.initialSetup(tid);

    _nodal_vec_aux_storage.sort(tid);
    _nodal_vec_aux_storage.initialSetup(tid);

    _elemental_aux_storage.sort(tid);
    _elemental_aux_storage.initialSetup(tid);

    _elemental_vec_aux_storage.sort(tid);
    _elemental_vec_aux_storage.initialSetup(tid);
  }
}

isScalarVariable()

bool SystemBase::isScalarVariable ( unsigned int  var_name ) const

virtualinherited

Definition at line 670 of file SystemBase.C.

Referenced by ODEKernel::computeOffDiagJacobian(), Assembly::init(), and Assembly::initNonlocalCoupling().

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

jacobianSetup()

void AuxiliarySystem::jacobianSetup ( )

virtual

Definition at line 140 of file AuxiliarySystem.C.

{
  for (unsigned int tid = 0; tid < libMesh::n_threads(); tid++)
  {
    _aux_scalar_storage.jacobianSetup(tid);
    _nodal_aux_storage.jacobianSetup(tid);
    _nodal_vec_aux_storage.jacobianSetup(tid);
    _elemental_aux_storage.jacobianSetup(tid);
    _elemental_vec_aux_storage.jacobianSetup(tid);
  }
}

matrixTagActive()

bool SystemBase::matrixTagActive ( TagID  tag )

virtualinherited

If or not a matrix tag is active.

Definition at line 879 of file SystemBase.C.

{
  mooseAssert(_subproblem.matrixTagExists(tag), "Matrix tag " << tag << " does not exist");

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

mesh()

virtual MooseMesh& SystemBase::mesh ( )

inlinevirtualinherited

Definition at line 104 of file SystemBase.h.

Referenced by CreateDisplacedProblemAction::addProxyAlgebraicRelationshipManagers(), CreateDisplacedProblemAction::addProxyGeometricRelationshipManagers(), DMMooseGetEmbedding_Private(), DMSetUp_Moose_Pre(), MooseVariableFE< Real >::MooseVariableFE(), ComputeNodalKernelsThread::onNode(), and ComputeNodalKernelJacobiansThread::onNode().

{ return _mesh; }

name()

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

virtualinherited

Definition at line 1049 of file SystemBase.C.

Referenced by NonlinearSystemBase::addBoundaryCondition(), NonlinearSystemBase::addConstraint(), NonlinearSystemBase::addDamper(), NonlinearSystemBase::addDGKernel(), NonlinearSystemBase::addDiracKernel(), NonlinearSystemBase::addInterfaceKernel(), MooseEigenSystem::addKernel(), addKernel(), NonlinearSystemBase::addKernel(), NonlinearSystem::addMatrix(), NonlinearSystemBase::addNodalKernel(), addScalarKernel(), NonlinearSystemBase::addScalarKernel(), NonlinearSystemBase::addSplit(), addTimeIntegrator(), NonlinearSystemBase::addTimeIntegrator(), SystemBase::addVector(), NonlinearSystemBase::getSplit(), DisplacedSystem::getVector(), SystemBase::getVector(), SystemBase::hasVector(), and SystemBase::removeVector().

{
  return system().name();
}

needMaterialOnSide()

bool AuxiliarySystem::needMaterialOnSide

(

BoundaryID

bnd_id

)

Indicated whether this system needs material properties on boundaries.

Returns

Boolean if IntegratedBCs are active

Definition at line 600 of file AuxiliarySystem.C.

{
  return _elemental_aux_storage.hasActiveBoundaryObjects(bnd_id) ||
         _elemental_vec_aux_storage.hasActiveBoundaryObjects(bnd_id);
}

nonTimeVectorTag()

TagID SystemBase::nonTimeVectorTag ( )

virtualinherited

Reimplemented in NonlinearSystemBase, and DisplacedSystem.

Definition at line 712 of file SystemBase.C.

Referenced by DisplacedSystem::nonTimeVectorTag().

{
  mooseError("Not implemented yet");
  return 0;
}

number()

unsigned int SystemBase::number ( ) const

virtualinherited

Gets the number of this system.

Returns

The number of this system

Definition at line 894 of file SystemBase.C.

Referenced by VectorNodalBC::computeOffDiagJacobian(), NodalBC::computeOffDiagJacobian(), NodalKernel::computeOffDiagJacobian(), EqualValueEmbeddedConstraint::computeQpJacobian(), EqualValueEmbeddedConstraint::computeQpOffDiagJacobian(), DebugResidualAux::computeValue(), NearestNodeValueAux::computeValue(), BoundsAux::computeValue(), NodalNormalsEvaluator::execute(), NodalNormalsCorner::execute(), NodalNormalsPreprocessor::execute(), NonlinearSystemBase::getNodeDofs(), EqualValueEmbeddedConstraint::reinitConstraint(), and MultiAppCopyTransfer::transferDofObject().

{
  return system().number();
}

nVariables()

unsigned int SystemBase::nVariables ( ) const

virtualinherited

Get the number of variables in this system.

Returns

the number of variables

Definition at line 676 of file SystemBase.C.

Referenced by FieldSplitPreconditioner::FieldSplitPreconditioner(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), NonlinearSystemBase::getNodeDofs(), Assembly::init(), MaxVarNDofsPerElem::onElement(), MaxVarNDofsPerNode::onNode(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), and SingleMatrixPreconditioner::SingleMatrixPreconditioner().

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

prepare()

void SystemBase::prepare ( THREAD_ID  tid )

virtualinherited

Prepare the system for use.

Parameters

tid	ID of the thread

Definition at line 242 of file SystemBase.C.

Referenced by DisplacedProblem::prepare(), DisplacedProblem::reinitDirac(), and DisplacedProblem::reinitElemPhys().

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

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

prepareFace()

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

virtualinherited

Prepare the system for use on sides.

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

Parameters

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

Definition at line 265 of file SystemBase.C.

Referenced by DisplacedProblem::prepareFace().

{
  // We only need to do something if the element prepare was restricted
  if (_subproblem.hasActiveElementalMooseVariables(tid))
  {
    const std::set<MooseVariableFEBase *> & active_elemental_moose_variables =
        _subproblem.getActiveElementalMooseVariables(tid);

    std::vector<MooseVariableFEBase *> newly_prepared_vars;

    const std::vector<MooseVariableFEBase *> & vars = _vars[tid].fieldVariables();
    for (const auto & var : vars)
    {
      // If it wasn't in the active list, we need to prepare it
      if (&(var->sys()) == this && !active_elemental_moose_variables.count(var))
      {
        var->prepare();
        newly_prepared_vars.push_back(var);
      }
    }

    // Make sure to resize the residual and jacobian datastructures for all the new variables
    if (resize_data)
      for (const auto var_ptr : newly_prepared_vars)
      {
        _subproblem.assembly(tid).prepareVariable(var_ptr);
        if (_subproblem.checkNonlocalCouplingRequirement())
          _subproblem.assembly(tid).prepareVariableNonlocal(var_ptr);
      }
  }
}

prepareNeighbor()

void SystemBase::prepareNeighbor ( THREAD_ID  tid )

virtualinherited

Prepare the system for use.

Parameters

tid	ID of the thread

Definition at line 298 of file SystemBase.C.

Referenced by DisplacedProblem::reinitNeighbor(), and DisplacedProblem::reinitNeighborPhys().

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

registerTimedSection()

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

protectedinherited

Call to register a named section for timing.

Parameters

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

Returns

The ID of the section - use when starting timing

Definition at line 50 of file PerfGraphInterface.C.

{
  if (_prefix != "")
    return _perf_graph.registerSection(_prefix + "::" + section_name, level);
  else
    return _perf_graph.registerSection(section_name, level);
}

reinitElem()

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

overridevirtual

Reinit an element assembly info.

Parameters

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

Reimplemented from SystemBase.

Definition at line 269 of file AuxiliarySystem.C.

{
  for (auto * var : _nodal_vars[tid])
    var->computeElemValues();

  for (auto * var : _elem_vars[tid])
  {
    var->reinitAux();
    var->computeElemValues();
  }
}

reinitElemFace()

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

overridevirtual

Reinit assembly info for a side of an element.

Parameters

elem	The element
side	Side of of the element
bnd_id	Boundary id on that side
tid	Thread ID

Reimplemented from SystemBase.

Definition at line 282 of file AuxiliarySystem.C.

{
  for (auto * var : _nodal_vars[tid])
    var->computeElemValuesFace();

  for (auto * var : _elem_vars[tid])
  {
    var->reinitAux();
    var->reinitAuxNeighbor();
    var->computeElemValuesFace();
  }
}

reinitNeighbor()

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

virtualinherited

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

Definition at line 348 of file SystemBase.C.

Referenced by DisplacedProblem::reinitNeighborPhys().

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

reinitNeighborFace()

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

virtualinherited

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

Definition at line 337 of file SystemBase.C.

Referenced by DisplacedProblem::reinitNeighbor(), and DisplacedProblem::reinitNeighborPhys().

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

reinitNode()

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

virtualinherited

Reinit nodal assembly info.

Parameters

node	Node to reinit for
tid	Thread ID

Definition at line 356 of file SystemBase.C.

Referenced by DisplacedProblem::reinitNode().

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

reinitNodeFace()

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

virtualinherited

Reinit nodal assembly info on a face.

Parameters

node	Node to reinit
bnd_id	Boundary ID
tid	Thread ID

Definition at line 370 of file SystemBase.C.

Referenced by DisplacedProblem::reinitNodeFace().

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

reinitNodes()

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

virtualinherited

Reinit variables at a set of nodes.

Parameters

nodes	List of node ids to reinit
tid	Thread ID

Definition at line 384 of file SystemBase.C.

Referenced by DisplacedProblem::reinitNodes().

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

reinitNodesNeighbor()

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

virtualinherited

Reinit variables at a set of neighbor nodes.

Parameters

nodes	List of node ids to reinit
tid	Thread ID

Definition at line 395 of file SystemBase.C.

Referenced by DisplacedProblem::reinitNodesNeighbor().

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

reinitScalars()

void SystemBase::reinitScalars ( THREAD_ID  tid )

virtualinherited

Reinit scalar varaibles.

Parameters

tid

Thread ID

Definition at line 406 of file SystemBase.C.

Referenced by DisplacedProblem::reinitScalars().

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

removeMatrix()

virtual void SystemBase::removeMatrix ( TagID  )

inlinevirtualinherited

Removes a jacobian sized vector.

Parameters

tag_name

The name of the tag

Definition at line 652 of file SystemBase.h.

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

removeVector() [1/2]

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

virtualinherited

Remove a vector from the system with the given name.

Definition at line 1043 of file SystemBase.C.

Referenced by SystemBase::restoreOldSolutions().

{
  system().remove_vector(name);
}

removeVector() [2/2]

void SystemBase::removeVector ( TagID  tag_id )

virtualinherited

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

Parameters

tag_id

Tag ID

Definition at line 580 of file SystemBase.C.

{
  if (!_subproblem.vectorTagExists(tag_id))
    mooseError("Cannot remove an unexisting tag or its associated vector, ",
               tag_id,
               ", that tag does not exist in System ",
               name());

  if (hasVector(tag_id))
  {
    auto vector_name = _subproblem.vectorTagName(tag_id);
    system().remove_vector(vector_name);
    _tagged_vectors[tag_id] = nullptr;
  }
}

residualCopy()

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

inlinevirtualinherited

Reimplemented in NonlinearSystemBase, and DisplacedSystem.

Definition at line 291 of file SystemBase.h.

Referenced by DisplacedSystem::residualCopy().

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

residualGhosted()

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

inlinevirtualinherited

Reimplemented in NonlinearSystemBase, and DisplacedSystem.

Definition at line 295 of file SystemBase.h.

Referenced by DisplacedSystem::residualGhosted().

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

residualSetup()

void AuxiliarySystem::residualSetup ( )

virtual

Definition at line 153 of file AuxiliarySystem.C.

{
  for (unsigned int tid = 0; tid < libMesh::n_threads(); tid++)
  {
    _aux_scalar_storage.residualSetup(tid);
    _nodal_aux_storage.residualSetup(tid);
    _nodal_vec_aux_storage.residualSetup(tid);
    _elemental_aux_storage.residualSetup(tid);
    _elemental_vec_aux_storage.residualSetup(tid);
  }
}

residualVectorTag()

TagID SystemBase::residualVectorTag ( )

virtualinherited

Reimplemented in NonlinearSystemBase.

Definition at line 719 of file SystemBase.C.

{
  mooseError("Not implemented yet");
  return 0;
}

restoreOldSolutions()

void SystemBase::restoreOldSolutions ( )

virtualinherited

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

Definition at line 497 of file SystemBase.C.

Referenced by DisplacedProblem::restoreOldSolutions().

{
  if (_saved_old)
  {
    solutionOld() = *_saved_old;
    removeVector("save_solution_old");
    _saved_old = nullptr;
  }
  if (_saved_older)
  {
    solutionOlder() = *_saved_older;
    removeVector("save_solution_older");
    _saved_older = nullptr;
  }
  if (_saved_dot_old && solutionUDotOld())
  {
    *solutionUDotOld() = *_saved_dot_old;
    removeVector("save_solution_dot_old");
    _saved_dot_old = NULL;
  }
  if (_saved_dotdot_old && solutionUDotDotOld())
  {
    *solutionUDotDotOld() = *_saved_dotdot_old;
    removeVector("save_solution_dotdot_old");
    _saved_dotdot_old = NULL;
  }
}

restoreSolutions()

void SystemBase::restoreSolutions ( )

virtualinherited

Restore current solutions (call after your solve failed)

Reimplemented in NonlinearSystemBase.

Definition at line 1029 of file SystemBase.C.

Referenced by NonlinearSystemBase::restoreSolutions().

{
  *(const_cast<NumericVector<Number> *&>(currentSolution())) = solutionOld();
  solution() = solutionOld();
  if (solutionUDotOld())
    *solutionUDot() = *solutionUDotOld();
  if (solutionUDotDotOld())
    *solutionUDotDot() = *solutionUDotDotOld();
  if (solutionPreviousNewton())
    *solutionPreviousNewton() = solutionOld();
  system().update();
}

saveOldSolutions()

void SystemBase::saveOldSolutions ( )

virtualinherited

Save the old and older solutions.

Definition at line 472 of file SystemBase.C.

Referenced by DisplacedProblem::saveOldSolutions().

{
  if (!_saved_old)
    _saved_old = &addVector("save_solution_old", false, PARALLEL);
  if (!_saved_older)
    _saved_older = &addVector("save_solution_older", false, PARALLEL);
  if (!_saved_dot_old && solutionUDotOld())
    _saved_dot_old = &addVector("save_solution_dot_old", false, PARALLEL);
  if (!_saved_dotdot_old && solutionUDotDotOld())
    _saved_dotdot_old = &addVector("save_solution_dotdot_old", false, PARALLEL);

  *_saved_old = solutionOld();
  *_saved_older = solutionOlder();

  if (solutionUDotOld())
    *_saved_dot_old = *solutionUDotOld();

  if (solutionUDotDotOld())
    *_saved_dotdot_old = *solutionUDotDotOld();
}

serializedSolution()

NumericVector< Number > & AuxiliarySystem::serializedSolution ( )

overridevirtual

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

Implements SystemBase.

Definition at line 299 of file AuxiliarySystem.C.

{
  _need_serialized_solution = true;
  return _serialized_solution;
}

serializeSolution()

void AuxiliarySystem::serializeSolution ( )

virtual

Definition at line 306 of file AuxiliarySystem.C.

Referenced by compute().

{
  if (_need_serialized_solution &&
      _sys.n_dofs() > 0) // libMesh does not like serializing of empty vectors
  {
    if (!_serialized_solution.initialized() || _serialized_solution.size() != _sys.n_dofs())
    {
      _serialized_solution.clear();
      _serialized_solution.init(_sys.n_dofs(), false, SERIAL);
    }

    solution().localize(_serialized_solution);
  }
}

setPreviousNewtonSolution()

void AuxiliarySystem::setPreviousNewtonSolution ( )

virtual

Definition at line 607 of file AuxiliarySystem.C.

{
  // Evaluate aux variables to get the solution vector
  compute(EXEC_LINEAR);
}

setScalarVariableCoupleableTags()

void AuxiliarySystem::setScalarVariableCoupleableTags

(

ExecFlagType

type

)

Definition at line 477 of file AuxiliarySystem.C.

Referenced by computeScalarVars().

{
  const MooseObjectWarehouse<AuxScalarKernel> & storage = _aux_scalar_storage[type];
  const std::vector<std::shared_ptr<AuxScalarKernel>> & objects = storage.getActiveObjects(0);

  std::set<TagID> needed_sc_var_matrix_tags;
  std::set<TagID> needed_sc_var_vector_tags;
  for (const auto & obj : objects)
  {
    auto & sc_var_coup_vtags = obj->getScalarVariableCoupleableVectorTags();
    needed_sc_var_vector_tags.insert(sc_var_coup_vtags.begin(), sc_var_coup_vtags.end());

    auto & sc_var_coup_mtags = obj->getScalarVariableCoupleableMatrixTags();
    needed_sc_var_matrix_tags.insert(sc_var_coup_mtags.begin(), sc_var_coup_mtags.end());
  }

  _fe_problem.setActiveScalarVariableCoupleableMatrixTags(needed_sc_var_matrix_tags, 0);
  _fe_problem.setActiveScalarVariableCoupleableVectorTags(needed_sc_var_vector_tags, 0);
}

solution()

virtual NumericVector<Number>& AuxiliarySystem::solution ( )

inlineoverridevirtual

Implements SystemBase.

Definition at line 158 of file AuxiliarySystem.h.

Referenced by Adaptivity::adaptMesh(), TransientMultiApp::appTransferVector(), MultiApp::appTransferVector(), computeElementalVarsHelper(), NonlinearSystemBase::computeJacobianInternal(), NonlinearSystemBase::computeNodalBCs(), computeNodalVarsHelper(), NonlinearSystemBase::computeResidualTags(), computeScalarVars(), NodalNormalsEvaluator::execute(), NodalNormalsCorner::execute(), NodalNormalsPreprocessor::execute(), NodalNormalsEvaluator::finalize(), NodalNormalsCorner::finalize(), NodalNormalsPreprocessor::finalize(), NodalNormalsEvaluator::initialize(), NodalNormalsCorner::initialize(), NodalNormalsPreprocessor::initialize(), ComputeMarkerThread::onElement(), ComputeIndicatorThread::onElement(), and serializeSolution().

{ return *_sys.solution; }

solutionOld()

virtual NumericVector<Number>& AuxiliarySystem::solutionOld ( )

inlineoverridevirtual

Implements SystemBase.

Definition at line 160 of file AuxiliarySystem.h.

{ return *_sys.old_local_solution; }

solutionOlder()

virtual NumericVector<Number>& AuxiliarySystem::solutionOlder ( )

inlineoverridevirtual

Implements SystemBase.

Definition at line 162 of file AuxiliarySystem.h.

{ return *_sys.older_local_solution; }

solutionPreviousNewton()

virtual NumericVector<Number>* AuxiliarySystem::solutionPreviousNewton ( )

inlineoverridevirtual

Implements SystemBase.

Definition at line 171 of file AuxiliarySystem.h.

  {
    return _solution_previous_nl;
  }

solutionUDot()

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

inlineoverridevirtual

Implements SystemBase.

Definition at line 108 of file AuxiliarySystem.h.

{ return _u_dot; }

solutionUDotDot()

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

inlineoverridevirtual

Implements SystemBase.

Definition at line 110 of file AuxiliarySystem.h.

{ return _u_dotdot; }

solutionUDotDotOld()

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

inlineoverridevirtual

Implements SystemBase.

Definition at line 170 of file AuxiliarySystem.h.

{ return _u_dotdot_old; }

solutionUDotOld()

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

inlineoverridevirtual

Implements SystemBase.

Definition at line 169 of file AuxiliarySystem.h.

{ return _u_dot_old; }

solve()

void SystemBase::solve ( )

virtualinherited

Solve the system (using libMesh magic)

Reimplemented in NonlinearSystemBase, NonlinearEigenSystem, DumpObjectsNonlinearSystem, and NonlinearSystem.

Definition at line 987 of file SystemBase.C.

{
  system().solve();
}

subdomainSetup()

void AuxiliarySystem::subdomainSetup ( )

virtual

Definition at line 127 of file AuxiliarySystem.C.

{
  for (unsigned int tid = 0; tid < libMesh::n_threads(); tid++)
  {
    _aux_scalar_storage.subdomainSetup(tid);
    _nodal_aux_storage.subdomainSetup(tid);
    _nodal_vec_aux_storage.subdomainSetup(tid);
    _elemental_aux_storage.subdomainSetup(tid);
    _elemental_vec_aux_storage.subdomainSetup(tid);
  }
}

subproblem()

virtual SubProblem& SystemBase::subproblem ( )

inlinevirtualinherited

Definition at line 105 of file SystemBase.h.

Referenced by CreateDisplacedProblemAction::addProxyAlgebraicRelationshipManagers(), CreateDisplacedProblemAction::addProxyGeometricRelationshipManagers(), MooseVariableBase::allDofIndices(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), MultiAppVariableValueSampleTransfer::execute(), MooseVariableFE< Real >::MooseVariableFE(), MooseVariableScalar::MooseVariableScalar(), and MooseVariableScalar::reinit().

{ return _subproblem; }

sys()

virtual TransientExplicitSystem& AuxiliarySystem::sys ( )

inlinevirtual

Definition at line 164 of file AuxiliarySystem.h.

Referenced by DT2::preExecute(), DT2::preSolve(), DT2::rejectStep(), and DT2::step().

{ return _sys; }

system() [1/2]

virtual System& AuxiliarySystem::system ( )

inlineoverridevirtual

Get the reference to the libMesh system.

Implements SystemBase.

Definition at line 166 of file AuxiliarySystem.h.

Referenced by TransientMultiApp::appTransferVector(), NodalNormalsPreprocessor::initialize(), ConsoleUtils::outputAuxiliarySystemInformation(), TransientMultiApp::setupApp(), and TransientMultiApp::solveStep().

{ return _sys; }

system() [2/2]

virtual const System& AuxiliarySystem::system ( ) const

inlineoverridevirtual

Implements SystemBase.

Definition at line 167 of file AuxiliarySystem.h.

{ return _sys; }

systemMatrixTag()

TagID SystemBase::systemMatrixTag ( )

virtualinherited

Return the Matrix Tag ID for System.

Reimplemented in NonlinearSystemBase.

Definition at line 705 of file SystemBase.C.

{
  mooseError("Not implemented yet");
  return 0;
}

timeMatrixTag()

TagID SystemBase::timeMatrixTag ( )

virtualinherited

Return the Matrix Tag ID for Time.

Definition at line 698 of file SystemBase.C.

{
  mooseError("Not implemented yet");
  return 0;
}

timestepSetup()

void AuxiliarySystem::timestepSetup ( )

virtual

Definition at line 114 of file AuxiliarySystem.C.

{
  for (unsigned int tid = 0; tid < libMesh::n_threads(); tid++)
  {
    _aux_scalar_storage.timestepSetup(tid);
    _nodal_aux_storage.timestepSetup(tid);
    _nodal_vec_aux_storage.timestepSetup(tid);
    _elemental_aux_storage.timestepSetup(tid);
    _elemental_vec_aux_storage.timestepSetup(tid);
  }
}

timeVectorTag()

TagID SystemBase::timeVectorTag ( )

virtualinherited

Ideally, we should not need this API.

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

Reimplemented in NonlinearSystemBase, and DisplacedSystem.

Definition at line 691 of file SystemBase.C.

Referenced by DisplacedSystem::timeVectorTag().

{
  mooseError("Not implemented yet");
  return 0;
}

update()

void SystemBase::update ( )

virtualinherited

Update the system (doing libMesh magic)

Definition at line 981 of file SystemBase.C.

Referenced by MooseEigenSystem::combineSystemSolution(), NonlinearSystemBase::computeDamping(), NonlinearSystemBase::computeJacobianInternal(), NonlinearSystemBase::computeResidualTags(), dataLoad(), MooseEigenSystem::initSystemSolution(), MooseEigenSystem::initSystemSolutionOld(), Resurrector::restartFromFile(), MooseEigenSystem::scaleSystemSolution(), NonlinearSystemBase::setConstraintSlaveValues(), NonlinearSystemBase::setInitialSolution(), PicardSolve::solve(), PicardSolve::solveStep(), DisplacedProblem::syncSolutions(), and MultiAppCopyTransfer::transfer().

{
  system().update();
}

updateActive()

void AuxiliarySystem::updateActive ( THREAD_ID  tid )

virtual

Definition at line 166 of file AuxiliarySystem.C.

{
  _aux_scalar_storage.updateActive(tid);
  _nodal_aux_storage.updateActive(tid);
  _nodal_vec_aux_storage.updateActive(tid);
  _elemental_aux_storage.updateActive(tid);
  _elemental_vec_aux_storage.updateActive(tid);
}

zeroTaggedVectors()

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

virtualinherited

Zero all vectors for given tags.

Definition at line 570 of file SystemBase.C.

Referenced by NonlinearSystemBase::computeResidualTags().

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

zeroVariables()

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

virtualinherited

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

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

Reimplemented in DisplacedSystem.

Definition at line 190 of file SystemBase.C.

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

{
  if (vars_to_be_zeroed.size() > 0)
  {
    NumericVector<Number> & solution = this->solution();

    AllLocalDofIndicesThread aldit(system(), vars_to_be_zeroed);
    ConstElemRange & elem_range = *_mesh.getActiveLocalElementRange();
    Threads::parallel_reduce(elem_range, aldit);

    const std::set<dof_id_type> & dof_indices_to_zero = aldit._all_dof_indices;

    solution.close();

    for (const auto & dof : dof_indices_to_zero)
      solution.set(dof, 0);

    solution.close();

    // Call update to update the current_local_solution for this system
    system().update();
  }
}

zeroVariablesForJacobian()

void SystemBase::zeroVariablesForJacobian ( )

virtualinherited

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

Definition at line 221 of file SystemBase.C.

{
  zeroVariables(_vars_to_be_zeroed_on_jacobian);
}

zeroVariablesForResidual()

void SystemBase::zeroVariablesForResidual ( )

virtualinherited

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

Definition at line 215 of file SystemBase.C.

{
  zeroVariables(_vars_to_be_zeroed_on_residual);
}

Friends And Related Function Documentation

ComputeIndicatorThread

friend class ComputeIndicatorThread

friend

Definition at line 251 of file AuxiliarySystem.h.

ComputeMarkerThread

friend class ComputeMarkerThread

friend

Definition at line 252 of file AuxiliarySystem.h.

ComputeNodalKernelBCJacobiansThread

friend class ComputeNodalKernelBCJacobiansThread

friend

Definition at line 257 of file AuxiliarySystem.h.

ComputeNodalKernelBcsThread

friend class ComputeNodalKernelBcsThread

friend

Definition at line 255 of file AuxiliarySystem.h.

ComputeNodalKernelJacobiansThread

friend class ComputeNodalKernelJacobiansThread

friend

Definition at line 256 of file AuxiliarySystem.h.

ComputeNodalKernelsThread

friend class ComputeNodalKernelsThread

friend

Definition at line 254 of file AuxiliarySystem.h.

FlagElementsThread

friend class FlagElementsThread

friend

Definition at line 253 of file AuxiliarySystem.h.

Member Data Documentation

_app

MooseApp& SystemBase::_app

protectedinherited

Definition at line 696 of file SystemBase.h.

Referenced by NonlinearSystemBase::computeJacobianBlocks(), NonlinearSystemBase::computeJacobianTags(), and NonlinearSystemBase::computeResidualTags().

_aux_scalar_storage

ExecuteMooseObjectWarehouse<AuxScalarKernel> AuxiliarySystem::_aux_scalar_storage

Definition at line 234 of file AuxiliarySystem.h.

Referenced by addScalarKernel(), computeScalarVars(), initialSetup(), jacobianSetup(), residualSetup(), setScalarVariableCoupleableTags(), subdomainSetup(), timestepSetup(), and updateActive().

_compute_elemental_vars_timer

const PerfID AuxiliarySystem::_compute_elemental_vars_timer

Definition at line 248 of file AuxiliarySystem.h.

Referenced by computeElementalVars().

_compute_elemental_vec_vars_timer

const PerfID AuxiliarySystem::_compute_elemental_vec_vars_timer

Definition at line 249 of file AuxiliarySystem.h.

Referenced by computeElementalVarsHelper(), and computeElementalVecVars().

_compute_nodal_vars_timer

const PerfID AuxiliarySystem::_compute_nodal_vars_timer

Definition at line 246 of file AuxiliarySystem.h.

Referenced by computeNodalVars().

_compute_nodal_vec_vars_timer

const PerfID AuxiliarySystem::_compute_nodal_vec_vars_timer

Definition at line 247 of file AuxiliarySystem.h.

Referenced by computeNodalVecVars().

_compute_scalar_vars_timer

const PerfID AuxiliarySystem::_compute_scalar_vars_timer

Timers.

Definition at line 245 of file AuxiliarySystem.h.

Referenced by computeScalarVars().

_current_solution

const NumericVector<Number>* AuxiliarySystem::_current_solution

solution vector from nonlinear solver

Definition at line 204 of file AuxiliarySystem.h.

Referenced by currentSolution().

_du_dot_du

Real SystemBase::_du_dot_du

protectedinherited

Definition at line 711 of file SystemBase.h.

Referenced by SystemBase::duDotDu().

_du_dotdot_du

Real SystemBase::_du_dotdot_du

protectedinherited

Definition at line 712 of file SystemBase.h.

Referenced by SystemBase::duDotDotDu().

_elem_std_vars

std::vector<std::vector<MooseVariableFEBase *> > AuxiliarySystem::_elem_std_vars

Definition at line 230 of file AuxiliarySystem.h.

Referenced by addVariable(), AuxiliarySystem(), and computeElementalVars().

_elem_vars

std::vector<std::vector<MooseVariableFEBase *> > AuxiliarySystem::_elem_vars

Definition at line 229 of file AuxiliarySystem.h.

Referenced by addVariable(), AuxiliarySystem(), ComputeMarkerThread::onElement(), ComputeIndicatorThread::onElement(), ComputeIndicatorThread::onInternalSide(), reinitElem(), reinitElemFace(), and ComputeMarkerThread::subdomainChanged().

_elem_vec_vars

std::vector<std::vector<MooseVariableFEBase *> > AuxiliarySystem::_elem_vec_vars

Definition at line 231 of file AuxiliarySystem.h.

Referenced by AuxiliarySystem(), and computeElementalVecVars().

_elemental_aux_storage

ExecuteMooseObjectWarehouse<AuxKernel> AuxiliarySystem::_elemental_aux_storage

Definition at line 238 of file AuxiliarySystem.h.

Referenced by addKernel(), computeElementalVars(), getDependObjects(), initialSetup(), jacobianSetup(), needMaterialOnSide(), residualSetup(), subdomainSetup(), timestepSetup(), and updateActive().

_elemental_vec_aux_storage

ExecuteMooseObjectWarehouse<VectorAuxKernel> AuxiliarySystem::_elemental_vec_aux_storage

Definition at line 242 of file AuxiliarySystem.h.

Referenced by addKernel(), computeElementalVecVars(), getDependObjects(), initialSetup(), jacobianSetup(), needMaterialOnSide(), residualSetup(), subdomainSetup(), timestepSetup(), and updateActive().

_factory

Factory& SystemBase::_factory

protectedinherited

Definition at line 697 of file SystemBase.h.

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

_fe_problem

FEProblemBase& AuxiliarySystem::_fe_problem

Definition at line 199 of file AuxiliarySystem.h.

Referenced by addDotVectors(), addExtraVectors(), clearScalarVariableCoupleableTags(), compute(), computeElementalVarsHelper(), computeNodalVarsHelper(), computeScalarVars(), and setScalarVariableCoupleableTags().

_matrix_tag_active_flags

std::vector<bool> SystemBase::_matrix_tag_active_flags

protectedinherited

Active flags for tagged matrices.

Definition at line 719 of file SystemBase.h.

Referenced by SystemBase::activeAllMatrixTags(), SystemBase::activeMatrixTag(), SystemBase::deactiveAllMatrixTags(), SystemBase::deactiveMatrixTag(), and SystemBase::matrixTagActive().

_max_var_n_dofs_per_elem

size_t SystemBase::_max_var_n_dofs_per_elem

protectedinherited

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

Definition at line 735 of file SystemBase.h.

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

_max_var_n_dofs_per_node

size_t SystemBase::_max_var_n_dofs_per_node

protectedinherited

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

Definition at line 738 of file SystemBase.h.

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

_mesh

MooseMesh& SystemBase::_mesh

protectedinherited

Definition at line 699 of file SystemBase.h.

Referenced by SystemBase::augmentSendList(), NonlinearSystemBase::computeDamping(), computeElementalVarsHelper(), NonlinearSystemBase::computeJacobianBlocks(), NonlinearSystemBase::computeJacobianInternal(), NonlinearSystemBase::computeNodalBCs(), computeNodalVarsHelper(), NonlinearSystemBase::computeResidualInternal(), NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::constraintResiduals(), NonlinearSystemBase::findImplicitGeometricCouplingEntries(), NonlinearSystemBase::getNodeDofs(), NonlinearSystemBase::init(), SystemBase::mesh(), NonlinearSystemBase::setConstraintSlaveValues(), NonlinearSystemBase::setInitialSolution(), NonlinearSystemBase::setVariableGlobalDoFs(), and SystemBase::zeroVariables().

_name

std::string SystemBase::_name

protectedinherited

The name of this system.

Definition at line 701 of file SystemBase.h.

_need_serialized_solution

bool AuxiliarySystem::_need_serialized_solution

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

Definition at line 222 of file AuxiliarySystem.h.

Referenced by compute(), serializedSolution(), and serializeSolution().

_nodal_aux_storage

ExecuteMooseObjectWarehouse<AuxKernel> AuxiliarySystem::_nodal_aux_storage

Definition at line 237 of file AuxiliarySystem.h.

Referenced by addKernel(), computeNodalVars(), getDependObjects(), initialSetup(), jacobianSetup(), residualSetup(), subdomainSetup(), timestepSetup(), and updateActive().

_nodal_std_vars

std::vector<std::vector<MooseVariableFEBase *> > AuxiliarySystem::_nodal_std_vars

Definition at line 226 of file AuxiliarySystem.h.

Referenced by addVariable(), AuxiliarySystem(), and computeNodalVars().

_nodal_vars

std::vector<std::vector<MooseVariableFEBase *> > AuxiliarySystem::_nodal_vars

Definition at line 225 of file AuxiliarySystem.h.

Referenced by addVariable(), AuxiliarySystem(), ComputeNodalKernelBcsThread::onNode(), ComputeNodalKernelBCJacobiansThread::onNode(), ComputeNodalKernelsThread::onNode(), ComputeNodalKernelJacobiansThread::onNode(), reinitElem(), and reinitElemFace().

_nodal_vec_aux_storage

ExecuteMooseObjectWarehouse<VectorAuxKernel> AuxiliarySystem::_nodal_vec_aux_storage

Definition at line 241 of file AuxiliarySystem.h.

Referenced by addKernel(), computeNodalVecVars(), getDependObjects(), initialSetup(), jacobianSetup(), residualSetup(), subdomainSetup(), timestepSetup(), and updateActive().

_nodal_vec_vars

std::vector<std::vector<MooseVariableFEBase *> > AuxiliarySystem::_nodal_vec_vars

Definition at line 227 of file AuxiliarySystem.h.

Referenced by addVariable(), AuxiliarySystem(), and computeNodalVecVars().

_perf_graph

PerfGraph& PerfGraphInterface::_perf_graph

protectedinherited

The performance graph to add to.

Definition at line 66 of file PerfGraphInterface.h.

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

_pg_params

const InputParameters* PerfGraphInterface::_pg_params

protectedinherited

Params.

Definition at line 63 of file PerfGraphInterface.h.

_prefix

std::string PerfGraphInterface::_prefix

protectedinherited

A prefix to use for all sections.

Definition at line 69 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::registerTimedSection().

_saved_dot_old

NumericVector<Real>* SystemBase::_saved_dot_old

protectedinherited

Definition at line 726 of file SystemBase.h.

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

_saved_dotdot_old

NumericVector<Real>* SystemBase::_saved_dotdot_old

protectedinherited

Definition at line 727 of file SystemBase.h.

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

_saved_old

NumericVector<Real>* SystemBase::_saved_old

protectedinherited

Definition at line 722 of file SystemBase.h.

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

_saved_older

NumericVector<Real>* SystemBase::_saved_older

protectedinherited

Definition at line 723 of file SystemBase.h.

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

_serialized_solution

NumericVector<Number>& AuxiliarySystem::_serialized_solution

Serialized version of the solution vector.

Definition at line 206 of file AuxiliarySystem.h.

Referenced by serializedSolution(), serializeSolution(), and ~AuxiliarySystem().

_solution_previous_nl

NumericVector<Number>* AuxiliarySystem::_solution_previous_nl

Solution vector of the previous nonlinear iterate.

Definition at line 208 of file AuxiliarySystem.h.

Referenced by addExtraVectors(), and solutionPreviousNewton().

_subproblem

SubProblem& SystemBase::_subproblem

protectedinherited

Definition at line 694 of file SystemBase.h.

Referenced by SystemBase::activeAllMatrixTags(), SystemBase::activeMatrixTag(), NonlinearSystem::addMatrix(), SystemBase::addScalarVariable(), SystemBase::addVariable(), SystemBase::addVector(), SystemBase::associateMatrixToTag(), SystemBase::associateVectorToTag(), SystemBase::augmentSendList(), SystemBase::closeTaggedVectors(), SystemBase::deactiveAllMatrixTags(), SystemBase::deactiveMatrixTag(), SystemBase::disassociateMatrixFromTag(), SystemBase::disassociateVectorFromTag(), SystemBase::matrixTagActive(), SystemBase::prepare(), SystemBase::prepareFace(), SystemBase::reinitElem(), SystemBase::removeVector(), SystemBase::subproblem(), and SystemBase::zeroTaggedVectors().

_sys

TransientExplicitSystem& AuxiliarySystem::_sys

Definition at line 201 of file AuxiliarySystem.h.

Referenced by addVector(), computeElementalVarsHelper(), computeNodalVarsHelper(), computeScalarVars(), currentSolution(), serializeSolution(), solution(), solutionOld(), solutionOlder(), sys(), and system().

_tagged_matrices

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

protectedinherited

Tagged matrices (pointer)

Definition at line 717 of file SystemBase.h.

Referenced by NonlinearSystem::addMatrix(), SystemBase::associateMatrixToTag(), SystemBase::disassociateAllTaggedMatrices(), SystemBase::disassociateMatrixFromTag(), SystemBase::getMatrix(), and SystemBase::hasMatrix().

_tagged_vectors

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

protectedinherited

Tagged vectors (pointer)

Definition at line 715 of file SystemBase.h.

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

_time_integrator

std::shared_ptr<TimeIntegrator> AuxiliarySystem::_time_integrator

Time integrator.

Definition at line 210 of file AuxiliarySystem.h.

Referenced by addTimeIntegrator(), and compute().

_u_dot

NumericVector<Number>* AuxiliarySystem::_u_dot

solution vector for u^dot

Definition at line 212 of file AuxiliarySystem.h.

Referenced by addDotVectors(), and solutionUDot().

_u_dot_old

NumericVector<Number>* AuxiliarySystem::_u_dot_old

Old solution vector for u^dot.

Definition at line 217 of file AuxiliarySystem.h.

Referenced by addDotVectors(), and solutionUDotOld().

_u_dotdot

NumericVector<Number>* AuxiliarySystem::_u_dotdot

solution vector for u^dotdot

Definition at line 214 of file AuxiliarySystem.h.

Referenced by addDotVectors(), and solutionUDotDot().

_u_dotdot_old

NumericVector<Number>* AuxiliarySystem::_u_dotdot_old

Old solution vector for u^dotdot.

Definition at line 219 of file AuxiliarySystem.h.

Referenced by addDotVectors(), and solutionUDotDotOld().

_var_kind

Moose::VarKindType SystemBase::_var_kind

protectedinherited

default kind of variables in this system

Definition at line 730 of file SystemBase.h.

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

_var_map

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

protectedinherited

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

Definition at line 706 of file SystemBase.h.

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

_var_to_copy

std::vector<VarCopyInfo> SystemBase::_var_to_copy

protectedinherited

Definition at line 732 of file SystemBase.h.

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

_vars

std::vector<VariableWarehouse> SystemBase::_vars

protectedinherited

Variable warehouses (one for each thread)

Definition at line 704 of file SystemBase.h.

Referenced by NonlinearSystemBase::addBoundaryCondition(), NonlinearSystemBase::addInterfaceKernel(), SystemBase::addScalarVariable(), addVariable(), SystemBase::addVariable(), compute(), SystemBase::getFieldVariable(), getMinQuadratureOrder(), SystemBase::getMinQuadratureOrder(), SystemBase::getScalarVariable(), SystemBase::getScalarVariables(), SystemBase::getVariable(), SystemBase::getVariableNames(), SystemBase::getVariables(), SystemBase::nVariables(), SystemBase::prepare(), SystemBase::prepareFace(), SystemBase::prepareNeighbor(), SystemBase::reinitElem(), SystemBase::reinitElemFace(), SystemBase::reinitNeighbor(), SystemBase::reinitNeighborFace(), SystemBase::reinitNode(), SystemBase::reinitNodeFace(), SystemBase::reinitNodes(), SystemBase::reinitNodesNeighbor(), and SystemBase::reinitScalars().

_vars_to_be_zeroed_on_jacobian

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

protectedinherited

Definition at line 709 of file SystemBase.h.

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

_vars_to_be_zeroed_on_residual

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

protectedinherited

Definition at line 708 of file SystemBase.h.

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

---

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

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