PhysicsBasedPreconditioner Class Reference

Implements a segregated solve preconditioner. More...

#include <PhysicsBasedPreconditioner.h>

Inheritance diagram for PhysicsBasedPreconditioner:

Public Member Functions
	PhysicsBasedPreconditioner (const InputParameters &params)
virtual	~PhysicsBasedPreconditioner ()
void	addSystem (unsigned int var, std::vector< unsigned int > off_diag, PreconditionerType type=AMG_PRECOND)
	Add a diagonal system + possibly off-diagonals ones as well, also specifying type of preconditioning. More...
virtual void	apply (const NumericVector< Number > &x, NumericVector< Number > &y)
	Computes the preconditioned vector "y" based on input "x". More...
virtual void	clear ()
	Release all memory and clear data structures. More...
virtual void	init ()
	Initialize data structures if not done so already. More...
virtual void	setup ()
	This is called every time the "operator might have changed". More...
const std::string &	type () const
	Get the type of this object. More...
virtual const std::string &	name () const
	Get the name of the object. More...
const InputParameters &	parameters () const
	Get the parameters of the object. More...
template<typename T >
const T &	getParamTempl (const std::string &name) const
	Retrieve a parameter for the object. More...
template<typename T >
T	getCheckedPointerParam (const std::string &name, const std::string &error_string="") const
	Verifies that the requested parameter exists and is not NULL and returns it to the caller. More...
bool	isParamValid (const std::string &name) const
	Test if the supplied parameter is valid. More...
MooseApp &	getMooseApp () const
	Get the MooseApp this object is associated with. More...
virtual bool	enabled () const
	Return the enabled status of the object. More...
template<typename... Args>
void	paramError (const std::string &param, Args... args) const
	Emits an error prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message. More...
template<typename... Args>
void	paramWarning (const std::string &param, Args... args) const
	Emits a warning prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message. More...
template<typename... Args>
void	paramInfo (const std::string &param, Args... args) const
	Emits an informational message prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message. More...
template<typename... Args>
void	mooseError (Args &&... args) const
template<typename... Args>
void	mooseWarning (Args &&... args) const
template<typename... Args>
void	mooseDeprecated (Args &&... args) const
template<typename... Args>
void	mooseInfo (Args &&... args) const

Static Public Member Functions
static InputParameters	validParams ()
	Constructor. More...
static void	copyVarValues (MeshBase &mesh, const unsigned int from_system, const unsigned int from_var, const NumericVector< Number > &from_vector, const unsigned int to_system, const unsigned int to_var, NumericVector< Number > &to_vector)
	Helper function for copying values associated with variables in vectors from two different systems. More...

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

Protected Member Functions
template<typename T >
T &	declareRestartableDataTempl (const std::string &data_name)
	Declare a piece of data as "restartable". More...
template<typename T >
T &	declareRestartableDataTempl (const std::string &data_name, const T &init_value)
	Declare a piece of data as "restartable" and initialize it. More...
template<typename T >
T &	declareRestartableDataWithContext (const std::string &data_name, void *context)
	Declare a piece of data as "restartable". More...
template<typename T >
T &	declareRestartableDataWithContext (const std::string &data_name, const T &init_value, void *context)
	Declare a piece of data as "restartable" and initialize it. More...
template<typename T >
T &	declareRestartableDataWithPrefixOverrideAndContext (const std::string &data_name, const std::string &prefix, void *context)
	Declare a piece of data as "restartable". More...
template<typename T >
T &	declareRecoverableData (const std::string &data_name)
	Declare a piece of data as "recoverable". More...
template<typename T >
T &	declareRecoverableData (const std::string &data_name, const T &init_value)
	Declare a piece of data as "restartable" and initialize it. More...
template<typename T >
T &	declareRestartableDataWithObjectName (const std::string &data_name, const std::string &object_name)
	Declare a piece of data as "restartable". More...
template<typename T >
T &	declareRestartableDataWithObjectNameWithContext (const std::string &data_name, const std::string &object_name, void *context)
	Declare a piece of data as "restartable". More...
PerfID	registerTimedSection (const std::string &section_name, const unsigned int level)
	Call to register a named section for timing. More...

Protected Attributes
NonlinearSystemBase &	_nl
	The nonlinear system this PBP is associated with (convenience reference) More...
std::vector< LinearImplicitSystem * >	_systems
	List of linear system that build up the preconditioner. More...
std::vector< std::unique_ptr< Preconditioner< Number > > >	_preconditioners
	Holds one Preconditioner object per small system to solve. More...
std::vector< unsigned int >	_solve_order
	Holds the order the blocks are solved for. More...
std::vector< PreconditionerType >	_pre_type
	Which preconditioner to use for each solve. More...
std::vector< std::vector< unsigned int > >	_off_diag
	Holds which off diagonal blocks to compute. More...
std::vector< std::vector< SparseMatrix< Number > * > >	_off_diag_mats
	Holds pointers to the off-diagonal matrices. More...
PerfID	_init_timer
	Timers. More...
PerfID	_apply_timer
FEProblemBase &	_fe_problem
	Subproblem this preconditioner is part of. More...
const InputParameters &	_pars
	Parameters of this object, references the InputParameters stored in the InputParametersWarehouse. More...
MooseApp &	_app
	The MooseApp this object is associated with. More...
const std::string &	_type
	The type of this object (the Class name) More...
const std::string &	_name
	The name of this object, reference to value stored in InputParameters. More...
const bool &	_enabled
	Reference to the "enable" InputParaemters, used by Controls for toggling on/off MooseObjects. 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...

Private Member Functions
template<typename... Args>
std::string	paramErrorMsg (const std::string &param, Args... args) const
RestartableDataValue &	registerRestartableDataOnApp (const std::string &name, std::unique_ptr< RestartableDataValue > data, THREAD_ID tid)
	Helper function for actually registering the restartable data. More...
void	registerRestartableNameWithFilterOnApp (const std::string &name, Moose::RESTARTABLE_FILTER filter)
	Helper function for actually registering the restartable data. More...

Private Attributes
MooseApp &	_restartable_app
	Reference to the application. More...
std::string	_restartable_name
	The name of the object. More...
std::string	_restartable_system_name
	The system name this object is in. More...
THREAD_ID	_restartable_tid
	The thread ID for this object. More...

Detailed Description

Implements a segregated solve preconditioner.

Definition at line 33 of file PhysicsBasedPreconditioner.h.

Constructor & Destructor Documentation

PhysicsBasedPreconditioner()

PhysicsBasedPreconditioner::PhysicsBasedPreconditioner

(

const InputParameters &

params

)

Definition at line 59 of file PhysicsBasedPreconditioner.C.

  : MoosePreconditioner(params),
    Preconditioner<Number>(MoosePreconditioner::_communicator),
    _nl(_fe_problem.getNonlinearSystemBase()),
    _init_timer(registerTimedSection("init", 2)),
    _apply_timer(registerTimedSection("apply", 1))
{
  unsigned int num_systems = _nl.system().n_vars();
  _systems.resize(num_systems);
  _preconditioners.resize(num_systems);
  _off_diag.resize(num_systems);
  _off_diag_mats.resize(num_systems);
  _pre_type.resize(num_systems);
 
  { // Setup the Coupling Matrix so MOOSE knows what we're doing
    NonlinearSystemBase & nl = _fe_problem.getNonlinearSystemBase();
    unsigned int n_vars = nl.nVariables();
 
    // The coupling matrix is held and released by FEProblemBase, so it is not released in this
    // object
    std::unique_ptr<CouplingMatrix> cm = libmesh_make_unique<CouplingMatrix>(n_vars);
 
    bool full = false; // getParam<bool>("full"); // TODO: add a FULL option for PBP
 
    if (!full)
    {
      // put 1s on diagonal
      for (unsigned int i = 0; i < n_vars; i++)
        (*cm)(i, i) = 1;
 
      // off-diagonal entries
      std::vector<std::vector<unsigned int>> off_diag(n_vars);
      for (unsigned int i = 0; i < getParam<std::vector<std::string>>("off_diag_row").size(); i++)
      {
        unsigned int row =
            nl.getVariable(0, getParam<std::vector<std::string>>("off_diag_row")[i]).number();
        unsigned int column =
            nl.getVariable(0, getParam<std::vector<std::string>>("off_diag_column")[i]).number();
        (*cm)(row, column) = 1;
      }
 
      // TODO: handle coupling entries between NL-vars and SCALAR-vars
    }
    else
    {
      for (unsigned int i = 0; i < n_vars; i++)
        for (unsigned int j = 0; j < n_vars; j++)
          (*cm)(i, j) = 1;
    }
 
    _fe_problem.setCouplingMatrix(std::move(cm));
  }
 
  // PC types
  const std::vector<std::string> & pc_types = getParam<std::vector<std::string>>("preconditioner");
  for (unsigned int i = 0; i < num_systems; i++)
    _pre_type[i] = Utility::string_to_enum<PreconditionerType>(pc_types[i]);
 
  // solve order
  const std::vector<std::string> & solve_order = getParam<std::vector<std::string>>("solve_order");
  _solve_order.resize(solve_order.size());
  for (unsigned int i = 0; i < solve_order.size(); i++)
    _solve_order[i] = _nl.system().variable_number(solve_order[i]);
 
  // diag and off-diag systems
  unsigned int n_vars = _nl.system().n_vars();
 
  // off-diagonal entries
  const std::vector<std::string> & odr = getParam<std::vector<std::string>>("off_diag_row");
  const std::vector<std::string> & odc = getParam<std::vector<std::string>>("off_diag_column");
  std::vector<std::vector<unsigned int>> off_diag(n_vars);
  for (unsigned int i = 0; i < odr.size(); i++)
  {
    unsigned int row = _nl.system().variable_number(odr[i]);
    unsigned int column = _nl.system().variable_number(odc[i]);
    off_diag[row].push_back(column);
  }
  // Add all of the preconditioning systems
  for (unsigned int var = 0; var < n_vars; var++)
    addSystem(var, off_diag[var], _pre_type[var]);
 
  _nl.nonlinearSolver()->attach_preconditioner(this);
 
  if (_fe_problem.solverParams()._type != Moose::ST_JFNK)
    mooseError("PBP must be used with JFNK solve type");
}

~PhysicsBasedPreconditioner()

PhysicsBasedPreconditioner::~PhysicsBasedPreconditioner ( )

virtual

Definition at line 146 of file PhysicsBasedPreconditioner.C.

{ this->clear(); }

Member Function Documentation

addSystem()

void PhysicsBasedPreconditioner::addSystem	(	unsigned int	var,
		std::vector< unsigned int >	off_diag,
		PreconditionerType	type = AMG_PRECOND
	)

Add a diagonal system + possibly off-diagonals ones as well, also specifying type of preconditioning.

Definition at line 149 of file PhysicsBasedPreconditioner.C.

{
  std::string var_name = _nl.system().variable_name(var);
 
  LinearImplicitSystem & precond_system =
      _fe_problem.es().add_system<LinearImplicitSystem>(var_name + "_system");
  precond_system.assemble_before_solve = false;
 
  const std::set<SubdomainID> * active_subdomains = _nl.getVariableBlocks(var);
  precond_system.add_variable(
      var_name + "_prec", _nl.system().variable(var).type(), active_subdomains);
 
  _systems[var] = &precond_system;
  _pre_type[var] = type;
 
  _off_diag_mats[var].resize(off_diag.size());
  for (unsigned int i = 0; i < off_diag.size(); i++)
  {
    // Add the matrix to hold the off-diagonal piece
    _off_diag_mats[var][i] = &precond_system.add_matrix(_nl.system().variable_name(off_diag[i]));
  }
 
  _off_diag[var] = off_diag;
}

Referenced by PhysicsBasedPreconditioner().

apply()

void PhysicsBasedPreconditioner::apply ( const NumericVector< Number > &  x, NumericVector< Number > &  y  )

virtual

Computes the preconditioned vector "y" based on input "x".

Usually by solving Py=x to get the action of P^-1 x.

Definition at line 249 of file PhysicsBasedPreconditioner.C.

{
  TIME_SECTION(_apply_timer);
 
  const unsigned int num_systems = _systems.size();
 
  MooseMesh & mesh = _fe_problem.mesh();
 
  // Zero out the solution vectors
  for (unsigned int sys = 0; sys < num_systems; sys++)
    _systems[sys]->solution->zero();
 
  // Loop over solve order
  for (unsigned int i = 0; i < _solve_order.size(); i++)
  {
    unsigned int system_var = _solve_order[i];
 
    LinearImplicitSystem & u_system = *_systems[system_var];
 
    // Copy rhs from the big system into the small one
    MoosePreconditioner::copyVarValues(
        mesh, _nl.system().number(), system_var, x, u_system.number(), 0, *u_system.rhs);
 
    // Modify the RHS by subtracting off the matvecs of the solutions for the other preconditioning
    // systems with the off diagonal blocks in this system.
    for (unsigned int diag = 0; diag < _off_diag[system_var].size(); diag++)
    {
      unsigned int coupled_var = _off_diag[system_var][diag];
      LinearImplicitSystem & coupled_system = *_systems[coupled_var];
      SparseMatrix<Number> & off_diag = *_off_diag_mats[system_var][diag];
      NumericVector<Number> & rhs = *u_system.rhs;
 
      // This next bit computes rhs -= A*coupled_solution
      // It does what it does because there is no vector_mult_sub()
      rhs.close();
      rhs.scale(-1.0);
      rhs.close();
      off_diag.vector_mult_add(rhs, *coupled_system.solution);
      rhs.close();
      rhs.scale(-1.0);
      rhs.close();
    }
 
    // Apply the preconditioner to the small system
    _preconditioners[system_var]->apply(*u_system.rhs, *u_system.solution);
 
    // Copy solution from small system into the big one
    // copyVarValues(mesh,system,0,*u_system.solution,0,system_var,y);
  }
 
  // Copy the solutions out
  for (unsigned int system_var = 0; system_var < num_systems; system_var++)
  {
    LinearImplicitSystem & u_system = *_systems[system_var];
 
    MoosePreconditioner::copyVarValues(
        mesh, u_system.number(), 0, *u_system.solution, _nl.system().number(), system_var, y);
  }
 
  y.close();
}

clear()

void PhysicsBasedPreconditioner::clear ( )

virtual

Release all memory and clear data structures.

Definition at line 312 of file PhysicsBasedPreconditioner.C.

{
}

Referenced by ~PhysicsBasedPreconditioner().

copyVarValues()

void MoosePreconditioner::copyVarValues ( MeshBase &  mesh, const unsigned int  from_system, const unsigned int  from_var, const NumericVector< Number > &  from_vector, const unsigned int  to_system, const unsigned int  to_var, NumericVector< Number > &  to_vector  )

staticinherited

Helper function for copying values associated with variables in vectors from two different systems.

Definition at line 52 of file MoosePreconditioner.C.

{
  for (auto & node : mesh.local_node_ptr_range())
  {
    unsigned int n_comp = node->n_comp(from_system, from_var);
 
    mooseAssert(node->n_comp(from_system, from_var) == node->n_comp(to_system, to_var),
                "Number of components does not match in each system");
 
    for (unsigned int i = 0; i < n_comp; i++)
    {
      dof_id_type from_dof = node->dof_number(from_system, from_var, i);
      dof_id_type to_dof = node->dof_number(to_system, to_var, i);
 
      to_vector.set(to_dof, from_vector(from_dof));
    }
  }
 
  for (auto & elem : as_range(mesh.local_elements_begin(), mesh.local_elements_end()))
  {
    unsigned int n_comp = elem->n_comp(from_system, from_var);
 
    mooseAssert(elem->n_comp(from_system, from_var) == elem->n_comp(to_system, to_var),
                "Number of components does not match in each system");
 
    for (unsigned int i = 0; i < n_comp; i++)
    {
      dof_id_type from_dof = elem->dof_number(from_system, from_var, i);
      dof_id_type to_dof = elem->dof_number(to_system, to_var, i);
 
      to_vector.set(to_dof, from_vector(from_dof));
    }
  }
}

Referenced by apply().

declareRecoverableData() [1/2]

template<typename T >

T & Restartable::declareRecoverableData ( const std::string &  data_name )

protectedinherited

Declare a piece of data as "recoverable".

This means that in the event of a recovery this piece of data will be restored back to its previous value.

Note - this data will NOT be restored on Restart!

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name

The name of the data (usually just use the same name as the member variable)

Definition at line 295 of file Restartable.h.

{
  std::string full_name = _restartable_system_name + "/" + _restartable_name + "/" + data_name;
 
  registerRestartableNameWithFilterOnApp(full_name, Moose::RESTARTABLE_FILTER::RECOVERABLE);
 
  return declareRestartableDataWithContext<T>(data_name, nullptr);
}

declareRecoverableData() [2/2]

template<typename T >

T & Restartable::declareRecoverableData ( const std::string &  data_name, const T &  init_value  )

protectedinherited

Declare a piece of data as "restartable" and initialize it.

This means that in the event of a restart this piece of data will be restored back to its previous value.

Note - this data will NOT be restored on Restart!

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
init_value	The initial value of the data

Definition at line 306 of file Restartable.h.

{
  std::string full_name = _restartable_system_name + "/" + _restartable_name + "/" + data_name;
 
  registerRestartableNameWithFilterOnApp(full_name, Moose::RESTARTABLE_FILTER::RECOVERABLE);
 
  return declareRestartableDataWithContext<T>(data_name, init_value, nullptr);
}

declareRestartableDataTempl() [1/2]

template<typename T >

T & Restartable::declareRestartableDataTempl ( const std::string &  data_name )

protectedinherited

Declare a piece of data as "restartable".

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name

The name of the data (usually just use the same name as the member variable)

Definition at line 222 of file Restartable.h.

{
  return declareRestartableDataWithContext<T>(data_name, nullptr);
}

declareRestartableDataTempl() [2/2]

template<typename T >

T & Restartable::declareRestartableDataTempl ( const std::string &  data_name, const T &  init_value  )

protectedinherited

Declare a piece of data as "restartable" and initialize it.

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
init_value	The initial value of the data

Definition at line 229 of file Restartable.h.

{
  return declareRestartableDataWithContext<T>(data_name, init_value, nullptr);
}

declareRestartableDataWithContext() [1/2]

template<typename T >

T & Restartable::declareRestartableDataWithContext ( const std::string &  data_name, const T &  init_value, void *  context  )

protectedinherited

Declare a piece of data as "restartable" and initialize it.

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
init_value	The initial value of the data
context	Context pointer that will be passed to the load and store functions

Definition at line 250 of file Restartable.h.

{
  std::string full_name = _restartable_system_name + "/" + _restartable_name + "/" + data_name;
 
  // Here we will create the RestartableData even though we may not use this instance.
  // If it's already in use, the App will return a reference to the existing instance and we'll
  // return that one instead. We might refactor this to have the app create the RestartableData
  // at a later date.
  auto data_ptr = libmesh_make_unique<RestartableData<T>>(full_name, context);
  auto & restartable_data_ref = static_cast<RestartableData<T> &>(
      registerRestartableDataOnApp(full_name, std::move(data_ptr), _restartable_tid));
 
  restartable_data_ref.set() = init_value;
  return restartable_data_ref.get();
}

declareRestartableDataWithContext() [2/2]

template<typename T >

T & Restartable::declareRestartableDataWithContext ( const std::string &  data_name, void *  context  )

protectedinherited

Declare a piece of data as "restartable".

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
context	Context pointer that will be passed to the load and store functions

Definition at line 236 of file Restartable.h.

{
  std::string full_name = _restartable_system_name + "/" + _restartable_name + "/" + data_name;
  auto data_ptr = libmesh_make_unique<RestartableData<T>>(full_name, context);
 
  // See comment in overloaded version of this function with "init_value"
  auto & restartable_data_ref = static_cast<RestartableData<T> &>(
      registerRestartableDataOnApp(full_name, std::move(data_ptr), _restartable_tid));
 
  return restartable_data_ref.get();
}

declareRestartableDataWithObjectName()

template<typename T >

T & Restartable::declareRestartableDataWithObjectName ( const std::string &  data_name, const std::string &  object_name  )

protectedinherited

Declare a piece of data as "restartable".

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
object_name	A supplied name for the object that is declaring this data.

Definition at line 270 of file Restartable.h.

{
  return declareRestartableDataWithObjectNameWithContext<T>(data_name, object_name, nullptr);
}

declareRestartableDataWithObjectNameWithContext()

template<typename T >

T & Restartable::declareRestartableDataWithObjectNameWithContext ( const std::string &  data_name, const std::string &  object_name, void *  context  )

protectedinherited

Declare a piece of data as "restartable".

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
object_name	A supplied name for the object that is declaring this data.
context	Context pointer that will be passed to the load and store functions

Definition at line 278 of file Restartable.h.

{
  std::string old_name = _restartable_name;
 
  _restartable_name = object_name;
 
  T & value = declareRestartableDataWithContext<T>(data_name, context);
 
  _restartable_name = old_name;
 
  return value;
}

declareRestartableDataWithPrefixOverrideAndContext()

template<typename T >

T& Restartable::declareRestartableDataWithPrefixOverrideAndContext ( const std::string &  data_name, const std::string &  prefix, void *  context  )

protectedinherited

Declare a piece of data as "restartable".

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
prefix	The prefix to prepend to the data_name, to retrieve data from another object.
context	Context pointer that will be passed to the load and store functions

enabled()

virtual bool MooseObject::enabled ( ) const

inlinevirtualinherited

Return the enabled status of the object.

Reimplemented in EigenKernel.

Definition at line 110 of file MooseObject.h.

{ return _enabled; }

Referenced by EigenKernel::enabled().

getCheckedPointerParam()

template<typename T >

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

inlineinherited

Verifies that the requested parameter exists and is not NULL and returns it to the caller.

The template parameter must be a pointer or an error will be thrown.

Definition at line 91 of file MooseObject.h.

  {
    return parameters().getCheckedPointerParam<T>(name, error_string);
  }

getMooseApp()

MooseApp& MooseObject::getMooseApp ( ) const

inlineinherited

Get the MooseApp this object is associated with.

Definition at line 105 of file MooseObject.h.

{ return _app; }

Referenced by MortarData::createMortarInterface(), Executioner::Executioner(), and ConsoleUtils::outputMeshInformation().

getParamTempl()

template<typename T >

const T & MooseObject::getParamTempl ( const std::string &  name ) const

inherited

Retrieve a parameter for the object.

Parameters

name	The name of the parameter

Returns

The value of the parameter

Definition at line 208 of file MooseObject.h.

{
  return InputParameters::getParamHelper(name, _pars, static_cast<T *>(0));
}

Referenced by FEProblemBase::addMaterialHelper(), ConstraintWarehouse::addObject(), EigenKernel::EigenKernel(), AttribThread::initFrom(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), Console::initialSetup(), ConsoleUtils::outputExecutionInformation(), and TimePeriod::TimePeriod().

init()

void PhysicsBasedPreconditioner::init ( )

virtual

Initialize data structures if not done so already.

Definition at line 177 of file PhysicsBasedPreconditioner.C.

{
  TIME_SECTION(_init_timer);
 
  // Tell libMesh that this is initialized!
  _is_initialized = true;
 
  const unsigned int num_systems = _systems.size();
 
  // If no order was specified, just solve them in increasing order
  if (_solve_order.size() == 0)
  {
    _solve_order.resize(num_systems);
    for (unsigned int i = 0; i < num_systems; i++)
      _solve_order[i] = i;
  }
 
  // Loop over variables
  for (unsigned int system_var = 0; system_var < num_systems; system_var++)
  {
    LinearImplicitSystem & u_system = *_systems[system_var];
 
    if (!_preconditioners[system_var])
      _preconditioners[system_var] =
          Preconditioner<Number>::build_preconditioner(MoosePreconditioner::_communicator);
 
    // we have to explicitly set the matrix in the preconditioner, because h-adaptivity could have
    // changed it and we have to work with the current one
    Preconditioner<Number> * preconditioner = _preconditioners[system_var].get();
    preconditioner->set_matrix(*u_system.matrix);
    preconditioner->set_type(_pre_type[system_var]);
 
    preconditioner->init();
  }
}

isParamValid()

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

inlineinherited

Test if the supplied parameter is valid.

Parameters

name	The name of the parameter to test

Definition at line 100 of file MooseObject.h.

{ return _pars.isParamValid(name); }

Referenced by AdvancedOutput::AdvancedOutput(), BicubicSplineFunction::BicubicSplineFunction(), GeneratedMesh::buildMesh(), DistributedGeneratedMesh::buildMesh(), CartesianMeshGenerator::CartesianMeshGenerator(), LibmeshPartitioner::clone(), OversampleOutput::cloneMesh(), ConstantVectorPostprocessor::ConstantVectorPostprocessor(), CSVReader::CSVReader(), DGKernelBase::DGKernelBase(), MultiAppNearestNodeTransfer::execute(), Executioner::Executioner(), Exodus::Exodus(), FEProblemBase::FEProblemBase(), FileOutput::FileOutput(), MultiApp::fillPositions(), FunctionDT::FunctionDT(), ExtraNodesetGenerator::generate(), RenameBoundaryGenerator::generate(), RenameBlockGenerator::generate(), BreakBoundaryOnSubdomainGenerator::generate(), ElementSubdomainIDGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), MeshSideSetGenerator::generate(), GeneratedMeshGenerator::generate(), ParsedSubdomainMeshGenerator::generate(), MeshExtruderGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), MultiAppNearestNodeTransfer::getLocalEntities(), MultiAppNearestNodeTransfer::getLocalEntitiesAndComponents(), MeshGenerator::getMesh(), MultiAppNearestNodeTransfer::getNearestNode(), EigenExecutionerBase::init(), IterationAdaptiveDT::init(), AdvancedOutput::initExecutionTypes(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), SolutionScalarAux::initialSetup(), SolutionAux::initialSetup(), MooseParsedVectorFunction::initialSetup(), Console::initialSetup(), Receiver::initialSetup(), SolutionFunction::initialSetup(), MooseParsedGradFunction::initialSetup(), MooseParsedFunction::initialSetup(), AdvancedOutput::initialSetup(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), IterationAdaptiveDT::IterationAdaptiveDT(), LeastSquaresFit::LeastSquaresFit(), LibmeshPartitioner::LibmeshPartitioner(), MatDiffusionBase< Real >::MatDiffusionBase(), MeshGeneratorMesh::MeshGeneratorMesh(), BreakBoundaryOnSubdomain::modify(), MeshExtruder::modify(), MeshSideSet::modify(), LowerDBlockFromSideset::modify(), AssignElementSubdomainID::modify(), ParsedSubdomainMeshModifier::modify(), RenameBlock::modify(), SubdomainBoundingBox::modify(), MooseMesh::MooseMesh(), EigenExecutionerBase::normalizeSolution(), Output::Output(), PetscOutput::PetscOutput(), PiecewiseBase::PiecewiseBase(), SolutionUserObject::readExodusII(), RenameBlock::RenameBlock(), RenameBlockGenerator::RenameBlockGenerator(), RenameBoundaryGenerator::RenameBoundaryGenerator(), SolutionUserObject::SolutionUserObject(), and TimePeriod::TimePeriod().

mooseDeprecated()

template<typename... Args>

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

inlineinherited

Definition at line 156 of file MooseObject.h.

  {
    moose::internal::mooseDeprecatedStream(_console, false, std::forward<Args>(args)...);
  }

Referenced by FEProblemBase::addArrayVariable(), FEProblemBase::addAuxArrayVariable(), FEProblemBase::addAuxScalarVariable(), FEProblemBase::addAuxVariable(), FEProblemBase::addScalarVariable(), FEProblemBase::addVariable(), ADFunctionPresetBC< compute_stage >::ADFunctionPresetBC(), ADPresetBC< compute_stage >::ADPresetBC(), ADPresetNodalBC< compute_stage >::ADPresetNodalBC(), FEProblemBase::advanceMultiApps(), MultiApp::appProblem(), MooseMesh::buildSideList(), ChangeOverTimestepPostprocessor::ChangeOverTimestepPostprocessor(), FEProblemBase::computeResidual(), MaterialBase::declarePropertyOlderTempl(), MaterialBase::declarePropertyOldTempl(), MooseMesh::elem(), MultiAppTransfer::execFlags(), UserForcingFunction::f(), FaceFaceConstraint< compute_stage >::FaceFaceConstraint(), FunctionDT::FunctionDT(), FunctionPresetBC::FunctionPresetBC(), RandomICBase::generateRandom(), Control::getExecuteOptions(), FEProblemBase::getNonlinearSystem(), Sampler::getSamples(), FEProblemBase::getUserObjects(), FEProblemBase::getVectorPostprocessorValue(), FEProblemBase::getVectorPostprocessorValueOld(), MatDiffusionBase< Real >::MatDiffusionBase(), NodalScalarKernel::NodalScalarKernel(), MooseMesh::node(), PercentChangePostprocessor::PercentChangePostprocessor(), PresetBC::PresetBC(), PresetNodalBC::PresetNodalBC(), Sampler::rand(), ReferenceResidualProblem::ReferenceResidualProblem(), MooseMesh::setBoundaryToNormalMap(), Exodus::setOutputDimension(), and UserForcingFunction::UserForcingFunction().

mooseError()

template<typename... Args>

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

inlineinherited

Definition at line 141 of file MooseObject.h.

  {
    std::ostringstream oss;
    moose::internal::mooseStreamAll(oss, std::forward<Args>(args)...);
    std::string msg = oss.str();
    callMooseErrorRaw(msg, &_app);
  }

Referenced by GridPartitioner::_do_partition(), PetscExternalPartitioner::_do_partition(), FEProblemBase::addConstraint(), ADDGKernel< compute_stage >::ADDGKernel(), FEProblemBase::addInitialCondition(), FEProblem::addLineSearch(), FEProblemBase::addLineSearch(), FEProblemBase::addOutput(), DiracKernel::addPointWithValidId(), FEProblemBase::addPostprocessor(), MooseMesh::addQuadratureNode(), FEProblemBase::addVectorPostprocessor(), MultiAppConservativeTransfer::adjustTransferedSolution(), MultiAppConservativeTransfer::adjustTransferedSolutionNearestPoint(), ADKernelTempl< T, compute_stage >::ADKernelTempl(), ADPiecewiseLinearInterpolationMaterial< compute_stage >::ADPiecewiseLinearInterpolationMaterial(), Output::advancedExecuteOn(), MooseVariableBase::allDofIndices(), MultiApp::appPostprocessorValue(), MultiApp::appProblem(), MultiApp::appProblemBase(), MultiApp::appUserObjectBase(), ArrayConstantIC::ArrayConstantIC(), ArrayDGKernel::ArrayDGKernel(), ArrayDiffusion::ArrayDiffusion(), ArrayFunctionIC::ArrayFunctionIC(), ArrayReaction::ArrayReaction(), ArrayTimeDerivative::ArrayTimeDerivative(), Function::average(), Axisymmetric2D3DSolutionFunction::Axisymmetric2D3DSolutionFunction(), BicubicSplineFunction::BicubicSplineFunction(), BoundingValueElementDamper::BoundingValueElementDamper(), BoundingValueNodalDamper::BoundingValueNodalDamper(), BoundsAux::BoundsAux(), BreakMeshByBlockGenerator::BreakMeshByBlockGenerator(), BreakMeshByBlockGeneratorBase::BreakMeshByBlockGeneratorBase(), MooseMesh::buildCoarseningMap(), PiecewiseBase::buildFromFile(), PiecewiseBase::buildFromXY(), PiecewiseLinearBase::buildInterpolation(), TiledMesh::buildMesh(), FileMesh::buildMesh(), DistributedGeneratedMesh::buildMesh(), GeneratedMesh::buildMesh(), SpiralAnnularMesh::buildMesh(), ImageMeshGenerator::buildMesh3D(), ImageMesh::buildMesh3D(), MooseMesh::buildMeshBaseObject(), MooseMesh::buildRefinementMap(), MooseMesh::buildSideList(), CartesianMeshGenerator::CartesianMeshGenerator(), ChangeOverTimePostprocessor::ChangeOverTimePostprocessor(), EigenExecutionerBase::chebyshev(), SubProblem::checkBlockMatProps(), SubProblem::checkBoundaryMatProps(), FEProblemBase::checkCoordinateSystems(), FEProblemBase::checkDependMaterialsHelper(), FEProblemBase::checkDisplacementOrders(), MaterialBase::checkExecutionStage(), BreakMeshByBlockBase::checkInputParameter(), Steady::checkIntegrity(), EigenExecutionerBase::checkIntegrity(), ExplicitTimeIntegrator::checkLinearConvergence(), FEProblemBase::checkProblemIntegrity(), MaterialBase::checkStatefulSanity(), FEProblemBase::checkUserObjects(), MultiAppTransfer::checkVariable(), LibmeshPartitioner::clone(), MooseMesh::clone(), ComparisonPostprocessor::comparisonIsTrue(), CompositeFunction::CompositeFunction(), ElementLpNormAux::compute(), ElementH1ErrorFunctionAux::compute(), NodalPatchRecovery::compute(), KernelBase::computeADOffDiagJacobian(), BlockWeightedPartitioner::computeElementWeight(), ArrayDGKernel::computeElemNeighJacobian(), ArrayDGKernel::computeElemNeighResidual(), TimeSequenceStepperBase::computeFailedDT(), IterationAdaptiveDT::computeFailedDT(), TimeStepper::computeFailedDT(), HistogramVectorPostprocessor::computeHistogram(), ArrayKernel::computeJacobian(), ArrayIntegratedBC::computeJacobian(), ArrayIntegratedBC::computeJacobianBlock(), ArrayDGKernel::computeOffDiagElemNeighJacobian(), ArrayKernel::computeOffDiagJacobian(), MaterialBase::computeProperties(), CoupledTiedValueConstraint::computeQpJacobian(), TiedValueConstraint::computeQpJacobian(), LinearNodalConstraint::computeQpJacobian(), EqualValueBoundaryConstraint::computeQpJacobian(), EqualValueEmbeddedConstraint::computeQpJacobian(), CoupledTiedValueConstraint::computeQpOffDiagJacobian(), EqualValueEmbeddedConstraint::computeQpOffDiagJacobian(), KernelValue::computeQpResidual(), ArrayKernel::computeResidual(), ArrayIntegratedBC::computeResidual(), FEProblemBase::computeResidualInternal(), FEProblemBase::computeResidualTag(), FEProblemBase::computeResidualType(), StatisticsVectorPostprocessor::computeStatValue(), MaterialBase::computeSubdomainProperties(), ActuallyExplicitEuler::computeTimeDerivatives(), ExplicitEuler::computeTimeDerivatives(), ImplicitEuler::computeTimeDerivatives(), BDF2::computeTimeDerivatives(), NewmarkBeta::computeTimeDerivatives(), CrankNicolson::computeTimeDerivatives(), LStableDirk2::computeTimeDerivatives(), LStableDirk3::computeTimeDerivatives(), ImplicitMidpoint::computeTimeDerivatives(), ExplicitTVDRK2::computeTimeDerivatives(), AStableDirk4::computeTimeDerivatives(), LStableDirk4::computeTimeDerivatives(), ExplicitRK2::computeTimeDerivatives(), PenetrationAux::computeValue(), ConcentricCircleMesh::ConcentricCircleMesh(), ConditionalEnableControl::ConditionalEnableControl(), TimeStepper::constrainStep(), CoupledForce::CoupledForce(), CoupledForceNodalKernel::CoupledForceNodalKernel(), SidesetInfoVectorPostprocessor::dataHelper(), DebugResidualAux::DebugResidualAux(), FunctorRelationshipManager::delete_remote_elements(), BicubicSplineFunction::derivative(), DerivativeSumMaterial::DerivativeSumMaterial(), DGKernel::DGKernel(), FunctorRelationshipManager::dofmap_reinit(), FEProblemBase::duplicateVariableCheck(), EigenProblem::EigenProblem(), Eigenvalues::Eigenvalues(), ElementalVariableValue::ElementalVariableValue(), ElementIntegerAux::ElementIntegerAux(), ElementQualityAux::ElementQualityAux(), MooseMesh::errorIfDistributedMesh(), SolutionUserObject::evalMeshFunction(), SolutionUserObject::evalMeshFunctionGradient(), SolutionUserObject::evalMultiValuedMeshFunction(), SolutionUserObject::evalMultiValuedMeshFunctionGradient(), MultiAppPostprocessorTransfer::execute(), DiscreteElementUserObject::execute(), MultiAppPostprocessorInterpolationTransfer::execute(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), ElementQualityChecker::execute(), NodalValueSampler::execute(), GreaterThanLessThanPostprocessor::execute(), MultiAppInterpolationTransfer::execute(), MultiAppUserObjectTransfer::execute(), InterfaceQpValueUserObject::execute(), PointValue::execute(), MultiAppPostprocessorToAuxScalarTransfer::execute(), MultiAppScalarToAuxScalarTransfer::execute(), MultiAppVariableValueSampleTransfer::execute(), FindValueOnLine::execute(), MultiAppNearestNodeTransfer::execute(), TimeExtremeValue::execute(), VectorPostprocessorComparison::execute(), LeastSquaresFit::execute(), LeastSquaresFitHistory::execute(), FEProblemBase::executeControls(), MultiAppVectorPostprocessorTransfer::executeFromMultiapp(), MultiAppVectorPostprocessorTransfer::executeToMultiapp(), Exodus::Exodus(), ExplicitSSPRungeKutta::ExplicitSSPRungeKutta(), FileOutput::FileOutput(), CentroidMultiApp::fillPositions(), MultiApp::fillPositions(), VerifyElementUniqueID::finalize(), VerifyNodalUniqueID::finalize(), DiscreteElementUserObject::finalize(), ElementQualityChecker::finalize(), MemoryUsage::finalize(), PointSamplerBase::finalize(), NearestPointIntegralVariablePostprocessor::finalize(), Transfer::find_sys(), BreakMeshByBlockBase::findFreeBoundaryId(), BreakMeshByBlockGeneratorBase::findFreeBoundaryId(), FunctionDT::FunctionDT(), FunctionMaterialBase::FunctionMaterialBase(), ParsedMaterialHelper::functionParse(), FunctionScalarAux::FunctionScalarAux(), FunctionScalarIC::FunctionScalarIC(), GapValueAux::GapValueAux(), WorkBalance::gather(), ExtraNodesetGenerator::generate(), RenameBoundaryGenerator::generate(), RenameBlockGenerator::generate(), ElementSubdomainIDGenerator::generate(), GeneratedMeshGenerator::generate(), CombinerGenerator::generate(), SideSetsFromBoundingBoxGenerator::generate(), MeshExtruderGenerator::generate(), StackGenerator::generate(), SpiralAnnularMeshGenerator::generate(), PatternedMeshGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), BoundingBoxNodeSetGenerator::generate(), GeneratedMesh::GeneratedMesh(), GeneratedMeshGenerator::GeneratedMeshGenerator(), RandomICBase::generateRandom(), GenericConstantMaterial::GenericConstantMaterial(), GenericFunctionMaterial::GenericFunctionMaterial(), DisplacedProblem::getArrayVariable(), FEProblemBase::getArrayVariable(), MooseMesh::getBoundaryID(), MultiApp::getBoundingBox(), MooseMesh::getCoarseningMap(), Control::getControllableParameterByName(), FEProblemBase::getCoordSystem(), PiecewiseConstant::getDirection(), FEProblemBase::getDistribution(), GhostingUserObject::getElementalValue(), ElementGenerator::getElemType(), MultiApp::getExecutioner(), FEProblemBase::getFunction(), SolutionUserObject::getLocalVarIndex(), SubProblem::getMatrixTagID(), AnnularMesh::getMaxInDimension(), DistributedGeneratedMesh::getMaxInDimension(), GeneratedMesh::getMaxInDimension(), FEProblemBase::getMaxQps(), FEProblemBase::getMaxShapeFunctions(), AnnularMesh::getMinInDimension(), DistributedGeneratedMesh::getMinInDimension(), GeneratedMesh::getMinInDimension(), MooseMesh::getNodeBlockIds(), MooseMesh::getNodeList(), FEProblemBase::getNonlinearSystem(), MooseMesh::getPairedBoundaryMapping(), ImageMesh::GetPixelInfo(), ImageMeshGenerator::GetPixelInfo(), InterfaceQpValueUserObject::getQpValue(), MaterialStdVectorAux::getRealValue(), MooseMesh::getRefinementMap(), FEProblemBase::getSampler(), DisplacedProblem::getScalarVariable(), FEProblemBase::getScalarVariable(), DisplacedProblem::getStandardVariable(), FEProblemBase::getStandardVariable(), MooseMesh::getSubdomainBoundaryIds(), MooseMesh::getSubdomainID(), DisplacedProblem::getSystem(), FEProblemBase::getSystem(), FEProblemBase::getUserObjectBase(), FEProblemBase::getUserObjectTempl(), NumRelationshipManagers::getValue(), PerformanceData::getValue(), Residual::getValue(), PerfGraphData::getValue(), LineValueSampler::getValue(), FindValueOnLine::getValueAtPoint(), SubProblem::getVariableHelper(), SubProblem::getVectorTagID(), DisplacedProblem::getVectorVariable(), FEProblemBase::getVectorVariable(), GhostingAux::GhostingAux(), MultiApp::globalAppToLocal(), MooseParsedVectorFunction::gradient(), AdvancedOutput::hasOutputHelper(), CrankNicolson::init(), CSVTimeSequenceStepper::init(), EigenExecutionerBase::init(), IterationAdaptiveDT::init(), Transient::init(), MooseMesh::init(), Sampler::init(), FEProblemBase::init(), NumPicardIterations::initialize(), PiecewiseLinearBase::initialSetup(), FullSolveMultiApp::initialSetup(), ReferenceResidualProblem::initialSetup(), MultiAppConservativeTransfer::initialSetup(), SolutionScalarAux::initialSetup(), SolutionAux::initialSetup(), Axisymmetric2D3DSolutionFunction::initialSetup(), Exodus::initialSetup(), SolutionFunction::initialSetup(), SolutionUserObject::initialSetup(), FEProblemBase::initialSetup(), AdvancedOutput::initOutputList(), AdvancedOutput::initShowHideLists(), MaterialBase::initStatefulProperties(), Function::integral(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), InterfaceTimeKernel::InterfaceTimeKernel(), AugmentSparsityOnInterface::internalInit(), EigenExecutionerBase::inversePowerIteration(), InversePowerMethod::InversePowerMethod(), IterationAdaptiveDT::IterationAdaptiveDT(), LayeredSideIntegral::LayeredSideIntegral(), LeastSquaresFit::LeastSquaresFit(), LibmeshPartitioner::LibmeshPartitioner(), LinearCombinationFunction::LinearCombinationFunction(), LinearCombinationPostprocessor::LinearCombinationPostprocessor(), LinearNodalConstraint::LinearNodalConstraint(), LineMaterialSamplerBase< Real >::LineMaterialSamplerBase(), LineSearch::lineSearch(), LineValueSampler::LineValueSampler(), LowerBoundNodalKernel::LowerBoundNodalKernel(), PNGOutput::makePNG(), MaterialRealTensorValueAux::MaterialRealTensorValueAux(), MaterialRealVectorValueAux::MaterialRealVectorValueAux(), MaterialStdVectorRealGradientAux::MaterialStdVectorRealGradientAux(), MaterialVectorPostprocessor::MaterialVectorPostprocessor(), Distribution::median(), FunctorRelationshipManager::mesh_reinit(), SubProblem::meshChanged(), MeshExtruder::MeshExtruder(), MeshExtruderGenerator::MeshExtruderGenerator(), MeshSideSetGenerator::MeshSideSetGenerator(), SideSetsFromNormals::modify(), SideSetsFromPoints::modify(), AddExtraNodeset::modify(), BreakMeshByBlockBase::modify(), MeshExtruder::modify(), AssignElementSubdomainID::modify(), SmoothMesh::modify(), AddAllSideSetsByNormals::modify(), ElementDeleterBase::modify(), ParsedSubdomainMeshModifier::modify(), RenameBlock::modify(), ImageSubdomain::modify(), OrientedSubdomainBoundingBox::modify(), BoundingBoxNodeSet::modify(), AddSideSetsFromBoundingBox::modify(), SubdomainBoundingBox::modify(), MooseGhostPointNeighbors::MooseGhostPointNeighbors(), MooseMesh::MooseMesh(), MooseVariableBase::MooseVariableBase(), MortarConstraintBase::MortarConstraintBase(), MultiAppPostprocessorTransfer::MultiAppPostprocessorTransfer(), NearestNodeDistanceAux::NearestNodeDistanceAux(), NearestNodeValueAux::NearestNodeValueAux(), RenameBlockGenerator::newBlockID(), RenameBlock::newBlockID(), RenameBlockGenerator::newBlockName(), RenameBlock::newBlockName(), NewmarkBeta::NewmarkBeta(), NodalConstraint::NodalConstraint(), NodalScalarKernel::NodalScalarKernel(), NodalVariableValue::NodalVariableValue(), NumDOFs::NumDOFs(), NumNonlinearIterations::NumNonlinearIterations(), NumVars::NumVars(), FunctorRelationshipManager::operator()(), RelationshipManager::operator==(), XDA::output(), SolutionHistory::output(), Exodus::output(), AdvancedOutput::outputElementalVariables(), AdvancedOutput::outputInput(), AdvancedOutput::outputNodalVariables(), AdvancedOutput::outputPostprocessors(), AdvancedOutput::outputScalarVariables(), AdvancedOutput::outputSystemInformation(), Console::outputVectorPostprocessors(), AdvancedOutput::outputVectorPostprocessors(), MooseObject::paramError(), PiecewiseBilinear::parse(), ParsedAddSideset::ParsedAddSideset(), ParsedAux::ParsedAux(), ParsedGenerateSideset::ParsedGenerateSideset(), ParsedODEKernel::ParsedODEKernel(), ParsedSubdomainMeshGenerator::ParsedSubdomainMeshGenerator(), ParsedSubdomainMeshModifier::ParsedSubdomainMeshModifier(), ExplicitTimeIntegrator::performExplicitSolve(), PetscExternalPartitioner::PetscExternalPartitioner(), PhysicsBasedPreconditioner(), PiecewiseBase::PiecewiseBase(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseLinearInterpolationMaterial::PiecewiseLinearInterpolationMaterial(), PiecewiseMulticonstant::PiecewiseMulticonstant(), PiecewiseMultiInterpolation::PiecewiseMultiInterpolation(), SolutionUserObject::pointValueGradientWrapper(), SolutionUserObject::pointValueWrapper(), LStableDirk2::postResidual(), LStableDirk3::postResidual(), ImplicitMidpoint::postResidual(), ExplicitTVDRK2::postResidual(), AStableDirk4::postResidual(), LStableDirk4::postResidual(), ExplicitRK2::postResidual(), Eigenvalue::postSolve(), Predictor::Predictor(), Transient::preExecute(), SolutionUserObject::readExodusII(), SolutionUserObject::readXda(), DerivativeParsedMaterialHelper::recurseDerivative(), FunctorRelationshipManager::redistribute(), ReferenceResidualProblem::ReferenceResidualProblem(), EqualValueEmbeddedConstraint::reinitConstraint(), RelativeSolutionDifferenceNorm::RelativeSolutionDifferenceNorm(), RenameBlock::RenameBlock(), RenameBlockGenerator::RenameBlockGenerator(), RenameBoundaryGenerator::RenameBoundaryGenerator(), RinglebMesh::RinglebMesh(), RinglebMeshGenerator::RinglebMeshGenerator(), ScalarComponentIC::ScalarComponentIC(), BicubicSplineFunction::secondDerivative(), FEProblemBase::setCoordSystem(), PiecewiseBase::setData(), EigenProblem::setEigenproblemType(), FEProblemSolve::setInnerSolve(), Sampler::setNumberOfCols(), Sampler::setNumberOfRandomSeeds(), Sampler::setNumberOfRows(), Exodus::setOutputDimensionInExodusWriter(), Split::setup(), TransientMultiApp::setupApp(), TimeSequenceStepperBase::setupSequence(), Transient::setupTimeIntegrator(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), SideSetsFromNormals::SideSetsFromNormals(), SideSetsFromNormalsGenerator::SideSetsFromNormalsGenerator(), SideSetsFromPoints::SideSetsFromPoints(), SideSetsFromPointsGenerator::SideSetsFromPointsGenerator(), SolutionTimeAdaptiveDT::SolutionTimeAdaptiveDT(), SolutionUserObject::SolutionUserObject(), PicardSolve::solve(), FullSolveMultiApp::solveStep(), SpatialAverageBase::SpatialAverageBase(), NearestPointIntegralVariablePostprocessor::spatialValue(), UserObject::spatialValue(), SpiralAnnularMesh::SpiralAnnularMesh(), SpiralAnnularMeshGenerator::SpiralAnnularMeshGenerator(), StitchedMesh::StitchedMesh(), NodalUserObject::subdomainSetup(), GeneralUserObject::subdomainSetup(), Constraint::subdomainSetup(), MaterialBase::subdomainSetup(), Console::systemInfoFlags(), TagMatrixAux::TagMatrixAux(), TagVectorAux::TagVectorAux(), Terminator::Terminator(), TestSetupPostprocessorDataActionFunction::TestSetupPostprocessorDataActionFunction(), ThreadedGeneralUserObject::ThreadedGeneralUserObject(), ThreadedGeneralUserObject::threadJoin(), DiscreteElementUserObject::threadJoin(), GeneralUserObject::threadJoin(), TiledMeshGenerator::TiledMeshGenerator(), Function::timeDerivative(), TimeExtremeValue::TimeExtremeValue(), TimePeriod::TimePeriod(), VectorPostprocessorVisualizationAux::timestepSetup(), MultiAppFieldTransfer::transfer(), MultiAppMeshFunctionTransfer::transferVariable(), MooseVariableScalar::uDot(), MooseVariableScalar::uDotDot(), MooseVariableScalar::uDotDotOld(), FEProblemBase::uDotDotOldRequested(), MooseVariableScalar::uDotOld(), FEProblemBase::uDotOldRequested(), EqualValueBoundaryConstraint::updateConstrainedNodes(), SolutionUserObject::updateExodusBracketingTimeIndices(), UpperBoundNodalKernel::UpperBoundNodalKernel(), NearestPointIntegralVariablePostprocessor::userObjectValue(), BoundingBoxIC::value(), Axisymmetric2D3DSolutionFunction::value(), ValueRangeMarker::ValueRangeMarker(), ValueThresholdMarker::ValueThresholdMarker(), MultiAppTransfer::variableIntegrityCheck(), VariableTimeIntegrationAux::VariableTimeIntegrationAux(), VectorNodalBC::VectorNodalBC(), VectorOfPostprocessors::VectorOfPostprocessors(), VectorPostprocessorFunction::VectorPostprocessorFunction(), MooseParsedGradFunction::vectorValue(), MooseParsedFunction::vectorValue(), VolumeHistogram::VolumeHistogram(), VTKOutput::VTKOutput(), DOFMapOutput::writeStreamToFile(), and Console::writeStreamToFile().

mooseInfo()

template<typename... Args>

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

inlineinherited

Definition at line 162 of file MooseObject.h.

  {
    moose::internal::mooseInfoStream(_console, std::forward<Args>(args)...);
  }

Referenced by AStableDirk4::AStableDirk4(), ExplicitRK2::ExplicitRK2(), ExplicitTVDRK2::ExplicitTVDRK2(), ParsedMaterialHelper::functionsOptimize(), ImplicitMidpoint::ImplicitMidpoint(), LStableDirk2::LStableDirk2(), LStableDirk3::LStableDirk3(), LStableDirk4::LStableDirk4(), PNGOutput::makeMeshFunc(), MooseObject::paramInfo(), DerivativeParsedMaterialHelper::recurseDerivative(), ReferenceResidualProblem::ReferenceResidualProblem(), and FEProblemBase::setRestartFile().

mooseWarning()

template<typename... Args>

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

inlineinherited

Definition at line 150 of file MooseObject.h.

  {
    moose::internal::mooseWarningStream(_console, std::forward<Args>(args)...);
  }

Referenced by CartesianMeshGenerator::CartesianMeshGenerator(), MultiAppTransfer::checkMultiAppExecuteOn(), OversampleOutput::cloneMesh(), GapValueAux::computeValue(), ElementQualityChecker::finalize(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), ElementSubdomainIDGenerator::generate(), MooseMesh::getBoundaryIDs(), FEProblemBase::getInterfaceMaterial(), FEProblemBase::getMaterial(), MooseMesh::getSubdomainIDs(), ReferenceResidualProblem::initialSetup(), DerivativeFunctionMaterialBase::initialSetup(), FEProblemBase::initialSetup(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), LeastSquaresFit::LeastSquaresFit(), MaterialVectorPostprocessor::MaterialVectorPostprocessor(), AssignElementSubdomainID::modify(), NewmarkBeta::NewmarkBeta(), NodalPatchRecovery::NodalPatchRecovery(), NonlocalIntegratedBC::NonlocalIntegratedBC(), NonlocalKernel::NonlocalKernel(), Output::Output(), MooseObject::paramWarning(), Executioner::problem(), MaterialBase::resetQpProperties(), FEProblemBase::sizeZeroes(), TransientMultiApp::solveStep(), Tecplot::Tecplot(), and Checkpoint::updateCheckpointFiles().

name()

virtual const std::string& MooseObject::name ( ) const

inlinevirtualinherited

Get the name of the object.

Returns

The name of the object TODO:MooseVariableToMooseObject (see #10601)

Reimplemented in MooseVariableBase.

Definition at line 70 of file MooseObject.h.

{ return _name; }

Referenced by GridPartitioner::_do_partition(), FEProblemBase::addADJacobianInterfaceMaterial(), FEProblemBase::addADJacobianMaterial(), FEProblemBase::addADKernel(), FEProblemBase::addADResidualInterfaceMaterial(), FEProblemBase::addADResidualMaterial(), Executioner::addAttributeReporter(), DumpObjectsProblem::addAuxKernel(), FEProblemBase::addAuxKernel(), DumpObjectsProblem::addAuxScalarKernel(), FEProblemBase::addAuxScalarKernel(), DisplacedProblem::addAuxVariable(), DumpObjectsProblem::addBoundaryCondition(), FEProblemBase::addBoundaryCondition(), DumpObjectsProblem::addConstraint(), FEProblemBase::addConstraint(), FEProblemBase::addDamper(), DumpObjectsProblem::addDGKernel(), FEProblemBase::addDGKernel(), DumpObjectsProblem::addDiracKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addDistribution(), DumpObjectsProblem::addFunction(), FEProblemBase::addFunction(), ADDGKernel< compute_stage >::ADDGKernel(), FEProblemBase::addIndicator(), DumpObjectsProblem::addInitialCondition(), FEProblemBase::addInitialCondition(), DumpObjectsProblem::addInterfaceKernel(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addInterfaceMaterial(), DumpObjectsProblem::addKernel(), FEProblemBase::addKernel(), FEProblemBase::addMarker(), DumpObjectsProblem::addMaterial(), FEProblemBase::addMaterial(), FEProblemBase::addMaterialHelper(), FEProblemBase::addMultiApp(), DumpObjectsProblem::addNodalKernel(), FEProblemBase::addNodalKernel(), FEProblemBase::addPostprocessor(), FEProblemBase::addPredictor(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), FEProblemBase::addSampler(), DumpObjectsProblem::addScalarKernel(), FEProblemBase::addScalarKernel(), FEProblemBase::addTimeIntegrator(), FEProblemBase::addTransfer(), FEProblemBase::addUserObject(), DisplacedProblem::addVariable(), FEProblemBase::addVectorPostprocessor(), ADKernelTempl< T, compute_stage >::ADKernelTempl(), Output::advancedExecuteOn(), MultiApp::appPostprocessorValue(), MultiApp::appProblem(), MultiApp::appProblemBase(), MultiApp::appUserObjectBase(), ArrayDGKernel::ArrayDGKernel(), DerivativeParsedMaterialHelper::assembleDerivatives(), AStableDirk4::AStableDirk4(), Function::average(), MultiApp::backup(), BreakMeshByBlockGenerator::BreakMeshByBlockGenerator(), ChangeOverTimePostprocessor::ChangeOverTimePostprocessor(), FEProblemBase::checkDependMaterialsHelper(), Damper::checkMinDamping(), MaterialBase::checkStatefulSanity(), CoarsenedPiecewiseLinear::CoarsenedPiecewiseLinear(), CompositeFunction::CompositeFunction(), MaterialBase::computeProperties(), MaterialBase::computeSubdomainProperties(), FEProblemBase::computeUserObjectByName(), VectorPostprocessorVisualizationAux::computeValue(), MultiApp::createApp(), MeshGenerator::declareMeshProperty(), FEProblemBase::declareVectorPostprocessorVector(), DOFMapOutput::demangle(), DerivativeSumMaterial::DerivativeSumMaterial(), DGKernel::DGKernel(), DGKernelBase::DGKernelBase(), DumpObjectsProblem::dumpObjectHelper(), ElementValueSampler::ElementValueSampler(), MooseMesh::errorIfDistributedMesh(), AB2PredictorCorrector::estimateTimeError(), SolutionUserObject::evalMeshFunction(), SolutionUserObject::evalMeshFunctionGradient(), SolutionUserObject::evalMultiValuedMeshFunction(), SolutionUserObject::evalMultiValuedMeshFunctionGradient(), MultiAppPostprocessorTransfer::execute(), StatisticsVectorPostprocessor::execute(), MultiAppPostprocessorInterpolationTransfer::execute(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), MultiAppVectorPostprocessorTransfer::execute(), MultiAppCopyTransfer::execute(), MultiAppMeshFunctionTransfer::execute(), MultiAppInterpolationTransfer::execute(), MultiAppUserObjectTransfer::execute(), PointValue::execute(), MultiAppScalarToAuxScalarTransfer::execute(), MultiAppPostprocessorToAuxScalarTransfer::execute(), MultiAppVariableValueSampleTransfer::execute(), MultiAppNearestNodeTransfer::execute(), HistogramVectorPostprocessor::execute(), MultiAppProjectionTransfer::execute(), Exodus::Exodus(), FancyExtruderGenerator::FancyExtruderGenerator(), MultiApp::fillPositions(), PointSamplerBase::finalize(), FunctionDT::FunctionDT(), FunctionPresetBC::FunctionPresetBC(), GeneralUserObject::GeneralUserObject(), LowerDBlockFromSidesetGenerator::generate(), GeneratedMeshGenerator::generate(), StitchedMeshGenerator::generate(), Material::getADMaterialPropertyTempl(), MultiApp::getBoundingBox(), MooseObject::getCheckedPointerParam(), Control::getControllableParameterByName(), Control::getControllableValue(), Control::getControllableValueByName(), DistributionInterface::getDistribution(), FEProblemBase::getDistribution(), DistributionInterface::getDistributionByName(), MultiApp::getExecutioner(), OutputWarehouse::getFileNumbers(), FEProblemBase::getFunction(), FEProblemBase::getInterfaceMaterial(), SolutionUserObject::getLocalVarIndex(), Marker::getMarkerValue(), FEProblemBase::getMaterial(), SubProblem::getMaterialPropertyBlockNames(), SubProblem::getMaterialPropertyBoundaryNames(), Material::getMaterialPropertyOlderTempl(), InterfaceMaterial::getMaterialPropertyOlderTempl(), NodalPatchRecovery::getMaterialPropertyOlderTempl(), AuxKernelTempl< ComputeValueType >::getMaterialPropertyOlderTempl(), Material::getMaterialPropertyOldTempl(), InterfaceMaterial::getMaterialPropertyOldTempl(), NodalPatchRecovery::getMaterialPropertyOldTempl(), AuxKernelTempl< ComputeValueType >::getMaterialPropertyOldTempl(), Material::getMaterialPropertyTempl(), InterfaceMaterial::getMaterialPropertyTempl(), NodalPatchRecovery::getMaterialPropertyTempl(), AuxKernelTempl< ComputeValueType >::getMaterialPropertyTempl(), MeshGenerator::getMesh(), InterfaceMaterial::getNeighborMaterialPropertyOld(), InterfaceMaterial::getNeighborMaterialPropertyOlder(), InterfaceMaterial::getNeighborMaterialPropertyTempl(), OutputWarehouse::getOutput(), MooseObject::getParamTempl(), GeneralUserObject::getPostprocessorValue(), FEProblemBase::getPostprocessorValue(), GeneralUserObject::getPostprocessorValueByName(), FEProblemBase::getPostprocessorValueOld(), FEProblemBase::getPostprocessorValueOlder(), FEProblemBase::getSampler(), FEProblemBase::getScatterVectorPostprocessorValue(), FEProblemBase::getScatterVectorPostprocessorValueOld(), Transient::getTimeStepperName(), InitialConditionBase::getUserObjectBase(), FEProblemBase::getUserObjectBase(), InitialConditionBase::getUserObjectByNameTempl(), InitialConditionBase::getUserObjectTempl(), FEProblemBase::getUserObjectTempl(), GeneralUserObject::getVectorPostprocessorValue(), FEProblemBase::getVectorPostprocessorValue(), GeneralUserObject::getVectorPostprocessorValueByName(), FEProblemBase::getVectorPostprocessorValueOld(), FEProblemBase::hasFunction(), AdvancedOutput::hasOutputHelper(), FEProblemBase::hasPostprocessor(), FEProblemBase::hasUserObject(), FEProblemBase::hasVectorPostprocessor(), FEProblemBase::init(), AdvancedOutput::initExecutionTypes(), AttribName::initFrom(), CSVReader::initialize(), StatisticsVectorPostprocessor::initialize(), HistogramVectorPostprocessor::initialize(), SolutionScalarAux::initialSetup(), MultiAppProjectionTransfer::initialSetup(), DerivativeFunctionMaterialBase::initialSetup(), MultiApp::initialSetup(), SolutionUserObject::initialSetup(), AdvancedOutput::initOutputList(), FEProblemBase::initPostprocessorData(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), MaterialBase::initStatefulProperties(), FEProblemBase::initVectorPostprocessorData(), Function::integral(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), Registry::isADObj(), MooseObject::isParamValid(), Registry::isRegisteredObj(), LinearCombinationFunction::LinearCombinationFunction(), Marker::Marker(), MatDiffusionBase< Real >::MatDiffusionBase(), MaterialDerivativeTestKernelBase< Real >::MaterialDerivativeTestKernelBase(), MaterialOutputAction::materialOutputHelper(), MaterialVectorPostprocessor::MaterialVectorPostprocessor(), Distribution::median(), MemoryUsageReporter::MemoryUsageReporter(), MeshSideSetGenerator::MeshSideSetGenerator(), ElementDeleterBase::modify(), MooseVariableInterface< Real >::MooseVariableInterface(), NodalValueSampler::NodalValueSampler(), NodalVariableValue::NodalVariableValue(), Registry::objData(), DOFMapOutput::output(), Output::Output(), AdvancedOutput::outputElementalVariables(), ConsoleUtils::outputExecutionInformation(), AdvancedOutput::outputInput(), AdvancedOutput::outputNodalVariables(), ConsoleUtils::outputOutputInformation(), Nemesis::outputPostprocessors(), Exodus::outputPostprocessors(), AdvancedOutput::outputPostprocessors(), AdvancedOutput::outputScalarVariables(), OversampleOutput::outputStep(), Output::outputStep(), AdvancedOutput::outputSystemInformation(), AdvancedOutput::outputVectorPostprocessors(), ParsedAddSideset::ParsedAddSideset(), ParsedAux::ParsedAux(), ParsedGenerateSideset::ParsedGenerateSideset(), ParsedODEKernel::ParsedODEKernel(), ParsedSubdomainMeshGenerator::ParsedSubdomainMeshGenerator(), ParsedSubdomainMeshModifier::ParsedSubdomainMeshModifier(), PointSamplerBase::PointSamplerBase(), MultiAppConservativeTransfer::postExecute(), PresetBC::PresetBC(), PresetNodalBC::PresetNodalBC(), Registry::registerObjectsTo(), FEProblemBase::registerRandomInterface(), MaterialBase::resetQpProperties(), MultiApp::restore(), ScalarComponentIC::ScalarComponentIC(), MooseMesh::setBoundaryName(), Control::setControllableValue(), Control::setControllableValueByName(), OutputWarehouse::setFileNumbers(), MooseMesh::setSubdomainName(), Split::setup(), TransientMultiApp::setupApp(), SideSetsFromNormalsGenerator::SideSetsFromNormalsGenerator(), SideSetsFromPointsGenerator::SideSetsFromPointsGenerator(), SideValueSampler::SideValueSampler(), TransientMultiApp::solveStep(), SpatialAverageBase::SpatialAverageBase(), UserObject::spatialValue(), StitchedMesh::StitchedMesh(), SubProblem::storeBoundaryDelayedCheckMatProp(), SubProblem::storeBoundaryMatPropName(), SubProblem::storeBoundaryZeroMatProp(), SubProblem::storeSubdomainDelayedCheckMatProp(), SubProblem::storeSubdomainMatPropName(), SubProblem::storeSubdomainZeroMatProp(), MaterialBase::subdomainSetup(), TaggingInterface::TaggingInterface(), ThreadedGeneralUserObject::ThreadedGeneralUserObject(), Function::timeDerivative(), VectorPostprocessorVisualizationAux::timestepSetup(), TransientMultiApp::TransientMultiApp(), MultiAppTransfer::variableIntegrityCheck(), and AdvancedOutput::wantOutput().

paramError()

template<typename... Args>

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

inherited

Emits an error prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

If this object's parameters were not created directly by the Parser, then this function falls back to the normal behavior of mooseError - only printing a message using the given args.

Definition at line 215 of file MooseObject.h.

{
  Moose::show_trace = false;
  mooseError(paramErrorMsg(param, std::forward<Args>(args)...));
  Moose::show_trace = true;
}

Referenced by ADDGKernel< compute_stage >::ADDGKernel(), ADIntegratedBCTempl< T, compute_stage >::ADIntegratedBCTempl(), ADKernelTempl< T, compute_stage >::ADKernelTempl(), ADVectorFunctionDirichletBC< compute_stage >::ADVectorFunctionDirichletBC(), AnnularMesh::AnnularMesh(), AnnularMeshGenerator::AnnularMeshGenerator(), ArrayDGKernel::ArrayDGKernel(), ArrayIntegratedBC::ArrayIntegratedBC(), ArrayKernel::ArrayKernel(), BlockWeightedPartitioner::BlockWeightedPartitioner(), checkComponent(), Coupleable::checkVar(), MultiAppTransfer::checkVariable(), CombinerGenerator::CombinerGenerator(), ConcentricCircleMeshGenerator::ConcentricCircleMeshGenerator(), ConstantVectorPostprocessor::ConstantVectorPostprocessor(), Coupleable::Coupleable(), DGKernel::DGKernel(), DGKernelBase::DGKernelBase(), Eigenvalue::Eigenvalue(), ElementValueSampler::ElementValueSampler(), Executioner::Executioner(), FancyExtruderGenerator::FancyExtruderGenerator(), RenameBoundaryGenerator::generate(), MeshCollectionGenerator::generate(), StackGenerator::generate(), StitchedMeshGenerator::generate(), CombinerGenerator::generate(), Sampler::getGlobalSamples(), Sampler::getLocalSamples(), Sampler::getNextLocalRow(), MultiApp::init(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), IntegratedBC::IntegratedBC(), InversePowerMethod::InversePowerMethod(), Kernel::Kernel(), PNGOutput::makeMeshFunc(), MeshCollectionGenerator::MeshCollectionGenerator(), MultiAppConservativeTransfer::MultiAppConservativeTransfer(), MultiAppInterpolationTransfer::MultiAppInterpolationTransfer(), MultiAppMeshFunctionTransfer::MultiAppMeshFunctionTransfer(), MultiAppNearestNodeTransfer::MultiAppNearestNodeTransfer(), MultiAppPostprocessorInterpolationTransfer::MultiAppPostprocessorInterpolationTransfer(), MultiAppPostprocessorToAuxScalarTransfer::MultiAppPostprocessorToAuxScalarTransfer(), MultiAppPostprocessorTransfer::MultiAppPostprocessorTransfer(), MultiAppProjectionTransfer::MultiAppProjectionTransfer(), MultiAppScalarToAuxScalarTransfer::MultiAppScalarToAuxScalarTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer(), MultiAppVariableValueSampleTransfer::MultiAppVariableValueSampleTransfer(), MultiAppVectorPostprocessorTransfer::MultiAppVectorPostprocessorTransfer(), NodalBC::NodalBC(), NodalEqualValueConstraint::NodalEqualValueConstraint(), NodalKernel::NodalKernel(), NodalValueSampler::NodalValueSampler(), PatchMeshGenerator::PatchMeshGenerator(), PatternedMeshGenerator::PatternedMeshGenerator(), PiecewiseFunctionTabulate::PiecewiseFunctionTabulate(), PlaneDeletionGenerator::PlaneDeletionGenerator(), RandomIC::RandomIC(), MooseMesh::setPartitioner(), MultiAppFieldTransfer::transfer(), Transfer::Transfer(), TransientMultiApp::TransientMultiApp(), VectorBodyForce::VectorBodyForce(), VectorFunctionDirichletBC::VectorFunctionDirichletBC(), and VectorFunctionIC::VectorFunctionIC().

paramErrorMsg()

template<typename... Args>

std::string MooseObject::paramErrorMsg ( const std::string &  param, Args...  args  ) const

inlineprivateinherited

Definition at line 185 of file MooseObject.h.

  {
    auto prefix = paramErrorPrefix(_pars, param);
    std::ostringstream oss;
    moose::internal::mooseStreamAll(oss, std::forward<Args>(args)...);
    std::string msg = oss.str();
 
    // Wrap error message to a separate line from prefix if it is about to
    // blow past 100 chars.  But only wrap if the prefix is long enough (12
    // chars) for the wrap to buy us much extra length.
    if ((prefix.size() > 12 && msg.size() + prefix.size() > 99) ||
        msg.find("\n") != std::string::npos)
    {
      if (prefix.size() > 0 && prefix[prefix.size() - 1] != ':')
        prefix += ":";
      return prefix + "\n    " + MooseUtils::replaceAll(msg, "\n", "\n    ");
    }
    return prefix + " " + msg;
  }

Referenced by MooseObject::paramError(), MooseObject::paramInfo(), and MooseObject::paramWarning().

parameters()

const InputParameters& MooseObject::parameters ( ) const

inlineinherited

Get the parameters of the object.

Returns

The parameters of the object

Definition at line 76 of file MooseObject.h.

{ return _pars; }

Referenced by FEProblemBase::addADJacobianInterfaceMaterial(), FEProblemBase::addADJacobianMaterial(), FEProblemBase::addADKernel(), FEProblemBase::addADResidualInterfaceMaterial(), FEProblemBase::addADResidualMaterial(), DumpObjectsProblem::addAuxKernel(), FEProblemBase::addAuxKernel(), DumpObjectsProblem::addAuxScalarKernel(), FEProblemBase::addAuxScalarKernel(), DisplacedProblem::addAuxVariable(), DumpObjectsProblem::addBoundaryCondition(), FEProblemBase::addBoundaryCondition(), DumpObjectsProblem::addConstraint(), FEProblemBase::addConstraint(), FEProblemBase::addDamper(), DumpObjectsProblem::addDGKernel(), FEProblemBase::addDGKernel(), DumpObjectsProblem::addDiracKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addDistribution(), DumpObjectsProblem::addFunction(), FEProblemBase::addFunction(), FEProblemBase::addIndicator(), DumpObjectsProblem::addInitialCondition(), FEProblemBase::addInitialCondition(), DumpObjectsProblem::addInterfaceKernel(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addInterfaceMaterial(), DumpObjectsProblem::addKernel(), FEProblemBase::addKernel(), FEProblem::addLineSearch(), FEProblemBase::addMarker(), DumpObjectsProblem::addMaterial(), FEProblemBase::addMaterial(), FEProblemBase::addMaterialHelper(), FEProblemBase::addMultiApp(), DumpObjectsProblem::addNodalKernel(), FEProblemBase::addNodalKernel(), FEProblemBase::addOutput(), FEProblemBase::addPostprocessor(), FEProblemBase::addPredictor(), FEProblemBase::addSampler(), DumpObjectsProblem::addScalarKernel(), FEProblemBase::addScalarKernel(), FEProblemBase::addTimeIntegrator(), FEProblemBase::addTransfer(), FEProblemBase::addUserObject(), DisplacedProblem::addVariable(), FEProblemBase::addVectorPostprocessor(), ADPiecewiseLinearInterpolationMaterial< compute_stage >::ADPiecewiseLinearInterpolationMaterial(), AdvancedOutput::AdvancedOutput(), ADVectorFunctionDirichletBC< compute_stage >::ADVectorFunctionDirichletBC(), AnnularMesh::AnnularMesh(), AnnularMeshGenerator::AnnularMeshGenerator(), assemble_l2(), Moose::assemble_matrix(), AuxKernelTempl< ComputeValueType >::AuxKernelTempl(), AuxScalarKernel::AuxScalarKernel(), BoundsAux::BoundsAux(), LibmeshPartitioner::clone(), OversampleOutput::cloneMesh(), Moose::compute_bounds(), Moose::compute_jacobian(), Moose::compute_nearnullspace(), Moose::compute_nullspace(), Moose::compute_postcheck(), Moose::compute_transpose_nullspace(), Console::Console(), DumpObjectsProblem::deduceNecessaryParameters(), DumpObjectsProblem::dumpObjectHelper(), EigenProblem::EigenProblem(), Eigenvalue::Eigenvalue(), Exodus::Exodus(), FEProblem::FEProblem(), GapValueAux::GapValueAux(), MooseObject::getCheckedPointerParam(), GhostingUserObject::GhostingUserObject(), MooseMesh::init(), BlockRestrictable::initializeBlockRestrictable(), FEProblemBase::initNullSpaceVectors(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), isValid(), LayeredSideIntegral::LayeredSideIntegral(), MooseVariableInterface< Real >::MooseVariableInterface(), NodeFaceConstraint::NodeFaceConstraint(), PatchMeshGenerator::PatchMeshGenerator(), PenetrationAux::PenetrationAux(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseLinearInterpolationMaterial::PiecewiseLinearInterpolationMaterial(), MultiAppProjectionTransfer::projectSolution(), RandomIC::RandomIC(), InputParameterWarehouse::removeInputParameters(), EigenProblem::scaleEigenvector(), FEProblem::setInputParametersFEProblem(), FEProblemBase::setInputParametersFEProblem(), DumpObjectsProblem::stringifyParameters(), Transient::Transient(), VectorBodyForce::VectorBodyForce(), VectorFunctionDirichletBC::VectorFunctionDirichletBC(), and VectorFunctionIC::VectorFunctionIC().

paramInfo()

template<typename... Args>

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

inherited

Emits an informational message prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

If this object's parameters were not created directly by the Parser, then this function falls back to the normal behavior of mooseInfo - only printing a message using the given args.

Definition at line 231 of file MooseObject.h.

{
  mooseInfo(paramErrorMsg(param, std::forward<Args>(args)...));
}

Referenced by TransientMultiApp::TransientMultiApp().

paramWarning()

template<typename... Args>

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

inherited

Emits a warning prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

If this object's parameters were not created directly by the Parser, then this function falls back to the normal behavior of mooseWarning - only printing a message using the given args.

Definition at line 224 of file MooseObject.h.

{
  mooseWarning(paramErrorMsg(param, std::forward<Args>(args)...));
}

Referenced by Executioner::Executioner().

registerRestartableDataOnApp()

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

privateinherited

Helper function for actually registering the restartable data.

Definition at line 48 of file Restartable.C.

{
  return _restartable_app.registerRestartableData(name, std::move(data), tid, false, false);
}

Referenced by Restartable::declareRestartableDataWithContext().

registerRestartableNameWithFilterOnApp()

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

privateinherited

Helper function for actually registering the restartable data.

Definition at line 56 of file Restartable.C.

{
  _restartable_app.registerRestartableNameWithFilter(name, filter);
}

Referenced by Restartable::declareRecoverableData().

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 51 of file PerfGraphInterface.C.

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

setup()

void PhysicsBasedPreconditioner::setup ( )

virtual

This is called every time the "operator might have changed".

This is essentially where you need to fill in your preconditioning matrix.

Definition at line 214 of file PhysicsBasedPreconditioner.C.

{
  const unsigned int num_systems = _systems.size();
 
  std::vector<JacobianBlock *> blocks;
 
  // Loop over variables
  for (unsigned int system_var = 0; system_var < num_systems; system_var++)
  {
    LinearImplicitSystem & u_system = *_systems[system_var];
 
    {
      JacobianBlock * block = new JacobianBlock(u_system, *u_system.matrix, system_var, system_var);
      blocks.push_back(block);
    }
 
    for (unsigned int diag = 0; diag < _off_diag[system_var].size(); diag++)
    {
      unsigned int coupled_var = _off_diag[system_var][diag];
      std::string coupled_name = _nl.system().variable_name(coupled_var);
 
      JacobianBlock * block =
          new JacobianBlock(u_system, *_off_diag_mats[system_var][diag], system_var, coupled_var);
      blocks.push_back(block);
    }
  }
 
  _fe_problem.computeJacobianBlocks(blocks);
 
  // cleanup
  for (auto & block : blocks)
    delete block;
}

type()

const std::string& MooseObject::type ( ) const

inlineinherited

Get the type of this object.

Returns

the name of the type of this object

Definition at line 63 of file MooseObject.h.

{ return _type; }

Referenced by FEProblemBase::addArrayVariable(), FEProblemBase::addAuxArrayVariable(), DumpObjectsProblem::addAuxKernel(), DumpObjectsProblem::addAuxScalarKernel(), FEProblemBase::addAuxScalarVariable(), FEProblemBase::addAuxVariable(), DumpObjectsProblem::addBoundaryCondition(), DumpObjectsProblem::addConstraint(), DumpObjectsProblem::addDGKernel(), DumpObjectsProblem::addDiracKernel(), FEProblemBase::addDistribution(), DumpObjectsProblem::addFunction(), FEProblemBase::addFunction(), DumpObjectsProblem::addInitialCondition(), DumpObjectsProblem::addInterfaceKernel(), DumpObjectsProblem::addKernel(), DumpObjectsProblem::addMaterial(), DumpObjectsProblem::addNodalKernel(), FEProblemBase::addPredictor(), FEProblemBase::addSampler(), DumpObjectsProblem::addScalarKernel(), FEProblemBase::addScalarVariable(), addSystem(), FEProblemBase::addTimeIntegrator(), FEProblemBase::addVariable(), FEProblemBase::advanceMultiApps(), FEProblemBase::backupMultiApps(), MooseMesh::buildRefinementAndCoarseningMaps(), FEProblemBase::computeAuxiliaryKernels(), DGKernel::computeElemNeighJacobian(), ArrayDGKernel::computeElemNeighJacobian(), ElemElemConstraint::computeElemNeighJacobian(), DGKernel::computeElemNeighResidual(), ElemElemConstraint::computeElemNeighResidual(), ArrayDGKernel::computeElemNeighResidual(), FEProblemBase::computeMultiAppsDT(), DGKernel::computeOffDiagElemNeighJacobian(), ArrayDGKernel::computeOffDiagElemNeighJacobian(), DGConvection::computeQpJacobian(), ArrayDGDiffusion::computeQpJacobian(), InterfaceReaction::computeQpJacobian(), TiedValueConstraint::computeQpJacobian(), CoupledTiedValueConstraint::computeQpJacobian(), DGDiffusion::computeQpJacobian(), LinearNodalConstraint::computeQpJacobian(), EqualValueBoundaryConstraint::computeQpJacobian(), EqualValueEmbeddedConstraint::computeQpJacobian(), CoupledTiedValueConstraint::computeQpOffDiagJacobian(), EqualValueEmbeddedConstraint::computeQpOffDiagJacobian(), ArrayDGKernel::computeQpOffDiagJacobian(), DGConvection::computeQpResidual(), ArrayDGDiffusion::computeQpResidual(), InterfaceReaction::computeQpResidual(), TiedValueConstraint::computeQpResidual(), CoupledTiedValueConstraint::computeQpResidual(), LinearNodalConstraint::computeQpResidual(), DGDiffusion::computeQpResidual(), EqualValueBoundaryConstraint::computeQpResidual(), EqualValueEmbeddedConstraint::computeQpResidual(), FEProblemBase::computeUserObjectByName(), FEProblemBase::computeUserObjects(), FEProblemBase::computeUserObjectsInternal(), DisplacedProblem::createQRules(), FEProblemBase::createQRules(), DumpObjectsProblem::deduceNecessaryParameters(), DumpObjectsProblem::dumpObjectHelper(), FEProblemBase::duplicateVariableCheck(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), FEProblemBase::execTransfers(), FEProblemBase::finishMultiAppStep(), ElementSubdomainIDGenerator::generate(), ElementGenerator::getElemType(), FEProblemBase::getInterfaceMaterial(), FEProblemBase::getMaterial(), FEProblemBase::getMaterialData(), FEProblemBase::getTransfers(), FEProblemBase::hasMultiApps(), AdvancedOutput::hasOutput(), FEProblemBase::incrementMultiAppTStep(), AdvancedOutput::initAvailableLists(), AdvancedOutput::initShowHideLists(), RelationshipManager::isType(), AssignElementSubdomainID::modify(), ControlOutput::output(), Gnuplot::output(), CSV::output(), Exodus::output(), Console::output(), Nemesis::output(), AdvancedOutput::output(), OversampleOutput::outputStep(), Output::outputStep(), FEProblemBase::outputStep(), FEProblemBase::restoreMultiApps(), FEProblemBase::setCoupling(), PerfGraphOutput::shouldOutput(), FileOutput::shouldOutput(), Output::shouldOutput(), AdvancedOutput::shouldOutput(), DisplacedProblem::updateGeomSearch(), FEProblemBase::updateGeomSearch(), and AdvancedOutput::wantOutput().

validParams()

InputParameters PhysicsBasedPreconditioner::validParams ( )

static

Constructor.

Initializes PhysicsBasedPreconditioner data structures

Definition at line 36 of file PhysicsBasedPreconditioner.C.

{
  InputParameters params = MoosePreconditioner::validParams();
 
  params.addRequiredParam<std::vector<std::string>>(
      "solve_order",
      "The order the block rows will be solved in.  Put the name of variables here "
      "to stand for solving that variable's block row.  A variable may appear more "
      "than once (to create cylces if you like).");
  params.addRequiredParam<std::vector<std::string>>("preconditioner", "TODO: docstring");
 
  params.addParam<std::vector<std::string>>(
      "off_diag_row",
      "The off diagonal row you want to add into the matrix, it will be associated "
      "with an off diagonal column from the same position in off_diag_colum.");
  params.addParam<std::vector<std::string>>("off_diag_column",
                                            "The off diagonal column you want to add into the "
                                            "matrix, it will be associated with an off diagonal "
                                            "row from the same position in off_diag_row.");
 
  return params;
}

Member Data Documentation

_app

MooseApp& MooseObject::_app

protectedinherited

The MooseApp this object is associated with.

Definition at line 172 of file MooseObject.h.

Referenced by GridPartitioner::_do_partition(), AB2PredictorCorrector::AB2PredictorCorrector(), Executioner::addAttributeReporter(), FEProblemBase::addMaterialHelper(), FEProblemBase::addMultiApp(), FEProblemBase::addOutput(), FEProblemBase::allowOutput(), AStableDirk4::AStableDirk4(), FileMesh::buildMesh(), MeshGeneratorMesh::buildMesh(), MooseMesh::buildMeshBaseObject(), FEProblemBase::checkNonlinearConvergence(), OversampleOutput::cloneMesh(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeResidualTags(), Console::Console(), TimeStepper::constrainStep(), MultiApp::createApp(), MeshGenerator::declareMeshProperty(), DumpObjectsProblem::dumpObjectHelper(), DumpObjectsProblem::dumpVariableHelper(), EigenExecutionerBase::EigenExecutionerBase(), EigenKernel::EigenKernel(), NonlinearEigen::execute(), InversePowerMethod::execute(), Transient::execute(), Steady::execute(), FileOutput::FileOutput(), FEProblemBase::forceOutput(), MeshGenerator::getMesh(), MeshGenerator::getMeshByName(), MooseObject::getMooseApp(), NumRelationshipManagers::getValue(), GhostingUserObject::GhostingUserObject(), NonlinearEigen::init(), InversePowerMethod::init(), Transient::init(), Steady::init(), MooseMesh::init(), NumPicardIterations::initialize(), TimePeriod::initialSetup(), Console::initialSetup(), MultiApp::initialSetup(), FEProblemBase::initialSetup(), AdvancedOutput::initOutputList(), FEProblemBase::initPetscOutput(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), ElementSideNeighborLayers::internalInit(), MeshGeneratorMesh::MeshGeneratorMesh(), MooseObject::mooseError(), EigenExecutionerBase::normalizeSolution(), AugmentSparsityOnInterface::operator()(), PerfGraphOutput::output(), Tecplot::output(), Exodus::output(), Nemesis::output(), ControlOutput::outputActiveObjects(), ControlOutput::outputChangedControls(), ControlOutput::outputControls(), Exodus::outputEmptyTimestep(), Console::outputInput(), Exodus::outputInput(), Exodus::outputNodalVariables(), OversampleOutput::outputStep(), Output::outputStep(), FEProblemBase::outputStep(), Console::outputSystemInformation(), MultiApp::parentOutputPositionChanged(), PerformanceData::PerformanceData(), PetscOutput::petscLinearOutput(), PetscOutput::petscNonlinearOutput(), Eigenvalue::postSolve(), Transient::preExecute(), FEProblemBase::projectSolution(), FEProblemBase::setRestartFile(), TransientMultiApp::setupApp(), TimeSequenceStepperBase::setupSequence(), Transient::setupTimeIntegrator(), TransientMultiApp::solveStep(), FEProblemBase::subdomainSetup(), FEProblemBase::theWarehouse(), TimeExtremeValue::TimeExtremeValue(), TimePeriod::TimePeriod(), FEProblemBase::timestepSetup(), Transient::Transient(), and Console::write().

_apply_timer

PerfID PhysicsBasedPreconditioner::_apply_timer

protected

Definition at line 101 of file PhysicsBasedPreconditioner.h.

Referenced by apply().

_console

const ConsoleStream ConsoleStreamInterface::_console

inherited

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

Definition at line 31 of file ConsoleStreamInterface.h.

Referenced by IterationAdaptiveDT::acceptStep(), Adaptivity::adaptMesh(), FEProblemBase::adaptMesh(), SimplePredictor::apply(), MultiApp::backup(), FEProblemBase::backupMultiApps(), ReferenceResidualProblem::checkNonlinearConvergence(), FEProblemBase::checkProblemIntegrity(), CoarsenedPiecewiseLinear::CoarsenedPiecewiseLinear(), IterationAdaptiveDT::computeAdaptiveDT(), Transient::computeConstrainedDT(), NonlinearSystemBase::computeDamping(), IterationAdaptiveDT::computeDT(), IterationAdaptiveDT::computeFailedDT(), IterationAdaptiveDT::computeInterpolationDT(), FEProblemBase::computeResidualTags(), NonlinearSystem::computeScaling(), IterationAdaptiveDT::constrainStep(), TimeStepper::constrainStep(), MultiApp::createApp(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), MultiAppPostprocessorTransfer::execute(), MultiAppPostprocessorInterpolationTransfer::execute(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), MultiAppVectorPostprocessorTransfer::execute(), MultiAppMeshFunctionTransfer::execute(), MultiAppCopyTransfer::execute(), MultiAppInterpolationTransfer::execute(), MultiAppUserObjectTransfer::execute(), MultiAppScalarToAuxScalarTransfer::execute(), MultiAppPostprocessorToAuxScalarTransfer::execute(), MultiAppVariableValueSampleTransfer::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppProjectionTransfer::execute(), Steady::execute(), ActionWarehouse::executeActionsWithAction(), ActionWarehouse::executeAllActions(), ElementQualityChecker::finalize(), FEProblemBase::finishMultiAppStep(), MultiApp::globalAppToLocal(), InversePowerMethod::init(), NonlinearEigen::init(), Steady::init(), FEProblemBase::initialAdaptMesh(), FEProblemBase::initialSetup(), EigenExecutionerBase::inversePowerIteration(), Transient::keepGoing(), IterationAdaptiveDT::limitDTByFunction(), IterationAdaptiveDT::limitDTToPostprocessorValue(), EigenExecutionerBase::makeBXConsistent(), Console::meshChanged(), MooseObject::mooseDeprecated(), MooseObject::mooseInfo(), MooseObject::mooseWarning(), PerfGraphOutput::output(), DOFMapOutput::output(), VariableResidualNormsDebugOutput::output(), Console::output(), ControlOutput::outputActiveObjects(), ControlOutput::outputChangedControls(), ControlOutput::outputControls(), Console::outputInput(), Console::outputPostprocessors(), Console::outputScalarVariables(), Console::outputSystemInformation(), FEProblemBase::possiblyRebuildGeomSearchPatches(), MultiAppConservativeTransfer::postExecute(), EigenExecutionerBase::postExecute(), AB2PredictorCorrector::postSolve(), ActionWarehouse::printActionDependencySets(), EigenExecutionerBase::printEigenvalue(), MaterialPropertyDebugOutput::printMaterialMap(), AutomaticMortarGeneration::projectMasterNodesSinglePair(), AutomaticMortarGeneration::projectSlaveNodesSinglePair(), SolutionTimeAdaptiveDT::rejectStep(), DT2::rejectStep(), MultiApp::restore(), FEProblemBase::restoreMultiApps(), SimplePredictor::shouldApply(), PicardSolve::solve(), NonlinearSystem::solve(), LStableDirk2::solve(), LStableDirk3::solve(), ImplicitMidpoint::solve(), ExplicitTVDRK2::solve(), AStableDirk4::solve(), LStableDirk4::solve(), ExplicitRK2::solve(), TransientMultiApp::solveStep(), PicardSolve::solveStep(), DT2::step(), AB2PredictorCorrector::step(), NonlinearEigen::takeStep(), Transient::takeStep(), Console::writeTimestepInformation(), Console::writeVariableNorms(), and FEProblemBase::~FEProblemBase().

_enabled

const bool& MooseObject::_enabled

protectedinherited

Reference to the "enable" InputParaemters, used by Controls for toggling on/off MooseObjects.

Definition at line 181 of file MooseObject.h.

Referenced by MooseObject::enabled().

_fe_problem

FEProblemBase& MoosePreconditioner::_fe_problem

protectedinherited

Subproblem this preconditioner is part of.

Definition at line 56 of file MoosePreconditioner.h.

Referenced by addSystem(), apply(), FieldSplitPreconditioner::FieldSplitPreconditioner(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), MoosePreconditioner::MoosePreconditioner(), PhysicsBasedPreconditioner(), setup(), and SingleMatrixPreconditioner::SingleMatrixPreconditioner().

_init_timer

PerfID PhysicsBasedPreconditioner::_init_timer

protected

Timers.

Definition at line 100 of file PhysicsBasedPreconditioner.h.

Referenced by init().

_name

const std::string& MooseObject::_name

protectedinherited

The name of this object, reference to value stored in InputParameters.

Definition at line 178 of file MooseObject.h.

Referenced by ADPiecewiseLinearInterpolationMaterial< compute_stage >::ADPiecewiseLinearInterpolationMaterial(), PiecewiseBase::buildFromFile(), PiecewiseBase::buildFromXY(), PiecewiseLinearBase::buildInterpolation(), CentroidMultiApp::fillPositions(), MultiApp::fillPositions(), FunctionDT::FunctionDT(), MooseObject::name(), PiecewiseBilinear::parse(), PiecewiseBase::PiecewiseBase(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseLinearInterpolationMaterial::PiecewiseLinearInterpolationMaterial(), DerivativeParsedMaterialHelper::recurseDerivative(), PiecewiseBase::setData(), Split::setup(), and VectorPostprocessorFunction::VectorPostprocessorFunction().

_nl

NonlinearSystemBase& PhysicsBasedPreconditioner::_nl

protected

The nonlinear system this PBP is associated with (convenience reference)

Definition at line 78 of file PhysicsBasedPreconditioner.h.

Referenced by addSystem(), apply(), PhysicsBasedPreconditioner(), and setup().

_off_diag

std::vector<std::vector<unsigned int> > PhysicsBasedPreconditioner::_off_diag

protected

Holds which off diagonal blocks to compute.

Definition at line 88 of file PhysicsBasedPreconditioner.h.

Referenced by addSystem(), apply(), PhysicsBasedPreconditioner(), and setup().

_off_diag_mats

std::vector<std::vector<SparseMatrix<Number> *> > PhysicsBasedPreconditioner::_off_diag_mats

protected

Holds pointers to the off-diagonal matrices.

This is in the same order as _off_diag.

This is really just for convenience so we don't have to keep looking this thing up through it's name.

Definition at line 97 of file PhysicsBasedPreconditioner.h.

Referenced by addSystem(), apply(), PhysicsBasedPreconditioner(), and setup().

_pars

const InputParameters& MooseObject::_pars

protectedinherited

Parameters of this object, references the InputParameters stored in the InputParametersWarehouse.

Definition at line 169 of file MooseObject.h.

Referenced by GridPartitioner::_do_partition(), BreakMeshByBlockGeneratorBase::BreakMeshByBlockGeneratorBase(), PNGOutput::calculateRescalingValues(), BreakMeshByBlockBase::checkInputParameter(), RandomPartitioner::clone(), PetscExternalPartitioner::clone(), BlockWeightedPartitioner::clone(), GridPartitioner::clone(), Console::Console(), Eigenvalue::execute(), Executioner::Executioner(), FEProblemSolve::FEProblemSolve(), FunctionMaterialBase::FunctionMaterialBase(), ParsedMaterialHelper::functionParse(), ExtraNodesetGenerator::generate(), MooseObject::getParamTempl(), GeneralUserObject::getPostprocessorValue(), InitialConditionBase::getUserObjectBase(), InitialConditionBase::getUserObjectTempl(), GeneralUserObject::getVectorPostprocessorValue(), Transient::init(), AdvancedOutput::initExecutionTypes(), Console::initialSetup(), MooseObject::isParamValid(), AddExtraNodeset::modify(), MooseObject::paramErrorMsg(), MooseObject::parameters(), MooseMesh::setPartitionerHelper(), and Transient::setupTimeIntegrator().

_perf_graph

PerfGraph& PerfGraphInterface::_perf_graph

protectedinherited

The performance graph to add to.

Definition at line 67 of file PerfGraphInterface.h.

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

_pg_params

const InputParameters* PerfGraphInterface::_pg_params

protectedinherited

Params.

Definition at line 64 of file PerfGraphInterface.h.

_pre_type

std::vector<PreconditionerType> PhysicsBasedPreconditioner::_pre_type

protected

Which preconditioner to use for each solve.

Definition at line 86 of file PhysicsBasedPreconditioner.h.

Referenced by addSystem(), init(), and PhysicsBasedPreconditioner().

_preconditioners

std::vector<std::unique_ptr<Preconditioner<Number> > > PhysicsBasedPreconditioner::_preconditioners

protected

Holds one Preconditioner object per small system to solve.

Definition at line 82 of file PhysicsBasedPreconditioner.h.

Referenced by apply(), init(), and PhysicsBasedPreconditioner().

_prefix

std::string PerfGraphInterface::_prefix

protectedinherited

A prefix to use for all sections.

Definition at line 70 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::registerTimedSection().

_restartable_app

MooseApp& Restartable::_restartable_app

privateinherited

Reference to the application.

Definition at line 208 of file Restartable.h.

Referenced by Restartable::registerRestartableDataOnApp(), and Restartable::registerRestartableNameWithFilterOnApp().

_restartable_name

std::string Restartable::_restartable_name

privateinherited

The name of the object.

Definition at line 211 of file Restartable.h.

Referenced by Restartable::declareRecoverableData(), Restartable::declareRestartableDataWithContext(), and Restartable::declareRestartableDataWithObjectNameWithContext().

_restartable_system_name

std::string Restartable::_restartable_system_name

privateinherited

The system name this object is in.

Definition at line 214 of file Restartable.h.

Referenced by Restartable::declareRecoverableData(), and Restartable::declareRestartableDataWithContext().

_restartable_tid

THREAD_ID Restartable::_restartable_tid

privateinherited

The thread ID for this object.

Definition at line 217 of file Restartable.h.

Referenced by Restartable::declareRestartableDataWithContext().

_solve_order

std::vector<unsigned int> PhysicsBasedPreconditioner::_solve_order

protected

Holds the order the blocks are solved for.

Definition at line 84 of file PhysicsBasedPreconditioner.h.

Referenced by apply(), init(), and PhysicsBasedPreconditioner().

_systems

std::vector<LinearImplicitSystem *> PhysicsBasedPreconditioner::_systems

protected

List of linear system that build up the preconditioner.

Definition at line 80 of file PhysicsBasedPreconditioner.h.

Referenced by addSystem(), apply(), init(), PhysicsBasedPreconditioner(), and setup().

_type

const std::string& MooseObject::_type

protectedinherited

The type of this object (the Class name)

Definition at line 175 of file MooseObject.h.

Referenced by FEProblemBase::init(), and MooseObject::type().

---

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

• include/preconditioners/PhysicsBasedPreconditioner.h
• src/preconditioners/PhysicsBasedPreconditioner.C