Interface for condensing out LMs for the dual mortar approach. More...

#include <VariableCondensationPreconditioner.h>

Inheritance diagram for VariableCondensationPreconditioner:

Public Types
using	DataFileParameterType = DataFileName
	The parameter type this interface expects for a data file name.

Public Member Functions
	VariableCondensationPreconditioner (const InputParameters &params)

virtual	~VariableCondensationPreconditioner ()

virtual void	init ()
	Initialize data structures if not done so already.

virtual void	setup ()
	This is called every time the "operator might have changed".

virtual void	apply (const NumericVector< Number > &y, NumericVector< Number > &x)
	Computes the preconditioned vector "x" based on input "y".

virtual void	clear ()
	Release all memory and clear data structures.

virtual void	initialSetup ()
	Perform some setup tasks such as storing the PETSc options.

virtual bool	enabled () const
	Return the enabled status of the object.

std::shared_ptr< MooseObject >	getSharedPtr ()
	Get another shared pointer to this object that has the same ownership group.

std::shared_ptr< const MooseObject >	getSharedPtr () const

bool	isKokkosObject () const
	Get whether this object is a Kokkos functor The parameter MooseBase::kokkos_object_param is set by the Kokkos base classes.

MooseApp &	getMooseApp () const
	Get the MooseApp this class is associated with.

const std::string &	type () const
	Get the type of this class.

const std::string &	name () const
	Get the name of the class.

std::string	typeAndName () const
	Get the class's combined type and name; useful in error handling.

MooseObjectParameterName	uniqueParameterName (const std::string &parameter_name) const

MooseObjectName	uniqueName () const

const InputParameters &	parameters () const
	Get the parameters of the object.

const hit::Node *	getHitNode () const

bool	hasBase () const

const std::string &	getBase () const

template<typename T >
const T &	getParam (const std::string &name) const
	Retrieve a parameter for the object.

template<typename T1 , typename T2 >
std::vector< std::pair< T1, T2 > >	getParam (const std::string &param1, const std::string &param2) const
	Retrieve two parameters and provide pair of parameters for the object.

template<typename T >
const T *	queryParam (const std::string &name) const
	Query a parameter for the object.

template<typename T >
const T &	getRenamedParam (const std::string &old_name, const std::string &new_name) const
	Retrieve a renamed parameter for the object.

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.

bool	isParamValid (const std::string &name) const
	Test if the supplied parameter is valid.

bool	isParamSetByUser (const std::string &name) const
	Test if the supplied parameter is set by a user, as opposed to not set or set to default.

void	connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const
	Connect controllable parameter of this action with the controllable parameters of the objects added by this action.

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.

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.

template<typename... Args>
void	paramWarning (const std::string &param, Args... args) const

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.

std::string	messagePrefix (const bool hit_prefix=true) const

std::string	errorPrefix (const std::string &) const
	Deprecated message prefix; the error type is no longer used.

template<typename... Args>
void	mooseError (Args &&... args) const
	Emits an error prefixed with object name and type and optionally a file path to the top-level block parameter if available.

template<typename... Args>
void	mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const

template<typename... Args>
void	mooseErrorNonPrefixed (Args &&... args) const
	Emits an error without the prefixing included in mooseError().

template<typename... Args>
void	mooseWarning (Args &&... args) const
	Emits a warning prefixed with object name and type.

template<typename... Args>
void	mooseWarning (Args &&... args) const

template<typename... Args>
void	mooseWarningNonPrefixed (Args &&... args) const
	Emits a warning without the prefixing included in mooseWarning().

template<typename... Args>
void	mooseWarningNonPrefixed (Args &&... args) const

template<typename... Args>
void	mooseDeprecated (Args &&... args) const
	Emits a deprecation warning prefixed with the object name and type, and a stack trace.

template<typename... Args>
void	mooseDeprecated (Args &&... args) const

template<typename... Args>
void	mooseDeprecatedNoTrace (Args &&... args) const
	Emits a deprecation warning prefixed with the object name and type, and no stack trace.

template<typename... Args>
void	mooseInfo (Args &&... args) const

void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) const
	External method for calling moose error with added object context.

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

std::string	getDataFileName (const std::string &param) const
	Deprecated method.

std::string	getDataFileNameByName (const std::string &relative_path) const
	Deprecated method.

std::string	getDataFilePath (const std::string &relative_path) const
	Returns the path of a data file for a given relative file path.

PerfGraph &	perfGraph ()
	Get the PerfGraph.

virtual bool	initialized () const

virtual void	apply (const NumericVector< T > &x, NumericVector< T > &y)=0

virtual void	zero ()

void	set_matrix (SparseMatrix< Number > &mat)

PreconditionerType	type () const

void	set_type (const PreconditionerType pct)

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Static Public Member Functions
static InputParameters	validParams ()

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.

static void	callMooseError (MooseApp const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node node, const bool show_trace=true)
	External method for calling moose error with added object context.

static std::unique_ptr< Preconditioner< T > >	build_preconditioner (const libMesh::Parallel::Communicator &comm, const SolverPackage solver_package=libMesh::default_solver_package())

static std::string	get_info ()

static void	print_info (std::ostream &out_stream=libMesh::out)

static unsigned int	n_objects ()

static void	enable_print_counter_info ()

static void	disable_print_counter_info ()

Public Attributes
	usingCombinedWarningSolutionWarnings

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

Static Public Attributes
static const std::string	type_param = "_type"
	The name of the parameter that contains the object type.

static const std::string	name_param = "_object_name"
	The name of the parameter that contains the object name.

static const std::string	unique_name_param = "_unique_name"
	The name of the parameter that contains the unique object name.

static const std::string	app_param = "_moose_app"
	The name of the parameter that contains the MooseApp.

static const std::string	moose_base_param = "_moose_base"
	The name of the parameter that contains the moose system base.

static const std::string	kokkos_object_param = "_kokkos_object"
	The name of the parameter that indicates an object is a Kokkos functor.

Protected Types
typedef std::map< std::string, std::pair< unsigned int, unsigned int > >	Counts

Protected Member Functions
void	setCouplingMatrix (std::unique_ptr< libMesh::CouplingMatrix > cm)
	Setup the coupling matrix on the finite element problem.

template<bool warning>
void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const
	Set solution invalid mark for the given solution ID.

InvalidSolutionID	registerInvalidSolutionInternal (const std::string &message, const bool warning) const

template<typename T , typename... Args>
T &	declareRestartableData (const std::string &data_name, Args &&... args)
	Declare a piece of data as "restartable" and initialize it.

template<typename T , typename... Args>
ManagedValue< T >	declareManagedRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)
	Declares a piece of "managed" restartable data and initialize it.

template<typename T , typename... Args>
const T &	getRestartableData (const std::string &data_name) const
	Declare a piece of data as "restartable" and initialize it Similar to `declareRestartableData` but returns a const reference to the object.

template<typename T , typename... Args>
T &	declareRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)
	Declare a piece of data as "restartable" and initialize it.

template<typename T , typename... Args>
T &	declareRecoverableData (const std::string &data_name, Args &&... args)
	Declare a piece of data as "recoverable" and initialize it.

template<typename T , typename... Args>
T &	declareRestartableDataWithObjectName (const std::string &data_name, const std::string &object_name, Args &&... args)
	Declare a piece of data as "restartable".

template<typename T , typename... Args>
T &	declareRestartableDataWithObjectNameWithContext (const std::string &data_name, const std::string &object_name, void *context, Args &&... args)
	Declare a piece of data as "restartable".

std::string	restartableName (const std::string &data_name) const
	Gets the name of a piece of restartable data given a data name, adding the system name and object name prefix.

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

PerfID	registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const
	Call to register a named section for timing.

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

void	increment_constructor_count (const std::string &name) noexcept

void	increment_destructor_count (const std::string &name) noexcept

Protected Attributes
FEProblemBase &	_fe_problem
	Subproblem this preconditioner is part of.

const unsigned int	_nl_sys_num
	The nonlinear system number whose linearization this preconditioner should be applied to.

const bool &	_enabled
	Reference to the "enable" InputParameters, used by Controls for toggling on/off MooseObjects.

MooseApp &	_app
	The MOOSE application this is associated with.

Factory &	_factory
	The Factory associated with the MooseApp.

ActionFactory &	_action_factory
	Builds Actions.

const std::string &	_type
	The type of this class.

const std::string &	_name
	The name of this class.

const InputParameters &	_pars
	The object's parameters.

const Parallel::Communicator &	_communicator

MooseApp &	_restartable_app
	Reference to the application.

const std::string	_restartable_system_name
	The system name this object is in.

const THREAD_ID	_restartable_tid
	The thread ID for this object.

const bool	_restartable_read_only
	Flag for toggling read only status (see ReporterData)

MooseApp &	_pg_moose_app
	The MooseApp that owns the PerfGraph.

const std::string	_prefix
	A prefix to use for all sections.

SparseMatrix< T > *	_matrix

PreconditionerType	_preconditioner_type

bool	_is_initialized

const Parallel::Communicator &	_communicator

Static Protected Attributes
static Counts	_counts

static Threads::atomic< unsigned int >	_n_objects

static Threads::spin_mutex	_mutex

static bool	_enable_print_counter

Private Member Functions
void	getDofToCondense ()
	Get dofs for the variable to be condensed out.

void	getDofColRow ()
	Get row and col dofs for the condensed system.

void	findZeroDiagonals (SparseMatrix< Number > &mat, std::vector< dof_id_type > &indices)
	Check if the original jacobian has zero diagonal entries and save the row indices.

void	condenseSystem ()
	Reconstruct the equation system.

void	preallocateCondensedJacobian (PetscMatrix< Number > &condensed_mat, PetscMatrix< Number > &original_mat, const std::vector< dof_id_type > &rows, const std::vector< dof_id_type > &cols, const std::vector< dof_id_type > &grows, const std::vector< dof_id_type > &gcols, PetscMatrix< Number > &block_mat)
	Preallocate memory for the condensed Jacobian matrix.

void	computeCondensedJacobian (PetscMatrix< Number > &condensed_mat, PetscMatrix< Number > &original_mat, const std::vector< dof_id_type > &grows, PetscMatrix< Number > &block_mat)
	The condensed Jacobian matrix is computed in this function.

void	computeDInverse (Mat &mat)
	Compute inverse of D using LU.

void	computeDInverseDiag (Mat &mat)
	Compute (approximate) inverse of D by inverting its diagonal entries.

void	getCondensedXY (const NumericVector< Number > &y, NumericVector< Number > &x)
	Get condensed x and y.

void	computeCondensedVariables ()
	Compute condensed variables (Lagrange multipliers) values using updated solution vector.

void	getFullSolution (const NumericVector< Number > &y, NumericVector< Number > &x)
	Assemble the full solution vector.

void	mergeArrays (const PetscInt a, const PetscInt b, const PetscInt &na, const PetscInt &nb, std::vector< PetscInt > &c)
	Find the common part of arrays `a` and `b` and save it in `c`.

RestartableDataValue &	registerRestartableDataOnApp (std::unique_ptr< RestartableDataValue > data, THREAD_ID tid) const
	Helper function for actually registering the restartable data.

void	registerRestartableNameWithFilterOnApp (const std::string &name, Moose::RESTARTABLE_FILTER filter)
	Helper function for actually registering the restartable data.

template<typename T , typename... Args>
RestartableData< T > &	declareRestartableDataHelper (const std::string &data_name, void *context, Args &&... args) const
	Helper function for declaring restartable data.

Static Private Member Functions
static const hit::Node *	getHitNode (const InputParameters &params)
	Internal method for getting a hit node (if available) given a set of parameters.

static std::string	messagePrefix (const InputParameters &params, const bool hit_prefix)
	Internal method for getting the message prefix for an object (object type, name, etc).

Private Attributes
NonlinearSystemBase &	_nl
	The nonlinear system this PC is associated with (convenience reference)

MooseMesh &	_mesh
	Mesh object for easy reference.

const libMesh::DofMap &	_dofmap
	DofMap for easy reference.

const bool	_is_lm_coupling_diagonal
	Whether the coupling is diagonal.

const bool	_adaptive_condensation
	Whether to condense all specified variable.

const unsigned int	_n_vars
	Number of variables.

const std::vector< std::string >	_lm_var_names
	Name and ID of the variables that are to be condensed out (usually the Lagrange multiplier variable)

std::vector< unsigned int >	_lm_var_ids

const std::vector< std::string >	_primary_var_names
	Name and ID of the corresponding coupled variable.

std::vector< unsigned int >	_primary_var_ids

std::unique_ptr< PetscMatrix< Number > >	_D
	Submatrices that are frequently needed while computing the condensed system _D: the submatrix that couples the primary variable with the Lagrange multiplier variable _M: the columns that correspond to the Lagrange multiplier DoFs _K: the rows that correspond to the primary variable DoFs.

std::unique_ptr< PetscMatrix< Number > >	_M

std::unique_ptr< PetscMatrix< Number > >	_K

Mat	_dinv
	inverse of _D

std::unique_ptr< PetscMatrix< Number > >	_J_condensed
	Condensed Jacobian.

std::unique_ptr< NumericVector< Number > >	_x_hat
	_x_hat, _y_hat: condensed solution and RHS vectors _primary_rhs_vec: part of the RHS vector that correspond to the primary variable DoFs _lm_sol_vec: solution vector that corresponds to the LM variable

std::unique_ptr< NumericVector< Number > >	_y_hat

std::unique_ptr< NumericVector< Number > >	_primary_rhs_vec

std::unique_ptr< NumericVector< Number > >	_lm_sol_vec

std::vector< dof_id_type >	_zero_rows
	The row indices that correspond to the zero diagonal entries in the original Jacobian matrix This is only used when _adaptive_condensation = true.

bool	_need_condense
	Whether the DoFs associated the variable are to be condensed.

libMesh::PreconditionerType	_pre_type
	Which preconditioner to use for the solve.

std::unique_ptr< Preconditioner< Number > >	_preconditioner
	Holds one Preconditioner object for the condensed system to solve.

std::vector< dof_id_type >	_global_lm_dofs
	Vectors of DoFs: indices associated with lagrange multipliers, and its coupled primary variable global<variable_name>_dofs represents the indices that are owned by all processors _<variable_name>_dofs represents the indices that are owned only by each processor lm: the Lagrange multiplier primary: the primal variable DoFs that couples with the Lagrange multiplier Note: the global index sets may not be scalable and necessary memory optimization will be investigated later.

std::vector< dof_id_type >	_lm_dofs

std::vector< dof_id_type >	_global_primary_dofs

std::vector< dof_id_type >	_primary_dofs

std::vector< dof_id_type >	_global_rows
	row and column indices for the condensed system

std::vector< dof_id_type >	_rows

std::vector< dof_id_type >	_global_cols

std::vector< dof_id_type >	_cols

std::unordered_map< dof_id_type, dof_id_type >	_global_rows_to_idx
	Maps to keep track of row and col indices from the original Jacobian matrix to the condensed Jacobian matrix.

std::unordered_map< dof_id_type, dof_id_type >	_rows_to_idx

std::unordered_map< dof_id_type, dof_id_type >	_global_cols_to_idx

std::unordered_map< dof_id_type, dof_id_type >	_cols_to_idx

std::unordered_map< dof_id_type, dof_id_type >	_map_global_lm_primary
	Maps to keep track of the dof orders for keeping nonzero diagonal entries of the condensed system _map_global_lm_primary: map between _global_lm_dofs and _global_primary_dofs.

std::unordered_map< dof_id_type, dof_id_type >	_map_global_primary_order

PerfID	_init_timer
	Timers.

PerfID	_apply_timer

const ParallelParamObject &	_parent

const MooseBase &	_si_moose_base
	The MooseBase that owns this interface.

const FEProblemBase *	_si_problem
	A pointer to FEProblem base.

const RestartableDataMapName	_metaname
	Restartable metadata name.

std::string	_restartable_name
	The name of the object.

Detailed Description

Interface for condensing out LMs for the dual mortar approach.

Definition at line 33 of file VariableCondensationPreconditioner.h.

Member Typedef Documentation

◆ DataFileParameterType

using DataFileInterface::DataFileParameterType = DataFileName

inherited

The parameter type this interface expects for a data file name.

Definition at line 27 of file DataFileInterface.h.

Constructor & Destructor Documentation

◆ VariableCondensationPreconditioner()

VariableCondensationPreconditioner::VariableCondensationPreconditioner ( const InputParameters & params )

Definition at line 79 of file VariableCondensationPreconditioner.C.

  : MoosePreconditioner(params),
    Preconditioner<Number>(MoosePreconditioner::_communicator),
    _nl(_fe_problem.getNonlinearSystemBase(_nl_sys_num)),
    _mesh(_fe_problem.mesh()),
    _dofmap(_nl.system().get_dof_map()),
    _is_lm_coupling_diagonal(getParam<bool>("is_lm_coupling_diagonal")),
    _adaptive_condensation(getParam<bool>("adaptive_condensation")),
    _n_vars(_nl.nVariables()),
    _lm_var_names(getParam<std::vector<std::string>>("lm_variable")),
    _primary_var_names(getParam<std::vector<std::string>>("primary_variable")),
    _D(std::make_unique<PetscMatrix<Number>>(MoosePreconditioner::_communicator)),
    _M(std::make_unique<PetscMatrix<Number>>(MoosePreconditioner::_communicator)),
    _K(std::make_unique<PetscMatrix<Number>>(MoosePreconditioner::_communicator)),
    _dinv(nullptr),
    _J_condensed(std::make_unique<PetscMatrix<Number>>(MoosePreconditioner::_communicator)),
    _x_hat(NumericVector<Number>::build(MoosePreconditioner::_communicator)),
    _y_hat(NumericVector<Number>::build(MoosePreconditioner::_communicator)),
    _primary_rhs_vec(NumericVector<Number>::build(MoosePreconditioner::_communicator)),
    _lm_sol_vec(NumericVector<Number>::build(MoosePreconditioner::_communicator)),
    _need_condense(true),
    _init_timer(registerTimedSection("init", 2)),
    _apply_timer(registerTimedSection("apply", 1))
{
  if (_lm_var_names.size() != _primary_var_names.size())
    paramError("coupled_variable", "coupled_variable should have the same size as the variable.");
 
  if (!_mesh.getMesh().is_replicated())
    mooseError("The VariableCondensationPreconditioner cannot be used with DistributedMesh");
 
  // get variable ids from the variable names
  for (const auto & var_name : _lm_var_names)
  {
    if (!_nl.system().has_variable(var_name))
      paramError("variable ", var_name, " does not exist in the system");
    const unsigned int id = _nl.system().variable_number(var_name);
    _lm_var_ids.push_back(id);
  }
 
  // get coupled variable ids from the coupled variable names
  for (const auto & var_name : _primary_var_names)
  {
    if (!_nl.system().has_variable(var_name))
      paramError("coupled_variable ", var_name, " does not exist in the system");
    const unsigned int id = _nl.system().variable_number(var_name);
    _primary_var_ids.push_back(id);
  }
 
  // PC type
  const std::vector<std::string> & pc_type = getParam<std::vector<std::string>>("preconditioner");
  if (pc_type.size() > 1)
    mooseWarning("We only use one preconditioner type in VCP, the ",
                 pc_type[0],
                 " preconditioner is utilized.");
  _pre_type = Utility::string_to_enum<PreconditionerType>(pc_type[0]);
 
  // The following obtains and sets the coupling matrix.
  // TODO: This part can be refactored together with what are in other classes, e.g.,
  // PhysicsBasedPreconditioner
  std::unique_ptr<CouplingMatrix> cm = std::make_unique<CouplingMatrix>(_n_vars);
  const bool full = getParam<bool>("full");
 
  if (!full)
  {
    // put 1s on diagonal
    for (const auto i : make_range(_n_vars))
      (*cm)(i, i) = 1;
 
    // off-diagonal entries from the off_diag_row and off_diag_column parameters
    std::vector<std::vector<unsigned int>> off_diag(_n_vars);
    if (isParamValid("off_diag_row") && isParamValid("off_diag_column"))
 
      for (const auto i : index_range(getParam<std::vector<NonlinearVariableName>>("off_diag_row")))
      {
        const unsigned int row =
            _nl.getVariable(0, getParam<std::vector<NonlinearVariableName>>("off_diag_row")[i])
                .number();
        const unsigned int column =
            _nl.getVariable(0, getParam<std::vector<NonlinearVariableName>>("off_diag_column")[i])
                .number();
        (*cm)(row, column) = 1;
      }
 
    // off-diagonal entries from the coupled_groups parameters
    for (const auto & coupled_group :
         getParam<std::vector<NonlinearVariableName>>("coupled_groups"))
    {
      std::vector<NonlinearVariableName> vars;
      MooseUtils::tokenize<NonlinearVariableName>(coupled_group, vars, 1, ",");
      for (unsigned int j : index_range(vars))
        for (unsigned int k = j + 1; k < vars.size(); ++k)
        {
          const unsigned int row = _nl.getVariable(0, vars[j]).number();
          const unsigned int column = _nl.getVariable(0, vars[k]).number();
          (*cm)(row, column) = 1;
          (*cm)(column, row) = 1;
        }
    }
  }
  else
  {
    for (unsigned int i = 0; i < _n_vars; i++)
      for (unsigned int j = 0; j < _n_vars; j++)
        (*cm)(i, j) = 1;
  }
 
  setCouplingMatrix(std::move(cm));
 
  _nl.attachPreconditioner(this);
}

◆ ~VariableCondensationPreconditioner()

VariableCondensationPreconditioner::~VariableCondensationPreconditioner ( )

virtual

Definition at line 191 of file VariableCondensationPreconditioner.C.

191{ this->clear(); }

VariableCondensationPreconditioner::clear

virtual void clear()

Release all memory and clear data structures.

Definition VariableCondensationPreconditioner.C:756

Member Function Documentation

◆ apply()

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

virtual

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

Usually by solving Px=y to get the action of P^-1 y.

Definition at line 624 of file VariableCondensationPreconditioner.C.

{
  TIME_SECTION(_apply_timer);
 
  if (_need_condense)
  {
    getCondensedXY(y, x);
 
    _preconditioner->apply(*_y_hat, *_x_hat);
 
    computeCondensedVariables();
 
    getFullSolution(y, x);
  }
  else
  {
    _preconditioner->apply(y, x);
  }
}

◆ callMooseError() [1/2]

void MooseBase::callMooseError	(	MooseApp *const	app,
		const InputParameters &	params,
		std::string	msg,
		const bool	with_prefix,
		const hit::Node *	node,
		const bool	show_trace = `true`
	)

staticinherited

External method for calling moose error with added object context.

Needed so that objects without the MooseBase context (InputParameters) can call errors with context

Parameters

app	The app pointer (if available); adds multiapp context and clears the console
params	The parameters, needed to obtain object information
msg	The message
with_prefix	If true, add the prefix from messagePrefix(), which is the object information (type, name, etc)
node	Optional hit node to add file path context as a prefix
show_trace	Whether or not to show a stack trace, defaults to true

Definition at line 114 of file MooseBase.C.

{
  if (!node)
    node = MooseBase::getHitNode(params);
 
  std::string multiapp_prefix = "";
  if (app)
  {
    if (!app->isUltimateMaster())
      multiapp_prefix = app->name();
    app->getOutputWarehouse().mooseConsole();
  }
 
  if (with_prefix)
    // False here because the hit context will get processed by the node
    msg = messagePrefix(params, false) + msg;
 
  moose::internal::mooseErrorRaw(msg, multiapp_prefix, node, show_trace);
}

◆ callMooseError() [2/2]

void MooseBase::callMooseError	(	std::string	msg,
		const bool	with_prefix,
		const hit::Node *	node = `nullptr`,
		const bool	show_trace = `true`
	)		const

inherited

External method for calling moose error with added object context.

Parameters

msg	The message
with_prefix	If true, add the prefix from messagePrefix(), which is the object information (type, name, etc)
node	Optional hit node to add file path context as a prefix
show_trace	Whether or not to show a stack trace, defaults to true

Definition at line 105 of file MooseBase.C.

{
  callMooseError(&_app, _pars, msg, with_prefix, node, show_trace);
}

Referenced by MooseBase::callMooseError(), InputParameters::callMooseError(), MooseBase::mooseDocumentedError(), MooseBase::mooseError(), and MooseBase::mooseErrorNonPrefixed().

◆ clear()

void VariableCondensationPreconditioner::clear ( )

virtual

Release all memory and clear data structures.

Reimplemented from libMesh::Preconditioner< Number >.

Definition at line 756 of file VariableCondensationPreconditioner.C.

{
  if (_dinv != nullptr)
    LibmeshPetscCallA(this->MoosePreconditioner::comm().get(), MatDestroy(&_dinv));
}

Referenced by ~VariableCondensationPreconditioner().

◆ computeCondensedJacobian()

void VariableCondensationPreconditioner::computeCondensedJacobian	(	PetscMatrix< Number > &	condensed_mat,
		PetscMatrix< Number > &	original_mat,
		const std::vector< dof_id_type > &	grows,
		PetscMatrix< Number > &	block_mat
	)

private

The condensed Jacobian matrix is computed in this function.

Definition at line 398 of file VariableCondensationPreconditioner.C.

{
  // obtain entries from the original matrix
  PetscInt pc_ncols = 0, block_ncols = 0;
  const PetscInt *pc_cols, *block_cols;
  const PetscScalar *pc_vals, *block_vals;
 
  // containers for the data
  std::vector<PetscInt> sub_cols;
  std::vector<PetscScalar> sub_vals;
 
  for (const auto & i : index_range(grows))
  {
    PetscInt sub_rid[] = {static_cast<PetscInt>(i)};
    PetscInt rid = grows[i];
    if (grows[i] >= original_mat.row_start() && grows[i] < original_mat.row_stop())
    {
      // get one row of data from the original matrix
      LibmeshPetscCallA(this->MoosePreconditioner::comm().get(),
                        MatGetRow(original_mat.mat(), rid, &pc_ncols, &pc_cols, &pc_vals));
      // get corresponding row of data from the block matrix
      LibmeshPetscCallA(this->MoosePreconditioner::comm().get(),
                        MatGetRow(block_mat.mat(), i, &block_ncols, &block_cols, &block_vals));
      // extract data from certain cols, subtract the value from the block mat, and save the indices
      // and entries sub_cols and sub_vals
      // First, save the submatrix col index and value as a map
      std::map<PetscInt, PetscScalar> pc_col_map;
      for (PetscInt pc_idx = 0; pc_idx < pc_ncols; pc_idx++)
      {
        // save only if the col exists in the condensed matrix
        if (_global_cols_to_idx.find(pc_cols[pc_idx]) != _global_cols_to_idx.end())
          pc_col_map.insert(std::make_pair(_global_cols_to_idx[pc_cols[pc_idx]], pc_vals[pc_idx]));
      }
      // Second, check the block cols and calculate new entries for the condensed system
      for (PetscInt block_idx = 0; block_idx < block_ncols; block_idx++)
      {
        PetscInt block_col = block_cols[block_idx];
        PetscScalar block_val = block_vals[block_idx];
        // if the block mat has nonzero at the same column, subtract value
        // otherwise, create a new key and save the negative value from the block matrix
        if (pc_col_map.find(block_col) != pc_col_map.end())
          pc_col_map[block_col] -= block_val;
        else
          pc_col_map[block_col] = -block_val;
      }
 
      // Third, save keys in the sub_cols and values in the sub_vals
      for (std::map<PetscInt, PetscScalar>::iterator it = pc_col_map.begin();
           it != pc_col_map.end();
           ++it)
      {
        sub_cols.push_back(it->first);
        sub_vals.push_back(it->second);
      }
 
      // Then, set values
      LibmeshPetscCallA(this->MoosePreconditioner::comm().get(),
                        MatSetValues(condensed_mat.mat(),
                                     1,
                                     sub_rid,
                                     sub_vals.size(),
                                     sub_cols.data(),
                                     sub_vals.data(),
                                     INSERT_VALUES));
      LibmeshPetscCallA(this->MoosePreconditioner::comm().get(),
                        MatRestoreRow(original_mat.mat(), rid, &pc_ncols, &pc_cols, &pc_vals));
      LibmeshPetscCallA(this->MoosePreconditioner::comm().get(),
                        MatRestoreRow(block_mat.mat(), i, &block_ncols, &block_cols, &block_vals));
      // clear data for this row
      sub_cols.clear();
      sub_vals.clear();
    }
  }
  condensed_mat.close();
}

Referenced by condenseSystem().

◆ computeCondensedVariables()

void VariableCondensationPreconditioner::computeCondensedVariables ( )

private

Compute condensed variables (Lagrange multipliers) values using updated solution vector.

Definition at line 682 of file VariableCondensationPreconditioner.C.

{
  _lm_sol_vec->clear();
 
  PetscMatrix<Number> Dinv(_dinv, MoosePreconditioner::_communicator);
 
  _lm_sol_vec->init(_D->m(), _D->local_m(), false, PARALLEL);
 
  std::unique_ptr<NumericVector<Number>> K_xhat(
      NumericVector<Number>::build(MoosePreconditioner::_communicator));
  K_xhat->init(_K->m(), _K->local_m(), false, PARALLEL);
  _K->vector_mult(*K_xhat, *_x_hat);
  K_xhat->close();
 
  (*_primary_rhs_vec) -= (*K_xhat);
  _primary_rhs_vec->close();
  Dinv.vector_mult(*_lm_sol_vec, *_primary_rhs_vec);
  _lm_sol_vec->close();
}

Referenced by apply().

◆ computeDInverse()

void VariableCondensationPreconditioner::computeDInverse ( Mat & mat )

private

Compute inverse of D using LU.

This method is used when _is_lm_coupling_diagonal = false.

Definition at line 763 of file VariableCondensationPreconditioner.C.

{
  Mat F, I, dinv_dense;
  IS perm, iperm;
  MatFactorInfo info;
 
  LibmeshPetscCallA(
      this->MoosePreconditioner::comm().get(),
      MatCreateDense(
          PETSC_COMM_WORLD, _D->local_n(), _D->local_m(), _D->n(), _D->m(), NULL, &dinv_dense));
 
  // Create an identity matrix as the right-hand-side
  LibmeshPetscCallA(
      this->MoosePreconditioner::comm().get(),
      MatCreateDense(PETSC_COMM_WORLD, _D->local_m(), _D->local_m(), _D->m(), _D->m(), NULL, &I));
 
  for (unsigned int i = 0; i < _D->m(); ++i)
    LibmeshPetscCallA(this->MoosePreconditioner::comm().get(),
                      MatSetValue(I, i, i, 1.0, INSERT_VALUES));
 
  LibmeshPetscCallA(this->MoosePreconditioner::comm().get(),
                    MatAssemblyBegin(I, MAT_FINAL_ASSEMBLY));
  LibmeshPetscCallA(this->MoosePreconditioner::comm().get(), MatAssemblyEnd(I, MAT_FINAL_ASSEMBLY));
 
  // Factorize D
  LibmeshPetscCallA(this->MoosePreconditioner::comm().get(),
                    MatGetOrdering(_D->mat(), MATORDERINGND, &perm, &iperm));
 
  LibmeshPetscCallA(this->MoosePreconditioner::comm().get(), MatFactorInfoInitialize(&info));
 
  LibmeshPetscCallA(this->MoosePreconditioner::comm().get(),
                    MatGetFactor(_D->mat(), MATSOLVERSUPERLU_DIST, MAT_FACTOR_LU, &F));
 
  LibmeshPetscCallA(this->MoosePreconditioner::comm().get(),
                    MatLUFactorSymbolic(F, _D->mat(), perm, iperm, &info));
 
  LibmeshPetscCallA(this->MoosePreconditioner::comm().get(),
                    MatLUFactorNumeric(F, _D->mat(), &info));
 
  // Solve for Dinv
  LibmeshPetscCallA(this->MoosePreconditioner::comm().get(), MatMatSolve(F, I, dinv_dense));
 
  LibmeshPetscCallA(this->MoosePreconditioner::comm().get(),
                    MatAssemblyBegin(dinv_dense, MAT_FINAL_ASSEMBLY));
  LibmeshPetscCallA(this->MoosePreconditioner::comm().get(),
                    MatAssemblyEnd(dinv_dense, MAT_FINAL_ASSEMBLY));
 
  // copy value to dinv
  LibmeshPetscCallA(this->MoosePreconditioner::comm().get(),
                    MatConvert(dinv_dense, MATAIJ, MAT_INITIAL_MATRIX, &dinv));
 
  LibmeshPetscCallA(this->MoosePreconditioner::comm().get(), MatDestroy(&dinv_dense));
 
  LibmeshPetscCallA(this->MoosePreconditioner::comm().get(), MatDestroy(&I));
  LibmeshPetscCallA(this->MoosePreconditioner::comm().get(), MatDestroy(&F));
  LibmeshPetscCallA(this->MoosePreconditioner::comm().get(), ISDestroy(&perm));
  LibmeshPetscCallA(this->MoosePreconditioner::comm().get(), ISDestroy(&iperm));
}

Referenced by condenseSystem().

◆ computeDInverseDiag()

void VariableCondensationPreconditioner::computeDInverseDiag ( Mat & mat )

private

Compute (approximate) inverse of D by inverting its diagonal entries.

This method is used when _is_lm_coupling_diagonal = true.

Definition at line 823 of file VariableCondensationPreconditioner.C.

{
  auto diag_D = NumericVector<Number>::build(MoosePreconditioner::_communicator);
  // Initialize dinv
  LibmeshPetscCallA(this->MoosePreconditioner::comm().get(),
                    MatCreateAIJ(PETSC_COMM_WORLD,
                                 _D->local_n(),
                                 _D->local_m(),
                                 _D->n(),
                                 _D->m(),
                                 1,
                                 NULL,
                                 0,
                                 NULL,
                                 &dinv));
  // Allocate storage
  diag_D->init(_D->m(), _D->local_m(), false, PARALLEL);
  // Fill entries
  for (const auto & i : make_range(_D->row_start(), _D->row_stop()))
  {
    auto it = _map_global_primary_order.find(_global_primary_dofs[i]);
    mooseAssert(it != _map_global_primary_order.end(), "Index does not exist in the map.");
    diag_D->set(it->second, (*_D)(i, it->second));
  }
 
  for (const auto & i : make_range(_D->row_start(), _D->row_stop()))
  {
    if (MooseUtils::absoluteFuzzyEqual((*diag_D)(i), 0.0))
      mooseError("Trying to compute reciprocal of 0.");
    LibmeshPetscCallA(this->MoosePreconditioner::comm().get(),
                      MatSetValue(dinv,
                                  i,
                                  _map_global_primary_order.at(_global_primary_dofs[i]),
                                  1.0 / (*diag_D)(i),
                                  INSERT_VALUES));
  }
 
  LibmeshPetscCallA(this->MoosePreconditioner::comm().get(),
                    MatAssemblyBegin(dinv, MAT_FINAL_ASSEMBLY));
  LibmeshPetscCallA(this->MoosePreconditioner::comm().get(),
                    MatAssemblyEnd(dinv, MAT_FINAL_ASSEMBLY));
}

Referenced by condenseSystem().

◆ condenseSystem()

void VariableCondensationPreconditioner::condenseSystem ( )

private

Reconstruct the equation system.

Definition at line 343 of file VariableCondensationPreconditioner.C.

{
  // extract _M from the original matrix
  _matrix->create_submatrix(*_M, _rows, _lm_dofs);
 
  // get the row associated with the coupled primary variable
  _K->init(_global_primary_dofs.size(), _global_cols.size(), _primary_dofs.size(), _cols.size());
  // Note: enabling nonzero allocation may be expensive. Improved memeory pre-allocation will be
  // investigated in the future
  LibmeshPetscCallA(this->MoosePreconditioner::comm().get(),
                    MatSetOption(_K->mat(), MAT_NEW_NONZERO_ALLOCATION_ERR, PETSC_FALSE));
  // here the _global_cols may not be sorted
  _matrix->create_submatrix_nosort(*_K, _global_primary_dofs, _global_cols);
 
  _matrix->create_submatrix(*_D, _primary_dofs, _lm_dofs);
 
  // clean dinv
  if (_dinv)
  {
    LibmeshPetscCallA(this->MoosePreconditioner::comm().get(), MatDestroy(&_dinv));
    _dinv = nullptr;
  }
 
  // Compute inverse of D
  if (_is_lm_coupling_diagonal)
    // when _D is strictly diagonal, we only need to compute the reciprocal number of the diagonal
    // entries
    computeDInverseDiag(_dinv);
  else
    // for general cases when _D is not necessarily strict diagonal, we compute the inverse of _D
    // using LU
    computeDInverse(_dinv);
 
  Mat MdinvK;
  // calculate MdinvK
  LibmeshPetscCallA(
      this->MoosePreconditioner::comm().get(),
      MatMatMatMult(_M->mat(), _dinv, _K->mat(), MAT_INITIAL_MATRIX, PETSC_DEFAULT, &MdinvK));
  PetscMatrix<Number> MDinv_K(MdinvK, MoosePreconditioner::_communicator);
 
  // Preallocate memory for _J_condensed
  // memory info is obtained from _matrix and MDinv_K
  // indices are from _global_rows, _global_cols
  auto pc_original_mat = cast_ptr<PetscMatrix<Number> *>(_matrix);
  preallocateCondensedJacobian(
      *_J_condensed, *pc_original_mat, _rows, _cols, _global_rows, _global_cols, MDinv_K);
 
  // Extract unchanged parts from _matrix and add changed parts (MDinv_K) to _J_condensed
  computeCondensedJacobian(*_J_condensed, *pc_original_mat, _global_rows, MDinv_K);
 
  // Destroy MdinvK here otherwise we will have memory leak
  LibmeshPetscCallA(this->MoosePreconditioner::comm().get(), MatDestroy(&MdinvK));
}

Referenced by setup().

◆ connectControllableParams()

void MooseBase::connectControllableParams	(	const std::string &	parameter,
		const std::string &	object_type,
		const std::string &	object_name,
		const std::string &	object_parameter
	)		const

inherited

Connect controllable parameter of this action with the controllable parameters of the objects added by this action.

Parameters

parameter	Name of the controllable parameter of this action
object_type	Type of the object added by this action.
object_name	Name of the object added by this action.
object_parameter	Name of the parameter of the object.

Definition at line 77 of file MooseBase.C.

{
  auto & factory = _app.getFactory();
  auto & ip_warehouse = _app.getInputParameterWarehouse();
 
  MooseObjectParameterName primary_name(uniqueName(), parameter);
  const auto base_type = factory.getValidParams(object_type).getBase();
  MooseObjectParameterName secondary_name(base_type, object_name, object_parameter);
  ip_warehouse.addControllableParameterConnection(primary_name, secondary_name);
 
  const auto & tags = _pars.get<std::vector<std::string>>("control_tags");
  for (const auto & tag : tags)
  {
    if (!tag.empty())
    {
      // Only adds the parameter with the different control tags if the derived class
      // properly registers the parameter to its own syntax
      MooseObjectParameterName tagged_name(tag, name(), parameter);
      ip_warehouse.addControllableParameterConnection(
          tagged_name, secondary_name, /*error_on_empty=*/false);
    }
  }
}

◆ 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 98 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 PhysicsBasedPreconditioner::apply().

◆ declareManagedRestartableDataWithContext()

template<typename T , typename... Args>

Restartable::ManagedValue< T > Restartable::declareManagedRestartableDataWithContext	(	const std::string &	data_name,
		void *	context,
		Args &&...	args
	)

protectedinherited

Declares a piece of "managed" restartable data and initialize it.

Here, "managed" restartable data means that the caller can destruct this data upon destruction of the return value of this method. Therefore, this ManagedValue<T> wrapper should survive after the final calls to dataStore() for it. That is... at the very end.

This is needed for objects whose destruction ordering is important, and enables natural c++ destruction in reverse construction order of the object that declares it.

See delcareRestartableData and declareRestartableDataWithContext for more information.

Definition at line 283 of file Restartable.h.

{
  auto & data_ptr =
      declareRestartableDataHelper<T>(data_name, context, std::forward<Args>(args)...);
  return Restartable::ManagedValue<T>(data_ptr);
}

◆ declareRecoverableData()

template<typename T , typename... Args>

T & Restartable::declareRecoverableData	(	const std::string &	data_name,
		Args &&...	args
	)

protectedinherited

Declare a piece of data as "recoverable" 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)
args	Arguments to forward to the constructor of the data

Definition at line 358 of file Restartable.h.

{
  const auto full_name = restartableName(data_name);
 
  registerRestartableNameWithFilterOnApp(full_name, Moose::RESTARTABLE_FILTER::RECOVERABLE);
 
  return declareRestartableDataWithContext<T>(data_name, nullptr, std::forward<Args>(args)...);
}

◆ declareRestartableData()

template<typename T , typename... Args>

T & Restartable::declareRestartableData	(	const std::string &	data_name,
		Args &&...	args
	)

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)
args	Arguments to forward to the constructor of the data

Definition at line 276 of file Restartable.h.

{
  return declareRestartableDataWithContext<T>(data_name, nullptr, std::forward<Args>(args)...);
}

◆ declareRestartableDataHelper()

template<typename T , typename... Args>

RestartableData< T > & Restartable::declareRestartableDataHelper	(	const std::string &	data_name,
		void *	context,
		Args &&...	args
	)		const

privateinherited

Helper function for declaring restartable data.

We use this function to reduce code duplication when returning const/nonconst references to the data.

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
args	Arguments to forward to the constructor of the data

Definition at line 310 of file Restartable.h.

{
  const auto full_name = restartableName(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 =
      std::make_unique<RestartableData<T>>(full_name, context, std::forward<Args>(args)...);
  auto & restartable_data_ref = cast_ref<RestartableData<T> &>(
      registerRestartableDataOnApp(std::move(data_ptr), _restartable_tid));
 
  return restartable_data_ref;
}

◆ declareRestartableDataWithContext()

template<typename T , typename... Args>

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

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)
context	Context pointer that will be passed to the load and store functions
args	Arguments to forward to the constructor of the data

Definition at line 301 of file Restartable.h.

{
  return declareRestartableDataHelper<T>(data_name, context, std::forward<Args>(args)...).set();
}

◆ declareRestartableDataWithObjectName()

template<typename T , typename... Args>

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

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.
args	Arguments to forward to the constructor of the data

Definition at line 330 of file Restartable.h.

{
  return declareRestartableDataWithObjectNameWithContext<T>(
      data_name, object_name, nullptr, std::forward<Args>(args)...);
}

◆ declareRestartableDataWithObjectNameWithContext()

template<typename T , typename... Args>

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

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
args	Arguments to forward to the constructor of the data

Definition at line 340 of file Restartable.h.

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

◆ enabled()

virtual bool MooseObject::enabled ( ) const

inlinevirtualinherited

Return the enabled status of the object.

Reimplemented in EigenKernel.

Definition at line 49 of file MooseObject.h.

49{ return _enabled; }

MooseObject::_enabled

const bool & _enabled

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

Definition MooseObject.h:71

Referenced by EigenKernel::enabled(), BlockRestrictionDebugOutput::printBlockRestrictionGroups(), BlockRestrictionDebugOutput::printBoundaryRestrictionGroups(), and NodeFaceConstraint::validParams().

◆ errorPrefix()

std::string MooseBase::errorPrefix ( const std::string & ) const

inlineinherited

Deprecated message prefix; the error type is no longer used.

Definition at line 264 of file MooseBase.h.

264{ return messagePrefix(); }

◆ findZeroDiagonals()

void VariableCondensationPreconditioner::findZeroDiagonals	(	SparseMatrix< Number > &	mat,
		std::vector< dof_id_type > &	indices
	)

private

Check if the original jacobian has zero diagonal entries and save the row indices.

Definition at line 728 of file VariableCondensationPreconditioner.C.

{
  indices.clear();
  IS zerodiags, zerodiags_all;
  const PetscInt * petsc_idx;
  PetscInt nrows;
  // make sure we have a PETSc matrix
  auto * const petsc_mat = cast_ptr<PetscMatrix<Number> *>(&mat);
  LibmeshPetscCallA(this->MoosePreconditioner::comm().get(),
                    MatFindZeroDiagonals(petsc_mat->mat(), &zerodiags));
  // synchronize all indices
  LibmeshPetscCallA(this->MoosePreconditioner::comm().get(),
                    ISAllGather(zerodiags, &zerodiags_all));
  LibmeshPetscCallA(this->MoosePreconditioner::comm().get(),
                    ISGetIndices(zerodiags_all, &petsc_idx));
  LibmeshPetscCallA(this->MoosePreconditioner::comm().get(), ISGetSize(zerodiags_all, &nrows));
 
  for (PetscInt i = 0; i < nrows; ++i)
    indices.push_back(petsc_idx[i]);
 
  LibmeshPetscCallA(this->MoosePreconditioner::comm().get(),
                    ISRestoreIndices(zerodiags_all, &petsc_idx));
  LibmeshPetscCallA(this->MoosePreconditioner::comm().get(), ISDestroy(&zerodiags));
  LibmeshPetscCallA(this->MoosePreconditioner::comm().get(), ISDestroy(&zerodiags_all));
}

Referenced by setup().

◆ flagInvalidSolutionInternal()

template<bool warning>

template void SolutionInvalidInterface::flagInvalidSolutionInternal< false > ( const InvalidSolutionID invalid_solution_id ) const

protectedinherited

Set solution invalid mark for the given solution ID.

Definition at line 41 of file SolutionInvalidInterface.C.

{
  mooseAssert(
      warning == moose::internal::getSolutionInvalidityRegistry().item(invalid_solution_id).warning,
      "Inconsistent warning flag");
  auto & solution_invalidity = _si_moose_base.getMooseApp().solutionInvalidity();
  if constexpr (!warning)
    if (!_si_problem || _si_problem->immediatelyPrintInvalidSolution())
      solution_invalidity.printDebug(invalid_solution_id);
  return solution_invalidity.flagInvalidSolutionInternal(invalid_solution_id);
}

◆ getBase()

const std::string & MooseBase::getBase ( ) const

inlineinherited

Returns: The registered base for this object (set via InputParameters::registerBase())

Definition at line 147 of file MooseBase.h.

147{ return _pars.getBase(); }

InputParameters::getBase

const std::string & getBase() const

Definition InputParameters.C:505

Referenced by MooseBase::uniqueParameterName().

◆ getCheckedPointerParam()

template<typename T >

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

inherited

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 450 of file MooseBase.h.

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

◆ getCondensedXY()

void VariableCondensationPreconditioner::getCondensedXY	(	const NumericVector< Number > &	y,
		NumericVector< Number > &	x
	)

private

Get condensed x and y.

Definition at line 646 of file VariableCondensationPreconditioner.C.

{
  Mat mdinv;
  // calculate mdinv
  LibmeshPetscCallA(this->MoosePreconditioner::comm().get(),
                    MatMatMult(_M->mat(), _dinv, MAT_INITIAL_MATRIX, PETSC_DEFAULT, &mdinv));
  PetscMatrix<Number> MDinv(mdinv, MoosePreconditioner::_communicator);
 
  _x_hat->init(_J_condensed->n(), _J_condensed->local_n(), false, PARALLEL);
  _y_hat->init(_J_condensed->m(), _J_condensed->local_m(), false, PARALLEL);
 
  x.create_subvector(*_x_hat, _global_cols);
  y.create_subvector(*_y_hat, _global_rows);
 
  _primary_rhs_vec->init(MDinv.n(), MDinv.local_n(), false, PARALLEL);
 
  std::unique_ptr<NumericVector<Number>> mdinv_primary_rhs(
      NumericVector<Number>::build(MoosePreconditioner::_communicator));
  mdinv_primary_rhs->init(MDinv.m(), MDinv.local_m(), false, PARALLEL);
 
  // get _primary_rhs_vec from the original y
  y.create_subvector(*_primary_rhs_vec, _global_primary_dofs);
 
  MDinv.vector_mult(*mdinv_primary_rhs, *_primary_rhs_vec);
  mdinv_primary_rhs->close();
 
  (*_y_hat) -= (*mdinv_primary_rhs);
 
  _y_hat->close();
  _x_hat->close();
 
  LibmeshPetscCallA(this->MoosePreconditioner::comm().get(), MatDestroy(&mdinv));
}

Referenced by apply().

◆ getDataFileName()

std::string DataFileInterface::getDataFileName ( const std::string & param ) const

inherited

Deprecated method.

The data file paths are now automatically set within the InputParameters object, so using getParam<DataFileName>("param_name") is now sufficient.

Definition at line 21 of file DataFileInterface.C.

{
  _parent.mooseDeprecated("getDataFileName() is deprecated. The file path is now directly set "
                          "within the InputParameters.\nUse getParam<DataFileName>(\"",
                          param,
                          "\") instead.");
  return _parent.getParam<DataFileName>(param);
}

◆ getDataFileNameByName()

std::string DataFileInterface::getDataFileNameByName ( const std::string & relative_path ) const

inherited

Deprecated method.

Use getDataFilePath() instead.

Definition at line 31 of file DataFileInterface.C.

{
  _parent.mooseDeprecated("getDataFileNameByName() is deprecated. Use getDataFilePath(\"",
                          relative_path,
                          "\") instead.");
  return getDataFilePath(relative_path);
}

◆ getDataFilePath()

std::string DataFileInterface::getDataFilePath ( const std::string & relative_path ) const

inherited

Returns the path of a data file for a given relative file path.

This can be used for hardcoded datafile names and will search the same locations as getDataFileName

Definition at line 40 of file DataFileInterface.C.

{
  // This should only ever be used with relative paths. There is no point to
  // use this search path with an absolute path.
  if (std::filesystem::path(relative_path).is_absolute())
    _parent.mooseWarning("While using getDataFilePath(\"",
                         relative_path,
                         "\"): This API should not be used for absolute paths.");
 
  // This will search the data paths for this relative path
  std::optional<std::string> error;
  Moose::DataFileUtils::Path found_path;
  {
    // Throw on error so that if getPath() fails, we can throw an error
    // with the context of _parent.mooseError()
    Moose::ScopedThrowOnError scoped_throw_on_error;
 
    try
    {
      found_path = Moose::DataFileUtils::getPath(relative_path);
    }
    catch (std::exception & e)
    {
      error = e.what();
    }
  }
 
  if (error)
    _parent.mooseError(*error);
 
  mooseAssert(found_path.context == Moose::DataFileUtils::Context::DATA,
              "Should only ever obtain data");
  mooseAssert(found_path.data_name, "Should be set");
 
  const std::string msg =
      "Using data file '" + found_path.path + "' from " + *found_path.data_name + " data";
  _parent.mooseInfo(msg);
 
  return found_path.path;
}

Referenced by DataFileInterface::getDataFileNameByName().

◆ getDofColRow()

void VariableCondensationPreconditioner::getDofColRow ( )

private

Get row and col dofs for the condensed system.

Definition at line 274 of file VariableCondensationPreconditioner.C.

{
  // clean the containers if we want to update the dofs
  _global_rows.clear();
  _rows.clear();
  _global_cols.clear();
  _cols.clear();
  _global_rows_to_idx.clear();
  _rows_to_idx.clear();
  _global_cols_to_idx.clear();
  _cols_to_idx.clear();
  // row: all without primary variable dofs
  // col: all without lm variable dofs
  for (dof_id_type i = 0; i < _dofmap.n_dofs(); ++i)
  {
    if (std::find(_global_primary_dofs.begin(), _global_primary_dofs.end(), i) !=
        _global_primary_dofs.end())
      continue;
 
    _global_rows.push_back(i);
    _global_rows_to_idx.insert(std::make_pair(i, _global_rows.size() - 1));
    if (_dofmap.local_index(i))
    {
      _rows.push_back(i);
      _rows_to_idx.insert(std::make_pair(i, _global_rows_to_idx[i]));
    }
 
    // ensure the lm and primary correspondance, so that the condensed Jacobian has non-zero
    // diagonal if the dof corresponds to the lm variable, then find the corresponding primary
    // variable dof and add to _global_cols
    if (_map_global_lm_primary.find(i) != _map_global_lm_primary.end())
    {
      auto primary_idx = _map_global_lm_primary[i];
      _global_cols.push_back(primary_idx);
      _global_cols_to_idx.insert(std::make_pair(primary_idx, _global_cols.size() - 1));
 
      if (_dofmap.local_index(primary_idx))
      {
        _cols.push_back(primary_idx);
        _cols_to_idx.insert(std::make_pair(primary_idx, _global_cols_to_idx[primary_idx]));
      }
    }
    else // if the dof does not correspond to the lm nor primary variable, just add to _global_cols
    {
      _global_cols.push_back(i);
      _global_cols_to_idx.insert(std::make_pair(i, _global_cols.size() - 1));
 
      if (_dofmap.local_index(i))
      {
        _cols.push_back(i);
        _cols_to_idx.insert(std::make_pair(i, _global_cols_to_idx[i]));
      }
    }
  }
}

Referenced by setup().

◆ getDofToCondense()

void VariableCondensationPreconditioner::getDofToCondense ( )

private

Get dofs for the variable to be condensed out.

Definition at line 194 of file VariableCondensationPreconditioner.C.

{
  // clean the containers if we want to update the dofs
  _global_lm_dofs.clear();
  _lm_dofs.clear();
  _global_primary_dofs.clear();
  _primary_dofs.clear();
  _map_global_lm_primary.clear();
  _map_global_primary_order.clear();
 
  // TODO: this might not work for distributed mesh and needs to be improved
  NodeRange * active_nodes = _mesh.getActiveNodeRange();
 
  // loop through the variable ids
  std::vector<dof_id_type> di, cp_di;
  for (const auto & vn : index_range(_lm_var_ids))
    for (const auto & node : *active_nodes)
    {
      di.clear();
      cp_di.clear();
      const auto var_id = _lm_var_ids[vn];
      // get coupled variable id
      const auto cp_var_id = _primary_var_ids[vn];
      // get var and cp_var dofs associated with this node
      _dofmap.dof_indices(node, di, var_id);
      // skip when di is empty
      if (di.empty())
        continue;
      _dofmap.dof_indices(node, cp_di, cp_var_id);
      if (cp_di.size() != di.size())
        mooseError("variable and coupled variable do not have the same number of dof on node ",
                   node->id(),
                   ".");
      for (const auto & i : index_range(di))
      {
        // when we have adaptive condensation, skip when di does not contain any indices in
        // _zero_rows
        if (std::find(_zero_rows.begin(), _zero_rows.end(), di[i]) == _zero_rows.end() &&
            _adaptive_condensation)
          break;
        _global_lm_dofs.push_back(di[i]);
        if (_dofmap.local_index(di[i]))
          _lm_dofs.push_back(di[i]);
 
        // save the corresponding coupled dof indices
        _global_primary_dofs.push_back(cp_di[i]);
        if (_dofmap.local_index(cp_di[i]))
          _primary_dofs.push_back(cp_di[i]);
        _map_global_lm_primary.insert(std::make_pair(di[i], cp_di[i]));
      }
    }
 
  // check if we endup with none dof to condense
  if (_global_lm_dofs.empty())
  {
    _need_condense = false;
    _console << std::endl
             << "The variable(s) provided do not have a saddle-point character at this step. VCP "
                "will continue without condensing the dofs."
             << std::endl
             << std::endl;
  }
  else
    _need_condense = true;
 
  std::sort(_global_lm_dofs.begin(), _global_lm_dofs.end());
  std::sort(_lm_dofs.begin(), _lm_dofs.end());
 
  std::sort(_global_primary_dofs.begin(), _global_primary_dofs.end());
  std::sort(_primary_dofs.begin(), _primary_dofs.end());
 
  for (const auto & i : index_range(_global_lm_dofs))
  {
    auto it = _map_global_lm_primary.find(_global_lm_dofs[i]);
    mooseAssert(it != _map_global_lm_primary.end(), "Index does not exist in the map.");
    _map_global_primary_order.insert(std::make_pair(it->second, i));
  }
}

Referenced by setup().

◆ getFullSolution()

void VariableCondensationPreconditioner::getFullSolution	(	const NumericVector< Number > &	y,
		NumericVector< Number > &	x
	)

private

Assemble the full solution vector.

Definition at line 703 of file VariableCondensationPreconditioner.C.

{
  std::vector<dof_id_type> dof_indices;
  std::vector<Number> vals;
 
  // save values and indices from _x_hat and _lm_sol_vec
  for (const auto & i : make_range(_x_hat->first_local_index(), _x_hat->last_local_index()))
  {
    dof_indices.push_back(_global_cols[i]);
    vals.push_back((*_x_hat)(i));
  }
 
  for (const auto & i :
       make_range(_lm_sol_vec->first_local_index(), _lm_sol_vec->last_local_index()))
  {
    dof_indices.push_back(_global_lm_dofs[i]);
    vals.push_back((*_lm_sol_vec)(i));
  }
 
  x.insert(vals.data(), dof_indices);
  x.close();
}

Referenced by apply().

◆ getHitNode() [1/2]

const hit::Node * MooseBase::getHitNode ( ) const

inlineinherited

Returns: The block-level hit node for this object, if any

Definition at line 136 of file MooseBase.h.

136{ return getHitNode(_pars); }

Referenced by MooseBase::callMooseError(), MooseBase::getHitNode(), and MooseBase::messagePrefix().

◆ getHitNode() [2/2]

const hit::Node * MooseBase::getHitNode ( const InputParameters & params )

staticprivateinherited

Internal method for getting a hit node (if available) given a set of parameters.

Needs to be static so that we can call it externally from InputParameters for errors that do not have context of the MooseBase

Definition at line 167 of file MooseBase.C.

{
  if (const auto hit_node = params.getHitNode())
    if (!hit_node->isRoot())
      return hit_node;
  return nullptr;
}

◆ getMooseApp()

MooseApp & MooseBase::getMooseApp ( ) const

inlineinherited

Get the MooseApp this class is associated with.

Definition at line 87 of file MooseBase.h.

87{ return _app; }

Referenced by ChainControlSetupAction::act(), AddDefaultConvergenceAction::addDefaultMultiAppFixedPointConvergence(), AddDefaultConvergenceAction::addDefaultNonlinearConvergence(), AddDefaultConvergenceAction::addDefaultSteadyStateConvergence(), FEProblemBase::advanceState(), ParsedChainControl::buildFunction(), ReporterTransferInterface::checkHasReporterValue(), AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedSteadyStateConvergenceParameters(), Coupleable::checkWritableVar(), ComponentPhysicsInterface::ComponentPhysicsInterface(), Coupleable::Coupleable(), MortarInterfaceWarehouse::createMortarInterface(), EigenProblem::doFreeNonlinearPowerIterations(), Terminator::execute(), FEProblemSolve::FEProblemSolve(), SolutionInvalidInterface::flagInvalidSolutionInternal(), ChainControl::getChainControlDataSystem(), FEProblemBase::getDistribution(), FEProblemBase::getFunction(), FEProblemBase::getFVInterpolationMethod(), FEProblemBase::getMultiApp(), FEProblemBase::getSampler(), DefaultConvergenceBase::getSharedExecutionerParam(), FEProblemBase::getUserObjectBase(), FEProblemBase::getVectorPostprocessorObjectByName(), ChainControlDataPostprocessor::initialSetup(), MaterialPropertyInterface::MaterialPropertyInterface(), MooseVariableDataFV< OutputType >::MooseVariableDataFV(), ProgressOutput::output(), PetscOutputInterface::petscLinearOutput(), PetscOutputInterface::petscNonlinearOutput(), Moose::PetscSupport::PetscOptionsScope::PetscOptionsScope(), PetscOutputInterface::PetscOutputInterface(), PostprocessorInterface::postprocessorsAdded(), MultiApp::preTransfer(), Reporter::Reporter(), ReporterInterface::reportersAdded(), LinearFVGradientInterface::resolveFVGradientMethod(), MultiApp::restore(), and VectorPostprocessorInterface::vectorPostprocessorsAdded().

◆ getParam() [1/2]

template<typename T >

const T & MooseBase::getParam ( 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 406 of file MooseBase.h.

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

◆ getParam() [2/2]

template<typename T1 , typename T2 >

std::vector< std::pair< T1, T2 > > MooseBase::getParam	(	const std::string &	param1,
		const std::string &	param2
	)		const

inherited

Retrieve two parameters and provide pair of parameters for the object.

Parameters

param1	The name of first parameter
param2	The name of second parameter

Returns: Vector of pairs of first and second parameters

Definition at line 443 of file MooseBase.h.

{
  return _pars.get<T1, T2>(param1, param2);
}

◆ getRenamedParam()

template<typename T >

const T & MooseBase::getRenamedParam	(	const std::string &	old_name,
		const std::string &	new_name
	)		const

inherited

Retrieve a renamed parameter for the object.

This helper makes sure we check both names before erroring, and that only one parameter is passed to avoid silent errors

Parameters

old_name	the old name for the parameter
new_name	the new name for the parameter

Definition at line 420 of file MooseBase.h.

{
  // Most important: accept new parameter
  if (isParamSetByUser(new_name) && !isParamValid(old_name))
    return getParam<T>(new_name);
  // Second most: accept old parameter
  if (isParamValid(old_name) && !isParamSetByUser(new_name))
    return getParam<T>(old_name);
  // Third most: accept default for new parameter
  if (isParamValid(new_name) && !isParamValid(old_name))
    return getParam<T>(new_name);
  // Refuse: no default, no value passed
  if (!isParamValid(old_name) && !isParamValid(new_name))
    mooseError("parameter '" + new_name +
               "' is being retrieved without being set.\nDid you misspell it?");
  // Refuse: both old and new parameters set by user
  else
    mooseError("Parameter '" + new_name + "' may not be provided alongside former parameter '" +
               old_name + "'");
}

◆ getRestartableData()

template<typename T , typename... Args>

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

protectedinherited

Declare a piece of data as "restartable" and initialize it Similar to declareRestartableData but returns a const reference to the object.

Forwarded arguments are not allowed in this case because we assume that the object is restarted and we won't need different constructors to initialize it.

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

Parameters

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

Definition at line 294 of file Restartable.h.

{
  return declareRestartableDataHelper<T>(data_name, nullptr).get();
}

◆ getSharedPtr() [1/2]

std::shared_ptr< MooseObject > MooseObject::getSharedPtr ( )

inherited

Get another shared pointer to this object that has the same ownership group.

Wrapper around shared_from_this().

Definition at line 70 of file MooseObject.C.

{
  try
  {
    return shared_from_this();
  }
  catch (std::bad_weak_ptr &)
  {
    mooseError(not_shared_error);
  }
}

Referenced by MFEMProblem::addImagComponentToBC(), MFEMProblem::addImagComponentToKernel(), MFEMProblem::addRealComponentToBC(), MFEMProblem::addRealComponentToKernel(), and WebServerControl::addServerAction().

◆ getSharedPtr() [2/2]

std::shared_ptr< const MooseObject > MooseObject::getSharedPtr ( ) const

inherited

Definition at line 83 of file MooseObject.C.

{
  try
  {
    return shared_from_this();
  }
  catch (std::bad_weak_ptr &)
  {
    mooseError(not_shared_error);
  }
}

◆ hasBase()

bool MooseBase::hasBase ( ) const

inlineinherited

Returns: Whether or not this object has a registered base (set via InputParameters::registerBase())

Definition at line 142 of file MooseBase.h.

142{ return _pars.hasBase(); }

InputParameters::hasBase

bool hasBase() const

Definition InputParameters.C:499

◆ init()

void VariableCondensationPreconditioner::init ( )

virtual

Initialize data structures if not done so already.

Reimplemented from libMesh::Preconditioner< Number >.

Definition at line 331 of file VariableCondensationPreconditioner.C.

{
  TIME_SECTION(_init_timer);
 
  if (!_preconditioner)
    _preconditioner =
        Preconditioner<Number>::build_preconditioner(MoosePreconditioner::_communicator);
 
  _is_initialized = true;
}

◆ initialSetup()

void MoosePreconditioner::initialSetup ( )

virtualinherited

Perform some setup tasks such as storing the PETSc options.

Reimplemented in MooseStaticCondensationPreconditioner.

Definition at line 146 of file MoosePreconditioner.C.

{
  Moose::PetscSupport::storePetscOptions(_fe_problem, _nl.prefix(), *this);
}

◆ isKokkosObject()

bool MooseObject::isKokkosObject ( ) const

inlineinherited

Get whether this object is a Kokkos functor The parameter MooseBase::kokkos_object_param is set by the Kokkos base classes.

Definition at line 63 of file MooseObject.h.

63{ return parameters().isKokkosObject(); }

InputParameters::isKokkosObject

bool isKokkosObject() const

Returns whether this InputParameters belongs to a Kokkos object Checks whether MooseBase::kokkos_obje...

Definition InputParameters.C:433

MooseBase::parameters

const InputParameters & parameters() const

Get the parameters of the object.

Definition MooseBase.h:131

Referenced by AttribKokkos::initFrom(), BlockRestrictable::initializeBlockRestrictable(), and BoundaryRestrictable::initializeBoundaryRestrictable().

◆ isParamSetByUser()

bool MooseBase::isParamSetByUser ( const std::string & name ) const

inlineinherited

Test if the supplied parameter is set by a user, as opposed to not set or set to default.

Parameters

name	The name of the parameter to test

Definition at line 205 of file MooseBase.h.

  {
    return _pars.isParamSetByUser(name);
  }

Referenced by DiffusionCG::addFEBCs(), DiffusionPhysicsBase::addInitialConditions(), CylinderComponent::addMeshGenerators(), AdvancedExtruderGenerator::AdvancedExtruderGenerator(), MFEMMesh::buildMesh(), MFEMBoundarySubMesh::buildSubMesh(), MFEMDomainSubMesh::buildSubMesh(), LibtorchNeuralNetControl::conditionalParameterError(), ConservativeAdvectionBCTempl< is_ad >::ConservativeAdvectionBCTempl(), MooseApp::copyInputs(), DiffusionPhysicsBase::DiffusionPhysicsBase(), MooseApp::errorCheck(), FileMesh::FileMesh(), FullSolveMultiApp::FullSolveMultiApp(), MeshDiagnosticsGenerator::generate(), OrientSurfaceMeshGenerator::generate(), SurfaceSubdomainsFromAllNormalsGenerator::generate(), MFEMVectorFESpace::getFECName(), MooseBase::getRenamedParam(), DefaultConvergenceBase::getSharedExecutionerParam(), AddVariableAction::init(), MFEMMesh::init(), PhysicsBase::initializePhysics(), ElementSubdomainModifierBase::initialSetup(), MatrixSymmetryCheck::MatrixSymmetryCheck(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MFEMGeneratedMeshGenerator::MFEMGeneratedMeshGenerator(), MFEMVariable::MFEMVariable(), MortarConstraintBase::MortarConstraintBase(), MultiAppGeneralFieldFunctorTransfer::MultiAppGeneralFieldFunctorTransfer(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), OrientSurfaceMeshGenerator::OrientSurfaceMeshGenerator(), SolutionInvalidityOutput::output(), Output::Output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), PetscExternalPartitioner::partition(), PolyLineMeshFollowingNodeSetGenerator::PolyLineMeshFollowingNodeSetGenerator(), MooseMesh::prepare(), SolutionUserObjectBase::readXda(), ReferenceResidualConvergence::ReferenceResidualConvergence(), PhysicsBase::reportPotentiallyMissedParameters(), MooseApp::run(), MooseApp::runInputFile(), MooseApp::runInputs(), Moose::MFEM::LinearSolverBase::SetPreconditioner(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), SmoothMeshGenerator::SmoothMeshGenerator(), SurfaceSubdomainsDelaunayRemesher::SurfaceSubdomainsDelaunayRemesher(), SurfaceSubdomainsFromAllNormalsGenerator::SurfaceSubdomainsFromAllNormalsGenerator(), TagVectorAux::TagVectorAux(), TimedSubdomainModifier::TimedSubdomainModifier(), TimeIntegratedPostprocessor::TimeIntegratedPostprocessor(), XYDelaunayGenerator::XYDelaunayGenerator(), and XYZDelaunayGenerator::XYZDelaunayGenerator().

◆ isParamValid()

bool MooseBase::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 199 of file MooseBase.h.

199{ return _pars.isParamValid(name); }

InputParameters::isParamValid

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

This method returns parameters that have been initialized in one fashion or another,...

Definition InputParameters.C:386

◆ mergeArrays()

void VariableCondensationPreconditioner::mergeArrays	(	const PetscInt *	a,
		const PetscInt *	b,
		const PetscInt &	na,
		const PetscInt &	nb,
		std::vector< PetscInt > &	c
	)

private

Find the common part of arrays a and b and save it in c.

The na and nb are the number of entries for the arrays. This function is used in the preallocateCondensedJacobian step.

Definition at line 569 of file VariableCondensationPreconditioner.C.

{
  c.clear();
 
  // use map to store unique elements.
  std::map<PetscInt, bool> mp;
 
  // Inserting values to a map.
  for (const auto & i : make_range(na))
    mp[a[i]] = true;
 
  for (const auto & i : make_range(nb))
    mp[b[i]] = true;
 
  // Save the merged values to c, if only the value also exist in gcols
  for (const auto & i : mp)
    c.push_back(i.first);
}

Referenced by preallocateCondensedJacobian().

◆ messagePrefix() [1/2]

std::string MooseBase::messagePrefix ( const bool hit_prefix = true ) const

inlineinherited

Returns: A prefix to be used in messages that contain the input file location associated with this object (if any) and the name and type of the object.

Definition at line 256 of file MooseBase.h.

  {
    return messagePrefix(_pars, hit_prefix);
  }

Referenced by MooseBase::callMooseError(), MooseBase::errorPrefix(), MooseBase::messagePrefix(), MooseBase::mooseDeprecated(), MooseBase::mooseDeprecatedNoTrace(), MooseBase::mooseInfo(), and MooseBase::mooseWarning().

◆ messagePrefix() [2/2]

std::string MooseBase::messagePrefix	(	const InputParameters &	params,
		const bool	hit_prefix
	)

staticprivateinherited

Internal method for getting the message prefix for an object (object type, name, etc).

Needs to be static so that we can call it externally from InputParameters for errors that do not have context of the MooseBase

Definition at line 140 of file MooseBase.C.

{
  std::string prefix = "";
 
  if (hit_prefix)
    if (const auto node = MooseBase::getHitNode(params))
      prefix += Moose::hitMessagePrefix(*node);
 
  // Don't have context without type and name
  if (!params.isMooseBaseObject())
    return prefix;
 
  const auto & name = params.getObjectName();
  const std::string base = params.hasBase() ? params.getBase() : "object";
  const bool is_main_app = base == "Application" && name == AppFactory::main_app_name;
  prefix += "The following occurred in the ";
  if (is_main_app)
    prefix += "main " + base;
  else
    prefix += base;
  if (base != params.getObjectName() && name.size() && !is_main_app)
    prefix += " '" + name + "'";
  prefix += " of type " + params.getObjectType() + ".";
  return prefix + "\n\n";
}

◆ mooseDeprecated() [1/2]

template<typename... Args>

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

inlineinherited

Emits a deprecation warning prefixed with the object name and type, and a stack trace.

Definition at line 317 of file MooseBase.h.

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

Referenced by MooseApp::addCapability(), DataFileInterface::getDataFileName(), DataFileInterface::getDataFileNameByName(), MooseApp::getRecoverFileBase(), MooseApp::hasRecoverFileBase(), and MooseApp::setupOptions().

◆ mooseDeprecated() [2/2]

template<typename... Args>

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

inlineinherited

Definition at line 87 of file SolutionInvalidInterface.h.

  {
    _si_moose_base.MooseBase::mooseDeprecated(std::forward<Args>(args)...);
    flagSolutionWarningMultipleRegistration(_si_moose_base.name() + ": deprecation");
  }

Referenced by MultiApp::appProblem(), AddVariableAction::determineType(), MooseMesh::elem(), MooseMesh::elem(), FunctionDT::FunctionDT(), MooseMesh::getBoundariesToElems(), Control::getExecuteOptions(), MooseMesh::isTranslatedPeriodic(), MooseMesh::minPeriodicDistance(), MooseMesh::minPeriodicVector(), MooseMesh::node(), MooseMesh::node(), FixedPointSolve::numPicardIts(), RelationshipManager::operator>=(), and MooseMesh::setBoundaryToNormalMap().

◆ mooseDeprecatedNoTrace()

template<typename... Args>

void MooseBase::mooseDeprecatedNoTrace ( Args &&... args ) const

inlineinherited

Emits a deprecation warning prefixed with the object name and type, and no stack trace.

Definition at line 327 of file MooseBase.h.

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

◆ mooseDocumentedError()

template<typename... Args>

void MooseBase::mooseDocumentedError	(	const std::string &	repo_name,
		const unsigned int	issue_num,
		Args &&...	args
	)		const

inlineinherited

Definition at line 277 of file MooseBase.h.

  {
    callMooseError(moose::internal::formatMooseDocumentedError(
                       repo_name, issue_num, argumentsToString(std::forward<Args>(args)...)),
                   /* with_prefix = */ true);
  }

Referenced by ManifoldSubdomainGenerator::ManifoldSubdomainGenerator().

◆ mooseError()

template<typename... Args>

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

inlineinherited

Emits an error prefixed with object name and type and optionally a file path to the top-level block parameter if available.

Definition at line 271 of file MooseBase.h.

  {
    callMooseError(argumentsToString(std::forward<Args>(args)...), /* with_prefix = */ true);
  }

◆ mooseErrorNonPrefixed()

template<typename... Args>

void MooseBase::mooseErrorNonPrefixed ( Args &&... args ) const

inlineinherited

Emits an error without the prefixing included in mooseError().

Definition at line 290 of file MooseBase.h.

  {
    callMooseError(argumentsToString(std::forward<Args>(args)...), /* with_prefix = */ false);
  }

◆ mooseInfo()

template<typename... Args>

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

inlineinherited

Definition at line 334 of file MooseBase.h.

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

Referenced by SetupRecoverFileBaseAction::act(), AStableDirk4::AStableDirk4(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), PIDTransientControl::execute(), Executioner::Executioner(), Executioner::Executioner(), ExplicitRK2::ExplicitRK2(), ExplicitTVDRK2::ExplicitTVDRK2(), FixedPointSolve::findTransformedSystem(), ManifoldSubdomainGenerator::generate(), PolyLineMeshFollowingNodeSetGenerator::generate(), DataFileInterface::getDataFilePath(), ImplicitMidpoint::ImplicitMidpoint(), LStableDirk2::LStableDirk2(), LStableDirk3::LStableDirk3(), LStableDirk4::LStableDirk4(), MultiAppTransfer::mapBackWithoutCollapsing(), SolutionInvalidityOutput::output(), MooseBase::paramInfo(), MooseApp::setupOptions(), SymmetryTransformGenerator::SymmetryTransformGenerator(), TransientBase::takeStep(), and TransientBase::TransientBase().

◆ mooseWarning() [1/2]

template<typename... Args>

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

inlineinherited

Emits a warning prefixed with object name and type.

Definition at line 299 of file MooseBase.h.

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

Referenced by DiracKernelInfo::findPoint(), DataFileInterface::getDataFilePath(), MooseApp::loadLibraryAndDependencies(), and MooseBase::paramWarning().

◆ mooseWarning() [2/2]

template<typename... Args>

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

inlineinherited

Definition at line 73 of file SolutionInvalidInterface.h.

  {
    _si_moose_base.MooseBase::mooseWarning(std::forward<Args>(args)...);
    flagSolutionWarningMultipleRegistration(_si_moose_base.name() + ": warning");
  }

Referenced by CopyMeshPartitioner::_do_partition(), AddFunctionAction::act(), AddKernelAction::act(), CommonOutputAction::act(), MaterialOutputAction::act(), MeshOnlyAction::act(), MooseMesh::addPeriodicVariable(), BoundaryMarker::BoundaryMarker(), DistributedRectilinearMeshGenerator::buildCube(), CartesianMeshGenerator::CartesianMeshGenerator(), CheckOutputAction::checkConsoleOutput(), MultiAppTransfer::checkMultiAppExecuteOn(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), MeshDiagnosticsGenerator::checkPolygons(), ActionComponent::checkRequiredTasks(), PhysicsBase::checkRequiredTasks(), MultiApp::createApp(), MeshDiagnosticsGenerator::diagnosticsLog(), CartesianGridDivision::divisionIndex(), CylindricalGridDivision::divisionIndex(), SphericalGridDivision::divisionIndex(), Postprocessor::evaluateDotWarning(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), FixedPointSolve::FixedPointSolve(), BSplineCurveGenerator::generate(), RenumberBySubdomainGenerator::generate(), SubdomainPerElementGenerator::generate(), SurfaceMeshGeneratorBase::get2DElemNormal(), MultiAppTransfer::getAppInfo(), FunctorBinnedValuesDivision::getBinIndex(), IndicatorMarker::IndicatorMarker(), CartesianGridDivision::initialize(), CylindricalGridDivision::initialize(), SphericalGridDivision::initialize(), MaterialBase::initStatefulProperties(), IterationAdaptiveDT::limitDTToPostprocessorValue(), MFEMRefinementMarker::MFEMRefinementMarker(), NewmarkBeta::NewmarkBeta(), Output::Output(), MaterialOutputAction::outputHelper(), Executioner::problem(), TestSourceStepper::rejectStep(), PhysicsBase::reportPotentiallyMissedParameters(), MaterialBase::resetQpProperties(), MooseMesh::setCoordSystem(), TransientMultiApp::solveStep(), MeshRepairGenerator::splitNonConvexPolygons(), and VariableCondensationPreconditioner().

◆ mooseWarningNonPrefixed() [1/2]

template<typename... Args>

void MooseBase::mooseWarningNonPrefixed ( Args &&... args ) const

inlineinherited

Emits a warning without the prefixing included in mooseWarning().

Definition at line 308 of file MooseBase.h.

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

◆ mooseWarningNonPrefixed() [2/2]

template<typename... Args>

void SolutionInvalidInterface::mooseWarningNonPrefixed ( Args &&... args ) const

inlineinherited

Definition at line 80 of file SolutionInvalidInterface.h.

  {
    _si_moose_base.MooseBase::mooseWarningNonPrefixed(std::forward<Args>(args)...);
    flagSolutionWarningMultipleRegistration(_si_moose_base.name() + ": warning");
  }

◆ name()

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

inlineinherited

Get the name of the class.

Returns: The name of the class

Definition at line 103 of file MooseBase.h.

  {
    mooseAssert(_name.size(), "Empty name");
    return _name;
  }

◆ paramError()

template<typename... Args>

void MooseBase::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 457 of file MooseBase.h.

{
  _pars.paramError(param, std::forward<Args>(args)...);
}

◆ parameters()

const InputParameters & MooseBase::parameters ( ) const

inlineinherited

Get the parameters of the object.

Returns: The parameters of the object

Definition at line 131 of file MooseBase.h.

131{ return _pars; }

◆ paramInfo()

template<typename... Args>

void MooseBase::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 471 of file MooseBase.h.

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

Referenced by GridPartitioner::_do_partition(), ComboMarker::ComboMarker(), Control::Control(), FunctorIC::FunctorIC(), and TransientMultiApp::TransientMultiApp().

◆ paramWarning() [1/2]

template<typename... Args>

void MooseBase::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 464 of file MooseBase.h.

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

◆ paramWarning() [2/2]

template<typename... Args>

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

inlineinherited

Definition at line 94 of file SolutionInvalidInterface.h.

  {
    _si_moose_base.MooseBase::paramWarning(param, std::forward<Args>(args)...);
    flagSolutionWarningMultipleRegistration(_si_moose_base.name() + ": warning for parameter '" +
                                            param + "'");
  }

Referenced by GridPartitioner::_do_partition(), CartesianMeshGenerator::CartesianMeshGenerator(), MultiAppTransfer::checkParentAppUserObjectExecuteOn(), EigenProblem::checkProblemIntegrity(), MooseMeshUtils::copyIntoMesh(), CylindricalGridDivision::CylindricalGridDivision(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), MultiAppNearestNodeTransfer::execute(), FEProblemSolve::FEProblemSolve(), PlaneIDMeshGenerator::generate(), SubdomainsFromPartitionerGenerator::generate(), UniqueExtraIDMeshGenerator::generate(), ReferenceResidualConvergence::initialSetup(), FullSolveMultiApp::initialSetup(), Terminator::initialSetup(), SampledOutput::initSample(), MooseMesh::MooseMesh(), MultiAppTransfer::MultiAppTransfer(), PNGOutput::PNGOutput(), FEProblemBase::setPreserveMatrixSparsityPattern(), and Terminator::Terminator().

◆ perfGraph()

PerfGraph & PerfGraphInterface::perfGraph ( )

inherited

Get the PerfGraph.

Definition at line 86 of file PerfGraphInterface.C.

{
  return _pg_moose_app.perfGraph();
}

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

◆ preallocateCondensedJacobian()

void VariableCondensationPreconditioner::preallocateCondensedJacobian	(	PetscMatrix< Number > &	condensed_mat,
		PetscMatrix< Number > &	original_mat,
		const std::vector< dof_id_type > &	rows,
		const std::vector< dof_id_type > &	cols,
		const std::vector< dof_id_type > &	grows,
		const std::vector< dof_id_type > &	gcols,
		PetscMatrix< Number > &	block_mat
	)

private

Preallocate memory for the condensed Jacobian matrix.

Definition at line 478 of file VariableCondensationPreconditioner.C.

{
  // quantities from the original matrix and the block matrix
  PetscInt ncols = 0, block_ncols = 0;
  const PetscInt * col_vals;
  const PetscInt * block_col_vals;
  const PetscScalar * vals;
  const PetscScalar * block_vals;
 
  std::vector<PetscInt> block_cols_to_org; // stores the nonzero column indices of the block
                                           // matrix w.r.t original matrix
  std::vector<PetscInt>
      merged_cols; // stores the nonzero column indices estimate of the condensed matrix
 
  // number of nonzeros in each row of the DIAGONAL and OFF-DIAGONAL portion of the local
  // condensed matrix
  std::vector<dof_id_type> n_nz, n_oz;
 
  // Get number of nonzeros from original_mat and block_mat for each row
  for (const auto & row_id : _rows)
  {
    // get number of non-zeros in the original matrix
    LibmeshPetscCallA(this->MoosePreconditioner::comm().get(),
                      MatGetRow(original_mat.mat(), row_id, &ncols, &col_vals, &vals));
 
    // get number of non-zeros in the block matrix
    dof_id_type block_row_id; // row id in the block matrix
 
    if (_global_rows_to_idx.find(row_id) != _global_rows_to_idx.end())
      block_row_id = _global_rows_to_idx[row_id];
    else
      mooseError("DoF ", row_id, " does not exist in the rows of condensed_mat");
 
    LibmeshPetscCallA(
        this->MoosePreconditioner::comm().get(),
        MatGetRow(block_mat.mat(), block_row_id, &block_ncols, &block_col_vals, &block_vals));
 
    // make sure the block index is transformed in terms of the original mat
    block_cols_to_org.clear();
    for (PetscInt i = 0; i < block_ncols; ++i)
    {
      auto idx = gcols[block_col_vals[i]];
      block_cols_to_org.push_back(idx);
    }
 
    // Now store nonzero column indices for the condensed Jacobian
    // merge `col_vals` and `block_cols_to_org` and save the common indices in `merged_cols`.
    mergeArrays(col_vals, block_cols_to_org.data(), ncols, block_ncols, merged_cols);
 
    LibmeshPetscCallA(
        this->MoosePreconditioner::comm().get(),
        MatRestoreRow(block_mat.mat(), block_row_id, &block_ncols, &block_col_vals, &block_vals));
 
    LibmeshPetscCallA(this->MoosePreconditioner::comm().get(),
                      MatRestoreRow(original_mat.mat(), row_id, &ncols, &col_vals, &vals));
 
    // Count the nnz for DIAGONAL and OFF-DIAGONAL parts
    PetscInt row_n_nz = 0, row_n_oz = 0;
    for (const auto & merged_col : merged_cols)
    {
      // find corresponding index in the block mat and skip the cols that do not exist in the
      // condensed system
      if (_global_cols_to_idx.find(merged_col) == _global_cols_to_idx.end())
        continue;
 
      dof_id_type col_idx = _global_cols_to_idx[merged_col];
      // find the corresponding row index
      dof_id_type row_idx = grows[col_idx];
      // check whether the index is local;
      // yes - DIAGONAL, no - OFF-DIAGONAL
      if (_rows_to_idx.find(row_idx) != _rows_to_idx.end())
        row_n_nz++;
      else
        row_n_oz++;
    }
 
    n_nz.push_back(cast_int<dof_id_type>(row_n_nz));
    n_oz.push_back(cast_int<dof_id_type>(row_n_oz));
  }
  // Then initialize and allocate memory for the condensed system matrix
  condensed_mat.init(grows.size(), gcols.size(), rows.size(), cols.size(), n_nz, n_oz);
}

Referenced by condenseSystem().

◆ queryParam()

template<typename T >

const T * MooseBase::queryParam ( const std::string & name ) const

inherited

Query a parameter for the object.

If a parameter of the given name and type does not exist or if the parameter is not valid, nullptr will be returned

Parameters

name	The name of the parameter

Returns: A pointer to the parameter value, if it exists

Definition at line 413 of file MooseBase.h.

{
  return _pars.queryParam<T>(name);
}

Referenced by MFEMExecutedObject::getRequestedItems(), and MFEMGeometricMultigridSolver::MFEMGeometricMultigridSolver().

◆ registerInvalidSolutionInternal()

InvalidSolutionID SolutionInvalidInterface::registerInvalidSolutionInternal	(	const std::string &	message,
		const bool	warning
	)		const

protectedinherited

Definition at line 55 of file SolutionInvalidInterface.C.

{
  return moose::internal::getSolutionInvalidityRegistry().registerInvalidity(
      _si_moose_base.type(), message, warning);
}

◆ registerRestartableDataOnApp()

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

privateinherited

Helper function for actually registering the restartable data.

Definition at line 63 of file Restartable.C.

{
  return _restartable_app.registerRestartableData(
      std::move(data), tid, _restartable_read_only, _metaname);
}

Referenced by Restartable::declareRestartableDataHelper().

◆ registerRestartableNameWithFilterOnApp()

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

privateinherited

Helper function for actually registering the restartable data.

Definition at line 71 of file Restartable.C.

{
  _restartable_app.registerRestartableNameWithFilter(name, filter);
}

Referenced by Restartable::declareRecoverableData().

◆ registerTimedSection() [1/2]

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

protectedinherited

Call to register a named section for timing.

Parameters

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

Returns: The ID of the section - use when starting timing

Definition at line 61 of file PerfGraphInterface.C.

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

◆ registerTimedSection() [2/2]

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

protectedinherited

Call to register a named section for timing.

Parameters

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

Returns: The ID of the section - use when starting timing

Definition at line 72 of file PerfGraphInterface.C.

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

◆ restartableName()

std::string Restartable::restartableName ( const std::string & data_name ) const

protectedinherited

Gets the name of a piece of restartable data given a data name, adding the system name and object name prefix.

This should only be used in this interface and in testing.

Definition at line 78 of file Restartable.C.

{
  return _restartable_system_name + "/" + _restartable_name + "/" + data_name;
}

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

◆ setCouplingMatrix()

void MoosePreconditioner::setCouplingMatrix ( std::unique_ptr< libMesh::CouplingMatrix > cm )

protectedinherited

Setup the coupling matrix on the finite element problem.

Definition at line 140 of file MoosePreconditioner.C.

{
  _fe_problem.setCouplingMatrix(std::move(cm), _nl_sys_num);
}

Referenced by FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), SingleMatrixPreconditioner::SingleMatrixPreconditioner(), and VariableCondensationPreconditioner().

◆ setup()

void VariableCondensationPreconditioner::setup ( )

virtual

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

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

Reimplemented from libMesh::Preconditioner< Number >.

Definition at line 593 of file VariableCondensationPreconditioner.C.

{
  if (_adaptive_condensation)
    findZeroDiagonals(*_matrix, _zero_rows);
 
  // save dofs that are to be condensed out
  getDofToCondense();
 
  // solve the condensed system only when needed, otherwise solve the original system
  if (_need_condense)
  {
    // get condensed dofs for rows and cols
    getDofColRow();
 
    condenseSystem();
 
    // make sure diagonal entries are not empty
    for (const auto & i : make_range(_J_condensed->row_start(), _J_condensed->row_stop()))
      _J_condensed->add(i, i, 0.0);
    _J_condensed->close();
 
    _preconditioner->set_matrix(*_J_condensed);
  }
  else
    _preconditioner->set_matrix(*_matrix);
 
  _preconditioner->set_type(_pre_type);
  _preconditioner->init();
}

◆ timedSectionName()

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

protectedinherited

Returns: The name of the timed section with the name section_name.

Optionally adds a prefix if one is defined.

Definition at line 55 of file PerfGraphInterface.C.

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

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

◆ type()

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

inlineinherited

Get the type of this class.

Returns: the name of the type of this class

Definition at line 93 of file MooseBase.h.

  {
    mooseAssert(_type.size(), "Empty type");
    return _type;
  }

◆ typeAndName()

std::string MooseBase::typeAndName ( ) const

inherited

Get the class's combined type and name; useful in error handling.

Returns: The type and name of this class in the form '<type()> "<name()>"'.

Definition at line 57 of file MooseBase.C.

{
  return type() + std::string(" \"") + name() + std::string("\"");
}

Referenced by MaterialPropertyStorage::addProperty(), FEProblemBase::checkUserObjectNameCollision(), MeshGeneratorSystem::dataDrivenError(), ReporterContext< T >::finalize(), ReporterData::getReporterInfo(), MFEMSamplerBase::initialSetup(), MFEMVariableSamplerBase::initialSetup(), WebServerControl::outputMessage(), and Action::timedAct().

◆ uniqueName()

MooseObjectName MooseBase::uniqueName ( ) const

inherited

Returns: The unique name for accessing input parameters of this object in the InputParameterWarehouse

Definition at line 69 of file MooseBase.C.

{
  if (!_pars.have_parameter<std::string>(unique_name_param))
    mooseError("uniqueName(): Object does not have a unique name");
  return MooseObjectName(_pars.get<std::string>(unique_name_param));
}

Referenced by MooseBase::connectControllableParams(), and Action::uniqueActionName().

◆ uniqueParameterName()

MooseObjectParameterName MooseBase::uniqueParameterName ( const std::string & parameter_name ) const

inherited

Returns: The unique parameter name of a valid parameter of this object for accessing parameter controls

Definition at line 63 of file MooseBase.C.

{
  return MooseObjectParameterName(getBase(), name(), parameter_name);
}

◆ validParams()

InputParameters VariableCondensationPreconditioner::validParams ( )

static

Definition at line 41 of file VariableCondensationPreconditioner.C.

{
  InputParameters params = MoosePreconditioner::validParams();
 
  params.addClassDescription(
      "Variable condensation preconditioner (VCP) condenses out specified variable(s) "
      "from the Jacobian matrix and produces a system of equations with less unkowns to "
      "be solved by the underlying preconditioners.");
 
  params.addParam<std::vector<NonlinearVariableName>>(
      "coupled_groups",
      {},
      "List multiple space separated groups of comma separated variables. "
      "Off-diagonal jacobians will be generated for all pairs within a group.");
 
  params.addParam<bool>(
      "is_lm_coupling_diagonal",
      false,
      "Set to true if you are sure the coupling matrix between Lagrange multiplier variable and "
      "the coupled primal variable is strict diagonal. This will speedup the linear solve. "
      "Otherwise set to false to ensure linear solve accuracy.");
  params.addParam<bool>(
      "adaptive_condensation",
      true,
      "By default VCP will check the Jacobian and only condense the rows with zero diagonals. Set "
      "to false if you want to condense out all the specified variable dofs.");
  params.addRequiredParam<std::vector<std::string>>("preconditioner", "Preconditioner type.");
  params.addRequiredParam<std::vector<std::string>>(
      "lm_variable",
      "Name of the variable(s) that is to be condensed out. Usually "
      "this will be the Lagrange multiplier variable(s).");
  params.addRequiredParam<std::vector<std::string>>(
      "primary_variable",
      "Name of the variable(s) that couples with the variable(s) specified in the `variable` "
      "block. Usually this is the primary variable that the Lagrange multiplier correspond to.");
  return params;
}

Member Data Documentation

◆ _action_factory

ActionFactory& ParallelParamObject::_action_factory

protectedinherited

Builds Actions.

Definition at line 40 of file ParallelParamObject.h.

Referenced by AddActionComponentAction::act(), CreateMeshSetupActionsForComponents::act(), ActionComponent::checkRequiredTasks(), PhysicsBase::checkRequiredTasks(), CommonOutputAction::create(), AddVariableAction::createInitialConditionAction(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), CreateExecutionerAction::setupAutoPreconditioning(), and ReadExecutorParamsAction::setupAutoPreconditioning().

◆ _adaptive_condensation

const bool VariableCondensationPreconditioner::_adaptive_condensation

private

Whether to condense all specified variable.

Definition at line 154 of file VariableCondensationPreconditioner.h.

Referenced by getDofToCondense(), and setup().

◆ _app

MooseApp& MooseBase::_app

protectedinherited

The MOOSE application this is associated with.

Definition at line 375 of file MooseBase.h.

Referenced by AB2PredictorCorrector::AB2PredictorCorrector(), FEProblemBase::acceptInvalidSolution(), FEProblemBase::addAnyRedistributers(), MeshGenerator::addChildMeshGenerator(), FEProblemBase::addMaterialHelper(), MeshGenerator::addMeshSubgenerator(), MeshGenerator::addMeshSubgenerator(), FEProblemBase::addOutput(), MeshGenerator::addParentMeshGenerator(), FEProblemBase::allowOutput(), AStableDirk4::AStableDirk4(), FileMesh::buildMesh(), MooseMesh::buildTypedMesh(), MooseMesh::cacheFaceInfoVariableOwnership(), MooseMesh::cacheFVElementalDoFs(), DefaultNonlinearConvergence::checkConvergence(), MeshGenerator::checkGetMesh(), FEProblemBase::checkICRestartError(), FEProblemBase::checkProblemIntegrity(), LibmeshPartitioner::clone(), BlockWeightedPartitioner::clone(), CopyMeshPartitioner::clone(), GridPartitioner::clone(), HierarchicalGridPartitioner::clone(), PetscExternalPartitioner::clone(), RandomPartitioner::clone(), SingleRankPartitioner::clone(), ElementPointNeighborLayers::clone(), ElementSideNeighborLayers::clone(), GhostAllPointNeighbors::clone(), GhostBoundary::clone(), GhostEverything::clone(), GhostHigherDLowerDPointNeighbors::clone(), GhostLowerDElems::clone(), GhostPrimaryFace::clone(), ProxyRelationshipManager::clone(), RedistributeProperties::clone(), SampledOutput::cloneMesh(), FEProblemBase::computeJacobianSys(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualSys(), FEProblemBase::computeResidualTags(), Console::Console(), TimeStepper::constrainStep(), Control::Control(), CopyMeshPartitioner::CopyMeshPartitioner(), MultiApp::createApp(), MultiApp::createApps(), FEProblemBase::customSetup(), MeshGenerator::declareMeshProperty(), MeshGenerator::declareNullMeshName(), MooseMesh::determineUseDistributedMesh(), DumpObjectsProblem::dumpObjectHelper(), DumpObjectsProblem::DumpObjectsProblem(), DumpObjectsProblem::dumpVariableHelper(), EigenExecutionerBase::EigenExecutionerBase(), EigenKernel::EigenKernel(), PIDTransientControl::execute(), Eigenvalue::execute(), InversePowerMethod::execute(), NonlinearEigen::execute(), SteadyBase::execute(), TransientBase::execute(), MFEMSteady::execute(), PseudoTimestep::execute(), IterationInfo::execute(), EigenProblem::execute(), Executioner::Executioner(), Executioner::Executioner(), ExtraIDIntegralReporter::ExtraIDIntegralReporter(), FEProblemBase::FEProblemBase(), FileOutput::FileOutput(), NEML2Assembly::finalize(), ChangeOverFixedPointPostprocessor::finalize(), RadialAverage::finalize(), FixedPointSolve::FixedPointSolve(), FEProblemBase::forceOutput(), FullSolveMultiApp::FullSolveMultiApp(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), FVAdvection::FVAdvection(), FileMeshGenerator::generate(), MeshGenerator::generateInternal(), MeshGenerator::generateInternalCSG(), MeshGenerator::getCSGBaseByName(), FEProblemBase::getExecutor(), MeshGenerator::getMeshByName(), NumFixedPointIterations::getValue(), NumRelationshipManagers::getValue(), GhostingUserObject::GhostingUserObject(), MooseMesh::init(), Eigenvalue::init(), InversePowerMethod::init(), NonlinearEigen::init(), TransientBase::init(), MFEMMesh::init(), FEProblemBase::init(), CompositionDT::init(), SubProblem::initialSetup(), PIDTransientControl::initialSetup(), RealFunctionControl::initialSetup(), TimePeriod::initialSetup(), EigenProblemSolve::initialSetup(), FEProblemSolve::initialSetup(), Console::initialSetup(), FEProblemBase::initialSetup(), BoundaryMeshBuilder::initialSetup(), AdvancedOutput::initOutputList(), FEProblemBase::initPetscOutputAndSomeSolverSettings(), EigenProblem::initPetscOutputAndSomeSolverSettings(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), FEProblemBase::meshChanged(), MeshGenerator::MeshGenerator(), MFEMProblemSolve::MFEMProblemSolve(), MooseMesh::MooseMesh(), MooseMesh::MooseMesh(), MooseObject::MooseObject(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), EigenExecutionerBase::normalizeSolution(), NumFailedTimeSteps::NumFailedTimeSteps(), Checkpoint::output(), Exodus::output(), Nemesis::output(), PerfGraphOutput::output(), Tecplot::output(), MortarNodalGeometryOutput::output(), ControlOutput::outputActiveObjects(), ControlOutput::outputChangedControls(), ControlOutput::outputControls(), Exodus::outputEmptyTimestep(), Console::outputInput(), Exodus::outputInput(), Exodus::outputNodalVariables(), JSONOutput::outputReporters(), Output::outputStep(), SampledOutput::outputStep(), FEProblemBase::outputStep(), Console::outputSystemInformation(), JSONOutput::outputSystemInformation(), OverlayMeshGenerator::OverlayMeshGenerator(), MultiApp::parentOutputPositionChanged(), TransientBase::preExecute(), FEProblemBase::projectSolution(), AnnularMesh::safeClone(), ConcentricCircleMesh::safeClone(), FileMesh::safeClone(), GeneratedMesh::safeClone(), ImageMesh::safeClone(), MeshGeneratorMesh::safeClone(), PatternedMesh::safeClone(), RinglebMesh::safeClone(), SpiralAnnularMesh::safeClone(), StitchedMesh::safeClone(), TiledMesh::safeClone(), MFEMFileMesh::safeClone(), MFEMMeshGeneratorMesh::safeClone(), MultiApp::setAppOutputFileBase(), FileOutput::setFileBaseInternal(), MeshGenerator::setMeshProperty(), MeshGenerator::setMeshPropertyHelper(), FEProblemBase::setRestartFile(), TransientMultiApp::setupApp(), TimeSequenceStepperBase::setupSequence(), TransientBase::setupTimeIntegrator(), Output::setWallTimeIntervalFromCommandLineParam(), SideSetExtruderGenerator::SideSetExtruderGenerator(), SolutionInvalidityReporter::SolutionInvalidityReporter(), FixedPointSolve::solve(), FEProblemBase::solve(), EigenProblem::solve(), FEProblemBase::solveLinearSystem(), PetscOutput::solveSetup(), FixedPointSolve::solveStep(), TransientMultiApp::solveStep(), FEProblemBase::subdomainSetup(), FEProblemBase::theWarehouse(), TimeExtremeValue::TimeExtremeValue(), TimeIntegratedPostprocessor::TimeIntegratedPostprocessor(), TimeIntervalTimes::TimeIntervalTimes(), TimePeriod::TimePeriod(), SubProblem::timestepSetup(), PIDTransientControl::timestepSetup(), FEProblemBase::timestepSetup(), TransientBase::TransientBase(), MooseMesh::update(), NEML2FEInterpolation::updateDofMap(), NEML2FEInterpolation::updateGradPhi(), NEML2FEInterpolation::updateInterpolations(), FEProblemBase::updateMortarMesh(), NEML2FEInterpolation::updatePhi(), Console::write(), and FEProblemBase::~FEProblemBase().

◆ _apply_timer

PerfID VariableCondensationPreconditioner::_apply_timer

private

Definition at line 221 of file VariableCondensationPreconditioner.h.

Referenced by apply().

◆ _cols

std::vector<dof_id_type> VariableCondensationPreconditioner::_cols

private

Definition at line 208 of file VariableCondensationPreconditioner.h.

Referenced by condenseSystem(), and getDofColRow().

◆ _cols_to_idx

std::unordered_map<dof_id_type, dof_id_type> VariableCondensationPreconditioner::_cols_to_idx

private

Definition at line 212 of file VariableCondensationPreconditioner.h.

Referenced by getDofColRow().

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

◆ _D

std::unique_ptr<PetscMatrix<Number> > VariableCondensationPreconditioner::_D

private

Submatrices that are frequently needed while computing the condensed system _D: the submatrix that couples the primary variable with the Lagrange multiplier variable _M: the columns that correspond to the Lagrange multiplier DoFs _K: the rows that correspond to the primary variable DoFs.

Definition at line 171 of file VariableCondensationPreconditioner.h.

Referenced by computeCondensedVariables(), computeDInverse(), computeDInverseDiag(), and condenseSystem().

◆ _dinv

Mat VariableCondensationPreconditioner::_dinv

private

inverse of _D

Definition at line 173 of file VariableCondensationPreconditioner.h.

Referenced by clear(), computeCondensedVariables(), condenseSystem(), and getCondensedXY().

◆ _dofmap

const libMesh::DofMap& VariableCondensationPreconditioner::_dofmap

private

DofMap for easy reference.

Definition at line 148 of file VariableCondensationPreconditioner.h.

Referenced by getDofColRow(), and getDofToCondense().

◆ _enabled

const bool& MooseObject::_enabled

protectedinherited

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

Definition at line 71 of file MooseObject.h.

Referenced by MooseObject::enabled().

◆ _factory

Factory& ParallelParamObject::_factory

protectedinherited

The Factory associated with the MooseApp.

Definition at line 37 of file ParallelParamObject.h.

Referenced by ElementIDOutputAction::act(), AdaptivityAction::act(), AddControlAction::act(), AddNodalNormalsAction::act(), AddPeriodicBCAction::act(), AutoCheckpointAction::act(), CombineComponentsMeshes::act(), CommonOutputAction::act(), ComposeTimeStepperAction::act(), CreateDisplacedProblemAction::act(), CreateExecutionerAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), DisplayGhostingAction::act(), MaterialDerivativeTestAction::act(), MaterialOutputAction::act(), PartitionerAction::act(), SetAdaptivityOptionsAction::act(), SetupDebugAction::act(), SetupMeshAction::act(), SetupPreconditionerAction::act(), SetupPredictorAction::act(), SetupResidualDebugAction::act(), SetupTimeStepperAction::act(), ComponentJunction::addMeshGenerators(), ComponentMeshTransformHelper::addMeshGenerators(), CylinderComponent::addMeshGenerators(), DiffusionPhysicsBase::addPostprocessors(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), AddActionComponentAction::addRelationshipManagers(), SampledOutput::cloneMesh(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), PhysicsBase::getFactory(), ActionComponent::getFactory(), PhysicsBase::getFactory(), MaterialOutputAction::getParams(), MFEMTransient::MFEMTransient(), and ProjectedStatefulMaterialStorageAction::processProperty().

◆ _fe_problem

FEProblemBase& MoosePreconditioner::_fe_problem

protectedinherited

Subproblem this preconditioner is part of.

Definition at line 65 of file MoosePreconditioner.h.

Referenced by PhysicsBasedPreconditioner::addSystem(), PhysicsBasedPreconditioner::apply(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), MoosePreconditioner::initialSetup(), MooseStaticCondensationPreconditioner::initialSetup(), MoosePreconditioner::MoosePreconditioner(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), MoosePreconditioner::setCouplingMatrix(), PhysicsBasedPreconditioner::setup(), and SingleMatrixPreconditioner::SingleMatrixPreconditioner().

◆ _global_cols

std::vector<dof_id_type> VariableCondensationPreconditioner::_global_cols

private

Definition at line 208 of file VariableCondensationPreconditioner.h.

Referenced by condenseSystem(), getCondensedXY(), getDofColRow(), and getFullSolution().

◆ _global_cols_to_idx

std::unordered_map<dof_id_type, dof_id_type> VariableCondensationPreconditioner::_global_cols_to_idx

private

Definition at line 212 of file VariableCondensationPreconditioner.h.

Referenced by computeCondensedJacobian(), getDofColRow(), and preallocateCondensedJacobian().

◆ _global_lm_dofs

std::vector<dof_id_type> VariableCondensationPreconditioner::_global_lm_dofs

private

Vectors of DoFs: indices associated with lagrange multipliers, and its coupled primary variable global<variable_name>_dofs represents the indices that are owned by all processors _<variable_name>_dofs represents the indices that are owned only by each processor lm: the Lagrange multiplier primary: the primal variable DoFs that couples with the Lagrange multiplier Note: the global index sets may not be scalable and necessary memory optimization will be investigated later.

Definition at line 205 of file VariableCondensationPreconditioner.h.

Referenced by getDofToCondense(), and getFullSolution().

◆ _global_primary_dofs

std::vector<dof_id_type> VariableCondensationPreconditioner::_global_primary_dofs

private

Definition at line 205 of file VariableCondensationPreconditioner.h.

Referenced by computeDInverseDiag(), condenseSystem(), getCondensedXY(), getDofColRow(), and getDofToCondense().

◆ _global_rows

std::vector<dof_id_type> VariableCondensationPreconditioner::_global_rows

private

row and column indices for the condensed system

Definition at line 208 of file VariableCondensationPreconditioner.h.

Referenced by condenseSystem(), getCondensedXY(), and getDofColRow().

◆ _global_rows_to_idx

std::unordered_map<dof_id_type, dof_id_type> VariableCondensationPreconditioner::_global_rows_to_idx

private

Maps to keep track of row and col indices from the original Jacobian matrix to the condensed Jacobian matrix.

Definition at line 211 of file VariableCondensationPreconditioner.h.

Referenced by getDofColRow(), and preallocateCondensedJacobian().

◆ _init_timer

PerfID VariableCondensationPreconditioner::_init_timer

private

Timers.

Definition at line 220 of file VariableCondensationPreconditioner.h.

Referenced by init().

◆ _is_lm_coupling_diagonal

const bool VariableCondensationPreconditioner::_is_lm_coupling_diagonal

private

Whether the coupling is diagonal.

Definition at line 151 of file VariableCondensationPreconditioner.h.

Referenced by condenseSystem().

◆ _J_condensed

std::unique_ptr<PetscMatrix<Number> > VariableCondensationPreconditioner::_J_condensed

private

Condensed Jacobian.

Definition at line 176 of file VariableCondensationPreconditioner.h.

Referenced by condenseSystem(), getCondensedXY(), and setup().

◆ _K

std::unique_ptr<PetscMatrix<Number> > VariableCondensationPreconditioner::_K

private

Definition at line 171 of file VariableCondensationPreconditioner.h.

Referenced by computeCondensedVariables(), and condenseSystem().

◆ _lm_dofs

std::vector<dof_id_type> VariableCondensationPreconditioner::_lm_dofs

private

Definition at line 205 of file VariableCondensationPreconditioner.h.

Referenced by condenseSystem(), and getDofToCondense().

◆ _lm_sol_vec

std::unique_ptr<NumericVector<Number> > VariableCondensationPreconditioner::_lm_sol_vec

private

Definition at line 181 of file VariableCondensationPreconditioner.h.

Referenced by computeCondensedVariables(), and getFullSolution().

◆ _lm_var_ids

std::vector<unsigned int> VariableCondensationPreconditioner::_lm_var_ids

private

Definition at line 161 of file VariableCondensationPreconditioner.h.

Referenced by getDofToCondense(), and VariableCondensationPreconditioner().

◆ _lm_var_names

const std::vector<std::string> VariableCondensationPreconditioner::_lm_var_names

private

Name and ID of the variables that are to be condensed out (usually the Lagrange multiplier variable)

Definition at line 160 of file VariableCondensationPreconditioner.h.

Referenced by VariableCondensationPreconditioner().

◆ _M

std::unique_ptr<PetscMatrix<Number> > VariableCondensationPreconditioner::_M

private

Definition at line 171 of file VariableCondensationPreconditioner.h.

Referenced by condenseSystem(), and getCondensedXY().

◆ _map_global_lm_primary

std::unordered_map<dof_id_type, dof_id_type> VariableCondensationPreconditioner::_map_global_lm_primary

private

Maps to keep track of the dof orders for keeping nonzero diagonal entries of the condensed system _map_global_lm_primary: map between _global_lm_dofs and _global_primary_dofs.

_map_global_primary_order: map between _global_primary_dofs and the corresponding row index in _D

Definition at line 217 of file VariableCondensationPreconditioner.h.

Referenced by getDofColRow(), and getDofToCondense().

◆ _map_global_primary_order

std::unordered_map<dof_id_type, dof_id_type> VariableCondensationPreconditioner::_map_global_primary_order

private

Definition at line 217 of file VariableCondensationPreconditioner.h.

Referenced by computeDInverseDiag(), and getDofToCondense().

◆ _mesh

MooseMesh& VariableCondensationPreconditioner::_mesh

private

Mesh object for easy reference.

Definition at line 145 of file VariableCondensationPreconditioner.h.

Referenced by getDofToCondense(), and VariableCondensationPreconditioner().

◆ _metaname

const RestartableDataMapName Restartable::_metaname

privateinherited

Restartable metadata name.

Definition at line 247 of file Restartable.h.

Referenced by Restartable::registerRestartableDataOnApp().

◆ _n_vars

const unsigned int VariableCondensationPreconditioner::_n_vars

private

Number of variables.

Definition at line 157 of file VariableCondensationPreconditioner.h.

Referenced by VariableCondensationPreconditioner().

◆ _name

const std::string& MooseBase::_name

protectedinherited

The name of this class.

Definition at line 381 of file MooseBase.h.

◆ _need_condense

bool VariableCondensationPreconditioner::_need_condense

mutableprivate

Whether the DoFs associated the variable are to be condensed.

If the DoF list for the variable to be condensed is empty, we do not carry out static condensation

Definition at line 189 of file VariableCondensationPreconditioner.h.

Referenced by apply(), getDofToCondense(), and setup().

◆ _nl

NonlinearSystemBase& VariableCondensationPreconditioner::_nl

private

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

Definition at line 142 of file VariableCondensationPreconditioner.h.

Referenced by VariableCondensationPreconditioner().

◆ _nl_sys_num

const unsigned int MoosePreconditioner::_nl_sys_num

protectedinherited

The nonlinear system number whose linearization this preconditioner should be applied to.

Definition at line 68 of file MoosePreconditioner.h.

Referenced by FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), MoosePreconditioner::setCouplingMatrix(), and SingleMatrixPreconditioner::SingleMatrixPreconditioner().

◆ _parent

const ParallelParamObject& DataFileInterface::_parent

privateinherited

Definition at line 58 of file DataFileInterface.h.

Referenced by DataFileInterface::getDataFileName(), DataFileInterface::getDataFileNameByName(), and DataFileInterface::getDataFilePath().

◆ _pars

const InputParameters& MooseBase::_pars

protectedinherited

The object's parameters.

Definition at line 384 of file MooseBase.h.

Referenced by AddAuxKernelAction::act(), AddFVICAction::act(), AddICAction::act(), CommonOutputAction::act(), ComposeTimeStepperAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), SetupDebugAction::act(), SetupMeshAction::act(), AddMFEMComplexBCComponentAction::act(), AddMFEMComplexKernelComponentAction::act(), FunctorMaterial::addFunctorPropertyByBlocks(), BreakMeshByBlockGenerator::BreakMeshByBlockGenerator(), PNGOutput::calculateRescalingValues(), MooseBase::callMooseError(), MooseBase::connectControllableParams(), Console::Console(), MooseApp::copyInputs(), MaterialBase::declareADProperty(), Moose::Kokkos::MaterialBase::declareKokkosOnDemandProperty(), Moose::Kokkos::MaterialBase::declareKokkosProperty(), MaterialBase::declareProperty(), FEProblemSolve::FEProblemSolve(), FileMeshGenerator::generate(), MooseBase::getBase(), MooseBase::getCheckedPointerParam(), MaterialBase::getGenericZeroMaterialProperty(), MooseBase::getHitNode(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), MooseBase::getParam(), MooseBase::getParam(), MooseBase::hasBase(), MeshGenerator::hasGenerateCSG(), MeshGenerator::hasGenerateData(), AddVariableAction::init(), AdvancedOutput::initExecutionTypes(), EigenProblemSolve::initialSetup(), Console::initialSetup(), MooseBase::isParamSetByUser(), MooseBase::isParamValid(), MultiApp::keepSolutionDuringRestore(), MooseBase::messagePrefix(), MooseBase::MooseBase(), MultiSystemSolveObject::MultiSystemSolveObject(), MooseApp::outputMachineReadableData(), MooseBase::paramError(), MooseBase::parameters(), MooseBase::paramInfo(), MooseBase::paramWarning(), MooseMesh::prepare(), MooseBase::queryParam(), MooseMesh::setCoordSystem(), MooseMesh::setPartitionerHelper(), SetupMeshAction::setupMesh(), TransientBase::setupTimeIntegrator(), MooseApp::showInputs(), and MooseBase::uniqueName().

◆ _pg_moose_app

MooseApp& PerfGraphInterface::_pg_moose_app

protectedinherited

The MooseApp that owns the PerfGraph.

Definition at line 135 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::perfGraph().

◆ _pre_type

libMesh::PreconditionerType VariableCondensationPreconditioner::_pre_type

private

Which preconditioner to use for the solve.

Definition at line 192 of file VariableCondensationPreconditioner.h.

Referenced by setup(), and VariableCondensationPreconditioner().

◆ _preconditioner

std::unique_ptr<Preconditioner<Number> > VariableCondensationPreconditioner::_preconditioner

private

Holds one Preconditioner object for the condensed system to solve.

Definition at line 195 of file VariableCondensationPreconditioner.h.

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

◆ _prefix

const std::string PerfGraphInterface::_prefix

protectedinherited

A prefix to use for all sections.

Definition at line 138 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::timedSectionName().

◆ _primary_dofs

std::vector<dof_id_type> VariableCondensationPreconditioner::_primary_dofs

private

Definition at line 205 of file VariableCondensationPreconditioner.h.

Referenced by condenseSystem(), and getDofToCondense().

◆ _primary_rhs_vec

std::unique_ptr<NumericVector<Number> > VariableCondensationPreconditioner::_primary_rhs_vec

private

Definition at line 181 of file VariableCondensationPreconditioner.h.

Referenced by computeCondensedVariables(), and getCondensedXY().

◆ _primary_var_ids

std::vector<unsigned int> VariableCondensationPreconditioner::_primary_var_ids

private

Definition at line 165 of file VariableCondensationPreconditioner.h.

Referenced by getDofToCondense(), and VariableCondensationPreconditioner().

◆ _primary_var_names

const std::vector<std::string> VariableCondensationPreconditioner::_primary_var_names

private

Name and ID of the corresponding coupled variable.

Definition at line 164 of file VariableCondensationPreconditioner.h.

Referenced by VariableCondensationPreconditioner().

◆ _restartable_app

MooseApp& Restartable::_restartable_app

protectedinherited

Reference to the application.

Definition at line 234 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 250 of file Restartable.h.

Referenced by Restartable::declareRestartableDataWithObjectNameWithContext(), and Restartable::restartableName().

◆ _restartable_read_only

const bool Restartable::_restartable_read_only

protectedinherited

Flag for toggling read only status (see ReporterData)

Definition at line 243 of file Restartable.h.

Referenced by Restartable::registerRestartableDataOnApp().

◆ _restartable_system_name

const std::string Restartable::_restartable_system_name

protectedinherited

The system name this object is in.

Definition at line 237 of file Restartable.h.

Referenced by Restartable::restartableName().

◆ _restartable_tid

const THREAD_ID Restartable::_restartable_tid

protectedinherited

The thread ID for this object.

Definition at line 240 of file Restartable.h.

Referenced by Restartable::declareRestartableDataHelper().

◆ _rows

std::vector<dof_id_type> VariableCondensationPreconditioner::_rows

private

Definition at line 208 of file VariableCondensationPreconditioner.h.

Referenced by condenseSystem(), getDofColRow(), and preallocateCondensedJacobian().

◆ _rows_to_idx

std::unordered_map<dof_id_type, dof_id_type> VariableCondensationPreconditioner::_rows_to_idx

private

Definition at line 211 of file VariableCondensationPreconditioner.h.

Referenced by getDofColRow(), and preallocateCondensedJacobian().

◆ _si_moose_base

const MooseBase& SolutionInvalidInterface::_si_moose_base

privateinherited

The MooseBase that owns this interface.

Definition at line 111 of file SolutionInvalidInterface.h.

Referenced by SolutionInvalidInterface::flagInvalidSolutionInternal(), SolutionInvalidInterface::mooseDeprecated(), SolutionInvalidInterface::mooseWarning(), SolutionInvalidInterface::mooseWarningNonPrefixed(), SolutionInvalidInterface::paramWarning(), and SolutionInvalidInterface::registerInvalidSolutionInternal().

◆ _si_problem

const FEProblemBase* SolutionInvalidInterface::_si_problem

privateinherited

A pointer to FEProblem base.

Definition at line 114 of file SolutionInvalidInterface.h.

Referenced by SolutionInvalidInterface::flagInvalidSolutionInternal().

◆ _type

const std::string& MooseBase::_type

protectedinherited

The type of this class.

Definition at line 378 of file MooseBase.h.

Referenced by FillBetweenCurvesGenerator::generate(), FillBetweenPointVectorsGenerator::generate(), FillBetweenSidesetsGenerator::generate(), MooseBase::MooseBase(), FEProblemBase::solverTypeString(), and MooseBase::type().

◆ _x_hat

std::unique_ptr<NumericVector<Number> > VariableCondensationPreconditioner::_x_hat

private

_x_hat, _y_hat: condensed solution and RHS vectors _primary_rhs_vec: part of the RHS vector that correspond to the primary variable DoFs _lm_sol_vec: solution vector that corresponds to the LM variable

Definition at line 181 of file VariableCondensationPreconditioner.h.

Referenced by apply(), computeCondensedVariables(), getCondensedXY(), and getFullSolution().

◆ _y_hat

std::unique_ptr<NumericVector<Number> > VariableCondensationPreconditioner::_y_hat

private

Definition at line 181 of file VariableCondensationPreconditioner.h.

Referenced by apply(), and getCondensedXY().

◆ _zero_rows

std::vector<dof_id_type> VariableCondensationPreconditioner::_zero_rows

private

The row indices that correspond to the zero diagonal entries in the original Jacobian matrix This is only used when _adaptive_condensation = true.

Definition at line 185 of file VariableCondensationPreconditioner.h.

Referenced by getDofToCondense(), and setup().

◆ app_param

const std::string MooseBase::app_param = "_moose_app"

staticinherited

The name of the parameter that contains the MooseApp.

Definition at line 59 of file MooseBase.h.

Referenced by FEProblemBase::addAnyRedistributers(), MeshGenerator::addMeshSubgenerator(), InputParameters::callMooseError(), ActionFactory::create(), ActionFactory::getValidParams(), Factory::getValidParams(), AutomaticMortarGeneration::initOutput(), SetupMeshAction::modifyParamsForUseSplit(), and MortarNodalGeometryOutput::validParams().

◆ kokkos_object_param

const std::string MooseBase::kokkos_object_param = "_kokkos_object"

staticinherited

The name of the parameter that indicates an object is a Kokkos functor.

Definition at line 64 of file MooseBase.h.

Referenced by InputParameters::isKokkosObject().

◆ moose_base_param

const std::string MooseBase::moose_base_param = "_moose_base"

staticinherited

The name of the parameter that contains the moose system base.

Definition at line 61 of file MooseBase.h.

Referenced by InputParameters::getBase(), InputParameters::hasBase(), and InputParameters::registerBase().

◆ name_param

const std::string MooseBase::name_param = "_object_name"

staticinherited

The name of the parameter that contains the object name.

Definition at line 55 of file MooseBase.h.

Referenced by InputParameterWarehouse::addInputParameters(), ActionUnitTest::buildMinimalObjects(), MooseObjectUnitTest::buildObjects(), AppFactory::create(), InputParameters::getObjectName(), AutomaticMortarGeneration::initOutput(), InputParameters::isMooseBaseObject(), MooseMesh::prepare(), CouplingFunctorCheckAction::validParams(), and MooseBase::validParams().

◆ type_param

const std::string MooseBase::type_param = "_type"

staticinherited

The name of the parameter that contains the object type.

Definition at line 53 of file MooseBase.h.

Referenced by ActionFactory::create(), AppFactory::create(), InputParameters::getObjectType(), Factory::initialize(), InputParameters::isMooseBaseObject(), InputParameters::queryObjectType(), MooseBase::validParams(), and MortarNodalGeometryOutput::validParams().

◆ unique_name_param

const std::string MooseBase::unique_name_param = "_unique_name"

staticinherited

The name of the parameter that contains the unique object name.

Definition at line 57 of file MooseBase.h.

Referenced by InputParameterWarehouse::addInputParameters(), AppFactory::create(), InputParameterWarehouse::removeInputParameters(), MooseBase::uniqueName(), and MooseBase::validParams().

◆ usingCombinedWarningSolutionWarnings

MooseObject::usingCombinedWarningSolutionWarnings

inherited

Definition at line 67 of file MooseObject.h.

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

include/preconditioners/VariableCondensationPreconditioner.h
src/preconditioners/VariableCondensationPreconditioner.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Types

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ DataFileParameterType

Constructor & Destructor Documentation

◆ VariableCondensationPreconditioner()

◆ ~VariableCondensationPreconditioner()

Member Function Documentation

◆ apply()

◆ callMooseError() [1/2]

◆ callMooseError() [2/2]

◆ clear()

◆ computeCondensedJacobian()

◆ computeCondensedVariables()

◆ computeDInverse()

◆ computeDInverseDiag()

◆ condenseSystem()

◆ connectControllableParams()

◆ copyVarValues()

◆ declareManagedRestartableDataWithContext()

◆ declareRecoverableData()

◆ declareRestartableData()

◆ declareRestartableDataHelper()

◆ declareRestartableDataWithContext()

◆ declareRestartableDataWithObjectName()

◆ declareRestartableDataWithObjectNameWithContext()

◆ enabled()

◆ errorPrefix()

◆ findZeroDiagonals()

◆ flagInvalidSolutionInternal()

◆ getBase()

◆ getCheckedPointerParam()

◆ getCondensedXY()

◆ getDataFileName()

◆ getDataFileNameByName()

◆ getDataFilePath()

◆ getDofColRow()

◆ getDofToCondense()

◆ getFullSolution()

◆ getHitNode() [1/2]

◆ getHitNode() [2/2]

◆ getMooseApp()

◆ getParam() [1/2]

◆ getParam() [2/2]

◆ getRenamedParam()

◆ getRestartableData()

◆ getSharedPtr() [1/2]

◆ getSharedPtr() [2/2]

◆ hasBase()

◆ init()

◆ initialSetup()

◆ isKokkosObject()

◆ isParamSetByUser()

◆ isParamValid()

◆ mergeArrays()

◆ messagePrefix() [1/2]

◆ messagePrefix() [2/2]

◆ mooseDeprecated() [1/2]

◆ mooseDeprecated() [2/2]

◆ mooseDeprecatedNoTrace()

◆ mooseDocumentedError()

◆ mooseError()

◆ mooseErrorNonPrefixed()

◆ mooseInfo()

◆ mooseWarning() [1/2]

◆ mooseWarning() [2/2]

◆ mooseWarningNonPrefixed() [1/2]

◆ mooseWarningNonPrefixed() [2/2]

◆ name()