libMesh
Public Member Functions | Static Public Member Functions | Protected Types | Protected Member Functions | Protected Attributes | Static Protected Attributes | Private Types | Private Member Functions | Static Private Member Functions | Private Attributes | List of all members
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 >:
[legend]

Public Member Functions

 PetscLinearSolver (const libMesh::Parallel::Communicator &comm_in)
 Constructor. More...
 
virtual ~PetscLinearSolver ()=default
 Destructor. More...
 
virtual void clear () override
 Release all memory and clear data structures. More...
 
virtual void init (const char *name=nullptr) override
 Initialize data structures if not done so already. More...
 
void init (PetscMatrix< T > *matrix, const char *name=nullptr)
 Initialize data structures if not done so already plus much more. More...
 
virtual void init_names (const System &) override
 Apply names to the system to be solved. More...
 
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. More...
 
virtual std::pair< unsigned int, Realsolve (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. More...
 
virtual std::pair< unsigned int, Realadjoint_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. More...
 
virtual std::pair< unsigned int, Realsolve (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. More...
 
virtual std::pair< unsigned int, Realsolve (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. More...
 
virtual std::pair< unsigned int, Realsolve (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. More...
 
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. More...
 
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. More...
 
PreconditionerType preconditioner_type () const
 
void set_preconditioner_type (const PreconditionerType pct)
 Sets the type of preconditioner to use. More...
 
void attach_preconditioner (Preconditioner< T > *preconditioner)
 Attaches a Preconditioner object to be used. More...
 
virtual void reuse_preconditioner (bool)
 Set the same_preconditioner flag, which indicates if we reuse the same preconditioner for subsequent solves. More...
 
bool get_same_preconditioner ()
 
std::pair< unsigned int, Realsolve (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. More...
 
std::pair< unsigned int, Realsolve (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. More...
 
virtual void print_converged_reason () const
 Prints a useful message about why the latest linear solve con(di)verged. More...
 
void set_solver_configuration (SolverConfiguration &solver_configuration)
 Set the solver configuration object. More...
 
const Parallel::Communicatorcomm () 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. More...
 
static std::string get_info ()
 Gets a string containing the reference information. More...
 
static void print_info (std::ostream &out_stream=libMesh::out)
 Prints the reference information, by default to libMesh::out. More...
 
static unsigned int n_objects ()
 Prints the number of outstanding (created, but not yet destroyed) objects. More...
 
static void enable_print_counter_info ()
 Methods to enable/disable the reference counter output from print_info() More...
 
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. More...
 

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. More...
 
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. More...
 
void increment_constructor_count (const std::string &name) noexcept
 Increments the construction counter. More...
 
void increment_destructor_count (const std::string &name) noexcept
 Increments the destruction counter. More...
 

Protected Attributes

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

Static Protected Attributes

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

Private Types

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

Private Member Functions

virtual std::pair< unsigned int, Realsolve_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, Realshell_solve_common (const ShellMatrix< T > &shell_matrix, PetscMatrix< 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, Realsolve_base (SparseMatrix< T > *matrix, PetscMatrix< 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. More...
 
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. More...
 

Static Private Member Functions

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

Private Attributes

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

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 99 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 262 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 94 of file petsc_linear_solver.C.

94  :
95  LinearSolver<T>(comm_in),
96  _restrict_solve_to_is(nullptr),
99 {
100  if (this->n_processors() == 1)
102  else
104 }
WrappedPetsc< IS > _restrict_solve_to_is
PETSc index set containing the dofs on which to solve (nullptr means solve on all dofs)...
processor_id_type n_processors() const
PreconditionerType _preconditioner_type
Enum stating with type of preconditioner to use.
SubsetSolveMode _subset_solve_mode
If restrict-solve-to-subset mode is active, this member decides what happens with the dofs outside th...
WrappedPetsc< IS > _restrict_solve_to_is_complement
PETSc index set, complement to _restrict_solve_to_is.

◆ ~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 1026 of file petsc_linear_solver.C.

1027 {
1028  // Get the matrix context.
1029  PetscErrorCode ierr=0;
1030  void * ctx;
1031  ierr = MatShellGetContext(mat,&ctx);
1032 
1033  // Get user shell matrix object.
1034  const ShellMatrix<T> & shell_matrix = *static_cast<const ShellMatrix<T> *>(ctx);
1035  CHKERRABORT(shell_matrix.comm().get(), ierr);
1036 
1037  // Make \p NumericVector instances around the vector.
1038  PetscVector<T> dest_global(dest, shell_matrix.comm());
1039 
1040  // Call the user function.
1041  shell_matrix.get_diagonal(dest_global);
1042 
1043  return ierr;
1044 }
void * ctx

◆ _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 972 of file petsc_linear_solver.C.

973 {
974  // Get the matrix context.
975  PetscErrorCode ierr=0;
976  void * ctx;
977  ierr = MatShellGetContext(mat,&ctx);
978 
979  // Get user shell matrix object.
980  const ShellMatrix<T> & shell_matrix = *static_cast<const ShellMatrix<T> *>(ctx);
981  CHKERRABORT(shell_matrix.comm().get(), ierr);
982 
983  // Make \p NumericVector instances around the vectors.
984  PetscVector<T> arg_global(arg, shell_matrix.comm());
985  PetscVector<T> dest_global(dest, shell_matrix.comm());
986 
987  // Call the user function.
988  shell_matrix.vector_mult(dest_global,arg_global);
989 
990  return ierr;
991 }
void * ctx

◆ _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 996 of file petsc_linear_solver.C.

997 {
998  // Get the matrix context.
999  PetscErrorCode ierr=0;
1000  void * ctx;
1001  ierr = MatShellGetContext(mat,&ctx);
1002 
1003  // Get user shell matrix object.
1004  const ShellMatrix<T> & shell_matrix = *static_cast<const ShellMatrix<T> *>(ctx);
1005  CHKERRABORT(shell_matrix.comm().get(), ierr);
1006 
1007  // Make \p NumericVector instances around the vectors.
1008  PetscVector<T> arg_global(arg, shell_matrix.comm());
1009  PetscVector<T> dest_global(dest, shell_matrix.comm());
1010  PetscVector<T> add_global(add, shell_matrix.comm());
1011 
1012  if (add!=arg)
1013  {
1014  arg_global = add_global;
1015  }
1016 
1017  // Call the user function.
1018  shell_matrix.vector_mult_add(dest_global,arg_global);
1019 
1020  return ierr;
1021 }
void * ctx

◆ 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 376 of file petsc_linear_solver.C.

381 {
382  LOG_SCOPE("adjoint_solve()", "PetscLinearSolver");
383 
384  const double rel_tol = this->get_real_solver_setting("rel_tol", tol);
385  const double abs_tol = this->get_real_solver_setting("abs_tol",
386  std::nullopt,
387  static_cast<Real>(PETSC_DEFAULT));
388  const double max_its = this->get_int_solver_setting("max_its", m_its);
389 
390  // Note that the matrix and precond matrix are the same
391  return this->solve_common(matrix_in, matrix_in, solution_in,
392  rhs_in, rel_tol, abs_tol, max_its, KSPSolveTranspose);
393 }
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.
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)
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.

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

121 {
122  libmesh_error_msg_if(this->_is_initialized,
123  "Preconditioner must be attached before the solver is initialized!");
124 
126  _preconditioner = preconditioner;
127 }
Preconditioner< T > * _preconditioner
Holds the Preconditioner object to be used for the linear solves.
PreconditionerType _preconditioner_type
Enum stating with type of preconditioner to use.
bool _is_initialized
Flag indicating if the data structures have been initialized.

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

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

61 {
62  // Avoid unused parameter warnings when no solver packages are enabled.
64 
65  // Build the appropriate solver
66  switch (solver_package)
67  {
68 #ifdef LIBMESH_HAVE_LASPACK
69  case LASPACK_SOLVERS:
70  return std::make_unique<LaspackLinearSolver<T>>(comm);
71 #endif
72 
73 
74 #ifdef LIBMESH_HAVE_PETSC
75  case PETSC_SOLVERS:
76  return std::make_unique<PetscLinearSolver<T>>(comm);
77 #endif
78 
79 
80 #ifdef LIBMESH_TRILINOS_HAVE_AZTECOO
81  case TRILINOS_SOLVERS:
82  return std::make_unique<AztecLinearSolver<T>>(comm);
83 #endif
84 
85 
86 #ifdef LIBMESH_HAVE_EIGEN
87  case EIGEN_SOLVERS:
88  return std::make_unique<EigenSparseLinearSolver<T>>(comm);
89 #endif
90 
91  default:
92  libmesh_error_msg("ERROR: Unrecognized solver package: " << solver_package);
93  }
94 
95  return std::unique_ptr<LinearSolver<T>>();
96 }
const Parallel::Communicator & comm() const
void libmesh_ignore(const Args &...)

◆ 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 109 of file petsc_linear_solver.C.

110 {
111  if (this->initialized())
112  {
113  this->_is_initialized = false;
114 
115  // Calls specialized destroy() functions
120 
121  // Previously we only called KSPDestroy(), we did not reset _ksp
122  // to nullptr, so that behavior is maintained here.
123  _ksp.destroy();
124 
125  // Mimic PETSc default solver and preconditioner
126  this->_solver_type = GMRES;
127 
128  if (!this->_preconditioner)
129  {
130  if (this->n_processors() == 1)
132  else
134  }
135  }
136 }
SolverType _solver_type
Enum stating which type of iterative solver to use.
void reset_to_zero()
Calls destroy() and sets the managed object to nullptr.
Definition: wrapped_petsc.h:70
Preconditioner< T > * _preconditioner
Holds the Preconditioner object to be used for the linear solves.
WrappedPetsc< IS > _restrict_solve_to_is
PETSc index set containing the dofs on which to solve (nullptr means solve on all dofs)...
processor_id_type n_processors() const
bool initialized() const
Definition: linear_solver.h:85
PreconditionerType _preconditioner_type
Enum stating with type of preconditioner to use.
WrappedPetsc< IS > _restrict_solve_to_is_complement
PETSc index set, complement to _restrict_solve_to_is.
void destroy()
Must be specialized to call the appropriate XXXDestroy() routine in order for a WrappedPetsc<T> objec...
WrappedPetsc< KSP > _ksp
Krylov subspace context.
bool _is_initialized
Flag indicating if the data structures have been 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.

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::__libmesh_tao_equality_constraints(), libMesh::__libmesh_tao_equality_constraints_jacobian(), libMesh::__libmesh_tao_gradient(), libMesh::__libmesh_tao_hessian(), libMesh::__libmesh_tao_inequality_constraints(), libMesh::__libmesh_tao_inequality_constraints_jacobian(), libMesh::__libmesh_tao_objective(), libMesh::MeshRefinement::_coarsen_elements(), libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::Partitioner::_find_global_index_by_pid_map(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::SlepcEigenSolver< libMesh::Number >::_petsc_shell_matrix_get_diagonal(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_get_diagonal(), libMesh::SlepcEigenSolver< libMesh::Number >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_mult_add(), libMesh::MeshRefinement::_refine_elements(), libMesh::MeshRefinement::_smooth_flags(), 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::EigenSystem::add_matrices(), libMesh::System::add_matrix(), libMesh::RBConstruction::add_scaled_matrix_and_vector(), libMesh::System::add_variable(), libMesh::System::add_variables(), libMesh::System::add_vector(), libMesh::MeshTools::Modification::all_tri(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::TransientRBConstruction::allocate_data_structures(), libMesh::RBConstruction::allocate_data_structures(), libMesh::TransientRBConstruction::assemble_affine_expansion(), 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::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::System::calculate_norm(), libMesh::DofMap::check_dirichlet_bcid_consistency(), 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::computeF(), libMesh::Problem_Interface::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), 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::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< libMesh::Number >::create_submatrix_nosort(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::RBEIMEvaluation::distribute_bfs(), libMesh::DofMap::distribute_dofs(), 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::PatchRecoveryErrorEstimator::estimate_error(), libMesh::WeightedPatchRecoveryErrorEstimator::estimate_error(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), 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::System::get_info(), libMesh::DofMap::get_info(), 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(), AssembleOptimization::inequality_constraints(), AssembleOptimization::inequality_constraints_jacobian(), libMesh::LocationMap< T >::init(), libMesh::TimeSolver::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_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::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_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_recalculate_monitor(), libMesh::libmesh_petsc_snes_fd_residual(), libMesh::libmesh_petsc_snes_jacobian(), libMesh::libmesh_petsc_snes_mffd_interface(), libMesh::libmesh_petsc_snes_mffd_residual(), libMesh::libmesh_petsc_snes_postcheck(), libMesh::libmesh_petsc_snes_precheck(), libMesh::libmesh_petsc_snes_residual(), libMesh::libmesh_petsc_snes_residual_helper(), 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::MeshRefinement::make_coarsening_compatible(), libMesh::MeshCommunication::make_elems_parallel_consistent(), libMesh::MeshRefinement::make_flags_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::MeshRefinement::make_refinement_compatible(), 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::DofMap::n_constrained_dofs(), 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::MeshBase::operator==(), libMesh::DistributedMesh::parallel_max_elem_id(), libMesh::DistributedMesh::parallel_max_node_id(), libMesh::ReplicatedMesh::parallel_max_unique_id(), libMesh::DistributedMesh::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(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::MeshBase::prepare_for_use(), libMesh::DofMap::print_dof_constraints(), libMesh::DofMap::process_mesh_constraint_rows(), libMesh::Partitioner::processor_pairs_to_interface_nodes(), libMesh::InterMeshProjection::project_system_vectors(), FEMParameters::read(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::EquationSystems::read(), libMesh::ExodusII_IO::read_header(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::System::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::System::read_legacy_data(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::RBConstruction::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(), libMesh::MeshBase::recalculate_n_partitions(), libMesh::MeshRefinement::refine_and_coarsen_elements(), 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::split_mesh(), libMesh::RBEIMConstruction::store_eim_solutions_for_training_set(), libMesh::MeshBase::subdomain_ids(), libMesh::BoundaryInfo::sync(), ConstraintOperatorTest::test1DCoarseningNewNodes(), ConstraintOperatorTest::test1DCoarseningOperator(), libMesh::MeshRefinement::test_level_one(), MeshfunctionDFEM::test_mesh_function_dfem(), MeshfunctionDFEM::test_mesh_function_dfem_grad(), MeshFunctionTest::test_p_level(), libMesh::MeshRefinement::test_unflagged(), DofMapTest::testBadElemFECombo(), SystemsTest::testBlockRestrictedVarNDofs(), BoundaryInfoTest::testBoundaryOnChildrenErrors(), MeshInputTest::testExodusIGASidesets(), MeshTriangulationTest::testFoundCenters(), PointLocatorTest::testLocator(), BoundaryInfoTest::testMesh(), PointLocatorTest::testPlanar(), MeshTriangulationTest::testPoly2TriRefinementBase(), SystemsTest::testProjectCubeWithMeshFunction(), BoundaryInfoTest::testRenumber(), CheckpointIOTest::testSplitter(), MeshInputTest::testTetgenIO(), MeshTriangulationTest::testTriangulatorInterp(), MeshTriangulationTest::testTriangulatorMeshedHoles(), libMesh::MeshTools::total_weight(), libMesh::RBConstruction::train_reduced_basis_with_POD(), libMesh::MeshFunctionSolutionTransfer::transfer(), libMesh::MeshfreeSolutionTransfer::transfer(), libMesh::Poly2TriTriangulator::triangulate(), libMesh::TransientRBConstruction::truth_assembly(), libMesh::RBConstruction::truth_assembly(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::TransientRBConstruction::update_RB_initial_condition_all_N(), libMesh::TransientRBConstruction::update_RB_system_matrices(), libMesh::RBConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_residual_terms(), libMesh::RBConstruction::update_residual_terms(), libMesh::NameBasedIO::write(), libMesh::XdrIO::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::TransientRBConstruction::write_riesz_representors_to_files(), libMesh::RBConstruction::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().

98  { return _communicator; }
const Parallel::Communicator & _communicator

◆ 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 1050 of file petsc_linear_solver.C.

1051 {
1054  {
1055  PetscErrorCode ierr = ISComplement(_restrict_solve_to_is,
1056  vec_in.first_local_index(),
1057  vec_in.last_local_index(),
1059  LIBMESH_CHKERR(ierr);
1060  }
1061 }
WrappedPetsc< IS > _restrict_solve_to_is
PETSc index set containing the dofs on which to solve (nullptr means solve on all dofs)...
libmesh_assert(ctx)
WrappedPetsc< IS > _restrict_solve_to_is_complement
PETSc index set, complement to _restrict_solve_to_is.

◆ disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )
staticinherited

Definition at line 100 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

101 {
102  _enable_print_counter = false;
103  return;
104 }
static bool _enable_print_counter
Flag to control whether reference count information is printed when print_info is called...

◆ enable_print_counter_info()

void libMesh::ReferenceCounter::enable_print_counter_info ( )
staticinherited

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

Definition at line 94 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

95 {
96  _enable_print_counter = true;
97  return;
98 }
static bool _enable_print_counter
Flag to control whether reference count information is printed when print_info is called...

◆ 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 924 of file petsc_linear_solver.C.

925 {
926  KSPConvergedReason reason;
927  KSPGetConvergedReason(_ksp, &reason);
928 
929  switch(reason)
930  {
931  case KSP_CONVERGED_RTOL_NORMAL : return CONVERGED_RTOL_NORMAL;
932  case KSP_CONVERGED_ATOL_NORMAL : return CONVERGED_ATOL_NORMAL;
933  case KSP_CONVERGED_RTOL : return CONVERGED_RTOL;
934  case KSP_CONVERGED_ATOL : return CONVERGED_ATOL;
935  case KSP_CONVERGED_ITS : return CONVERGED_ITS;
936 #if PETSC_VERSION_LESS_THAN(3,19,0)
937  case KSP_CONVERGED_CG_NEG_CURVE : return CONVERGED_CG_NEG_CURVE;
938  // This was deprecated for STEP_LENGTH
939  case KSP_CONVERGED_CG_CONSTRAINED : return CONVERGED_CG_CONSTRAINED;
940 #else
941  case KSP_CONVERGED_NEG_CURVE : return CONVERGED_CG_NEG_CURVE;
942 #endif
943  case KSP_CONVERGED_STEP_LENGTH : return CONVERGED_STEP_LENGTH;
944  case KSP_CONVERGED_HAPPY_BREAKDOWN : return CONVERGED_HAPPY_BREAKDOWN;
945  case KSP_DIVERGED_NULL : return DIVERGED_NULL;
946  case KSP_DIVERGED_ITS : return DIVERGED_ITS;
947  case KSP_DIVERGED_DTOL : return DIVERGED_DTOL;
948  case KSP_DIVERGED_BREAKDOWN : return DIVERGED_BREAKDOWN;
949  case KSP_DIVERGED_BREAKDOWN_BICG : return DIVERGED_BREAKDOWN_BICG;
950  case KSP_DIVERGED_NONSYMMETRIC : return DIVERGED_NONSYMMETRIC;
951  case KSP_DIVERGED_INDEFINITE_PC : return DIVERGED_INDEFINITE_PC;
952  case KSP_DIVERGED_NANORINF : return DIVERGED_NAN;
953  case KSP_DIVERGED_INDEFINITE_MAT : return DIVERGED_INDEFINITE_MAT;
954  case KSP_CONVERGED_ITERATING : return CONVERGED_ITERATING;
955 #if !PETSC_VERSION_LESS_THAN(3,7,0)
956 // PETSc-3.7.0 to 3.10.x
957 #if PETSC_VERSION_LESS_THAN(3,11,0) && PETSC_VERSION_RELEASE
958  case KSP_DIVERGED_PCSETUP_FAILED : return DIVERGED_PCSETUP_FAILED;
959 // PETSc master and future PETSc
960 #else
961  case KSP_DIVERGED_PC_FAILED : return DIVERGED_PCSETUP_FAILED;
962 #endif
963 #endif
964  default :
965  libMesh::err << "Unknown convergence flag!" << std::endl;
966  return UNKNOWN_FLAG;
967  }
968 }
OStreamProxy err
WrappedPetsc< KSP > _ksp
Krylov subspace context.

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

References libMesh::ReferenceCounter::_counts, and libMesh::Quality::name().

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

48 {
49 #if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
50 
51  std::ostringstream oss;
52 
53  oss << '\n'
54  << " ---------------------------------------------------------------------------- \n"
55  << "| Reference count information |\n"
56  << " ---------------------------------------------------------------------------- \n";
57 
58  for (const auto & [name, cd] : _counts)
59  oss << "| " << name << " reference count information:\n"
60  << "| Creations: " << cd.first << '\n'
61  << "| Destructions: " << cd.second << '\n';
62 
63  oss << " ---------------------------------------------------------------------------- \n";
64 
65  return oss.str();
66 
67 #else
68 
69  return "";
70 
71 #endif
72 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
static Counts _counts
Actually holds the data.

◆ 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 808 of file petsc_linear_solver.C.

809 {
810  PetscErrorCode ierr = 0;
811  PetscInt its = 0;
812 
813  // Fill the residual history vector with the residual norms
814  // Note that GetResidualHistory() does not copy any values, it
815  // simply sets the pointer p. Note that for some Krylov subspace
816  // methods, the number of residuals returned in the history
817  // vector may be different from what you are expecting. For
818  // example, TFQMR returns two residual values per iteration step.
819 
820  // Recent versions of PETSc require the residual
821  // history vector pointer to be declared as const.
822 #if PETSC_VERSION_LESS_THAN(3,15,0)
823  PetscReal * p;
824 #else
825  const PetscReal * p;
826 #endif
827 
828 
829  ierr = KSPGetResidualHistory(_ksp, &p, &its);
830  LIBMESH_CHKERR(ierr);
831 
832  // Check no residual history
833  if (its == 0)
834  {
835  libMesh::err << "No iterations have been performed, returning 0." << std::endl;
836  return 0.;
837  }
838 
839  // Otherwise, return the value pointed to by p.
840  return *p;
841 }
OStreamProxy err
WrappedPetsc< KSP > _ksp
Krylov subspace context.

◆ 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 207 of file linear_solver.C.

210 {
211  if (setting.has_value())
212  return setting.value();
213  else if (_solver_configuration)
214  {
215  auto it = this->_solver_configuration->int_valued_data.find(setting_name);
216 
217  if (it != this->_solver_configuration->int_valued_data.end())
218  return it->second;
219  }
220  else if (default_value.has_value())
221  return default_value.value();
222  else
223  libmesh_error_msg("Iteration configuration parameter to the linear solver should either be supplied through input arguments or a SolverConfiguration object!");
224 
225  return 0.0;
226 
227 }
std::map< std::string, int > int_valued_data
Store integer solver parameters in this map, e.g.
SolverConfiguration * _solver_configuration
Optionally store a SolverOptions object that can be used to set parameters like solver type...

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

188 {
189  if (setting.has_value())
190  return setting.value();
191  else if (_solver_configuration)
192  {
193  auto it = this->_solver_configuration->real_valued_data.find(setting_name);
194 
195  if (it != this->_solver_configuration->real_valued_data.end())
196  return it->second;
197  }
198  else if (default_value.has_value())
199  return default_value.value();
200  else
201  libmesh_error_msg("Iteration configuration parameter to the linear solver should either be supplied through input arguments or a SolverConfiguration object!");
202 
203  return 0.0;
204 }
std::map< std::string, Real > real_valued_data
Store real-valued solver parameters in this map, e.g.
SolverConfiguration * _solver_configuration
Optionally store a SolverOptions object that can be used to set parameters like solver type...

◆ 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 767 of file petsc_linear_solver.C.

768 {
769  PetscErrorCode ierr = 0;
770  PetscInt its = 0;
771 
772  // Fill the residual history vector with the residual norms
773  // Note that GetResidualHistory() does not copy any values, it
774  // simply sets the pointer p. Note that for some Krylov subspace
775  // methods, the number of residuals returned in the history
776  // vector may be different from what you are expecting. For
777  // example, TFQMR returns two residual values per iteration step.
778 
779  // Recent versions of PETSc require the residual
780  // history vector pointer to be declared as const.
781 #if PETSC_VERSION_LESS_THAN(3,15,0)
782  PetscReal * p;
783 #else
784  const PetscReal * p;
785 #endif
786 
787  ierr = KSPGetResidualHistory(_ksp, &p, &its);
788  LIBMESH_CHKERR(ierr);
789 
790  // Check for early return
791  if (its == 0) return;
792 
793  // Create space to store the result
794  hist.resize(its);
795 
796  // Copy history into the vector provided by the user.
797  for (PetscInt i=0; i<its; ++i)
798  {
799  hist[i] = *p;
800  p++;
801  }
802 }
WrappedPetsc< KSP > _ksp
Krylov subspace context.

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

328 {
329  return same_preconditioner;
330 }
bool same_preconditioner
Boolean flag to indicate whether we want to use an identical preconditioner to the previous solve...

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

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

Referenced by libMesh::ReferenceCountedObject< RBParametrized >::ReferenceCountedObject().

184 {
185  libmesh_try
186  {
187  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
188  std::pair<unsigned int, unsigned int> & p = _counts[name];
189  p.first++;
190  }
191  libmesh_catch (...)
192  {
193  auto stream = libMesh::err.get();
194  stream->exceptions(stream->goodbit); // stream must not throw
195  libMesh::err << "Encountered unrecoverable error while calling "
196  << "ReferenceCounter::increment_constructor_count() "
197  << "for a(n) " << name << " object." << std::endl;
198  std::terminate();
199  }
200 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
OStreamProxy err
static Counts _counts
Actually holds the data.
streamT * get()
Rather than implement every ostream/ios/ios_base function, we&#39;ll be lazy and make esoteric uses go th...
spin_mutex spin_mtx
A convenient spin mutex object which can be used for obtaining locks.
Definition: threads.C:30

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

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

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

208 {
209  libmesh_try
210  {
211  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
212  std::pair<unsigned int, unsigned int> & p = _counts[name];
213  p.second++;
214  }
215  libmesh_catch (...)
216  {
217  auto stream = libMesh::err.get();
218  stream->exceptions(stream->goodbit); // stream must not throw
219  libMesh::err << "Encountered unrecoverable error while calling "
220  << "ReferenceCounter::increment_destructor_count() "
221  << "for a(n) " << name << " object." << std::endl;
222  std::terminate();
223  }
224 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
OStreamProxy err
static Counts _counts
Actually holds the data.
streamT * get()
Rather than implement every ostream/ios/ios_base function, we&#39;ll be lazy and make esoteric uses go th...
spin_mutex spin_mtx
A convenient spin mutex object which can be used for obtaining locks.
Definition: threads.C:30

◆ 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 141 of file petsc_linear_solver.C.

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

142 {
143  // Initialize the data structures if not done so already.
144  if (!this->initialized())
145  {
146  this->_is_initialized = true;
147 
148  PetscErrorCode ierr=0;
149 
150  ierr = KSPCreate (this->comm().get(), _ksp.get());
151  LIBMESH_CHKERR(ierr);
152 
153  if (name)
154  {
155  ierr = KSPSetOptionsPrefix(_ksp, name);
156  LIBMESH_CHKERR(ierr);
157  }
158 
159  // Create the preconditioner context
160  ierr = KSPGetPC (_ksp, &_pc);
161  LIBMESH_CHKERR(ierr);
162 
163  // Set user-specified solver and preconditioner types
164  this->set_petsc_solver_type();
165 
166  // If the SolverConfiguration object is provided, use it to set
167  // options during solver initialization.
168  if (this->_solver_configuration)
169  {
171  }
172 
173  // Set the options from user-input
174  // Set runtime options, e.g.,
175  // -ksp_type <type> -pc_type <type> -ksp_monitor -ksp_rtol <rtol>
176  // These options will override those specified above as long as
177  // KSPSetFromOptions() is called _after_ any other customization
178  // routines.
179  ierr = KSPSetFromOptions (_ksp);
180  LIBMESH_CHKERR(ierr);
181 
182  // Have the Krylov subspace method use our good initial guess
183  // rather than 0, unless the user requested a KSPType of
184  // preonly, which complains if asked to use initial guesses.
185  KSPType ksp_type;
186 
187  ierr = KSPGetType (_ksp, &ksp_type);
188  LIBMESH_CHKERR(ierr);
189 
190  if (strcmp(ksp_type, "preonly"))
191  {
192  ierr = KSPSetInitialGuessNonzero (_ksp, PETSC_TRUE);
193  LIBMESH_CHKERR(ierr);
194  }
195 
196  // Notify PETSc of location to store residual history.
197  // This needs to be called before any solves, since
198  // it sets the residual history length to zero. The default
199  // behavior is for PETSc to allocate (internally) an array
200  // of size 1000 to hold the residual norm history.
201  ierr = KSPSetResidualHistory(_ksp,
202  LIBMESH_PETSC_NULLPTR, // pointer to the array which holds the history
203  PETSC_DECIDE, // size of the array holding the history
204  PETSC_TRUE); // Whether or not to reset the history for each solve.
205  LIBMESH_CHKERR(ierr);
206 
208 
209  //If there is a preconditioner object we need to set the internal setup and apply routines
210  if (this->_preconditioner)
211  {
212  this->_preconditioner->init();
213  PCShellSetContext(_pc,(void *)this->_preconditioner);
214  PCShellSetSetUp(_pc,libmesh_petsc_preconditioner_setup);
215  PCShellSetApply(_pc,libmesh_petsc_preconditioner_apply);
216  }
217  }
218 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
virtual void set_options_during_init()
Apply options during initialization of a solver.
Preconditioner< T > * _preconditioner
Holds the Preconditioner object to be used for the linear solves.
const Parallel::Communicator & comm() const
bool initialized() const
Definition: linear_solver.h:85
SolverConfiguration * _solver_configuration
Optionally store a SolverOptions object that can be used to set parameters like solver type...
void set_petsc_solver_type()
Tells PETSC to use the user-specified solver stored in _solver_type.
PetscErrorCode libmesh_petsc_preconditioner_apply(PC pc, Vec x, Vec y)
This function is called by PETSc to actually apply the preconditioner.
PC _pc
Preconditioner context.
static void set_petsc_preconditioner_type(const PreconditionerType &preconditioner_type, PC &pc)
Tells PETSc to use the user-specified preconditioner.
PetscErrorCode libmesh_petsc_preconditioner_setup(PC pc)
This function is called by PETSc to initialize the preconditioner.
PreconditionerType _preconditioner_type
Enum stating with type of preconditioner to use.
WrappedPetsc< KSP > _ksp
Krylov subspace context.
bool _is_initialized
Flag indicating if the data structures have been initialized.

◆ init() [2/2]

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

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

Definition at line 222 of file petsc_linear_solver.C.

224 {
225  // Initialize the data structures if not done so already.
226  if (!this->initialized())
227  {
228  this->_is_initialized = true;
229 
230  PetscErrorCode ierr=0;
231 
232  ierr = KSPCreate (this->comm().get(), _ksp.get());
233  LIBMESH_CHKERR(ierr);
234 
235  if (name)
236  {
237  ierr = KSPSetOptionsPrefix(_ksp, name);
238  LIBMESH_CHKERR(ierr);
239  }
240 
241  // Create the preconditioner context
242  ierr = KSPGetPC (_ksp, &_pc);
243  LIBMESH_CHKERR(ierr);
244 
245  // Set operators. The input matrix works as the preconditioning matrix
246  ierr = KSPSetOperators(_ksp, matrix->mat(), matrix->mat());
247  LIBMESH_CHKERR(ierr);
248 
249  // Set user-specified solver and preconditioner types
250  this->set_petsc_solver_type();
251 
252  // If the SolverConfiguration object is provided, use it to set
253  // options during solver initialization.
254  if (this->_solver_configuration)
255  {
257  }
258 
259  // Set the options from user-input
260  // Set runtime options, e.g.,
261  // -ksp_type <type> -pc_type <type> -ksp_monitor -ksp_rtol <rtol>
262  // These options will override those specified above as long as
263  // KSPSetFromOptions() is called _after_ any other customization
264  // routines.
265  ierr = KSPSetFromOptions (_ksp);
266  LIBMESH_CHKERR(ierr);
267 
268  // Have the Krylov subspace method use our good initial guess
269  // rather than 0, unless the user requested a KSPType of
270  // preonly, which complains if asked to use initial guesses.
271  KSPType ksp_type;
272 
273  ierr = KSPGetType (_ksp, &ksp_type);
274  LIBMESH_CHKERR(ierr);
275 
276  if (strcmp(ksp_type, "preonly"))
277  {
278  ierr = KSPSetInitialGuessNonzero (_ksp, PETSC_TRUE);
279  LIBMESH_CHKERR(ierr);
280  }
281 
282  // Notify PETSc of location to store residual history.
283  // This needs to be called before any solves, since
284  // it sets the residual history length to zero. The default
285  // behavior is for PETSc to allocate (internally) an array
286  // of size 1000 to hold the residual norm history.
287  ierr = KSPSetResidualHistory(_ksp,
288  LIBMESH_PETSC_NULLPTR, // pointer to the array which holds the history
289  PETSC_DECIDE, // size of the array holding the history
290  PETSC_TRUE); // Whether or not to reset the history for each solve.
291  LIBMESH_CHKERR(ierr);
292 
294  if (this->_preconditioner)
295  {
296  this->_preconditioner->set_matrix(*matrix);
297  this->_preconditioner->init();
298  PCShellSetContext(_pc,(void *)this->_preconditioner);
299  PCShellSetSetUp(_pc,libmesh_petsc_preconditioner_setup);
300  PCShellSetApply(_pc,libmesh_petsc_preconditioner_apply);
301  }
302  }
303 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:42
virtual void set_options_during_init()
Apply options during initialization of a solver.
Preconditioner< T > * _preconditioner
Holds the Preconditioner object to be used for the linear solves.
const Parallel::Communicator & comm() const
bool initialized() const
Definition: linear_solver.h:85
SolverConfiguration * _solver_configuration
Optionally store a SolverOptions object that can be used to set parameters like solver type...
void set_petsc_solver_type()
Tells PETSC to use the user-specified solver stored in _solver_type.
PetscErrorCode libmesh_petsc_preconditioner_apply(PC pc, Vec x, Vec y)
This function is called by PETSc to actually apply the preconditioner.
PC _pc
Preconditioner context.
static void set_petsc_preconditioner_type(const PreconditionerType &preconditioner_type, PC &pc)
Tells PETSc to use the user-specified preconditioner.
PetscErrorCode libmesh_petsc_preconditioner_setup(PC pc)
This function is called by PETSc to initialize the preconditioner.
PreconditionerType _preconditioner_type
Enum stating with type of preconditioner to use.
WrappedPetsc< KSP > _ksp
Krylov subspace context.
bool _is_initialized
Flag indicating if the data structures have been initialized.

◆ init_names()

template<typename T >
void libMesh::PetscLinearSolver< T >::init_names ( const System sys)
overridevirtual

Apply names to the system to be solved.

This sets an option prefix from the system name and sets field names from the system's variable names.

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 309 of file petsc_linear_solver.C.

310 {
311  petsc_auto_fieldsplit(this->pc(), sys);
312 }
void petsc_auto_fieldsplit(PC my_pc, const 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.

85 { return _is_initialized; }
bool _is_initialized
Flag indicating if the data structures have been 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 760 of file petsc_linear_solver.C.

761 {
762  this->init();
763  return _ksp;
764 }
virtual void init(const char *name=nullptr) override
Initialize data structures if not done so already.
WrappedPetsc< KSP > _ksp
Krylov subspace context.

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

References libMesh::ReferenceCounter::_n_objects.

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

86  { return _n_objects; }
static Threads::atomic< unsigned int > _n_objects
The number of objects.

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

References libMesh::ParallelObject::_communicator, libMesh::libmesh_assert(), and TIMPI::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::DofMap::add_neighbors_to_send_list(), 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::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::ExodusII_IO::copy_scalar_solution(), libMesh::Nemesis_IO::copy_scalar_solution(), libMesh::UnstructuredMesh::create_pid_mesh(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_scalar_dofs(), libMesh::DistributedMesh::DistributedMesh(), libMesh::EnsightIO::EnsightIO(), libMesh::RBEIMEvaluation::gather_bfs(), libMesh::MeshBase::get_info(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::Nemesis_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::DistributedMesh::insert_elem(), 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::DofMap::local_variable_indices(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshBase::n_active_elem_on_proc(), libMesh::MeshBase::n_elem_on_proc(), libMesh::MeshBase::n_nodes_on_proc(), libMesh::RBEIMEvaluation::node_gather_bfs(), libMesh::Partitioner::partition(), libMesh::MeshBase::partition(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::DofMap::prepare_send_list(), libMesh::DofMap::print_dof_constraints(), libMesh::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::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::MeshRefinement::uniformly_coarsen(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::VTKIO::write_nodal_data(), libMesh::ExodusII_IO::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().

104  {
105  processor_id_type returnval =
106  cast_int<processor_id_type>(_communicator.size());
107  libmesh_assert(returnval); // We never have an empty comm
108  return returnval;
109  }
const Parallel::Communicator & _communicator
processor_id_type size() const
uint8_t processor_id_type
libmesh_assert(ctx)

◆ 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 230 of file petsc_linear_solver.h.

230 { this->init(); return _pc; }
virtual void init(const char *name=nullptr) override
Initialize data structures if not done so already.
PC _pc
Preconditioner context.

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

101 {
102  if (_preconditioner)
103  return _preconditioner->type();
104 
105  return _preconditioner_type;
106 }
Preconditioner< T > * _preconditioner
Holds the Preconditioner object to be used for the linear solves.
PreconditionerType _preconditioner_type
Enum stating with type of preconditioner to use.

◆ 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::AztecLinearSolver< T >, and libMesh::LaspackLinearSolver< T >.

Definition at line 172 of file linear_solver.C.

173 {
175  libMesh::out << "Linear solver convergence/divergence reason: " << Utility::enum_to_string(reason) << std::endl;
176 }
LinearConvergenceReason
Linear solver convergence flags (taken from the PETSc flags).
std::string enum_to_string(const T e)
virtual LinearConvergenceReason get_converged_reason() const =0
OStreamProxy 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.

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

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

82 {
84  out_stream << ReferenceCounter::get_info();
85 }
static std::string get_info()
Gets a string containing the reference information.
static bool _enable_print_counter
Flag to control whether reference count information is printed when print_info is called...

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

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

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::BoundaryInfo::add_elements(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::DistributedMesh::add_node(), libMesh::MeshTools::Modification::all_tri(), libMesh::DofMap::allgather_recursive_constraints(), 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::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::DistributedMesh::delete_elem(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DofMap::distribute_scalar_dofs(), libMesh::DistributedMesh::DistributedMesh(), libMesh::DofMap::end_dof(), libMesh::DofMap::end_old_dof(), libMesh::EnsightIO::EnsightIO(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::find_dofs_to_send(), libMesh::MeshFunction::find_element(), libMesh::MeshFunction::find_elements(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::DofMap::first_dof(), libMesh::DofMap::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::DofMap::get_info(), libMesh::Nemesis_IO_Helper::get_init_global(), libMesh::Nemesis_IO_Helper::get_init_info(), libMesh::Nemesis_IO_Helper::get_loadbal_param(), libMesh::DofMap::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(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), 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::DofMap::is_evaluable(), libMesh::SparsityPattern::Build::join(), libMesh::TransientRBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBSCMEvaluation::legacy_write_offline_data_to_files(), libMesh::RBEvaluation::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(), libMesh::DofMap::local_variable_indices(), main(), libMesh::MeshRefinement::make_coarsening_compatible(), AugmentSparsityOnInterface::mesh_reinit(), libMesh::TriangulatorInterface::MeshedHole::MeshedHole(), libMesh::MeshBase::n_active_local_elem(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::DofMap::n_local_dofs(), libMesh::System::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::SparsityPattern::Build::operator()(), libMesh::DistributedMesh::own_node(), libMesh::BoundaryInfo::parallel_sync_node_ids(), libMesh::BoundaryInfo::parallel_sync_side_ids(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), 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::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::CheckpointIO::read(), libMesh::EquationSystems::read(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::ExodusII_IO_Helper::read_global_values(), libMesh::ExodusII_IO::read_header(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::System::read_header(), libMesh::System::read_legacy_data(), libMesh::DynaIO::read_mesh(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::System::read_parallel_data(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::RBConstruction::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::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(), ExodusTest< elem_type >::test_read_gold(), ExodusTest< elem_type >::test_write(), MeshInputTest::testAbaqusRead(), 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::testLowOrderEdgeBlocks(), SystemsTest::testProjectMatrix1D(), SystemsTest::testProjectMatrix2D(), SystemsTest::testProjectMatrix3D(), BoundaryInfoTest::testShellFaceConstraints(), MeshInputTest::testSingleElementImpl(), WriteVecAndScalar::testSolution(), CheckpointIOTest::testSplitter(), MeshInputTest::testTetgenIO(), libMesh::MeshTools::total_weight(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::DTKAdapter::update_variable_values(), libMesh::NameBasedIO::write(), libMesh::XdrIO::write(), libMesh::CheckpointIO::write(), libMesh::EquationSystems::write(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO::write_element_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::UCDIO::write_nodal_data(), libMesh::VTKIO::write_nodal_data(), libMesh::ExodusII_IO::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::Nemesis_IO_Helper::write_nodesets(), libMesh::ExodusII_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::Nemesis_IO_Helper::write_sidesets(), libMesh::ExodusII_IO_Helper::write_sidesets(), libMesh::ExodusII_IO::write_timestep(), libMesh::ExodusII_IO_Helper::write_timestep(), and libMesh::ExodusII_IO::write_timestep_discontinuous().

115  { return cast_int<processor_id_type>(_communicator.rank()); }
processor_id_type rank() const
const Parallel::Communicator & _communicator

◆ 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 318 of file petsc_linear_solver.C.

320 {
321  PetscErrorCode ierr=0;
322 
323  // The preconditioner (in particular if a default preconditioner)
324  // will have to be reset. We call this->clear() to do that. This
325  // call will also remove and free any previous subset that may have
326  // been set before.
327  this->clear();
328 
329  _subset_solve_mode = subset_solve_mode;
330 
331  if (dofs != nullptr)
332  {
333  PetscInt * petsc_dofs = nullptr;
334  ierr = PetscMalloc(dofs->size()*sizeof(PetscInt), &petsc_dofs);
335  LIBMESH_CHKERR(ierr);
336 
337  for (auto i : index_range(*dofs))
338  petsc_dofs[i] = (*dofs)[i];
339 
340  // Create the IS
341  // PETSc now takes over ownership of the "petsc_dofs"
342  // array, so we don't have to worry about it any longer.
343  ierr = ISCreateGeneral(this->comm().get(),
344  cast_int<PetscInt>(dofs->size()),
345  petsc_dofs, PETSC_OWN_POINTER,
347  LIBMESH_CHKERR(ierr);
348  }
349 }
WrappedPetsc< IS > _restrict_solve_to_is
PETSc index set containing the dofs on which to solve (nullptr means solve on all dofs)...
const Parallel::Communicator & comm() const
SubsetSolveMode _subset_solve_mode
If restrict-solve-to-subset mode is active, this member decides what happens with the dofs outside th...
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
Definition: int_range.h:111
virtual void clear() override
Release all memory and clear data structures.

◆ 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 1066 of file petsc_linear_solver.C.

1067 {
1069 
1070  PetscInt s;
1071  int ierr = ISGetLocalSize(_restrict_solve_to_is, &s);
1072  LIBMESH_CHKERR(ierr);
1073 
1074  return s;
1075 }
WrappedPetsc< IS > _restrict_solve_to_is
PETSc index set containing the dofs on which to solve (nullptr means solve on all dofs)...
libmesh_assert(ctx)

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

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

132 {
133  same_preconditioner = reuse_flag;
134 }
bool same_preconditioner
Boolean flag to indicate whether we want to use an identical preconditioner to the previous solve...

◆ 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 847 of file petsc_linear_solver.C.

848 {
849  PetscErrorCode ierr = 0;
850 
851  switch (this->_solver_type)
852  {
853 
854  case CG:
855  ierr = KSPSetType (_ksp, const_cast<KSPType>(KSPCG));
856  LIBMESH_CHKERR(ierr);
857  return;
858 
859  case CR:
860  ierr = KSPSetType (_ksp, const_cast<KSPType>(KSPCR));
861  LIBMESH_CHKERR(ierr);
862  return;
863 
864  case CGS:
865  ierr = KSPSetType (_ksp, const_cast<KSPType>(KSPCGS));
866  LIBMESH_CHKERR(ierr);
867  return;
868 
869  case BICG:
870  ierr = KSPSetType (_ksp, const_cast<KSPType>(KSPBICG));
871  LIBMESH_CHKERR(ierr);
872  return;
873 
874  case TCQMR:
875  ierr = KSPSetType (_ksp, const_cast<KSPType>(KSPTCQMR));
876  LIBMESH_CHKERR(ierr);
877  return;
878 
879  case TFQMR:
880  ierr = KSPSetType (_ksp, const_cast<KSPType>(KSPTFQMR));
881  LIBMESH_CHKERR(ierr);
882  return;
883 
884  case LSQR:
885  ierr = KSPSetType (_ksp, const_cast<KSPType>(KSPLSQR));
886  LIBMESH_CHKERR(ierr);
887  return;
888 
889  case BICGSTAB:
890  ierr = KSPSetType (_ksp, const_cast<KSPType>(KSPBCGS));
891  LIBMESH_CHKERR(ierr);
892  return;
893 
894  case MINRES:
895  ierr = KSPSetType (_ksp, const_cast<KSPType>(KSPMINRES));
896  LIBMESH_CHKERR(ierr);
897  return;
898 
899  case GMRES:
900  ierr = KSPSetType (_ksp, const_cast<KSPType>(KSPGMRES));
901  LIBMESH_CHKERR(ierr);
902  return;
903 
904  case RICHARDSON:
905  ierr = KSPSetType (_ksp, const_cast<KSPType>(KSPRICHARDSON));
906  LIBMESH_CHKERR(ierr);
907  return;
908 
909  case CHEBYSHEV:
910  ierr = KSPSetType (_ksp, const_cast<KSPType>(KSPCHEBYSHEV));
911  LIBMESH_CHKERR(ierr);
912  return;
913 
914  default:
915  libMesh::err << "ERROR: Unsupported PETSC Solver: "
916  << Utility::enum_to_string(this->_solver_type) << std::endl
917  << "Continuing with PETSC defaults" << std::endl;
918  }
919 }
OStreamProxy err
SolverType _solver_type
Enum stating which type of iterative solver to use.
std::string enum_to_string(const T e)
WrappedPetsc< KSP > _ksp
Krylov subspace context.

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

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

111 {
112  if (_preconditioner)
113  _preconditioner->set_type(pct);
114  else
115  _preconditioner_type = pct;
116 }
Preconditioner< T > * _preconditioner
Holds the Preconditioner object to be used for the linear solves.
PreconditionerType _preconditioner_type
Enum stating with type of preconditioner to use.

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

180 {
181  _solver_configuration = &solver_configuration;
182 }
SolverConfiguration * _solver_configuration
Optionally store a SolverOptions object that can be used to set parameters like solver type...

◆ 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 116 of file linear_solver.h.

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

117  { _solver_type = st; }
SolverType _solver_type
Enum stating which type of iterative solver to use.

◆ shell_solve_common()

template<typename T>
std::pair< unsigned int, Real > libMesh::PetscLinearSolver< T >::shell_solve_common ( const ShellMatrix< T > &  shell_matrix,
PetscMatrix< 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 474 of file petsc_linear_solver.C.

481 {
482  LOG_SCOPE("solve()", "PetscLinearSolver");
483 
484  // We don't really have a matrix for our matrix here
485  SparseMatrix<T> * matrix = nullptr;
486 
487  this->init ();
488 
489  PetscErrorCode ierr=0;
490 
491  // Prepare the matrix.
492  WrappedPetsc<Mat> mat;
493  ierr = MatCreateShell(this->comm().get(),
494  rhs_in.local_size(),
495  solution_in.local_size(),
496  rhs_in.size(),
497  solution_in.size(),
498  const_cast<void *>(static_cast<const void *>(&shell_matrix)),
499  mat.get());
500  // Note that the const_cast above is only necessary because PETSc
501  // does not accept a const void *. Inside the member function
502  // _petsc_shell_matrix() below, the pointer is casted back to a
503  // const ShellMatrix<T> *.
504 
505  LIBMESH_CHKERR(ierr);
506  ierr = MatShellSetOperation(mat, MATOP_MULT, reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_mult));
507  LIBMESH_CHKERR(ierr);
508  ierr = MatShellSetOperation(mat, MATOP_MULT_ADD, reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_mult_add));
509  LIBMESH_CHKERR(ierr);
510  ierr = MatShellSetOperation(mat, MATOP_GET_DIAGONAL, reinterpret_cast<void(*)(void)>(_petsc_shell_matrix_get_diagonal));
511  LIBMESH_CHKERR(ierr);
512 
513  return this->solve_base
514  (matrix, precond, mat, solution_in, rhs_in, rel_tol, abs_tol, m_its, KSPSolve);
515 }
std::pair< unsigned int, Real > solve_base(SparseMatrix< T > *matrix, PetscMatrix< 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)
virtual void init(const char *name=nullptr) override
Initialize data structures if not done so already.
static PetscErrorCode _petsc_shell_matrix_mult_add(Mat mat, Vec arg, Vec add, Vec dest)
Internal function if shell matrix mode is used.
const Parallel::Communicator & comm() const
processor_id_type size() const
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_get_diagonal(Mat mat, Vec dest)
Internal function if shell matrix mode is used.

◆ solve() [1/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 155 of file petsc_linear_solver.h.

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

160  {
161  return this->solve(matrix_in, matrix_in, solution_in, rhs_in, tol, m_its);
162  }
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.

◆ solve() [2/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 355 of file petsc_linear_solver.C.

361 {
362  LOG_SCOPE("solve()", "PetscLinearSolver");
363 
364  const double rel_tol = this->get_real_solver_setting("rel_tol", tol);
365  const double abs_tol = this->get_real_solver_setting("abs_tol",
366  std::nullopt,
367  static_cast<Real>(PETSC_DEFAULT));
368  const double max_its = this->get_int_solver_setting("max_its", m_its);
369 
370  return this->solve_common(matrix_in, precond_in, solution_in,
371  rhs_in, rel_tol, abs_tol, max_its, KSPSolve);
372 }
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.
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)
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.

◆ solve() [3/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.

341 {
342  if (pc_mat)
343  return this->solve(mat, *pc_mat, sol, rhs, tol, n_iter);
344  else
345  return this->solve(mat, sol, rhs, tol, n_iter);
346 }
virtual std::pair< unsigned int, Real > solve(SparseMatrix< T > &, NumericVector< T > &, NumericVector< T > &, const std::optional< double > tol=std::nullopt, const std::optional< unsigned int > m_its=std::nullopt)=0
This function calls the solver _solver_type preconditioned with the _preconditioner_type precondition...

◆ solve() [4/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 427 of file petsc_linear_solver.C.

432 {
433  LOG_SCOPE("solve()", "PetscLinearSolver");
434 
435  const double rel_tol = this->get_real_solver_setting("rel_tol", tol);
436  const double abs_tol = this->get_real_solver_setting("abs_tol",
437  std::nullopt,
438  static_cast<Real>(PETSC_DEFAULT));
439  const double max_its = this->get_int_solver_setting("max_its", m_its);
440 
441  return this->shell_solve_common(shell_matrix, nullptr, solution_in,
442  rhs_in, rel_tol, abs_tol, max_its);
443 }
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.
virtual std::pair< unsigned int, Real > shell_solve_common(const ShellMatrix< T > &shell_matrix, PetscMatrix< T > *precond_matrix, NumericVector< T > &solution_in, NumericVector< T > &rhs_in, const double rel_tol, const double abs_tol, const unsigned int m_its)
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.

◆ solve() [5/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 449 of file petsc_linear_solver.C.

455 {
456  const double rel_tol = this->get_real_solver_setting("rel_tol", tol);
457  const double abs_tol = this->get_real_solver_setting("abs_tol",
458  std::nullopt,
459  static_cast<Real>(PETSC_DEFAULT));
460  const double max_its = this->get_int_solver_setting("max_its", m_its);
461 
462  // Make sure the data passed in are really of Petsc types
463  const PetscMatrix<T> * precond = cast_ptr<const PetscMatrix<T> *>(&precond_matrix);
464 
465  return this->shell_solve_common
466  (shell_matrix, const_cast<PetscMatrix<T> *>(precond), solution_in,
467  rhs_in, rel_tol, abs_tol, max_its);
468 }
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.
virtual std::pair< unsigned int, Real > shell_solve_common(const ShellMatrix< T > &shell_matrix, PetscMatrix< T > *precond_matrix, NumericVector< T > &solution_in, NumericVector< T > &rhs_in, const double rel_tol, const double abs_tol, const unsigned int m_its)
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.

◆ solve() [6/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.

358 {
359  if (pc_mat)
360  return this->solve(mat, *pc_mat, sol, rhs, tol, n_iter);
361  else
362  return this->solve(mat, sol, rhs, tol, n_iter);
363 }
virtual std::pair< unsigned int, Real > solve(SparseMatrix< T > &, NumericVector< T > &, NumericVector< T > &, const std::optional< double > tol=std::nullopt, const std::optional< unsigned int > m_its=std::nullopt)=0
This function calls the solver _solver_type preconditioned with the _preconditioner_type precondition...

◆ solve_base()

template<typename T>
std::pair< unsigned int, Real > libMesh::PetscLinearSolver< T >::solve_base ( SparseMatrix< T > *  matrix,
PetscMatrix< 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 521 of file petsc_linear_solver.C.

530 {
531  // Make sure the data passed in are really of Petsc types
532  PetscVector<T> * solution = cast_ptr<PetscVector<T> *>(&solution_in);
533  PetscVector<T> * rhs = cast_ptr<PetscVector<T> *>(&rhs_in);
534 
535  // Close the vectors in case this wasn't already done.
536  solution->close ();
537  rhs->close ();
538 
539  PetscErrorCode ierr=0;
540  PetscInt its=0, max_its = static_cast<PetscInt>(m_its);
541  PetscReal final_resid=0.;
542 
543  std::unique_ptr<PetscMatrix<Number>> subprecond_matrix;
544  WrappedPetsc<Mat> subprecond;
545 
546  WrappedPetsc<Mat> submat;
547  WrappedPetsc<Vec> subrhs;
548  WrappedPetsc<Vec> subsolution;
549  WrappedPetsc<VecScatter> scatter;
550 
551  // Restrict rhs and solution vectors and set operators. The input
552  // matrix works as the preconditioning matrix.
554  {
555  PetscInt is_local_size = this->restrict_solve_to_is_local_size();
556 
557  ierr = VecCreate(this->comm().get(), subrhs.get());
558  LIBMESH_CHKERR(ierr);
559  ierr = VecSetSizes(subrhs, is_local_size, PETSC_DECIDE);
560  LIBMESH_CHKERR(ierr);
561  ierr = VecSetFromOptions(subrhs);
562  LIBMESH_CHKERR(ierr);
563 
564  ierr = VecCreate(this->comm().get(), subsolution.get());
565  LIBMESH_CHKERR(ierr);
566  ierr = VecSetSizes(subsolution, is_local_size, PETSC_DECIDE);
567  LIBMESH_CHKERR(ierr);
568  ierr = VecSetFromOptions(subsolution);
569  LIBMESH_CHKERR(ierr);
570 
571  ierr = VecScatterCreate(rhs->vec(), _restrict_solve_to_is, subrhs, nullptr, scatter.get());
572  LIBMESH_CHKERR(ierr);
573 
574  VecScatterBeginEnd(this->comm(), scatter, rhs->vec(), subrhs, INSERT_VALUES, SCATTER_FORWARD);
575  VecScatterBeginEnd(this->comm(), scatter, solution->vec(), subsolution, INSERT_VALUES, SCATTER_FORWARD);
576 
577  ierr = LibMeshCreateSubMatrix(mat,
580  MAT_INITIAL_MATRIX,
581  submat.get());
582  LIBMESH_CHKERR(ierr);
583 
584  if (precond)
585  {
586  ierr = LibMeshCreateSubMatrix(const_cast<PetscMatrix<T> *>(precond)->mat(),
589  MAT_INITIAL_MATRIX,
590  subprecond.get());
591  LIBMESH_CHKERR(ierr);
592  }
593 
594  // Since removing columns of the matrix changes the equation
595  // system, we will now change the right hand side to compensate
596  // for this. Note that this is not necessary if \p SUBSET_ZERO
597  // has been selected.
599  {
600  this->create_complement_is(rhs_in);
601  PetscInt is_complement_local_size =
602  cast_int<PetscInt>(rhs_in.local_size()-is_local_size);
603 
604  WrappedPetsc<Vec> subvec1;
605  ierr = VecCreate(this->comm().get(), subvec1.get());
606  LIBMESH_CHKERR(ierr);
607  ierr = VecSetSizes(subvec1, is_complement_local_size, PETSC_DECIDE);
608  LIBMESH_CHKERR(ierr);
609  ierr = VecSetFromOptions(subvec1);
610  LIBMESH_CHKERR(ierr);
611 
612  WrappedPetsc<VecScatter> scatter1;
613  ierr = VecScatterCreate(rhs->vec(), _restrict_solve_to_is_complement, subvec1, nullptr, scatter1.get());
614  LIBMESH_CHKERR(ierr);
615 
616  VecScatterBeginEnd(this->comm(), scatter1, _subset_solve_mode==SUBSET_COPY_RHS ? rhs->vec() : solution->vec(), subvec1, INSERT_VALUES, SCATTER_FORWARD);
617 
618  ierr = VecScale(subvec1, -1.0);
619  LIBMESH_CHKERR(ierr);
620 
621  WrappedPetsc<Mat> submat1;
622  ierr = LibMeshCreateSubMatrix(mat,
625  MAT_INITIAL_MATRIX,
626  submat1.get());
627  LIBMESH_CHKERR(ierr);
628 
629  ierr = MatMultAdd(submat1, subvec1, subrhs, subrhs);
630  LIBMESH_CHKERR(ierr);
631  }
632 
633  if (precond)
634  ierr = KSPSetOperators(_ksp, submat, subprecond);
635  else
636  ierr = KSPSetOperators(_ksp, submat, submat);
637 
638  LIBMESH_CHKERR(ierr);
639 
640  PetscBool ksp_reuse_preconditioner = this->same_preconditioner ? PETSC_TRUE : PETSC_FALSE;
641  ierr = KSPSetReusePreconditioner(_ksp, ksp_reuse_preconditioner);
642  LIBMESH_CHKERR(ierr);
643 
644  if (precond && this->_preconditioner)
645  {
646  subprecond_matrix = std::make_unique<PetscMatrix<Number>>(subprecond, this->comm());
647  this->_preconditioner->set_matrix(*subprecond_matrix);
648  this->_preconditioner->init();
649  }
650  }
651  else
652  {
653  PetscBool ksp_reuse_preconditioner = this->same_preconditioner ? PETSC_TRUE : PETSC_FALSE;
654  ierr = KSPSetReusePreconditioner(_ksp, ksp_reuse_preconditioner);
655  LIBMESH_CHKERR(ierr);
656 
657  if (precond)
658  {
659  ierr = KSPSetOperators(_ksp, mat, const_cast<PetscMatrix<T> *>(precond)->mat());
660  LIBMESH_CHKERR(ierr);
661  }
662  else
663  {
664  ierr = KSPSetOperators(_ksp, mat, mat);
665  LIBMESH_CHKERR(ierr);
666  }
667 
668  if (this->_preconditioner)
669  {
670  if (matrix)
671  this->_preconditioner->set_matrix(*matrix);
672  else if (precond)
673  this->_preconditioner->set_matrix(const_cast<PetscMatrix<Number> &>(*precond));
674 
675  this->_preconditioner->init();
676  }
677  }
678 
679  // Set the tolerances for the iterative solver. Use the user-supplied
680  // tolerance for the relative residual & leave the others at default values.
681  ierr = KSPSetTolerances (_ksp, rel_tol, abs_tol,
682  PETSC_DEFAULT, max_its);
683  LIBMESH_CHKERR(ierr);
684 
685  // Allow command line options to override anything set programmatically.
686  ierr = KSPSetFromOptions(_ksp);
687  LIBMESH_CHKERR(ierr);
688 
689  // If the SolverConfiguration object is provided, use it to override
690  // solver options.
691  if (this->_solver_configuration)
692  {
694  }
695 
696  // Solve the linear system
698  {
699  ierr = solve_func (_ksp, subrhs, subsolution);
700  LIBMESH_CHKERR(ierr);
701  }
702  else
703  {
704  ierr = solve_func (_ksp, rhs->vec(), solution->vec());
705  LIBMESH_CHKERR(ierr);
706  }
707 
708  // Get the number of iterations required for convergence
709  ierr = KSPGetIterationNumber (_ksp, &its);
710  LIBMESH_CHKERR(ierr);
711 
712  // Get the norm of the final residual to return to the user.
713  ierr = KSPGetResidualNorm (_ksp, &final_resid);
714  LIBMESH_CHKERR(ierr);
715 
717  {
718  switch(_subset_solve_mode)
719  {
720  case SUBSET_ZERO:
721  ierr = VecZeroEntries(solution->vec());
722  LIBMESH_CHKERR(ierr);
723  break;
724 
725  case SUBSET_COPY_RHS:
726  ierr = VecCopy(rhs->vec(),solution->vec());
727  LIBMESH_CHKERR(ierr);
728  break;
729 
730  case SUBSET_DONT_TOUCH:
731  // Nothing to do here.
732  break;
733 
734  default:
735  libmesh_error_msg("Invalid subset solve mode = " << _subset_solve_mode);
736  }
737 
738  VecScatterBeginEnd(this->comm(), scatter, subsolution, solution->vec(), INSERT_VALUES, SCATTER_REVERSE);
739 
740  if (precond && this->_preconditioner)
741  {
742  // Before subprecond_matrix gets cleaned up, we should give
743  // the _preconditioner a different matrix.
744  if (matrix)
745  this->_preconditioner->set_matrix(*matrix);
746  else
747  this->_preconditioner->set_matrix(*precond);
748 
749  this->_preconditioner->init();
750  }
751  }
752 
753  // return the # of its. and the final residual norm.
754  return std::make_pair(its, final_resid);
755 }
template class LIBMESH_EXPORT PetscMatrix< Number >
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...
Preconditioner< T > * _preconditioner
Holds the Preconditioner object to be used for the linear solves.
WrappedPetsc< IS > _restrict_solve_to_is
PETSc index set containing the dofs on which to solve (nullptr means solve on all dofs)...
const Parallel::Communicator & comm() const
PetscInt restrict_solve_to_is_local_size() const
virtual void configure_solver()=0
Apply solver options to a particular solver.
SolverConfiguration * _solver_configuration
Optionally store a SolverOptions object that can be used to set parameters like solver type...
communicator & get()
SubsetSolveMode _subset_solve_mode
If restrict-solve-to-subset mode is active, this member decides what happens with the dofs outside th...
bool same_preconditioner
Boolean flag to indicate whether we want to use an identical preconditioner to the previous solve...
WrappedPetsc< IS > _restrict_solve_to_is_complement
PETSc index set, complement to _restrict_solve_to_is.
WrappedPetsc< KSP > _ksp
Krylov subspace context.

◆ 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 398 of file petsc_linear_solver.C.

406 {
407  // Make sure the data passed in are really of Petsc types
408  PetscMatrix<T> * matrix = cast_ptr<PetscMatrix<T> *>(&matrix_in);
409  PetscMatrix<T> * precond = cast_ptr<PetscMatrix<T> *>(&precond_in);
410 
411  this->init (matrix);
412 
413  // Close the matrices in case this wasn't already done.
414  matrix->close ();
415  if (precond != matrix)
416  precond->close ();
417 
418  auto mat = matrix->mat();
419 
420  return this->solve_base
421  (matrix, precond, mat, solution_in, rhs_in, rel_tol, abs_tol, m_its, solve_func);
422 }
std::pair< unsigned int, Real > solve_base(SparseMatrix< T > *matrix, PetscMatrix< 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)
virtual void init(const char *name=nullptr) override
Initialize data structures if not done so already.

◆ solver_type()

template<typename T>
SolverType libMesh::LinearSolver< T >::solver_type ( ) const
inlineinherited
Returns
The type of solver to use.

Definition at line 111 of file linear_solver.h.

111 { return _solver_type; }
SolverType _solver_type
Enum stating which type of iterative solver to use.

Member Data Documentation

◆ _communicator

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

◆ _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< Number >::initialized().

◆ _ksp

template<typename T>
WrappedPetsc<KSP> libMesh::PetscLinearSolver< T >::_ksp
private

Krylov subspace context.

Definition at line 334 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(), and libMesh::ReferenceCounter::~ReferenceCounter().

◆ _pc

template<typename T>
PC libMesh::PetscLinearSolver< T >::_pc
private

Preconditioner context.

Definition at line 329 of file petsc_linear_solver.h.

Referenced by libMesh::PetscLinearSolver< Number >::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 340 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 347 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

◆ _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 365 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: