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

Public Member Functions
	VariableCondensationPreconditioner (const InputParameters &params)

virtual	~VariableCondensationPreconditioner ()

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

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

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

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

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

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

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

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

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

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

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

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

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

MooseObjectName	uniqueName () const

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

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

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

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

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

template<typename T >
T	getCheckedPointerParam (const std::string &name, const std::string &error_string="") const
	Verifies that the requested parameter exists and is not NULL and returns it to the caller. More...

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

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

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

template<typename... Args>
void	paramError (const std::string &param, Args... args) const
	Emits an error prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message. More...

template<typename... Args>
void	paramWarning (const std::string &param, Args... args) const
	Emits a warning prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message. More...

template<typename... Args>
void	paramInfo (const std::string &param, Args... args) const
	Emits an informational message prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message. More...

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

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

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

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

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

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

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

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

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

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

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

PerfGraph &	perfGraph ()
	Get the PerfGraph. More...

virtual bool	initialized () const

virtual void	apply (const NumericVector< Number > &x, NumericVector< Number > &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. More...

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

static std::unique_ptr< Preconditioner< Number > >	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
const ConsoleStream	_console
	An instance of helper class to write streams to the Console objects. More...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

MooseApp &	_app
	The MOOSE application this is associated with. More...

Factory &	_factory
	The Factory associated with the MooseApp. More...

ActionFactory &	_action_factory
	Builds Actions. More...

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

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

const InputParameters &	_pars
	The object's parameters. More...

const Parallel::Communicator &	_communicator

MooseApp &	_restartable_app
	Reference to the application. More...

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

const THREAD_ID	_restartable_tid
	The thread ID for this object. More...

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

MooseApp &	_pg_moose_app
	The MooseApp that owns the PerfGraph. More...

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

SparseMatrix< Number > *	_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. More...

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

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

void	condenseSystem ()
	Reconstruct the equation system. More...

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

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

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

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

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

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

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

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

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

MooseMesh &	_mesh
	Mesh object for easy reference. More...

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

const bool	_is_lm_coupling_diagonal
	Whether the coupling is diagonal. More...

const bool	_adaptive_condensation
	Whether to condense all specified variable. More...

const unsigned int	_n_vars
	Number of variables. More...

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

std::vector< unsigned int >	_lm_var_ids

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

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

std::unique_ptr< PetscMatrix< Number > >	_M

std::unique_ptr< PetscMatrix< Number > >	_K

Mat	_dinv
	inverse of _D More...

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

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

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

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

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

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

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

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

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

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

std::unordered_map< dof_id_type, dof_id_type >	_map_global_primary_order

PerfID	_init_timer
	Timers. More...

PerfID	_apply_timer

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 81 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 193 of file VariableCondensationPreconditioner.C.

193 { this->clear(); }

VariableCondensationPreconditioner::clear

virtual void clear()

Release all memory and clear data structures.

Definition: VariableCondensationPreconditioner.C:758

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 626 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	(	std::string	msg,
		const bool	with_prefix,
		const hit::Node *	node = `nullptr`
	)		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

Definition at line 102 of file MooseBase.C.

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

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

◆ callMooseError() [2/2]

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

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

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

◆ clear()

void VariableCondensationPreconditioner::clear ( )

virtual

Release all memory and clear data structures.

Reimplemented from libMesh::Preconditioner< Number >.

Definition at line 758 of file VariableCondensationPreconditioner.C.

Referenced by ~VariableCondensationPreconditioner().

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

◆ 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 400 of file VariableCondensationPreconditioner.C.

Referenced by condenseSystem().

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

◆ computeCondensedVariables()

void VariableCondensationPreconditioner::computeCondensedVariables ( )

private

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

Definition at line 684 of file VariableCondensationPreconditioner.C.

Referenced by apply().

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

◆ 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 765 of file VariableCondensationPreconditioner.C.

Referenced by condenseSystem().

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

◆ 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 825 of file VariableCondensationPreconditioner.C.

Referenced by condenseSystem().

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

◆ condenseSystem()

void VariableCondensationPreconditioner::condenseSystem ( )

private

Reconstruct the equation system.

Definition at line 345 of file VariableCondensationPreconditioner.C.

Referenced by setup().

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

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

Referenced by PhysicsBasedPreconditioner::apply().

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

◆ 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 276 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 351 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 269 of file Restartable.h.

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

◆ 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 294 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 323 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 333 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 39 of file MooseObject.h.

Referenced by EigenKernel::enabled().

39 { return _enabled; }

MooseObject::_enabled

const bool & _enabled

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

Definition: MooseObject.h:50

◆ errorPrefix()

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

inlineinherited

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

Definition at line 260 of file MooseBase.h.

260 { return messagePrefix(); }

MooseBase::messagePrefix

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

Definition: MooseBase.h:252

◆ 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 730 of file VariableCondensationPreconditioner.C.

Referenced by setup().

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

◆ getBase()

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

inlineinherited

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

Definition at line 143 of file MooseBase.h.

Referenced by Factory::copyConstruct(), and MooseBase::uniqueParameterName().

143 { return _pars.getBase(); }

MooseBase::_pars

const InputParameters & _pars

The object's parameters.

Definition: MooseBase.h:362

InputParameters::getBase

const std::string & getBase() const

Definition: InputParameters.C:497

◆ 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 428 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 648 of file VariableCondensationPreconditioner.C.

Referenced by apply().

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

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

Referenced by DataFileInterface::getDataFileNameByName().

 {
   // 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.");
 
   // Throw on error so that if getPath() fails, we can throw an error
   // with the context of _parent.mooseError()
   const auto throw_on_error_before = Moose::_throw_on_error;
   Moose::_throw_on_error = true;
   std::optional<std::string> error;
 
   // This will search the data paths for this relative path
   Moose::DataFileUtils::Path found_path;
   try
   {
     found_path = Moose::DataFileUtils::getPath(relative_path);
   }
   catch (std::exception & e)
   {
     error = e.what();
   }
 
   Moose::_throw_on_error = throw_on_error_before;
   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;
 }

◆ getDofColRow()

void VariableCondensationPreconditioner::getDofColRow ( )

private

Get row and col dofs for the condensed system.

Definition at line 276 of file VariableCondensationPreconditioner.C.

Referenced by setup().

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

◆ getDofToCondense()

void VariableCondensationPreconditioner::getDofToCondense ( )

private

Get dofs for the variable to be condensed out.

Definition at line 196 of file VariableCondensationPreconditioner.C.

Referenced by setup().

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

◆ getFullSolution()

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

private

Assemble the full solution vector.

Definition at line 705 of file VariableCondensationPreconditioner.C.

Referenced by apply().

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

◆ getHitNode()

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

inlineinherited

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

Definition at line 132 of file MooseBase.h.

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

132 { return getHitNode(_pars); }

MooseBase::_pars

const InputParameters & _pars

The object's parameters.

Definition: MooseBase.h:362

MooseBase::getHitNode

const hit::Node * getHitNode() const

Definition: MooseBase.h:132

◆ getMooseApp()

MooseApp& MooseBase::getMooseApp ( ) const

inlineinherited

Get the MooseApp this class is associated with.

Definition at line 83 of file MooseBase.h.

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(), MortarData::createMortarInterface(), EigenProblem::doFreeNonlinearPowerIterations(), Terminator::execute(), FEProblemSolve::FEProblemSolve(), SolutionInvalidInterface::flagInvalidSolutionInternal(), ChainControl::getChainControlDataSystem(), DefaultConvergenceBase::getSharedExecutionerParam(), ChainControlDataPostprocessor::initialSetup(), MaterialPropertyInterface::MaterialPropertyInterface(), MooseVariableDataFV< OutputType >::MooseVariableDataFV(), ProgressOutput::output(), PetscOutputInterface::petscLinearOutput(), PetscOutputInterface::petscNonlinearOutput(), PetscOutputInterface::PetscOutputInterface(), PostprocessorInterface::postprocessorsAdded(), MultiApp::preTransfer(), Reporter::Reporter(), ReporterInterface::reportersAdded(), MultiApp::restore(), and VectorPostprocessorInterface::vectorPostprocessorsAdded().

83 { return _app; }

MooseBase::_app

MooseApp & _app

The MOOSE application this is associated with.

Definition: MooseBase.h:353

◆ 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 384 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 421 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 398 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 287 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 61 of file MooseObject.C.

Referenced by MFEMProblem::addBoundaryCondition(), MFEMProblem::addKernel(), and MFEMProblem::addMFEMSolver().

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

◆ getSharedPtr() [2/2]

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

inherited

Definition at line 74 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 138 of file MooseBase.h.

138 { return _pars.hasBase(); }

MooseBase::_pars

const InputParameters & _pars

The object's parameters.

Definition: MooseBase.h:362

InputParameters::hasBase

bool hasBase() const

Definition: InputParameters.C:491

◆ init()

void VariableCondensationPreconditioner::init ( )

virtual

Initialize data structures if not done so already.

Reimplemented from libMesh::Preconditioner< Number >.

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

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

Referenced by SetupDebugAction::act(), ADConservativeAdvectionBC::ADConservativeAdvectionBC(), DiffusionCG::addFEBCs(), DiffusionPhysicsBase::addInitialConditions(), MFEMMesh::buildMesh(), LibtorchNeuralNetControl::conditionalParameterError(), MooseApp::copyInputs(), DiffusionPhysicsBase::DiffusionPhysicsBase(), MooseApp::errorCheck(), MooseBase::getRenamedParam(), DefaultConvergenceBase::getSharedExecutionerParam(), AddVariableAction::init(), PhysicsBase::initializePhysics(), ElementSubdomainModifierBase::initialSetup(), MatrixSymmetryCheck::MatrixSymmetryCheck(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), SolutionInvalidityOutput::output(), Output::Output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), PetscExternalPartitioner::partition(), PiecewiseTabularBase::PiecewiseTabularBase(), MooseMesh::prepare(), SolutionUserObjectBase::readXda(), PhysicsBase::reportPotentiallyMissedParameters(), MooseApp::runInputFile(), MooseApp::runInputs(), MFEMSolverBase::setPreconditioner(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), TimedSubdomainModifier::TimedSubdomainModifier(), and XYDelaunayGenerator::XYDelaunayGenerator().

   {
     return _pars.isParamSetByUser(name);
   }

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

195 { return _pars.isParamValid(name); }

MooseBase::_pars

const InputParameters & _pars

The object's parameters.

Definition: MooseBase.h:362

MooseBase::name

const std::string & name() const

Get the name of the class.

Definition: MooseBase.h:99

InputParameters::isParamValid

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

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

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 571 of file VariableCondensationPreconditioner.C.

Referenced by preallocateCondensedJacobian().

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

◆ messagePrefix()

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

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

   {
     return messagePrefix(_pars, hit_prefix);
   }

◆ mooseDeprecated()

template<typename... Args>

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

inlineinherited

Definition at line 310 of file MooseBase.h.

Referenced by FEProblemBase::addAuxArrayVariable(), FEProblemBase::addAuxScalarVariable(), FEProblemBase::addAuxVariable(), FEProblemBase::advanceMultiApps(), MultiApp::appProblem(), MooseMesh::buildSideList(), ChangeOverTimestepPostprocessor::ChangeOverTimestepPostprocessor(), AddVariableAction::determineType(), EigenProblem::EigenProblem(), Eigenvalue::Eigenvalue(), MooseMesh::elem(), UserForcingFunction::f(), FaceFaceConstraint::FaceFaceConstraint(), FunctionDT::FunctionDT(), RandomICBase::generateRandom(), MooseMesh::getBoundariesToElems(), DataFileInterface::getDataFileName(), DataFileInterface::getDataFileNameByName(), Control::getExecuteOptions(), FEProblemBase::getNonlinearSystem(), MooseApp::getRecoverFileBase(), FEProblemBase::getUserObjects(), FEProblemBase::hasPostprocessor(), MooseApp::hasRecoverFileBase(), MatDiffusionBase< Real >::MatDiffusionBase(), MultiAppNearestNodeTransfer::MultiAppNearestNodeTransfer(), MultiAppShapeEvaluationTransfer::MultiAppShapeEvaluationTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), NodalScalarKernel::NodalScalarKernel(), MooseMesh::node(), FixedPointSolve::numPicardIts(), RelationshipManager::operator>=(), PercentChangePostprocessor::PercentChangePostprocessor(), ReferenceResidualConvergence::ReferenceResidualConvergence(), Residual::Residual(), MooseMesh::setBoundaryToNormalMap(), Exodus::setOutputDimension(), MooseApp::setupOptions(), UserForcingFunction::UserForcingFunction(), and VariableResidual::VariableResidual().

   {
     moose::internal::mooseDeprecatedStream(
         _console, false, true, 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 273 of file MooseBase.h.

Referenced by ArrayDGLowerDKernel::ArrayDGLowerDKernel(), ArrayHFEMDirichletBC::ArrayHFEMDirichletBC(), ArrayLowerDIntegratedBC::ArrayLowerDIntegratedBC(), DGLowerDKernel::DGLowerDKernel(), HFEMDirichletBC::HFEMDirichletBC(), and LowerDIntegratedBC::LowerDIntegratedBC().

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

◆ 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 267 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 286 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 317 of file MooseBase.h.

Referenced by SetupRecoverFileBaseAction::act(), AStableDirk4::AStableDirk4(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MultiAppGeneralFieldNearestLocationTransfer::evaluateInterpValuesNearestNode(), PIDTransientControl::execute(), Executioner::Executioner(), ExplicitRK2::ExplicitRK2(), ExplicitTVDRK2::ExplicitTVDRK2(), DataFileInterface::getDataFilePath(), MFEMScalarFESpace::getFECName(), MultiAppTransfer::getPointInTargetAppFrame(), ImplicitMidpoint::ImplicitMidpoint(), ParsedDownSelectionPositions::initialize(), PropertyReadFile::initialize(), MultiAppGeneralFieldTransfer::initialSetup(), InversePowerMethod::InversePowerMethod(), LStableDirk2::LStableDirk2(), LStableDirk3::LStableDirk3(), LStableDirk4::LStableDirk4(), PNGOutput::makeMeshFunc(), NonlinearEigen::NonlinearEigen(), SolutionInvalidityOutput::output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), MooseBase::paramInfo(), ProjectionAux::ProjectionAux(), ReferenceResidualConvergence::ReferenceResidualConvergence(), MFEMDataCollection::registerFields(), FEProblemBase::setRestartFile(), MooseApp::setupOptions(), SolutionUserObjectBase::SolutionUserObjectBase(), SymmetryTransformGenerator::SymmetryTransformGenerator(), TransientBase::takeStep(), and TransientBase::TransientBase().

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

◆ mooseWarning()

template<typename... Args>

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

inlineinherited

Emits a warning prefixed with object name and type.

Definition at line 295 of file MooseBase.h.

Referenced by CopyMeshPartitioner::_do_partition(), AddKernelAction::act(), MeshOnlyAction::act(), AddFunctionAction::act(), MaterialOutputAction::act(), CommonOutputAction::act(), MFEMProblem::addFunction(), MooseMesh::addPeriodicVariable(), DiracKernelBase::addPoint(), BoundaryMarker::BoundaryMarker(), DistributedRectilinearMeshGenerator::buildCube(), MultiAppVariableValueSamplePostprocessorTransfer::cacheElemToPostprocessorData(), CartesianMeshGenerator::CartesianMeshGenerator(), CheckOutputAction::checkConsoleOutput(), MultiAppTransfer::checkMultiAppExecuteOn(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), ActionComponent::checkRequiredTasks(), PhysicsBase::checkRequiredTasks(), SampledOutput::cloneMesh(), MultiAppGeneralFieldTransfer::closestToPosition(), VariableValueElementSubdomainModifier::computeSubdomainID(), GapValueAux::computeValue(), MultiApp::createApp(), DebugResidualAux::DebugResidualAux(), MeshDiagnosticsGenerator::diagnosticsLog(), CartesianGridDivision::divisionIndex(), CylindricalGridDivision::divisionIndex(), SphericalGridDivision::divisionIndex(), ElementMaterialSampler::ElementMaterialSampler(), Postprocessor::evaluateDotWarning(), MeshDivisionFunctorReductionVectorPostprocessor::execute(), ElementQualityChecker::finalize(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), FixedPointSolve::FixedPointSolve(), SubdomainPerElementGenerator::generate(), StitchMeshGenerator::generate(), ParsedGenerateSideset::generate(), MultiAppTransfer::getAppInfo(), FunctorBinnedValuesDivision::getBinIndex(), DataFileInterface::getDataFilePath(), PointSamplerBase::getLocalElemContainingPoint(), FEProblemBase::getMaterial(), LineValueSampler::getValue(), Terminator::handleMessage(), IndicatorMarker::IndicatorMarker(), CylindricalGridDivision::initialize(), CartesianGridDivision::initialize(), SphericalGridDivision::initialize(), ElementGroupCentroidPositions::initialize(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), BoundsBase::initialSetup(), ReferenceResidualConvergence::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), FEProblemBase::initialSetup(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), MaterialBase::initStatefulProperties(), LeastSquaresFit::LeastSquaresFit(), IterationAdaptiveDT::limitDTToPostprocessorValue(), MooseApp::loadLibraryAndDependencies(), FEProblemBase::mesh(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), NewmarkBeta::NewmarkBeta(), NodalPatchRecovery::NodalPatchRecovery(), NonlocalIntegratedBC::NonlocalIntegratedBC(), NonlocalKernel::NonlocalKernel(), Output::Output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), MooseBase::paramWarning(), PiecewiseConstantFromCSV::PiecewiseConstantFromCSV(), Executioner::problem(), PropertyReadFile::readData(), TestSourceStepper::rejectStep(), PhysicsBase::reportPotentiallyMissedParameters(), MaterialBase::resetQpProperties(), SecondTimeDerivativeAux::SecondTimeDerivativeAux(), MooseMesh::setCoordSystem(), SidesetAroundSubdomainUpdater::SidesetAroundSubdomainUpdater(), FEProblemBase::sizeZeroes(), TransientMultiApp::solveStep(), Tecplot::Tecplot(), TimeDerivativeAux::TimeDerivativeAux(), Checkpoint::updateCheckpointFiles(), SampledOutput::updateSample(), PiecewiseConstantFromCSV::value(), and VariableCondensationPreconditioner().

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

◆ mooseWarningNonPrefixed()

template<typename... Args>

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

inlineinherited

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

Definition at line 304 of file MooseBase.h.

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

◆ name()

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

inlineinherited

Get the name of the class.

Returns: The name of the class

Definition at line 99 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 435 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 127 of file MooseBase.h.

127 { return _pars; }

MooseBase::_pars

const InputParameters & _pars

The object's parameters.

Definition: MooseBase.h:362

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

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

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

◆ paramWarning()

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

Referenced by GridPartitioner::_do_partition(), MultiAppTransfer::checkParentAppUserObjectExecuteOn(), EigenProblem::checkProblemIntegrity(), CombinerGenerator::copyIntoMesh(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), MultiAppNearestNodeTransfer::execute(), FEProblemSolve::FEProblemSolve(), UniqueExtraIDMeshGenerator::generate(), PlaneIDMeshGenerator::generate(), Terminator::initialSetup(), SampledOutput::initSample(), MooseMesh::MooseMesh(), FEProblemBase::setPreserveMatrixSparsityPattern(), and Terminator::Terminator().

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

◆ perfGraph()

PerfGraph & PerfGraphInterface::perfGraph ( )

inherited

Get the PerfGraph.

Definition at line 78 of file PerfGraphInterface.C.

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

 {
   return _pg_moose_app.perfGraph();
 }

◆ 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 480 of file VariableCondensationPreconditioner.C.

Referenced by condenseSystem().

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

◆ queryParam()

template<typename T >

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

inherited

Query a parameter for the object.

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

 {
   return isParamValid(name) ? &getParam<T>(name) : nullptr;
 }

◆ 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 53 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 64 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 66 of file Restartable.C.

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

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

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

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

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

◆ 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 595 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 47 of file PerfGraphInterface.C.

Referenced by PerfGraphInterface::registerTimedSection().

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

◆ 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 89 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 54 of file MooseBase.C.

Referenced by FEProblemBase::addPostprocessor(), MaterialPropertyStorage::addProperty(), FEProblemBase::addReporter(), FEProblemBase::addVectorPostprocessor(), MeshGeneratorSystem::dataDrivenError(), ReporterContext< std::vector< T > >::finalize(), and ReporterData::getReporterInfo().

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

◆ uniqueName()

MooseObjectName MooseBase::uniqueName ( ) const

inherited

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

Definition at line 66 of file MooseBase.C.

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

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

◆ 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 60 of file MooseBase.C.

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

◆ validParams()

InputParameters VariableCondensationPreconditioner::validParams ( )

static

Definition at line 43 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 353 of file MooseBase.h.

◆ _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 211 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 50 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(), AutoCheckpointAction::act(), PartitionerAction::act(), CreateExecutionerAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), SetupMeshAction::act(), AdaptivityAction::act(), CombineComponentsMeshes::act(), SetupPredictorAction::act(), SetupTimeStepperAction::act(), SetupDebugAction::act(), ComposeTimeStepperAction::act(), SetupPreconditionerAction::act(), SetupResidualDebugAction::act(), MaterialDerivativeTestAction::act(), CreateDisplacedProblemAction::act(), SetAdaptivityOptionsAction::act(), DisplayGhostingAction::act(), AddControlAction::act(), MaterialOutputAction::act(), AddPeriodicBCAction::act(), CommonOutputAction::act(), AddNodalNormalsAction::act(), ComponentMeshTransformHelper::addMeshGenerators(), CylinderComponent::addMeshGenerators(), DiffusionPhysicsBase::addPostprocessors(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), Action::addRelationshipManager(), SampledOutput::cloneMesh(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), ActionComponent::getFactory(), PhysicsBase::getFactory(), MaterialOutputAction::getParams(), 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(), MooseStaticCondensationPreconditioner::initialSetup(), MoosePreconditioner::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 211 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().

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

◆ _pars

const InputParameters& MooseBase::_pars

protectedinherited

The object's parameters.

Definition at line 362 of file MooseBase.h.

Referenced by AddFVICAction::act(), AddICAction::act(), CreateProblemDefaultAction::act(), CreateProblemAction::act(), SetupMeshAction::act(), ComposeTimeStepperAction::act(), SetupDebugAction::act(), AddAuxKernelAction::act(), AddPeriodicBCAction::act(), CommonOutputAction::act(), FunctorMaterial::addFunctorPropertyByBlocks(), BreakMeshByBlockGeneratorBase::BreakMeshByBlockGeneratorBase(), PiecewiseTabularBase::buildFromFile(), PNGOutput::calculateRescalingValues(), MooseBase::callMooseError(), MooseBase::connectControllableParams(), Console::Console(), MooseApp::copyInputs(), MaterialBase::declareADProperty(), MaterialBase::declareProperty(), FEProblemSolve::FEProblemSolve(), FunctionMaterialBase< is_ad >::FunctionMaterialBase(), FileMeshGenerator::generate(), MooseBase::getBase(), MooseBase::getCheckedPointerParam(), MaterialBase::getGenericZeroMaterialProperty(), MooseBase::getHitNode(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), MooseBase::getParam(), MooseBase::hasBase(), MeshGenerator::hasGenerateData(), AddVariableAction::init(), AdvancedOutput::initExecutionTypes(), Console::initialSetup(), MooseBase::isParamSetByUser(), MooseBase::isParamValid(), MultiApp::keepSolutionDuringRestore(), MooseBase::messagePrefix(), MooseBase::MooseBase(), MooseApp::outputMachineReadableData(), MooseBase::paramError(), GlobalParamsAction::parameters(), MooseBase::parameters(), MooseBase::paramInfo(), MooseBase::paramWarning(), MooseMesh::prepare(), Eigenvalue::prepareSolverOptions(), 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 124 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 127 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 227 of file Restartable.h.

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

◆ _restartable_read_only

const bool Restartable::_restartable_read_only

protectedinherited

Flag for toggling read only status (see ReporterData)

Definition at line 236 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 230 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 233 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().

◆ _type

const std::string& MooseBase::_type

protectedinherited

The type of this class.

Definition at line 356 of file MooseBase.h.

Referenced by ExplicitTimeIntegrator::ExplicitTimeIntegrator(), FEProblemSolve::FEProblemSolve(), FillBetweenSidesetsGenerator::generate(), FillBetweenCurvesGenerator::generate(), FillBetweenPointVectorsGenerator::generate(), ExplicitTimeIntegrator::init(), FEProblemBase::init(), MooseBase::MooseBase(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), 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(), Factory::getValidParams(), ActionFactory::getValidParams(), AutomaticMortarGeneration::initOutput(), SetupMeshAction::modifyParamsForUseSplit(), and MortarNodalGeometryOutput::validParams().

◆ 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(), MooseObjectUnitTest::buildObjects(), ActionFactory::create(), 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(), 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().

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

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

◆ declareRestartableDataWithContext()

◆ declareRestartableDataWithObjectName()

◆ declareRestartableDataWithObjectNameWithContext()

◆ enabled()

◆ errorPrefix()

◆ findZeroDiagonals()

◆ getBase()

◆ getCheckedPointerParam()

◆ getCondensedXY()

◆ getDataFileName()

◆ getDataFileNameByName()

◆ getDataFilePath()

◆ getDofColRow()

◆ getDofToCondense()

◆ getFullSolution()

◆ getHitNode()

◆ getMooseApp()

◆ getParam() [1/2]

◆ getParam() [2/2]

◆ getRenamedParam()

◆ getRestartableData()

◆ getSharedPtr() [1/2]

◆ getSharedPtr() [2/2]

◆ hasBase()

◆ init()

◆ initialSetup()

◆ isParamSetByUser()

◆ isParamValid()

◆ mergeArrays()

◆ messagePrefix()

◆ mooseDeprecated()

◆ mooseDocumentedError()

◆ mooseError()

◆ mooseErrorNonPrefixed()

◆ mooseInfo()

◆ mooseWarning()

◆ mooseWarningNonPrefixed()

◆ name()

◆ paramError()

◆ parameters()

◆ paramInfo()

◆ paramWarning()

◆ perfGraph()

◆ preallocateCondensedJacobian()

◆ queryParam()

◆ registerTimedSection() [1/2]

◆ registerTimedSection() [2/2]

◆ restartableName()