libMesh::PetscLinearSolver< T > Class Template Reference

This class provides an interface to PETSc iterative solvers that is compatible with the libMesh LinearSolver<> More...

#include <petsc_linear_solver.h>

Inheritance diagram for libMesh::PetscLinearSolver< T >:

Public Member Functions
	PetscLinearSolver (const libMesh::Parallel::Communicator &comm_in)
	Constructor.
virtual	~PetscLinearSolver ()=default
	Destructor.
virtual void	clear () override
	Release all memory and clear data structures.
virtual void	init (const char *name=nullptr) override
	Initialize data structures if not done so already.
void	init (PetscMatrixBase< T > *matrix, const char *name=nullptr)
	Initialize data structures if not done so already plus much more.
virtual void	init_systems (const System &) override
	Apply names to the system to be solved and set auxiliary preconditioner data.
virtual void	restrict_solve_to (const std::vector< unsigned int > *const dofs, const SubsetSolveMode subset_solve_mode=SUBSET_ZERO) override
	After calling this method, all successive solves will be restricted to the given set of dofs, which must contain local dofs on each processor only and not contain any duplicates.
virtual std::pair< unsigned int, Real >	solve (SparseMatrix< T > &matrix_in, NumericVector< T > &solution_in, NumericVector< T > &rhs_in, const std::optional< double > tol=std::nullopt, const std::optional< unsigned int > m_its=std::nullopt) override
	Call the Petsc solver.
virtual std::pair< unsigned int, Real >	adjoint_solve (SparseMatrix< T > &matrix_in, NumericVector< T > &solution_in, NumericVector< T > &rhs_in, const std::optional< double > tol=std::nullopt, const std::optional< unsigned int > m_its=std::nullopt) override
	Call the Petsc solver.
virtual std::pair< unsigned int, Real >	solve (SparseMatrix< T > &matrix, SparseMatrix< T > &preconditioner, NumericVector< T > &solution, NumericVector< T > &rhs, const std::optional< double > tol=std::nullopt, const std::optional< unsigned int > m_its=std::nullopt) override
	This method allows you to call a linear solver while specifying the matrix to use as the (left) preconditioning matrix.
virtual std::pair< unsigned int, Real >	solve (const ShellMatrix< T > &shell_matrix, NumericVector< T > &solution_in, NumericVector< T > &rhs_in, const std::optional< double > tol=std::nullopt, const std::optional< unsigned int > m_its=std::nullopt) override
	This function solves a system whose matrix is a shell matrix.
virtual std::pair< unsigned int, Real >	solve (const ShellMatrix< T > &shell_matrix, const SparseMatrix< T > &precond_matrix, NumericVector< T > &solution_in, NumericVector< T > &rhs_in, const std::optional< double > tol=std::nullopt, const std::optional< unsigned int > m_its=std::nullopt) override
	This function solves a system whose matrix is a shell matrix, but a sparse matrix is used as preconditioning matrix, this allowing other preconditioners than JACOBI.
PC	pc ()
KSP	ksp ()
void	get_residual_history (std::vector< double > &hist)
	Fills the input vector with the sequence of residual norms from the latest iterative solve.
Real	get_initial_residual ()
virtual LinearConvergenceReason	get_converged_reason () const override
bool	initialized () const
SolverType	solver_type () const
void	set_solver_type (const SolverType st)
	Sets the type of solver to use.
PreconditionerType	preconditioner_type () const
void	set_preconditioner_type (const PreconditionerType pct)
	Sets the type of preconditioner to use.
void	attach_preconditioner (Preconditioner< T > *preconditioner)
	Attaches a Preconditioner object to be used.
virtual void	reuse_preconditioner (bool)
	Set the same_preconditioner flag, which indicates if we reuse the same preconditioner for subsequent solves.
bool	get_same_preconditioner ()
std::pair< unsigned int, Real >	solve (SparseMatrix< T > &matrix, SparseMatrix< T > *precond_matrix, NumericVector< T > &, NumericVector< T > &, const std::optional< double > tol=std::nullopt, const std::optional< unsigned int > m_its=std::nullopt)
	This function calls the solver "_solver_type" preconditioned with the "_preconditioner_type" preconditioner.
std::pair< unsigned int, Real >	solve (const ShellMatrix< T > &matrix, const SparseMatrix< T > *precond_matrix, NumericVector< T > &, NumericVector< T > &, const std::optional< double > tol=std::nullopt, const std::optional< unsigned int > m_its=std::nullopt)
	This function solves a system whose matrix is a shell matrix, but an optional sparse matrix may be used as preconditioning matrix.
virtual void	print_converged_reason () const
	Prints a useful message about why the latest linear solve con(di)verged.
void	set_solver_configuration (SolverConfiguration &solver_configuration)
	Set the solver configuration object.
const Parallel::Communicator &	comm () const
processor_id_type	n_processors () const
processor_id_type	processor_id () const

Static Public Member Functions
static std::unique_ptr< LinearSolver< T > >	build (const libMesh::Parallel::Communicator &comm_in, const SolverPackage solver_package=libMesh::default_solver_package())
	Builds a LinearSolver using the linear solver package specified by solver_package.
static std::string	get_info ()
	Gets a string containing the reference information.
static void	print_info (std::ostream &out_stream=libMesh::out)
	Prints the reference information, by default to libMesh::out.
static unsigned int	n_objects ()
	Prints the number of outstanding (created, but not yet destroyed) objects.
static void	enable_print_counter_info ()
	Methods to enable/disable the reference counter output from print_info().
static void	disable_print_counter_info ()

Protected Types
typedef std::map< std::string, std::pair< unsigned int, unsigned int > >	Counts
	Data structure to log the information.

Protected Member Functions
double	get_real_solver_setting (const std::string &setting_name, const std::optional< double > &setting, const std::optional< double > default_value=std::nullopt)
	Get solver settings based on optional parameters and the solver configuration object.
int	get_int_solver_setting (const std::string &setting_name, const std::optional< int > &setting, const std::optional< int > default_value=std::nullopt)
	Get solver settings based on optional parameters and the solver configuration object.
void	increment_constructor_count (const std::string &name) noexcept
	Increments the construction counter.
void	increment_destructor_count (const std::string &name) noexcept
	Increments the destruction counter.

Protected Attributes
SolverType	_solver_type
	Enum stating which type of iterative solver to use.
PreconditionerType	_preconditioner_type
	Enum stating with type of preconditioner to use.
bool	_is_initialized
	Flag indicating if the data structures have been initialized.
Preconditioner< T > *	_preconditioner
	Holds the Preconditioner object to be used for the linear solves.
bool	same_preconditioner
	Boolean flag to indicate whether we want to use an identical preconditioner to the previous solve.
SolverConfiguration *	_solver_configuration
	Optionally store a SolverOptions object that can be used to set parameters like solver type, tolerances and iteration limits.
const Parallel::Communicator &	_communicator

Static Protected Attributes
static Counts	_counts
	Actually holds the data.
static Threads::atomic< unsigned int >	_n_objects
	The number of objects.
static Threads::spin_mutex	_mutex
	Mutual exclusion object to enable thread-safe reference counting.
static bool	_enable_print_counter = true
	Flag to control whether reference count information is printed when print_info is called.

Private Types
typedef PetscErrorCode(*	ksp_solve_func_type) (KSP, Vec, Vec)

Private Member Functions
virtual std::pair< unsigned int, Real >	solve_common (SparseMatrix< T > &matrix_in, SparseMatrix< T > &precond_in, NumericVector< T > &solution_in, NumericVector< T > &rhs_in, const double rel_tol, const double abs_tol, const unsigned int m_its, ksp_solve_func_type solve_func)
virtual std::pair< unsigned int, Real >	shell_solve_common (const ShellMatrix< T > &shell_matrix, PetscMatrixBase< T > *precond_matrix, NumericVector< T > &solution_in, NumericVector< T > &rhs_in, const double rel_tol, const double abs_tol, const unsigned int m_its)
std::pair< unsigned int, Real >	solve_base (SparseMatrix< T > *matrix, PetscMatrixBase< T > *precond, Mat mat, NumericVector< T > &solution_in, NumericVector< T > &rhs_in, const double rel_tol, const double abs_tol, const unsigned int m_its, ksp_solve_func_type solve_func)
void	set_petsc_solver_type ()
	Tells PETSC to use the user-specified solver stored in _solver_type.
PetscInt	restrict_solve_to_is_local_size () const
void	create_complement_is (const NumericVector< T > &vec_in)
	Creates _restrict_solve_to_is_complement to contain all indices that are local in vec_in, except those that are contained in _restrict_solve_to_is.

Static Private Member Functions
static PetscErrorCode	_petsc_shell_matrix_mult (Mat mat, Vec arg, Vec dest)
	Internal function if shell matrix mode is used.
static PetscErrorCode	_petsc_shell_matrix_mult_add (Mat mat, Vec arg, Vec add, Vec dest)
	Internal function if shell matrix mode is used.
static PetscErrorCode	_petsc_shell_matrix_get_diagonal (Mat mat, Vec dest)
	Internal function if shell matrix mode is used.

Private Attributes
PC	_pc
	Preconditioner context.
WrappedPetsc< KSP >	_ksp
	Krylov subspace context.
WrappedPetsc< IS >	_restrict_solve_to_is
	PETSc index set containing the dofs on which to solve (nullptr means solve on all dofs).
WrappedPetsc< IS >	_restrict_solve_to_is_complement
	PETSc index set, complement to _restrict_solve_to_is.
SubsetSolveMode	_subset_solve_mode
	If restrict-solve-to-subset mode is active, this member decides what happens with the dofs outside the subset.

Detailed Description

template<typename T>
class libMesh::PetscLinearSolver< T >

This class provides an interface to PETSc iterative solvers that is compatible with the libMesh LinearSolver<>

Author

Benjamin Kirk

Date

2002-2007

Definition at line 85 of file petsc_linear_solver.h.

Member Typedef Documentation

Counts

typedef std::map<std::string, std::pair<unsigned int, unsigned int> > libMesh::ReferenceCounter::Counts

protectedinherited

Data structure to log the information.

The log is identified by the class name.

Definition at line 119 of file reference_counter.h.

ksp_solve_func_type

template<typename T >

typedef PetscErrorCode(* libMesh::PetscLinearSolver< T >::ksp_solve_func_type) (KSP, Vec, Vec)

private

Definition at line 249 of file petsc_linear_solver.h.

Constructor & Destructor Documentation

PetscLinearSolver()

template<typename T >

libMesh::PetscLinearSolver< T >::PetscLinearSolver

(

const libMesh::Parallel::Communicator &

comm_in

)

Constructor.

Initializes Petsc data structures

Definition at line 89 of file petsc_linear_solver.C.

                                                                                   :
  LinearSolver<T>(comm_in),
  _restrict_solve_to_is(nullptr),
  _restrict_solve_to_is_complement(nullptr),
  _subset_solve_mode(SUBSET_ZERO)
{
  if (this->n_processors() == 1)
    this->_preconditioner_type = ILU_PRECOND;
  else
    this->_preconditioner_type = BLOCK_JACOBI_PRECOND;
}

~PetscLinearSolver()

template<typename T >

virtual libMesh::PetscLinearSolver< T >::~PetscLinearSolver ( )

virtualdefault

Destructor.

Member Function Documentation

_petsc_shell_matrix_get_diagonal()

template<typename T >

PetscErrorCode libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_get_diagonal ( Mat  mat, Vec  dest  )

staticprivate

Internal function if shell matrix mode is used.

Definition at line 863 of file petsc_linear_solver.C.

{
  PetscFunctionBegin;
 
  // Get the matrix context.
  void * ctx;
  PetscErrorCode ierr = MatShellGetContext(mat,&ctx);
 
  // Get user shell matrix object.
  const ShellMatrix<T> & shell_matrix = *static_cast<const ShellMatrix<T> *>(ctx);
  CHKERRABORT(shell_matrix.comm().get(), ierr);
 
  // Make \p NumericVector instances around the vector.
  PetscVector<T> dest_global(dest, shell_matrix.comm());
 
  // Call the user function.
  shell_matrix.get_diagonal(dest_global);
 
  PetscFunctionReturn(ierr);
}

References libMesh::ParallelObject::comm(), libMesh::ctx, libMesh::Parallel::Communicator::get(), libMesh::ShellMatrix< T >::get_diagonal(), and libMesh::PetscFunctionReturn().

_petsc_shell_matrix_mult()

template<typename T >

PetscErrorCode libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult ( Mat  mat, Vec  arg, Vec  dest  )

staticprivate

Internal function if shell matrix mode is used.

Definition at line 807 of file petsc_linear_solver.C.

{
  PetscFunctionBegin;
 
  // Get the matrix context.
  void * ctx;
  PetscErrorCode ierr = MatShellGetContext(mat,&ctx);
 
  // Get user shell matrix object.
  const ShellMatrix<T> & shell_matrix = *static_cast<const ShellMatrix<T> *>(ctx);
  CHKERRABORT(shell_matrix.comm().get(), ierr);
 
  // Make \p NumericVector instances around the vectors.
  PetscVector<T> arg_global(arg, shell_matrix.comm());
  PetscVector<T> dest_global(dest, shell_matrix.comm());
 
  // Call the user function.
  shell_matrix.vector_mult(dest_global,arg_global);
 
  PetscFunctionReturn(ierr);
}

References libMesh::ParallelObject::comm(), libMesh::ctx, libMesh::Parallel::Communicator::get(), libMesh::PetscFunctionReturn(), and libMesh::ShellMatrix< T >::vector_mult().

_petsc_shell_matrix_mult_add()

template<typename T >

PetscErrorCode libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult_add ( Mat  mat, Vec  arg, Vec  add, Vec  dest  )

staticprivate

Internal function if shell matrix mode is used.

Definition at line 832 of file petsc_linear_solver.C.

{
  PetscFunctionBegin;
 
  // Get the matrix context.
  void * ctx;
  PetscErrorCode ierr = MatShellGetContext(mat,&ctx);
 
  // Get user shell matrix object.
  const ShellMatrix<T> & shell_matrix = *static_cast<const ShellMatrix<T> *>(ctx);
  CHKERRABORT(shell_matrix.comm().get(), ierr);
 
  // Make \p NumericVector instances around the vectors.
  PetscVector<T> arg_global(arg, shell_matrix.comm());
  PetscVector<T> dest_global(dest, shell_matrix.comm());
  PetscVector<T> add_global(add, shell_matrix.comm());
 
  if (add!=arg)
    {
      arg_global = add_global;
    }
 
  // Call the user function.
  shell_matrix.vector_mult_add(dest_global,arg_global);
 
  PetscFunctionReturn(ierr);
}

References libMesh::ParallelObject::comm(), libMesh::ctx, libMesh::Parallel::Communicator::get(), libMesh::PetscFunctionReturn(), and libMesh::ShellMatrix< T >::vector_mult_add().

adjoint_solve()

template<typename T >

std::pair< unsigned int, Real > libMesh::PetscLinearSolver< T >::adjoint_solve ( SparseMatrix< T > &  matrix_in, NumericVector< T > &  solution_in, NumericVector< T > &  rhs_in, const std::optional< double >  tol = std::nullopt, const std::optional< unsigned int >  m_its = std::nullopt  )

overridevirtual

Call the Petsc solver.

It calls the method below, using the same matrix for the system and preconditioner matrices.

Reimplemented from libMesh::LinearSolver< T >.

Definition at line 288 of file petsc_linear_solver.C.

{
  LOG_SCOPE("adjoint_solve()", "PetscLinearSolver");
 
  const double rel_tol = this->get_real_solver_setting("rel_tol", tol);
  const double abs_tol = this->get_real_solver_setting("abs_tol",
                                                       std::nullopt,
                                                       static_cast<double>(PETSC_DEFAULT));
  const double max_its = this->get_int_solver_setting("max_its", m_its);
 
  // Note that the matrix and precond matrix are the same
  return this->solve_common(matrix_in, matrix_in, solution_in,
                            rhs_in, rel_tol, abs_tol, max_its, KSPSolveTranspose);
}

attach_preconditioner()

template<typename T >

void libMesh::LinearSolver< T >::attach_preconditioner ( Preconditioner< T > *  preconditioner )

inherited

Attaches a Preconditioner object to be used.

Definition at line 120 of file linear_solver.C.

{
  libmesh_error_msg_if(this->_is_initialized,
                       "Preconditioner must be attached before the solver is initialized!");
 
  _preconditioner_type = SHELL_PRECOND;
  _preconditioner = preconditioner;
}

build()

template<typename T >

std::unique_ptr< LinearSolver< T > > libMesh::LinearSolver< T >::build ( const libMesh::Parallel::Communicator &  comm_in, const SolverPackage  solver_package = libMesh::default_solver_package()  )

staticinherited

Builds a LinearSolver using the linear solver package specified by solver_package.

Definition at line 59 of file linear_solver.C.

{
  // Avoid unused parameter warnings when no solver packages are enabled.
  libmesh_ignore(comm);
 
  // Build the appropriate solver
  switch (solver_package)
    {
#ifdef LIBMESH_HAVE_LASPACK
    case LASPACK_SOLVERS:
      return std::make_unique<LaspackLinearSolver<T>>(comm);
#endif
 
 
#ifdef LIBMESH_HAVE_PETSC
    case PETSC_SOLVERS:
      return std::make_unique<PetscLinearSolver<T>>(comm);
#endif
 
 
#ifdef LIBMESH_TRILINOS_HAVE_AZTECOO
    case TRILINOS_SOLVERS:
      return std::make_unique<AztecLinearSolver<T>>(comm);
#endif
 
 
#ifdef LIBMESH_HAVE_EIGEN
    case EIGEN_SOLVERS:
      return std::make_unique<EigenSparseLinearSolver<T>>(comm);
#endif
 
    default:
      libmesh_error_msg("ERROR:  Unrecognized solver package: " << solver_package);
    }
 
  return std::unique_ptr<LinearSolver<T>>();
}

References libMesh::libmesh_ignore().

Referenced by libMesh::ContinuationSystem::ContinuationSystem(), libMesh::ImplicitSystem::get_linear_solver(), libMesh::StaticCondensation::init(), libMesh::TimeSolver::init(), libMesh::LinearImplicitSystem::LinearImplicitSystem(), main(), and libMesh::DofMap::process_mesh_constraint_rows().

clear()

template<typename T >

void libMesh::PetscLinearSolver< T >::clear ( )

overridevirtual

Release all memory and clear data structures.

Reimplemented from libMesh::LinearSolver< T >.

Definition at line 104 of file petsc_linear_solver.C.

{
  if (this->initialized())
    {
      this->_is_initialized = false;
 
      // Calls specialized destroy() functions
      if (_restrict_solve_to_is)
        _restrict_solve_to_is.reset_to_zero();
      if (_restrict_solve_to_is_complement)
        _restrict_solve_to_is_complement.reset_to_zero();
 
      // Previously we only called KSPDestroy(), we did not reset _ksp
      // to nullptr, so that behavior is maintained here.
      _ksp.destroy();
 
      // Mimic PETSc default solver and preconditioner
      this->_solver_type = GMRES;
 
      if (!this->_preconditioner)
        {
          if (this->n_processors() == 1)
            this->_preconditioner_type = ILU_PRECOND;
          else
            this->_preconditioner_type = BLOCK_JACOBI_PRECOND;
        }
    }
}

References libMesh::initialized().

comm()

const Parallel::Communicator & libMesh::ParallelObject::comm ( ) const

inlineinherited

Returns

A reference to the Parallel::Communicator object used by this mesh.

Definition at line 97 of file parallel_object.h.

  { return _communicator; }

References libMesh::ParallelObject::_communicator.

Referenced by libMesh::__libmesh_petsc_diff_solver_jacobian(), libMesh::__libmesh_petsc_diff_solver_monitor(), libMesh::__libmesh_petsc_diff_solver_residual(), libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::Partitioner::_find_global_index_by_pid_map(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::SlepcEigenSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult(), libMesh::SlepcEigenSolver< T >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult_add(), libMesh::DofMap::add_constraints_to_send_list(), add_cube_convex_hull_to_mesh(), libMesh::PetscDMWrapper::add_dofs_helper(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::TransientRBConstruction::add_IC_to_RB_space(), libMesh::RBEIMEvaluation::add_interpolation_data(), libMesh::CondensedEigenSystem::add_matrices(), libMesh::EigenSystem::add_matrices(), libMesh::System::add_matrix(), libMesh::System::add_matrix(), libMesh::System::add_matrix(), libMesh::RBConstruction::add_scaled_matrix_and_vector(), libMesh::System::add_vector(), libMesh::MeshTools::Modification::all_tri(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::RBConstruction::allocate_data_structures(), libMesh::TransientRBConstruction::allocate_data_structures(), libMesh::TransientRBConstruction::assemble_affine_expansion(), libMesh::AdvectionSystem::assemble_claw_rhs(), libMesh::FEMSystem::assemble_qoi(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::MeshCommunication::assign_global_indices(), libMesh::Partitioner::assign_partitioning(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::Partitioner::build_graph(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::PetscDMWrapper::build_section(), libMesh::PetscDMWrapper::build_sf(), libMesh::MeshBase::cache_elem_data(), libMesh::DofMap::check_dirichlet_bcid_consistency(), libMesh::MeshTetInterface::check_hull_integrity(), libMesh::MeshBase::complete_preparation(), libMesh::RBConstruction::compute_Fq_representor_innerprods(), libMesh::RBConstruction::compute_max_error_bound(), libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::RBConstruction::compute_output_dual_innerprods(), libMesh::RBConstruction::compute_residual_dual_norm_slow(), libMesh::RBSCMConstruction::compute_SCM_bounds_on_training_set(), libMesh::DofMap::computed_sparsity_already(), libMesh::Problem_Interface::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), PetscSolverConfiguration::configure_solver(), libMesh::ContinuationSystem::ContinuationSystem(), libMesh::MeshBase::copy_constraint_rows(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::ExodusII_IO::copy_nodal_solution(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::CondensedEigenSystem::copy_super_to_sub(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::MeshTools::create_bounding_box(), libMesh::DofMap::create_dof_constraints(), libMesh::MeshTools::create_nodal_bounding_box(), libMesh::MeshRefinement::create_parent_error_vector(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::MeshTools::create_subdomain_bounding_box(), libMesh::PetscMatrix< T >::create_submatrix_nosort(), create_wrapped_function(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::MeshBase::detect_interior_parents(), libMesh::RBEIMEvaluation::distribute_bfs(), DMlibMeshFunction(), DMlibMeshJacobian(), DMlibMeshSetSystem_libMesh(), DMVariableBounds_libMesh(), libMesh::DTKSolutionTransfer::DTKSolutionTransfer(), libMesh::MeshRefinement::eliminate_unrefined_patches(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_interiors(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_nodes(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_sides(), libMesh::TransientRBConstruction::enrich_RB_space(), libMesh::EpetraVector< T >::EpetraVector(), AssembleOptimization::equality_constraints(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::PatchRecoveryErrorEstimator::estimate_error(), libMesh::WeightedPatchRecoveryErrorEstimator::estimate_error(), libMesh::SmoothnessEstimator::estimate_smoothness(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_error_fraction(), libMesh::MeshRefinement::flag_elements_by_error_tolerance(), libMesh::MeshRefinement::flag_elements_by_mean_stddev(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::RBEIMEvaluation::gather_bfs(), libMesh::DofMap::gather_constraints(), libMesh::MeshfreeInterpolation::gather_remote_data(), libMesh::CondensedEigenSystem::get_eigenpair(), libMesh::RBEIMEvaluation::get_eim_basis_function_node_value(), libMesh::RBEIMEvaluation::get_eim_basis_function_side_value(), libMesh::RBEIMEvaluation::get_eim_basis_function_value(), libMesh::MeshBase::get_info(), libMesh::RBEIMEvaluation::get_interior_basis_functions_as_vecs(), libMesh::ImplicitSystem::get_linear_solver(), libMesh::RBEIMConstruction::get_max_abs_value(), libMesh::RBEIMConstruction::get_node_max_abs_value(), libMesh::RBEIMEvaluation::get_parametrized_function_node_value(), libMesh::RBEIMEvaluation::get_parametrized_function_side_value(), libMesh::RBEIMEvaluation::get_parametrized_function_value(), libMesh::RBEIMConstruction::get_random_point(), libMesh::RBEIMConstruction::get_random_point(), libMesh::RBEIMConstruction::get_random_point(), libMesh::MeshTetInterface::improve_hull_integrity(), AssembleOptimization::inequality_constraints(), AssembleOptimization::inequality_constraints_jacobian(), libMesh::StaticCondensation::init(), libMesh::TimeSolver::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::LocationMap< T >::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), ElasticitySystem::init_data(), libMesh::AdvectionSystem::init_data(), libMesh::ClawSystem::init_data(), libMesh::PetscDMWrapper::init_petscdm(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::OptimizationSystem::initialize_equality_constraints_storage(), libMesh::OptimizationSystem::initialize_inequality_constraints_storage(), libMesh::RBEIMConstruction::initialize_parametrized_functions_in_training_set(), libMesh::RBEIMConstruction::inner_product(), integrate_function(), libMesh::MeshTools::Modification::interpolate_surface(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_equal_connectivity(), libMesh::MeshTools::libmesh_assert_equal_points(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_constraint_rows(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_flags(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_p_levels(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::MeshTools::libmesh_assert_valid_unique_ids(), libMesh::libmesh_petsc_linesearch_shellfunc(), libMesh::libmesh_petsc_preconditioner_apply(), libMesh::libmesh_petsc_snes_mffd_interface(), libMesh::libmesh_petsc_snes_postcheck(), libMesh::MeshRefinement::limit_level_mismatch_at_edge(), libMesh::MeshRefinement::limit_level_mismatch_at_node(), libMesh::MeshRefinement::limit_overrefined_boundary(), libMesh::MeshRefinement::limit_underrefined_boundary(), libMesh::LinearImplicitSystem::LinearImplicitSystem(), main(), libMesh::MeshCommunication::make_elems_parallel_consistent(), libMesh::MeshCommunication::make_new_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_new_nodes_parallel_consistent(), libMesh::MeshCommunication::make_node_bcids_parallel_consistent(), libMesh::MeshCommunication::make_node_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_unique_ids_parallel_consistent(), libMesh::MeshCommunication::make_nodes_parallel_consistent(), libMesh::MeshCommunication::make_p_levels_parallel_consistent(), libMesh::TransientRBConstruction::mass_matrix_scaled_matvec(), libMesh::FEMSystem::mesh_position_set(), libMesh::TriangulatorInterface::MeshedHole::MeshedHole(), LinearElasticityWithContact::move_mesh(), libMesh::DistributedMesh::n_active_elem(), libMesh::MeshTools::n_active_levels(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::MeshTools::n_connected_components(), libMesh::DofMap::n_constrained_dofs(), libMesh::MeshBase::n_constraint_rows(), libMesh::DofMap::n_dofs(), libMesh::DofMap::n_dofs_per_processor(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::CondensedEigenSystem::n_global_non_condensed_dofs(), libMesh::MeshTools::n_levels(), MixedOrderTest::n_neighbor_links(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::SparsityPattern::Build::n_nonzeros(), libMesh::MeshTools::n_p_levels(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::RBEIMEvaluation::node_distribute_bfs(), libMesh::RBEIMEvaluation::node_gather_bfs(), libMesh::RBEIMConstruction::node_inner_product(), libMesh::PetscVector< T >::operator=(), libMesh::MeshBase::operator==(), libMesh::DistributedMesh::parallel_max_elem_id(), libMesh::DistributedMesh::parallel_max_node_id(), libMesh::DistributedMesh::parallel_max_unique_id(), libMesh::ReplicatedMesh::parallel_max_unique_id(), libMesh::DistributedMesh::parallel_n_elem(), libMesh::DistributedMesh::parallel_n_nodes(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::BoundaryInfo::parallel_sync_node_ids(), libMesh::BoundaryInfo::parallel_sync_side_ids(), libMesh::MeshTools::paranoid_n_levels(), libMesh::Partitioner::partition(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::petsc_auto_fieldsplit(), LaplaceSystem::postprocess(), PoissonSystem::postprocess(), libMesh::MeshBase::print_constraint_rows(), libMesh::DofMap::print_dof_constraints(), libMesh::DofMap::process_mesh_constraint_rows(), libMesh::Partitioner::processor_pairs_to_interface_nodes(), libMesh::InterMeshProjection::project_system_vectors(), libMesh::XdrIO::read(), libMesh::Nemesis_IO::read(), FEMParameters::read(), libMesh::EquationSystems::read(), libMesh::CheckpointIO::read_header(), libMesh::ExodusII_IO::read_header(), libMesh::System::read_header(), libMesh::XdrIO::read_header(), libMesh::RBEIMEvaluation::read_in_interior_basis_functions(), libMesh::RBEIMEvaluation::read_in_node_basis_functions(), libMesh::RBEIMEvaluation::read_in_side_basis_functions(), libMesh::RBEvaluation::read_in_vectors_from_multiple_files(), libMesh::RBConstruction::read_riesz_representors_from_files(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::System::read_SCALAR_dofs(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::System::read_serialized_vector(), libMesh::Nemesis_IO_Helper::read_var_names_impl(), MeshFunctionTest::read_variable_info_from_output_data(), libMesh::MeshBase::recalculate_n_partitions(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::StaticCondensationDofMap::reinit(), libMesh::BoundaryInfo::remove_edge_id(), libMesh::BoundaryInfo::remove_node_id(), libMesh::BoundaryInfo::remove_shellface_id(), libMesh::BoundaryInfo::remove_side_id(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::DistributedMesh::renumber_nodes_and_elements(), LinearElasticityWithContact::residual_and_jacobian(), OverlappingAlgebraicGhostingTest::run_ghosting_test(), OverlappingCouplingGhostingTest::run_sparsity_pattern_test(), scale_mesh_and_plot(), libMesh::DofMap::scatter_constraints(), libMesh::CheckpointIO::select_split_config(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::send_and_insert_dof_values(), libMesh::TransientRBConstruction::set_error_temporal_data(), libMesh::Partitioner::set_interface_node_processor_ids_BFS(), libMesh::Partitioner::set_interface_node_processor_ids_linear(), libMesh::Partitioner::set_interface_node_processor_ids_petscpartitioner(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::Partitioner::set_parent_processor_ids(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::PetscDiffSolver::setup_petsc_data(), libMesh::RBEIMEvaluation::side_distribute_bfs(), libMesh::RBEIMEvaluation::side_gather_bfs(), libMesh::RBEIMConstruction::side_inner_product(), libMesh::Partitioner::single_partition(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::VariationalMeshSmoother::smooth(), libMesh::NoxNonlinearSolver< Number >::solve(), libMesh::ClawSystem::solve_conservation_law(), libMesh::split_mesh(), libMesh::RBEIMConstruction::store_eim_solutions_for_training_set(), libMesh::MeshBase::subdomain_ids(), libMesh::BoundaryInfo::sync(), libMesh::MeshBase::sync_subdomain_name_map(), ConstraintOperatorTest::test1DCoarseningNewNodes(), ConstraintOperatorTest::test1DCoarseningOperator(), MeshFunctionTest::test_bad_gradient_var_with_out_of_mesh_value(), MeshFunctionTest::test_bad_hessian_var_with_out_of_mesh_value(), MeshfunctionDFEM::test_mesh_function_dfem(), MeshfunctionDFEM::test_mesh_function_dfem_grad(), MeshFunctionTest::test_p_level(), ExodusC0PolyhedronTest::test_write_and_read_hexagonal_prism(), ExodusC0PolygonTest::test_write_and_read_pentagon(), DofMapTest::testBadElemFECombo(), SystemsTest::testBlockRestrictedVarNDofs(), BoundaryInfoTest::testBoundaryOnChildrenErrors(), CheckpointIOTest::testC0PolygonCheckpoint(), VolumeTest::testC0PolygonMethods(), CheckpointIOTest::testC0PolyhedronCheckpoint(), VolumeTest::testC0PolyhedronMethods(), ConstraintOperatorTest::testCoreform(), ConnectedComponentsTest::testEdge(), MeshInputTest::testExodusIGASidesets(), MeshTriangulationTest::testFoundCenters(), PointLocatorTest::testLocator(), BoundaryInfoTest::testMesh(), BoundaryMeshSubdomainTest::testPerBoundarySubdomain(), PointLocatorTest::testPlanar(), MeshTriangulationTest::testPoly2TriEdge3ToTri7CenterFixup(), MeshTriangulationTest::testPoly2TriRefinementBase(), SystemsTest::testProjectCubeWithMeshFunction(), SystemsTest::testProjectScalarCoarsening(), BoundaryInfoTest::testRenumber(), BoundaryInfoTest::testSelectiveRenumber(), BoundaryMeshSubdomainTest::testSingleSubdomain(), CheckpointIOTest::testSplitter(), MeshInputTest::testTetgenIO(), MeshTriangulationTest::testTriangulatorInterp(), MeshTriangulationTest::testTriangulatorMeshedHoles(), MeshTriangulationTest::testTriangulatorRoundHole(), MeshSmootherTest::testVariationalSmoother(), libMesh::MeshTools::total_weight(), libMesh::RBConstruction::train_reduced_basis_with_POD(), libMesh::MeshfreeSolutionTransfer::transfer(), libMesh::MeshFunctionSolutionTransfer::transfer(), libMesh::Poly2TriTriangulator::triangulate(), libMesh::RBConstruction::truth_assembly(), libMesh::TransientRBConstruction::truth_assembly(), update_current_local_solution(), libMesh::TransientRBConstruction::update_RB_initial_condition_all_N(), libMesh::RBConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_residual_terms(), libMesh::RBConstruction::update_residual_terms(), libMesh::MeshTools::volume(), libMesh::STLIO::write(), libMesh::XdrIO::write(), libMesh::NameBasedIO::write(), libMesh::VTKIO::write_nodal_data(), libMesh::RBEIMEvaluation::write_out_interior_basis_functions(), libMesh::RBEIMEvaluation::write_out_node_basis_functions(), libMesh::RBEIMEvaluation::write_out_side_basis_functions(), libMesh::RBEvaluation::write_out_vectors(), libMesh::RBConstruction::write_riesz_representors_to_files(), libMesh::TransientRBConstruction::write_riesz_representors_to_files(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::RBDataSerialization::RBEvaluationSerialization::write_to_file(), libMesh::RBDataSerialization::TransientRBEvaluationSerialization::write_to_file(), libMesh::RBDataSerialization::RBEIMEvaluationSerialization::write_to_file(), and libMesh::RBDataSerialization::RBSCMEvaluationSerialization::write_to_file().

create_complement_is()

template<typename T >

void libMesh::PetscLinearSolver< T >::create_complement_is ( const NumericVector< T > &  vec_in )

private

Creates _restrict_solve_to_is_complement to contain all indices that are local in vec_in, except those that are contained in _restrict_solve_to_is.

Definition at line 888 of file petsc_linear_solver.C.

{
  libmesh_assert(_restrict_solve_to_is);
  if (!_restrict_solve_to_is_complement)
    LibmeshPetscCall(ISComplement(_restrict_solve_to_is,
                                  vec_in.first_local_index(),
                                  vec_in.last_local_index(),
                                  _restrict_solve_to_is_complement.get()));
}

References libMesh::NumericVector< T >::first_local_index(), libMesh::NumericVector< T >::last_local_index(), and libMesh::libmesh_assert().

disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )

staticinherited

Definition at line 100 of file reference_counter.C.

{
  _enable_print_counter = false;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

enable_print_counter_info()

void libMesh::ReferenceCounter::enable_print_counter_info ( )

staticinherited

Methods to enable/disable the reference counter output from print_info().

Enabled by default.

Definition at line 94 of file reference_counter.C.

{
  _enable_print_counter = true;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

Referenced by libMesh::LibMeshInit::~LibMeshInit().

get_converged_reason()

template<typename T >

LinearConvergenceReason libMesh::PetscLinearSolver< T >::get_converged_reason ( ) const

overridevirtual

Returns

The solver's convergence flag

Implements libMesh::LinearSolver< T >.

Definition at line 754 of file petsc_linear_solver.C.

{
  KSPConvergedReason reason;
  LibmeshPetscCall(KSPGetConvergedReason(_ksp, &reason));
 
  switch(reason)
    {
#if PETSC_VERSION_LESS_THAN(3,24,0)
    case KSP_CONVERGED_RTOL_NORMAL     : return CONVERGED_RTOL_NORMAL;
    case KSP_CONVERGED_ATOL_NORMAL     : return CONVERGED_ATOL_NORMAL;
#else
    case KSP_CONVERGED_RTOL_NORMAL_EQUATIONS : return CONVERGED_RTOL_NORMAL;
    case KSP_CONVERGED_ATOL_NORMAL_EQUATIONS : return CONVERGED_ATOL_NORMAL;
#endif
    case KSP_CONVERGED_RTOL            : return CONVERGED_RTOL;
    case KSP_CONVERGED_ATOL            : return CONVERGED_ATOL;
    case KSP_CONVERGED_ITS             : return CONVERGED_ITS;
#if PETSC_VERSION_LESS_THAN(3,19,0)
    case KSP_CONVERGED_CG_NEG_CURVE    : return CONVERGED_CG_NEG_CURVE;
    // This was deprecated for STEP_LENGTH
    case KSP_CONVERGED_CG_CONSTRAINED  : return CONVERGED_CG_CONSTRAINED;
#else
    case KSP_CONVERGED_NEG_CURVE       : return CONVERGED_CG_NEG_CURVE;
#endif
    case KSP_CONVERGED_STEP_LENGTH     : return CONVERGED_STEP_LENGTH;
    case KSP_CONVERGED_HAPPY_BREAKDOWN : return CONVERGED_HAPPY_BREAKDOWN;
    case KSP_DIVERGED_NULL             : return DIVERGED_NULL;
    case KSP_DIVERGED_ITS              : return DIVERGED_ITS;
    case KSP_DIVERGED_DTOL             : return DIVERGED_DTOL;
    case KSP_DIVERGED_BREAKDOWN        : return DIVERGED_BREAKDOWN;
    case KSP_DIVERGED_BREAKDOWN_BICG   : return DIVERGED_BREAKDOWN_BICG;
    case KSP_DIVERGED_NONSYMMETRIC     : return DIVERGED_NONSYMMETRIC;
    case KSP_DIVERGED_INDEFINITE_PC    : return DIVERGED_INDEFINITE_PC;
    case KSP_DIVERGED_NANORINF         : return DIVERGED_NAN;
    case KSP_DIVERGED_INDEFINITE_MAT   : return DIVERGED_INDEFINITE_MAT;
    case KSP_CONVERGED_ITERATING       : return CONVERGED_ITERATING;
#if !PETSC_VERSION_LESS_THAN(3,7,0)
// PETSc-3.7.0 to 3.10.x
#if PETSC_VERSION_LESS_THAN(3,11,0) && PETSC_VERSION_RELEASE
    case KSP_DIVERGED_PCSETUP_FAILED   : return DIVERGED_PCSETUP_FAILED;
// PETSc master and future PETSc
#else
    case KSP_DIVERGED_PC_FAILED        : return DIVERGED_PCSETUP_FAILED;
#endif
#endif
    default :
      libMesh::err << "Unknown convergence flag!" << std::endl;
      return UNKNOWN_FLAG;
    }
}

References libMesh::CONVERGED_ATOL, libMesh::CONVERGED_ATOL_NORMAL, libMesh::CONVERGED_CG_CONSTRAINED, libMesh::CONVERGED_CG_NEG_CURVE, libMesh::CONVERGED_HAPPY_BREAKDOWN, libMesh::CONVERGED_ITERATING, libMesh::CONVERGED_ITS, libMesh::CONVERGED_RTOL, libMesh::CONVERGED_RTOL_NORMAL, libMesh::CONVERGED_STEP_LENGTH, libMesh::DIVERGED_BREAKDOWN, libMesh::DIVERGED_BREAKDOWN_BICG, libMesh::DIVERGED_DTOL, libMesh::DIVERGED_INDEFINITE_MAT, libMesh::DIVERGED_INDEFINITE_PC, libMesh::DIVERGED_ITS, libMesh::DIVERGED_NAN, libMesh::DIVERGED_NONSYMMETRIC, libMesh::DIVERGED_NULL, libMesh::DIVERGED_PCSETUP_FAILED, libMesh::err, and libMesh::UNKNOWN_FLAG.

get_info()

std::string libMesh::ReferenceCounter::get_info ( )

staticinherited

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

{
#if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
 
  std::ostringstream oss;
 
  oss << '\n'
      << " ---------------------------------------------------------------------------- \n"
      << "| Reference count information                                                |\n"
      << " ---------------------------------------------------------------------------- \n";
 
  for (const auto & [name, cd] : _counts)
    oss << "| " << name << " reference count information:\n"
        << "|  Creations:    " << cd.first    << '\n'
        << "|  Destructions: " << cd.second << '\n';
 
  oss << " ---------------------------------------------------------------------------- \n";
 
  return oss.str();
 
#else
 
  return "";
 
#endif
}

References libMesh::ReferenceCounter::_counts.

Referenced by libMesh::ReferenceCounter::print_info().

get_initial_residual()

template<typename T >

Real libMesh::PetscLinearSolver< T >::get_initial_residual

(

)

Returns

Just the initial residual for the solve just completed with this interface.

Use this method instead of the one above if you just want the starting residual and not the entire history.

Definition at line 685 of file petsc_linear_solver.C.

{
  PetscInt its  = 0;
 
  // Fill the residual history vector with the residual norms
  // Note that GetResidualHistory() does not copy any values, it
  // simply sets the pointer p.  Note that for some Krylov subspace
  // methods, the number of residuals returned in the history
  // vector may be different from what you are expecting.  For
  // example, TFQMR returns two residual values per iteration step.
 
  // Recent versions of PETSc require the residual
  // history vector pointer to be declared as const.
#if PETSC_VERSION_LESS_THAN(3,15,0)
  PetscReal * p;
#else
  const PetscReal * p;
#endif
 
 
  LibmeshPetscCall(KSPGetResidualHistory(_ksp, &p, &its));
 
  // Check no residual history
  if (its == 0)
    {
      libMesh::err << "No iterations have been performed, returning 0." << std::endl;
      return 0.;
    }
 
  // Otherwise, return the value pointed to by p.
  return *p;
}

References libMesh::err.

get_int_solver_setting()

template<typename T >

int libMesh::LinearSolver< T >::get_int_solver_setting ( const std::string &  setting_name, const std::optional< int > &  setting, const std::optional< int >  default_value = std::nullopt  )

protectedinherited

Get solver settings based on optional parameters and the solver configuration object.

Definition at line 206 of file linear_solver.C.

{
  if (setting.has_value())
    return setting.value();
  else if (_solver_configuration)
  {
    if (const auto it = this->_solver_configuration->int_valued_data.find(setting_name);
        it != this->_solver_configuration->int_valued_data.end())
      return it->second;
  }
  else if (default_value.has_value())
    return default_value.value();
  else
    libmesh_error_msg("Iteration configuration parameter to the linear solver should either be supplied through input arguments or a SolverConfiguration object!");
 
  return 0.0;
 
}

get_real_solver_setting()

template<typename T >

double libMesh::LinearSolver< T >::get_real_solver_setting ( const std::string &  setting_name, const std::optional< double > &  setting, const std::optional< double >  default_value = std::nullopt  )

protectedinherited

Get solver settings based on optional parameters and the solver configuration object.

Definition at line 185 of file linear_solver.C.

{
  if (setting.has_value())
    return setting.value();
  else if (_solver_configuration)
  {
    if (const auto it = this->_solver_configuration->real_valued_data.find(setting_name);
        it != this->_solver_configuration->real_valued_data.end())
      return double(it->second);
  }
  else if (default_value.has_value())
    return default_value.value();
  else
    libmesh_error_msg("Iteration configuration parameter to the linear solver should either be supplied through input arguments or a SolverConfiguration object!");
 
  return 0.0;
}

get_residual_history()

template<typename T >

void libMesh::PetscLinearSolver< T >::get_residual_history

(

std::vector< double > &

hist

)

Fills the input vector with the sequence of residual norms from the latest iterative solve.

Definition at line 646 of file petsc_linear_solver.C.

{
  PetscInt its  = 0;
 
  // Fill the residual history vector with the residual norms
  // Note that GetResidualHistory() does not copy any values, it
  // simply sets the pointer p.  Note that for some Krylov subspace
  // methods, the number of residuals returned in the history
  // vector may be different from what you are expecting.  For
  // example, TFQMR returns two residual values per iteration step.
 
  // Recent versions of PETSc require the residual
  // history vector pointer to be declared as const.
#if PETSC_VERSION_LESS_THAN(3,15,0)
  PetscReal * p;
#else
  const PetscReal * p;
#endif
 
  LibmeshPetscCall(KSPGetResidualHistory(_ksp, &p, &its));
 
  // Check for early return
  if (its == 0) return;
 
  // Create space to store the result
  hist.resize(its);
 
  // Copy history into the vector provided by the user.
  for (PetscInt i=0; i<its; ++i)
    {
      hist[i] = *p;
      p++;
    }
}

get_same_preconditioner()

template<typename T >

bool libMesh::LinearSolver< T >::get_same_preconditioner ( )

inlineinherited

Returns

same_preconditioner, which indicates if we reuse the same preconditioner for subsequent solves.

Definition at line 327 of file linear_solver.h.

{
  return same_preconditioner;
}

increment_constructor_count()

void libMesh::ReferenceCounter::increment_constructor_count ( const std::string &  name )

inlineprotectednoexceptinherited

Increments the construction counter.

Should be called in the constructor of any derived class that will be reference counted.

Definition at line 183 of file reference_counter.h.

{
  libmesh_try
  {
    Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
    std::pair<unsigned int, unsigned int> & p = _counts[name];
    p.first++;
  }
  libmesh_catch (...)
  {
    auto stream = libMesh::err.get();
    stream->exceptions(stream->goodbit); // stream must not throw
    libMesh::err << "Encountered unrecoverable error while calling "
                 << "ReferenceCounter::increment_constructor_count() "
                 << "for a(n) " << name << " object." << std::endl;
    std::terminate();
  }
}

References libMesh::err, libMesh::BasicOStreamProxy< charT, traits >::get(), and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCountedObject< T >::ReferenceCountedObject(), libMesh::ReferenceCountedObject< T >::ReferenceCountedObject(), and libMesh::ReferenceCountedObject< T >::ReferenceCountedObject().

increment_destructor_count()

void libMesh::ReferenceCounter::increment_destructor_count ( const std::string &  name )

inlineprotectednoexceptinherited

Increments the destruction counter.

Should be called in the destructor of any derived class that will be reference counted.

Definition at line 207 of file reference_counter.h.

{
  libmesh_try
  {
    Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
    std::pair<unsigned int, unsigned int> & p = _counts[name];
    p.second++;
  }
  libmesh_catch (...)
  {
    auto stream = libMesh::err.get();
    stream->exceptions(stream->goodbit); // stream must not throw
    libMesh::err << "Encountered unrecoverable error while calling "
                 << "ReferenceCounter::increment_destructor_count() "
                 << "for a(n) " << name << " object." << std::endl;
    std::terminate();
  }
}

References libMesh::err, libMesh::BasicOStreamProxy< charT, traits >::get(), and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCountedObject< T >::~ReferenceCountedObject().

init() [1/2]

template<typename T >

void libMesh::PetscLinearSolver< T >::init ( const char *  name = nullptr )

overridevirtual

Initialize data structures if not done so already.

Assigns a name, which is turned into an underscore-separated prefix for the underlying KSP object.

Implements libMesh::LinearSolver< T >.

Definition at line 136 of file petsc_linear_solver.C.

{
  // Initialize the data structures if not done so already.
  if (!this->initialized())
    {
      this->_is_initialized = true;
 
      LibmeshPetscCall(KSPCreate(this->comm().get(), _ksp.get()));
 
      if (name)
        LibmeshPetscCall(KSPSetOptionsPrefix(_ksp, name));
 
      // Create the preconditioner context
      LibmeshPetscCall(KSPGetPC(_ksp, &_pc));
 
      // Set user-specified  solver and preconditioner types
      this->set_petsc_solver_type();
 
      // If the SolverConfiguration object is provided, use it to set
      // options during solver initialization.
      if (this->_solver_configuration)
        {
          this->_solver_configuration->set_options_during_init();
        }
 
      // Set the options from user-input
      // Set runtime options, e.g.,
      //      -ksp_type <type> -pc_type <type> -ksp_monitor -ksp_rtol <rtol>
      //  These options will override those specified above as long as
      //  KSPSetFromOptions() is called _after_ any other customization
      //  routines.
      LibmeshPetscCall(KSPSetFromOptions(_ksp));
 
      // Have the Krylov subspace method use our good initial guess
      // rather than 0, unless the user requested a KSPType of
      // preonly, which complains if asked to use initial guesses.
      KSPType ksp_type;
 
      LibmeshPetscCall(KSPGetType(_ksp, &ksp_type));
 
      if (strcmp(ksp_type, "preonly"))
        LibmeshPetscCall(KSPSetInitialGuessNonzero(_ksp, PETSC_TRUE));
 
      // Notify PETSc of location to store residual history.
      // This needs to be called before any solves, since
      // it sets the residual history length to zero.  The default
      // behavior is for PETSc to allocate (internally) an array
      // of size 1000 to hold the residual norm history.
      LibmeshPetscCall(KSPSetResidualHistory(_ksp,
                                             LIBMESH_PETSC_NULLPTR, // pointer to the array which holds the history
                                             PETSC_DECIDE, // size of the array holding the history
                                             PETSC_TRUE)); // Whether or not to reset the history for each solve.
 
      PetscPreconditioner<T>::set_petsc_preconditioner_type(this->_preconditioner_type,_pc);
 
      //If there is a preconditioner object we need to set the internal setup and apply routines
      if (this->_preconditioner)
        {
          this->_preconditioner->init();
          LibmeshPetscCall(PCShellSetContext(_pc,(void *)this->_preconditioner));
          LibmeshPetscCall(PCShellSetSetUp(_pc,libmesh_petsc_preconditioner_setup));
          LibmeshPetscCall(PCShellSetApply(_pc,libmesh_petsc_preconditioner_apply));
        }
    }
}

References libMesh::initialized().

Referenced by libMesh::PetscLinearSolver< T >::pc().

init() [2/2]

template<typename T >

void libMesh::PetscLinearSolver< T >::init	(	PetscMatrixBase< T > *	matrix,
		const char *	name = nullptr
	)

Initialize data structures if not done so already plus much more.

Definition at line 204 of file petsc_linear_solver.C.

{
  // Initialize the data structures if not done so already.
  if (!this->initialized())
    {
      if (this->_preconditioner)
        this->_preconditioner->set_matrix(*matrix);
 
      this->init(name);
 
      // Set operators. The input matrix works as the preconditioning matrix
      LibmeshPetscCall(KSPSetOperators(_ksp, matrix->mat(), matrix->mat()));
    }
}

References libMesh::initialized(), and libMesh::PetscMatrixBase< T >::mat().

init_systems()

template<typename T >

void libMesh::PetscLinearSolver< T >::init_systems ( const System &  sys )

overridevirtual

Apply names to the system to be solved and set auxiliary preconditioner data.

This a) sets an option prefix from the system name and sets field names from the system's variable names and b) sets auxiliary data needed by preconditioners such as hypre ams/ads.

Since field names are applied to DoF numberings, this method must be called again after any System reinit.

Reimplemented from libMesh::LinearSolver< T >.

Definition at line 224 of file petsc_linear_solver.C.

{
  petsc_auto_fieldsplit(this->pc(), sys);
  PetscPreconditioner<T>::set_petsc_aux_data(_pc, const_cast<System &>(sys));
}

initialized()

template<typename T >

bool libMesh::LinearSolver< T >::initialized ( ) const

inlineinherited

Returns

true if the data structures are initialized, false otherwise.

Definition at line 85 of file linear_solver.h.

{ return _is_initialized; }

References libMesh::LinearSolver< T >::_is_initialized.

ksp()

template<typename T >

KSP libMesh::PetscLinearSolver< T >::ksp

(

)

Returns

The raw PETSc ksp context pointer.

This is useful if you are for example setting a custom convergence test with KSPSetConvergenceTest().

Definition at line 639 of file petsc_linear_solver.C.

{
  this->init();
  return _ksp;
}

Referenced by PetscSolverConfiguration::configure_solver().

n_objects()

static unsigned int libMesh::ReferenceCounter::n_objects ( )

inlinestaticinherited

Prints the number of outstanding (created, but not yet destroyed) objects.

Definition at line 85 of file reference_counter.h.

  { return _n_objects; }

References libMesh::ReferenceCounter::_n_objects.

Referenced by libMesh::LibMeshInit::~LibMeshInit().

n_processors()

processor_id_type libMesh::ParallelObject::n_processors ( ) const

inlineinherited

Returns

The number of processors in the group.

Definition at line 103 of file parallel_object.h.

  {
    processor_id_type returnval =
      cast_int<processor_id_type>(_communicator.size());
    libmesh_assert(returnval); // We never have an empty comm
    return returnval;
  }

References libMesh::ParallelObject::_communicator, libMesh::libmesh_assert(), and libMesh::Parallel::Communicator::size().

Referenced by libMesh::Partitioner::_find_global_index_by_pid_map(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::DofMap::add_constraints_to_send_list(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::DistributedMesh::add_node(), libMesh::System::add_vector(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::FEMSystem::assembly(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::Partitioner::assign_partitioning(), libMesh::AztecLinearSolver< T >::AztecLinearSolver(), libMesh::Partitioner::build_graph(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::DistributedMesh::clear(), libMesh::DistributedMesh::clear_elems(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::Nemesis_IO::copy_scalar_solution(), libMesh::UnstructuredMesh::create_pid_mesh(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::DistributedMesh::DistributedMesh(), libMesh::EnsightIO::EnsightIO(), libMesh::RBEIMEvaluation::gather_bfs(), libMesh::MeshBase::get_info(), libMesh::StaticCondensation::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_petscdm(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::Nemesis_IO_Helper::initialize(), libMesh::DistributedMesh::insert_elem(), libMesh::NumericVector< T >::is_effectively_ghosted(), libMesh::NumericVector< T >::is_effectively_serial(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::MeshBase::n_active_elem_on_proc(), libMesh::DofMap::n_dofs_per_processor(), libMesh::MeshBase::n_elem_on_proc(), libMesh::MeshBase::n_nodes_on_proc(), libMesh::RBEIMEvaluation::node_gather_bfs(), libMesh::MeshBase::partition(), libMesh::Partitioner::partition(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::MeshBase::print_constraint_rows(), libMesh::DofMap::print_dof_constraints(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::NameBasedIO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::XdrIO::read_header(), libMesh::CheckpointIO::read_nodes(), libMesh::System::read_parallel_data(), libMesh::System::read_SCALAR_dofs(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::System::read_serialized_vector(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::Partitioner::repartition(), OverlappingFunctorTest::run_partitioner_test(), libMesh::DofMap::scatter_constraints(), libMesh::DistributedMesh::set_next_unique_id(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), WriteVecAndScalar::setupTests(), libMesh::RBEIMEvaluation::side_gather_bfs(), DistributedMeshTest::testRemoteElemError(), CheckpointIOTest::testSplitter(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::VTKIO::write_nodal_data(), libMesh::System::write_parallel_data(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), and libMesh::XdrIO::write_serialized_nodesets().

pc()

template<typename T >

PC libMesh::PetscLinearSolver< T >::pc ( )

inline

Returns

The raw PETSc preconditioner context pointer.

This allows you to specify the PCShellSetApply() and PCShellSetSetUp() functions if you desire. Just don't do anything crazy like calling libMeshPCDestroy() on the pointer!

Definition at line 217 of file petsc_linear_solver.h.

{ this->init(); return _pc; }

References libMesh::PetscLinearSolver< T >::_pc, and libMesh::PetscLinearSolver< T >::init().

Referenced by PetscSolverConfiguration::configure_solver().

preconditioner_type()

template<typename T >

PreconditionerType libMesh::LinearSolver< T >::preconditioner_type ( ) const

inherited

Returns

The type of preconditioner to use.

Definition at line 100 of file linear_solver.C.

{
  if (_preconditioner)
    return _preconditioner->type();
 
  return _preconditioner_type;
}

print_converged_reason()

template<typename T >

void libMesh::LinearSolver< T >::print_converged_reason ( ) const

virtualinherited

Prints a useful message about why the latest linear solve con(di)verged.

Reimplemented in libMesh::LaspackLinearSolver< T >, and libMesh::AztecLinearSolver< T >.

Definition at line 172 of file linear_solver.C.

{
  LinearConvergenceReason reason = this->get_converged_reason();
  libMesh::out << "Linear solver convergence/divergence reason: " << Utility::enum_to_string(reason) << std::endl;
}

References libMesh::Utility::enum_to_string(), and libMesh::out.

print_info()

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

staticinherited

Prints the reference information, by default to libMesh::out.

Definition at line 81 of file reference_counter.C.

{
  if (_enable_print_counter)
    out_stream << ReferenceCounter::get_info();
}

References libMesh::ReferenceCounter::_enable_print_counter, and libMesh::ReferenceCounter::get_info().

Referenced by libMesh::LibMeshInit::~LibMeshInit().

processor_id()

processor_id_type libMesh::ParallelObject::processor_id ( ) const

inlineinherited

Returns

The rank of this processor in the group.

Definition at line 114 of file parallel_object.h.

  { return cast_int<processor_id_type>(_communicator.rank()); }

References libMesh::ParallelObject::_communicator, and libMesh::Parallel::Communicator::rank().

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::BoundaryInfo::add_elements(), libMesh::DistributedMesh::add_node(), libMesh::MeshTools::Modification::all_tri(), libMesh::FEMSystem::assembly(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::Partitioner::assign_partitioning(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::Partitioner::build_graph(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::MeshFunction::check_found_elem(), libMesh::DistributedMesh::clear(), libMesh::DistributedMesh::clear_elems(), libMesh::ExodusII_IO_Helper::close(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::compute_communication_map_parameters(), libMesh::Nemesis_IO_Helper::compute_internal_and_border_elems_and_internal_nodes(), libMesh::RBConstruction::compute_max_error_bound(), libMesh::Nemesis_IO_Helper::compute_node_communication_maps(), libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::ExodusII_IO::copy_nodal_solution(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::Nemesis_IO::copy_scalar_solution(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::ExodusII_IO_Helper::create(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::DistributedMesh::DistributedMesh(), libMesh::DistributedMesh::DistributedMesh(), libMesh::DofMapBase::end_dof(), libMesh::DofMapBase::end_old_dof(), libMesh::EnsightIO::EnsightIO(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::find_dofs_to_send(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::DofMapBase::first_dof(), libMesh::DofMapBase::first_old_dof(), libMesh::RBEIMEvaluation::gather_bfs(), libMesh::Nemesis_IO_Helper::get_cmap_params(), libMesh::Nemesis_IO_Helper::get_eb_info_global(), libMesh::Nemesis_IO_Helper::get_elem_cmap(), libMesh::Nemesis_IO_Helper::get_elem_map(), libMesh::MeshBase::get_info(), libMesh::Nemesis_IO_Helper::get_init_global(), libMesh::Nemesis_IO_Helper::get_init_info(), libMesh::RBEIMEvaluation::get_interior_basis_functions_as_vecs(), libMesh::Nemesis_IO_Helper::get_loadbal_param(), libMesh::DofMap::get_local_constraints(), libMesh::MeshBase::get_local_constraints(), libMesh::Nemesis_IO_Helper::get_node_cmap(), libMesh::Nemesis_IO_Helper::get_node_map(), libMesh::Nemesis_IO_Helper::get_ns_param_global(), libMesh::Nemesis_IO_Helper::get_ss_param_global(), libMesh::SparsityPattern::Build::handle_vi_vj(), libMesh::LaplaceMeshSmoother::init(), libMesh::SystemSubsetBySubdomain::init(), HeatSystem::init_data(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize_element_variables(), libMesh::ExodusII_IO_Helper::initialize_global_variables(), libMesh::ExodusII_IO_Helper::initialize_nodal_variables(), libMesh::DistributedMesh::insert_elem(), libMesh::MeshTools::Modification::interpolate_surface(), libMesh::SparsityPattern::Build::join(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBSCMEvaluation::legacy_write_offline_data_to_files(), libMesh::TransientRBEvaluation::legacy_write_offline_data_to_files(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), main(), AugmentSparsityOnInterface::mesh_reinit(), libMesh::TriangulatorInterface::MeshedHole::MeshedHole(), libMesh::MeshBase::n_active_local_elem(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::MeshTools::n_connected_components(), libMesh::MeshBase::n_constraint_rows(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::DofMapBase::n_local_dofs(), libMesh::MeshBase::n_local_elem(), libMesh::MeshBase::n_local_nodes(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::RBEIMEvaluation::node_gather_bfs(), libMesh::DistributedMesh::own_node(), libMesh::BoundaryInfo::parallel_sync_node_ids(), libMesh::BoundaryInfo::parallel_sync_side_ids(), libMesh::MeshBase::print_constraint_rows(), libMesh::DofMap::print_dof_constraints(), libMesh::DofMap::process_mesh_constraint_rows(), libMesh::Nemesis_IO_Helper::put_cmap_params(), libMesh::Nemesis_IO_Helper::put_elem_cmap(), libMesh::Nemesis_IO_Helper::put_elem_map(), libMesh::Nemesis_IO_Helper::put_loadbal_param(), libMesh::Nemesis_IO_Helper::put_node_cmap(), libMesh::Nemesis_IO_Helper::put_node_map(), libMesh::XdrIO::read(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::NameBasedIO::read(), libMesh::EquationSystems::read(), libMesh::EquationSystems::read(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::ExodusII_IO_Helper::read_global_values(), libMesh::CheckpointIO::read_header(), libMesh::ExodusII_IO::read_header(), libMesh::System::read_header(), libMesh::XdrIO::read_header(), libMesh::DynaIO::read_mesh(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::System::read_parallel_data(), libMesh::RBConstruction::read_riesz_representors_from_files(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::System::read_SCALAR_dofs(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::System::read_serialized_data(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::System::read_serialized_vector(), libMesh::System::read_serialized_vectors(), libMesh::Nemesis_IO_Helper::read_var_names_impl(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::StaticCondensationDofMap::reinit(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::DistributedMesh::renumber_nodes_and_elements(), libMesh::DofMap::scatter_constraints(), libMesh::CheckpointIO::select_split_config(), libMesh::DistributedMesh::set_next_unique_id(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::RBEIMEvaluation::side_gather_bfs(), MeshFunctionTest::test_bad_gradient_var_with_out_of_mesh_value(), MeshFunctionTest::test_bad_hessian_var_with_out_of_mesh_value(), ExodusTest< elem_type >::test_read_gold(), ExodusTest< elem_type >::test_write(), ExodusC0PolyhedronTest::test_write_and_read_hexagonal_prism(), ExodusC0PolygonTest::test_write_and_read_pentagon(), MeshInputTest::testAbaqusRead(), MeshInputTest::testBadGmsh(), BoundaryInfoTest::testBoundaryIDs(), MeshInputTest::testCopyElementSolutionImpl(), MeshInputTest::testCopyElementVectorImpl(), MeshInputTest::testCopyNodalSolutionImpl(), DefaultCouplingTest::testCoupling(), PointNeighborCouplingTest::testCoupling(), MeshInputTest::testDynaFileMappings(), MeshInputTest::testDynaNoSplines(), MeshInputTest::testDynaReadElem(), MeshInputTest::testDynaReadPatch(), MeshInputTest::testExodusFileMappings(), MeshInputTest::testExodusIGASidesets(), MeshInputTest::testExodusWriteElementDataFromDiscontinuousNodalData(), MeshInputTest::testGmshBCIDOverlap(), MeshInputTest::testGoodGmsh(), MeshInputTest::testGoodSTL(), MeshInputTest::testGoodSTLBinary(), BoundaryInfoTest::testInternalBoundary(), MeshInputTest::testLowOrderEdgeBlocks(), BoundaryMeshSubdomainTest::testPerBoundarySubdomain(), SystemsTest::testProjectMatrix3D(), BoundaryInfoTest::testShellFaceConstraints(), MeshInputTest::testSingleElementImpl(), BoundaryMeshSubdomainTest::testSingleSubdomain(), WriteVecAndScalar::testSolution(), CheckpointIOTest::testSplitter(), MeshInputTest::testTetgenIO(), MeshSmootherTest::testVariationalSmoother(), libMesh::MeshTools::total_weight(), libMesh::NetGenMeshInterface::triangulate(), libMesh::Parallel::Packing< Elem * >::unpack(), libMesh::Parallel::Packing< Node * >::unpack(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::DTKAdapter::update_variable_values(), libMesh::MeshTools::volume(), libMesh::STLIO::write(), libMesh::XdrIO::write(), libMesh::NameBasedIO::write(), libMesh::CheckpointIO::write(), libMesh::EquationSystems::write(), libMesh::EquationSystems::write(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO::write_element_data(), libMesh::ExodusII_IO::write_element_data_from_discontinuous_nodal_data(), libMesh::ExodusII_IO_Helper::write_element_values(), libMesh::ExodusII_IO_Helper::write_element_values_element_major(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::ExodusII_IO_Helper::write_elemset_data(), libMesh::ExodusII_IO_Helper::write_elemsets(), libMesh::ExodusII_IO::write_global_data(), libMesh::ExodusII_IO_Helper::write_global_values(), libMesh::System::write_header(), libMesh::ExodusII_IO::write_information_records(), libMesh::ExodusII_IO_Helper::write_information_records(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::VTKIO::write_nodal_data(), libMesh::UCDIO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data_common(), libMesh::ExodusII_IO::write_nodal_data_discontinuous(), libMesh::ExodusII_IO_Helper::write_nodal_values(), libMesh::ExodusII_IO_Helper::write_nodeset_data(), libMesh::ExodusII_IO_Helper::write_nodesets(), libMesh::Nemesis_IO_Helper::write_nodesets(), libMesh::RBEIMEvaluation::write_out_interior_basis_functions(), libMesh::RBEIMEvaluation::write_out_node_basis_functions(), libMesh::RBEIMEvaluation::write_out_side_basis_functions(), write_output_solvedata(), libMesh::System::write_parallel_data(), libMesh::RBConstruction::write_riesz_representors_to_files(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bc_names(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::System::write_serialized_data(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::XdrIO::write_serialized_subdomain_names(), libMesh::System::write_serialized_vector(), libMesh::System::write_serialized_vectors(), libMesh::ExodusII_IO_Helper::write_sideset_data(), libMesh::ExodusII_IO_Helper::write_sidesets(), libMesh::Nemesis_IO_Helper::write_sidesets(), libMesh::ExodusII_IO::write_timestep(), libMesh::ExodusII_IO_Helper::write_timestep(), and libMesh::ExodusII_IO::write_timestep_discontinuous().

restrict_solve_to()

template<typename T >

void libMesh::PetscLinearSolver< T >::restrict_solve_to ( const std::vector< unsigned int > *const  dofs, const SubsetSolveMode  subset_solve_mode = SUBSET_ZERO  )

overridevirtual

After calling this method, all successive solves will be restricted to the given set of dofs, which must contain local dofs on each processor only and not contain any duplicates.

This mode can be disabled by calling this method with dofs being a nullptr.

Reimplemented from libMesh::LinearSolver< T >.

Definition at line 234 of file petsc_linear_solver.C.

{
  // The preconditioner (in particular if a default preconditioner)
  // will have to be reset.  We call this->clear() to do that.  This
  // call will also remove and free any previous subset that may have
  // been set before.
  this->clear();
 
  _subset_solve_mode = subset_solve_mode;
 
  if (dofs != nullptr)
    {
      PetscInt * petsc_dofs = nullptr;
      LibmeshPetscCall(PetscMalloc(dofs->size()*sizeof(PetscInt), &petsc_dofs));
 
      for (auto i : index_range(*dofs))
        petsc_dofs[i] = (*dofs)[i];
 
      // Create the IS
      // PETSc now takes over ownership of the "petsc_dofs"
      // array, so we don't have to worry about it any longer.
      LibmeshPetscCall(ISCreateGeneral(this->comm().get(),
                                       cast_int<PetscInt>(dofs->size()),
                                       petsc_dofs, PETSC_OWN_POINTER,
                                       _restrict_solve_to_is.get()));
    }
}

restrict_solve_to_is_local_size()

template<typename T >

PetscInt libMesh::PetscLinearSolver< T >::restrict_solve_to_is_local_size ( ) const

private

Returns

The local size of _restrict_solve_to_is.

Definition at line 901 of file petsc_linear_solver.C.

{
  libmesh_assert(_restrict_solve_to_is);
 
  PetscInt s;
  LibmeshPetscCall(ISGetLocalSize(_restrict_solve_to_is, &s));
 
  return s;
}

References libMesh::libmesh_assert().

reuse_preconditioner()

template<typename T >

void libMesh::LinearSolver< T >::reuse_preconditioner ( bool  reuse_flag )

virtualinherited

Set the same_preconditioner flag, which indicates if we reuse the same preconditioner for subsequent solves.

Definition at line 131 of file linear_solver.C.

{
  same_preconditioner = reuse_flag;
}

Referenced by libMesh::ImplicitSystem::disable_cache(), libMesh::RBConstruction::initialize_rb_construction(), and main().

set_petsc_solver_type()

template<typename T >

void libMesh::PetscLinearSolver< T >::set_petsc_solver_type ( )

private

Tells PETSC to use the user-specified solver stored in _solver_type.

Definition at line 722 of file petsc_linear_solver.C.

{
  #define CaseKSPSetType(SolverType, KSPT)                          \
  case SolverType:                                                  \
    LibmeshPetscCall(KSPSetType (_ksp, const_cast<KSPType>(KSPT))); \
    return;
 
  switch (this->_solver_type)
    {
    CaseKSPSetType(CG,         KSPCG)
    CaseKSPSetType(CR,         KSPCR)
    CaseKSPSetType(CGS,        KSPCGS)
    CaseKSPSetType(BICG,       KSPBICG)
    CaseKSPSetType(TCQMR,      KSPTCQMR)
    CaseKSPSetType(TFQMR,      KSPTFQMR)
    CaseKSPSetType(LSQR,       KSPLSQR)
    CaseKSPSetType(BICGSTAB,   KSPBCGS)
    CaseKSPSetType(MINRES,     KSPMINRES)
    CaseKSPSetType(GMRES,      KSPGMRES)
    CaseKSPSetType(RICHARDSON, KSPRICHARDSON)
    CaseKSPSetType(CHEBYSHEV,  KSPCHEBYSHEV)
 
    default:
      libMesh::err << "ERROR:  Unsupported PETSC Solver: "
                   << Utility::enum_to_string(this->_solver_type) << std::endl
                   << "Continuing with PETSC defaults" << std::endl;
    }
}

References libMesh::BICG, libMesh::BICGSTAB, libMesh::CG, libMesh::CGS, libMesh::CHEBYSHEV, libMesh::CR, libMesh::Utility::enum_to_string(), libMesh::err, libMesh::GMRES, libMesh::LSQR, libMesh::MINRES, libMesh::RICHARDSON, libMesh::TCQMR, and libMesh::TFQMR.

set_preconditioner_type()

template<typename T >

void libMesh::LinearSolver< T >::set_preconditioner_type ( const PreconditionerType  pct )

inherited

Sets the type of preconditioner to use.

Definition at line 110 of file linear_solver.C.

{
  if (_preconditioner)
    _preconditioner->set_type(pct);
  else
    _preconditioner_type = pct;
}

Referenced by TimeSolverTestImplementation< TimeSolverType >::run_test_with_exact_soln(), and SystemsTest::testDofCouplingWithVarGroups().

set_solver_configuration()

template<typename T >

void libMesh::LinearSolver< T >::set_solver_configuration ( SolverConfiguration &  solver_configuration )

inherited

Set the solver configuration object.

Definition at line 179 of file linear_solver.C.

{
  _solver_configuration = &solver_configuration;
}

set_solver_type()

template<typename T >

void libMesh::LinearSolver< T >::set_solver_type ( const SolverType  st )

inlineinherited

Sets the type of solver to use.

Definition at line 118 of file linear_solver.h.

  { _solver_type = st; }

References libMesh::LinearSolver< T >::_solver_type.

Referenced by adjust_linear_solver(), main(), TimeSolverTestImplementation< TimeSolverType >::run_test_with_exact_soln(), and SystemsTest::testDofCouplingWithVarGroups().

shell_solve_common()

template<typename T >

std::pair< unsigned int, Real > libMesh::PetscLinearSolver< T >::shell_solve_common ( const ShellMatrix< T > &  shell_matrix, PetscMatrixBase< T > *  precond_matrix, NumericVector< T > &  solution_in, NumericVector< T > &  rhs_in, const double  rel_tol, const double  abs_tol, const unsigned int  m_its  )

privatevirtual

Definition at line 386 of file petsc_linear_solver.C.

{
  LOG_SCOPE("solve()", "PetscLinearSolver");
 
  // We don't really have a matrix for our matrix here
  SparseMatrix<T> * matrix = nullptr;
 
  this->init ();
 
  // Prepare the matrix.
  WrappedPetsc<Mat> mat;
  LibmeshPetscCall(MatCreateShell(this->comm().get(),
                                  rhs_in.local_size(),
                                  solution_in.local_size(),
                                  rhs_in.size(),
                                  solution_in.size(),
                                  const_cast<void *>(static_cast<const void *>(&shell_matrix)),
                                  mat.get()));
  // Note that the const_cast above is only necessary because PETSc
  // does not accept a const void *.  Inside the member function
  // _petsc_shell_matrix() below, the pointer is casted back to a
  // const ShellMatrix<T> *.
 
  LibmeshPetscCall(MatShellSetOperation(mat, MATOP_MULT, reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_mult)));
  LibmeshPetscCall(MatShellSetOperation(mat, MATOP_MULT_ADD, reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_mult_add)));
  LibmeshPetscCall(MatShellSetOperation(mat, MATOP_GET_DIAGONAL, reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_get_diagonal)));
 
  return this->solve_base
    (matrix, precond, mat, solution_in, rhs_in, rel_tol, abs_tol, m_its, KSPSolve);
}

References libMesh::WrappedPetsc< T >::get(), libMesh::NumericVector< T >::local_size(), and libMesh::NumericVector< T >::size().

solve() [1/6]

template<typename T >

std::pair< unsigned int, Real > libMesh::LinearSolver< T >::solve ( const ShellMatrix< T > &  matrix, const SparseMatrix< T > *  precond_matrix, NumericVector< T > &  sol, NumericVector< T > &  rhs, const std::optional< double >  tol = std::nullopt, const std::optional< unsigned int >  m_its = std::nullopt  )

inlineinherited

This function solves a system whose matrix is a shell matrix, but an optional sparse matrix may be used as preconditioning matrix.

Definition at line 352 of file linear_solver.h.

{
  if (pc_mat)
    return this->solve(mat, *pc_mat, sol, rhs, tol, n_iter);
  else
    return this->solve(mat, sol, rhs, tol, n_iter);
}

solve() [2/6]

template<typename T >

std::pair< unsigned int, Real > libMesh::PetscLinearSolver< T >::solve ( const ShellMatrix< T > &  shell_matrix, const SparseMatrix< T > &  precond_matrix, NumericVector< T > &  solution_in, NumericVector< T > &  rhs_in, const std::optional< double >  tol = std::nullopt, const std::optional< unsigned int >  m_its = std::nullopt  )

overridevirtual

This function solves a system whose matrix is a shell matrix, but a sparse matrix is used as preconditioning matrix, this allowing other preconditioners than JACOBI.

Implements libMesh::LinearSolver< T >.

Definition at line 361 of file petsc_linear_solver.C.

{
  const double rel_tol = this->get_real_solver_setting("rel_tol", tol);
  const double abs_tol = this->get_real_solver_setting("abs_tol",
                                                       std::nullopt,
                                                       static_cast<double>(PETSC_DEFAULT));
  const double max_its = this->get_int_solver_setting("max_its", m_its);
 
  // Make sure the data passed in are really of Petsc types
  const PetscMatrixBase<T> * precond  = cast_ptr<const PetscMatrixBase<T> *>(&precond_matrix);
 
  return this->shell_solve_common
    (shell_matrix, const_cast<PetscMatrixBase<T> *>(precond), solution_in,
     rhs_in, rel_tol, abs_tol, max_its);
}

solve() [3/6]

template<typename T >

std::pair< unsigned int, Real > libMesh::PetscLinearSolver< T >::solve ( const ShellMatrix< T > &  shell_matrix, NumericVector< T > &  solution_in, NumericVector< T > &  rhs_in, const std::optional< double >  tol = std::nullopt, const std::optional< unsigned int >  m_its = std::nullopt  )

overridevirtual

This function solves a system whose matrix is a shell matrix.

Implements libMesh::LinearSolver< T >.

Definition at line 339 of file petsc_linear_solver.C.

{
  LOG_SCOPE("solve()", "PetscLinearSolver");
 
  const double rel_tol = this->get_real_solver_setting("rel_tol", tol);
  const double abs_tol = this->get_real_solver_setting("abs_tol",
                                                       std::nullopt,
                                                       static_cast<double>(PETSC_DEFAULT));
  const double max_its = this->get_int_solver_setting("max_its", m_its);
 
  return this->shell_solve_common(shell_matrix, nullptr, solution_in,
                                  rhs_in, rel_tol, abs_tol, max_its);
}

solve() [4/6]

template<typename T >

std::pair< unsigned int, Real > libMesh::PetscLinearSolver< T >::solve ( SparseMatrix< T > &  matrix, SparseMatrix< T > &  preconditioner, NumericVector< T > &  solution, NumericVector< T > &  rhs, const std::optional< double >  tol = std::nullopt, const std::optional< unsigned int >  m_its = std::nullopt  )

overridevirtual

This method allows you to call a linear solver while specifying the matrix to use as the (left) preconditioning matrix.

Note

The linear solver will not compute a preconditioner in this case, and will instead premultiply by the matrix you provide. In PETSc, this is accomplished by calling

PCSetType(_pc, PCMAT);

before invoking KSPSolve().

This functionality is not implemented in the LinearSolver class since there is not a built-in analog to this method for LASPACK. You could probably implement it by hand if you wanted.

Implements libMesh::LinearSolver< T >.

Definition at line 267 of file petsc_linear_solver.C.

{
  LOG_SCOPE("solve()", "PetscLinearSolver");
 
  const double rel_tol = this->get_real_solver_setting("rel_tol", tol);
  const double abs_tol = this->get_real_solver_setting("abs_tol",
                                                       std::nullopt,
                                                       static_cast<double>(PETSC_DEFAULT));
  const double max_its = this->get_int_solver_setting("max_its", m_its);
 
  return this->solve_common(matrix_in, precond_in, solution_in,
                            rhs_in, rel_tol, abs_tol, max_its, KSPSolve);
}

solve() [5/6]

template<typename T >

std::pair< unsigned int, Real > libMesh::LinearSolver< T >::solve ( SparseMatrix< T > &  matrix, SparseMatrix< T > *  precond_matrix, NumericVector< T > &  sol, NumericVector< T > &  rhs, const std::optional< double >  tol = std::nullopt, const std::optional< unsigned int >  m_its = std::nullopt  )

inlineinherited

This function calls the solver "_solver_type" preconditioned with the "_preconditioner_type" preconditioner.

The preconditioning matrix is used if it is provided, or the system matrix is used if precond_matrix is null

Definition at line 335 of file linear_solver.h.

{
  if (pc_mat)
    return this->solve(mat, *pc_mat, sol, rhs, tol, n_iter);
  else
    return this->solve(mat, sol, rhs, tol, n_iter);
}

solve() [6/6]

template<typename T >

virtual std::pair< unsigned int, Real > libMesh::PetscLinearSolver< T >::solve ( SparseMatrix< T > &  matrix_in, NumericVector< T > &  solution_in, NumericVector< T > &  rhs_in, const std::optional< double >  tol = std::nullopt, const std::optional< unsigned int >  m_its = std::nullopt  )

inlineoverridevirtual

Call the Petsc solver.

It calls the method below, using the same matrix for the system and preconditioner matrices.

Implements libMesh::LinearSolver< T >.

Definition at line 142 of file petsc_linear_solver.h.

  {
    return this->solve(matrix_in, matrix_in, solution_in, rhs_in, tol, m_its);
  }

References libMesh::PetscLinearSolver< T >::solve().

Referenced by libMesh::PetscLinearSolver< T >::solve().

solve_base()

template<typename T >

std::pair< unsigned int, Real > libMesh::PetscLinearSolver< T >::solve_base ( SparseMatrix< T > *  matrix, PetscMatrixBase< T > *  precond, Mat  mat, NumericVector< T > &  solution_in, NumericVector< T > &  rhs_in, const double  rel_tol, const double  abs_tol, const unsigned int  m_its, ksp_solve_func_type  solve_func  )

private

Definition at line 427 of file petsc_linear_solver.C.

{
  // Make sure the data passed in are really of Petsc types
  PetscVector<T> * solution = cast_ptr<PetscVector<T> *>(&solution_in);
  PetscVector<T> * rhs      = cast_ptr<PetscVector<T> *>(&rhs_in);
 
  // Close the vectors in case this wasn't already done.
  solution->close ();
  rhs->close ();
 
  PetscInt its=0, max_its = static_cast<PetscInt>(m_its);
  PetscReal final_resid=0.;
 
  std::unique_ptr<PetscMatrixBase<Number>> subprecond_matrix;
  WrappedPetsc<Mat> subprecond;
 
  WrappedPetsc<Mat> submat;
  WrappedPetsc<Vec> subrhs;
  WrappedPetsc<Vec> subsolution;
  WrappedPetsc<VecScatter> scatter;
 
  // Restrict rhs and solution vectors and set operators.  The input
  // matrix works as the preconditioning matrix.
  if (_restrict_solve_to_is)
    {
      PetscInt is_local_size = this->restrict_solve_to_is_local_size();
 
      LibmeshPetscCall(VecCreate(this->comm().get(), subrhs.get()));
      LibmeshPetscCall(VecSetSizes(subrhs, is_local_size, PETSC_DECIDE));
      LibmeshPetscCall(VecSetFromOptions(subrhs));
 
      LibmeshPetscCall(VecCreate(this->comm().get(), subsolution.get()));
      LibmeshPetscCall(VecSetSizes(subsolution, is_local_size, PETSC_DECIDE));
      LibmeshPetscCall(VecSetFromOptions(subsolution));
 
      LibmeshPetscCall(VecScatterCreate(rhs->vec(), _restrict_solve_to_is, subrhs, nullptr, scatter.get()));
 
      VecScatterBeginEnd(this->comm(), scatter, rhs->vec(), subrhs, INSERT_VALUES, SCATTER_FORWARD);
      VecScatterBeginEnd(this->comm(), scatter, solution->vec(), subsolution, INSERT_VALUES, SCATTER_FORWARD);
 
      LibmeshPetscCall(LibMeshCreateSubMatrix(mat,
                                              _restrict_solve_to_is,
                                              _restrict_solve_to_is,
                                              MAT_INITIAL_MATRIX,
                                              submat.get()));
 
      if (precond)
        LibmeshPetscCall(LibMeshCreateSubMatrix(const_cast<PetscMatrixBase<T> *>(precond)->mat(),
                                                _restrict_solve_to_is,
                                                _restrict_solve_to_is,
                                                MAT_INITIAL_MATRIX,
                                                subprecond.get()));
 
      // Since removing columns of the matrix changes the equation
      // system, we will now change the right hand side to compensate
      // for this.  Note that this is not necessary if \p SUBSET_ZERO
      // has been selected.
      if (_subset_solve_mode!=SUBSET_ZERO)
        {
          this->create_complement_is(rhs_in);
          PetscInt is_complement_local_size =
            cast_int<PetscInt>(rhs_in.local_size()-is_local_size);
 
          WrappedPetsc<Vec> subvec1;
          LibmeshPetscCall(VecCreate(this->comm().get(), subvec1.get()));
          LibmeshPetscCall(VecSetSizes(subvec1, is_complement_local_size, PETSC_DECIDE));
          LibmeshPetscCall(VecSetFromOptions(subvec1));
 
          WrappedPetsc<VecScatter> scatter1;
          LibmeshPetscCall(VecScatterCreate(rhs->vec(), _restrict_solve_to_is_complement, subvec1, nullptr, scatter1.get()));
 
          VecScatterBeginEnd(this->comm(), scatter1, _subset_solve_mode==SUBSET_COPY_RHS ? rhs->vec() : solution->vec(), subvec1, INSERT_VALUES, SCATTER_FORWARD);
 
          LibmeshPetscCall(VecScale(subvec1, -1.0));
 
          WrappedPetsc<Mat> submat1;
          LibmeshPetscCall(LibMeshCreateSubMatrix(mat,
                                                  _restrict_solve_to_is,
                                                  _restrict_solve_to_is_complement,
                                                  MAT_INITIAL_MATRIX,
                                                  submat1.get()));
 
          LibmeshPetscCall(MatMultAdd(submat1, subvec1, subrhs, subrhs));
        }
 
      if (precond)
        LibmeshPetscCall(KSPSetOperators(_ksp, submat, subprecond));
      else
        LibmeshPetscCall(KSPSetOperators(_ksp, submat, submat));
 
      PetscBool ksp_reuse_preconditioner = this->same_preconditioner ? PETSC_TRUE : PETSC_FALSE;
      LibmeshPetscCall(KSPSetReusePreconditioner(_ksp, ksp_reuse_preconditioner));
 
      if (precond && this->_preconditioner)
        {
          subprecond_matrix = std::make_unique<PetscMatrix<Number>>(subprecond, this->comm());
          this->_preconditioner->set_matrix(*subprecond_matrix);
          this->_preconditioner->init();
        }
    }
  else
    {
      PetscBool ksp_reuse_preconditioner = this->same_preconditioner ? PETSC_TRUE : PETSC_FALSE;
      LibmeshPetscCall(KSPSetReusePreconditioner(_ksp, ksp_reuse_preconditioner));
 
      if (precond)
        LibmeshPetscCall(KSPSetOperators(_ksp, mat, const_cast<PetscMatrixBase<T> *>(precond)->mat()));
      else
        LibmeshPetscCall(KSPSetOperators(_ksp, mat, mat));
 
      if (this->_preconditioner)
        {
          if (matrix)
            this->_preconditioner->set_matrix(*matrix);
          else if (precond)
            this->_preconditioner->set_matrix(const_cast<PetscMatrixBase<Number> &>(*precond));
 
          this->_preconditioner->init();
        }
    }
 
  // Set the tolerances for the iterative solver.  Use the user-supplied
  // tolerance for the relative residual & leave the others at default values.
  LibmeshPetscCall(KSPSetTolerances(_ksp, rel_tol, abs_tol,
                                    PETSC_DEFAULT, max_its));
 
  // Allow command line options to override anything set programmatically.
  LibmeshPetscCall(KSPSetFromOptions(_ksp));
 
#if defined(LIBMESH_HAVE_PETSC_HYPRE) && PETSC_VERSION_LESS_THAN(3, 23, 0) &&                      \
    !PETSC_VERSION_LESS_THAN(3, 12, 0) && defined(PETSC_HAVE_HYPRE_DEVICE)
  {
    // Make sure hypre has been initialized
    LibmeshPetscCallExternal(HYPRE_Initialize);
    PetscScalar * dummyarray;
    PetscMemType mtype;
    LibmeshPetscCall(VecGetArrayAndMemType(solution->vec(), &dummyarray, &mtype));
    LibmeshPetscCall(VecRestoreArrayAndMemType(solution->vec(), &dummyarray));
    if (PetscMemTypeHost(mtype))
      LibmeshPetscCallExternal(HYPRE_SetMemoryLocation, HYPRE_MEMORY_HOST);
  }
#endif
 
  // If the SolverConfiguration object is provided, use it to override
  // solver options.
  if (this->_solver_configuration)
    {
      this->_solver_configuration->configure_solver();
    }
 
  // Solve the linear system
  if (_restrict_solve_to_is)
    LibmeshPetscCall(solve_func (_ksp, subrhs, subsolution));
  else
    LibmeshPetscCall(solve_func (_ksp, rhs->vec(), solution->vec()));
 
  // Get the number of iterations required for convergence
  LibmeshPetscCall(KSPGetIterationNumber (_ksp, &its));
 
  // Get the norm of the final residual to return to the user.
  LibmeshPetscCall(KSPGetResidualNorm (_ksp, &final_resid));
 
  if (_restrict_solve_to_is)
    {
      switch(_subset_solve_mode)
        {
        case SUBSET_ZERO:
          LibmeshPetscCall(VecZeroEntries(solution->vec()));
          break;
 
        case SUBSET_COPY_RHS:
          LibmeshPetscCall(VecCopy(rhs->vec(),solution->vec()));
          break;
 
        case SUBSET_DONT_TOUCH:
          // Nothing to do here.
          break;
 
        default:
          libmesh_error_msg("Invalid subset solve mode = " << _subset_solve_mode);
        }
 
      VecScatterBeginEnd(this->comm(), scatter, subsolution, solution->vec(), INSERT_VALUES, SCATTER_REVERSE);
 
      if (precond && this->_preconditioner)
        {
          // Before subprecond_matrix gets cleaned up, we should give
          // the _preconditioner a different matrix.
          if (matrix)
            this->_preconditioner->set_matrix(*matrix);
          else
            this->_preconditioner->set_matrix(*precond);
 
          this->_preconditioner->init();
        }
    }
 
  // return the # of its. and the final residual norm.
  return std::make_pair(its, final_resid);
}

References libMesh::PetscVector< T >::close(), libMesh::WrappedPetsc< T >::get(), libMesh::NumericVector< T >::local_size(), libMesh::SUBSET_COPY_RHS, libMesh::SUBSET_DONT_TOUCH, libMesh::SUBSET_ZERO, and libMesh::PetscVector< T >::vec().

solve_common()

template<typename T >

std::pair< unsigned int, Real > libMesh::PetscLinearSolver< T >::solve_common ( SparseMatrix< T > &  matrix_in, SparseMatrix< T > &  precond_in, NumericVector< T > &  solution_in, NumericVector< T > &  rhs_in, const double  rel_tol, const double  abs_tol, const unsigned int  m_its, ksp_solve_func_type  solve_func  )

privatevirtual

Definition at line 310 of file petsc_linear_solver.C.

{
  // Make sure the data passed in are really of Petsc types
  PetscMatrixBase<T> * matrix   = cast_ptr<PetscMatrixBase<T> *>(&matrix_in);
  PetscMatrixBase<T> * precond  = cast_ptr<PetscMatrixBase<T> *>(&precond_in);
 
  this->init (matrix);
 
  // Close the matrices in case this wasn't already done.
  matrix->close ();
  if (precond != matrix)
    precond->close ();
 
  auto mat = matrix->mat();
 
  return this->solve_base
    (matrix, precond, mat, solution_in, rhs_in, rel_tol, abs_tol, m_its, solve_func);
}

solver_type()

template<typename T >

SolverType libMesh::LinearSolver< T >::solver_type ( ) const

inlineinherited

Returns

The type of solver to use.

Definition at line 113 of file linear_solver.h.

{ return _solver_type; }

References libMesh::LinearSolver< T >::_solver_type.

Member Data Documentation

_communicator

const Parallel::Communicator& libMesh::ParallelObject::_communicator

protectedinherited

Definition at line 120 of file parallel_object.h.

Referenced by libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::StaticCondensation::close(), libMesh::ParallelObject::comm(), libMesh::CondensedEigenSystem::initialize_condensed_matrices(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::operator=(), libMesh::ParallelObject::processor_id(), libMesh::BoundaryInfo::regenerate_id_sets(), libMesh::StaticCondensationDofMap::reinit(), and libMesh::BoundaryInfo::synchronize_global_id_set().

_counts

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts

staticprotectedinherited

Actually holds the data.

Definition at line 124 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::get_info().

_enable_print_counter

bool libMesh::ReferenceCounter::_enable_print_counter = true

staticprotectedinherited

Flag to control whether reference count information is printed when print_info is called.

Definition at line 143 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::disable_print_counter_info(), libMesh::ReferenceCounter::enable_print_counter_info(), and libMesh::ReferenceCounter::print_info().

_is_initialized

template<typename T >

bool libMesh::LinearSolver< T >::_is_initialized

protectedinherited

Flag indicating if the data structures have been initialized.

Definition at line 276 of file linear_solver.h.

Referenced by libMesh::LinearSolver< T >::initialized().

_ksp

template<typename T >

WrappedPetsc<KSP> libMesh::PetscLinearSolver< T >::_ksp

private

Krylov subspace context.

Definition at line 321 of file petsc_linear_solver.h.

_mutex

Threads::spin_mutex libMesh::ReferenceCounter::_mutex

staticprotectedinherited

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 137 of file reference_counter.h.

_n_objects

Threads::atomic< unsigned int > libMesh::ReferenceCounter::_n_objects

staticprotectedinherited

The number of objects.

Print the reference count information when the number returns to 0.

Definition at line 132 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::n_objects(), libMesh::ReferenceCounter::ReferenceCounter(), libMesh::ReferenceCounter::ReferenceCounter(), libMesh::ReferenceCounter::ReferenceCounter(), and libMesh::ReferenceCounter::~ReferenceCounter().

_pc

template<typename T >

PC libMesh::PetscLinearSolver< T >::_pc

private

Preconditioner context.

Definition at line 316 of file petsc_linear_solver.h.

Referenced by libMesh::PetscLinearSolver< T >::pc().

_preconditioner

template<typename T >

Preconditioner<T>* libMesh::LinearSolver< T >::_preconditioner

protectedinherited

Holds the Preconditioner object to be used for the linear solves.

Definition at line 281 of file linear_solver.h.

_preconditioner_type

template<typename T >

PreconditionerType libMesh::LinearSolver< T >::_preconditioner_type

protectedinherited

Enum stating with type of preconditioner to use.

Definition at line 271 of file linear_solver.h.

Referenced by libMesh::AztecLinearSolver< T >::AztecLinearSolver().

_restrict_solve_to_is

template<typename T >

WrappedPetsc<IS> libMesh::PetscLinearSolver< T >::_restrict_solve_to_is

private

PETSc index set containing the dofs on which to solve (nullptr means solve on all dofs).

Definition at line 327 of file petsc_linear_solver.h.

_restrict_solve_to_is_complement

template<typename T >

WrappedPetsc<IS> libMesh::PetscLinearSolver< T >::_restrict_solve_to_is_complement

private

PETSc index set, complement to _restrict_solve_to_is.

This will be created on demand by the method _create_complement_is().

Definition at line 334 of file petsc_linear_solver.h.

_solver_configuration

template<typename T >

SolverConfiguration* libMesh::LinearSolver< T >::_solver_configuration

protectedinherited

Optionally store a SolverOptions object that can be used to set parameters like solver type, tolerances and iteration limits.

Definition at line 295 of file linear_solver.h.

_solver_type

template<typename T >

SolverType libMesh::LinearSolver< T >::_solver_type

protectedinherited

Enum stating which type of iterative solver to use.

Definition at line 266 of file linear_solver.h.

Referenced by libMesh::EigenSparseLinearSolver< T >::EigenSparseLinearSolver(), libMesh::LinearSolver< T >::set_solver_type(), and libMesh::LinearSolver< T >::solver_type().

_subset_solve_mode

template<typename T >

SubsetSolveMode libMesh::PetscLinearSolver< T >::_subset_solve_mode

private

If restrict-solve-to-subset mode is active, this member decides what happens with the dofs outside the subset.

Definition at line 352 of file petsc_linear_solver.h.

same_preconditioner

template<typename T >

bool libMesh::LinearSolver< T >::same_preconditioner

protectedinherited

Boolean flag to indicate whether we want to use an identical preconditioner to the previous solve.

This can save substantial work in the cases where the system matrix is the same for successive solves.

Definition at line 289 of file linear_solver.h.

---

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

• include/solvers/petsc_linear_solver.h
• src/solvers/petsc_linear_solver.C