libMesh
Public Member Functions | Static Public Member Functions | Protected Types | Protected Member Functions | Protected Attributes | Static Protected Attributes | Private Member Functions | Static Private Member Functions | Private Attributes | Static Private Attributes | List of all members
libMesh::EigenSparseLinearSolver< T > Class Template Reference

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

#include <eigen_sparse_matrix.h>

Inheritance diagram for libMesh::EigenSparseLinearSolver< T >:
[legend]

Public Member Functions

 EigenSparseLinearSolver (const libMesh::Parallel::Communicator &comm_in)
 Constructor. More...
 
 ~EigenSparseLinearSolver ()
 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...
 
virtual std::pair< unsigned int, Realsolve (SparseMatrix< T > &matrix, NumericVector< T > &solution, NumericVector< T > &rhs, const std::optional< double > tol=std::nullopt, const std::optional< unsigned int > m_its=std::nullopt) override
 Call the Eigen solver. More...
 
virtual std::pair< unsigned int, Realadjoint_solve (SparseMatrix< T > &matrix, NumericVector< T > &solution, NumericVector< T > &rhs, const std::optional< double > tol=std::nullopt, const std::optional< unsigned int > m_its=std::nullopt) override
 Call the Eigen solver to solve A^T x = b. More...
 
virtual std::pair< unsigned int, Realsolve (SparseMatrix< T > &matrix, SparseMatrix< T > &pc, NumericVector< T > &solution, NumericVector< T > &rhs, const std::optional< double > tol=std::nullopt, const std::optional< unsigned int > m_its=std::nullopt) override
 Call the Eigen solver. 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...
 
virtual LinearConvergenceReason get_converged_reason () const override
 
bool initialized () const
 
virtual void init_names (const System &)
 Apply names to the system to be solved. More...
 
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 ()
 
virtual void restrict_solve_to (const std::vector< unsigned int > *const dofs, const SubsetSolveMode subset_solve_mode=SUBSET_ZERO)
 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...
 
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 Member Functions

void set_eigen_preconditioner_type ()
 Tells Eigen to use the user-specified preconditioner stored in _preconditioner_type. More...
 

Static Private Member Functions

static std::map< Eigen::ComputationInfo, LinearConvergenceReasonbuild_map ()
 Static function used to initialize _convergence_reasons map. More...
 

Private Attributes

Eigen::ComputationInfo _comp_info
 Store the result of the last solve. More...
 

Static Private Attributes

static std::map< Eigen::ComputationInfo, LinearConvergenceReason_convergence_reasons = EigenSparseLinearSolver<T>::build_map()
 Static map between Eigen ComputationInfo enumerations and libMesh LinearConvergenceReason enumerations. More...
 

Detailed Description

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

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

Author
Benjamin Kirk
Date
2013

Definition at line 43 of file eigen_sparse_matrix.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.

Constructor & Destructor Documentation

◆ EigenSparseLinearSolver()

Constructor.

Initializes Eigen data structures

Definition at line 43 of file eigen_sparse_linear_solver.C.

References libMesh::LinearSolver< T >::_solver_type, and libMesh::BICGSTAB.

43  :
44  LinearSolver<T>(comm_in),
45  _comp_info(Eigen::Success)
46 {
47  // The GMRES _solver_type can be used in EigenSparseLinearSolver,
48  // however, the GMRES iterative solver is currently in the Eigen
49  // "unsupported" directory, so we use BICGSTAB as our default.
50  this->_solver_type = BICGSTAB;
51 }
SolverType _solver_type
Enum stating which type of iterative solver to use.
Eigen::ComputationInfo _comp_info
Store the result of the last solve.

◆ ~EigenSparseLinearSolver()

template<typename T >
libMesh::EigenSparseLinearSolver< T >::~EigenSparseLinearSolver ( )
inline

Destructor.

Definition at line 176 of file eigen_sparse_linear_solver.h.

177 {
178  this->clear ();
179 }
virtual void clear() override
Release all memory and clear data structures.

Member Function Documentation

◆ adjoint_solve()

template<typename T >
std::pair< unsigned int, Real > libMesh::EigenSparseLinearSolver< T >::adjoint_solve ( SparseMatrix< T > &  matrix,
NumericVector< T > &  solution,
NumericVector< T > &  rhs,
const std::optional< double >  tol = std::nullopt,
const std::optional< unsigned int m_its = std::nullopt 
)
overridevirtual

Call the Eigen solver to solve A^T x = b.

Reimplemented from libMesh::LinearSolver< T >.

Definition at line 333 of file eigen_sparse_linear_solver.C.

References libMesh::SparseMatrix< T >::get_transpose().

338 {
339  LOG_SCOPE("adjoint_solve()", "EigenSparseLinearSolver");
340 
341  libmesh_experimental();
342  EigenSparseMatrix<T> mat_trans(this->comm());
343  matrix_in.get_transpose(mat_trans);
344 
345  std::pair<unsigned int, Real> retval = this->solve (mat_trans,
346  solution_in,
347  rhs_in,
348  tol,
349  m_its);
350 
351  return retval;
352 }
const Parallel::Communicator & comm() const
virtual std::pair< unsigned int, Real > solve(SparseMatrix< T > &matrix, NumericVector< T > &solution, NumericVector< T > &rhs, const std::optional< double > tol=std::nullopt, const std::optional< unsigned int > m_its=std::nullopt) override
Call the Eigen solver.

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

◆ build_map()

template<typename T>
static std::map<Eigen::ComputationInfo, LinearConvergenceReason> libMesh::EigenSparseLinearSolver< T >::build_map ( )
inlinestaticprivate

Static function used to initialize _convergence_reasons map.

Definition at line 152 of file eigen_sparse_linear_solver.h.

References libMesh::CONVERGED_ITS, libMesh::DIVERGED_BREAKDOWN, libMesh::DIVERGED_ITS, and libMesh::DIVERGED_NULL.

153  {
154  std::map<Eigen::ComputationInfo, LinearConvergenceReason> ret;
155  ret[Eigen::Success] = CONVERGED_ITS;
156  ret[Eigen::NumericalIssue] = DIVERGED_BREAKDOWN;
157  ret[Eigen::NoConvergence] = DIVERGED_ITS;
158  ret[Eigen::InvalidInput] = DIVERGED_NULL;
159  return ret;
160  }

◆ clear()

template<typename T >
void libMesh::EigenSparseLinearSolver< T >::clear ( )
overridevirtual

Release all memory and clear data structures.

Reimplemented from libMesh::LinearSolver< T >.

Definition at line 56 of file eigen_sparse_linear_solver.C.

References libMesh::libMeshPrivateData::_is_initialized, libMesh::BICGSTAB, libMesh::ILU_PRECOND, and libMesh::initialized().

57 {
58  if (this->initialized())
59  {
60  this->_is_initialized = false;
61 
62  this->_solver_type = BICGSTAB;
64  }
65 }
SolverType _solver_type
Enum stating which type of iterative solver to use.
bool initialized() const
Definition: linear_solver.h:85
PreconditionerType _preconditioner_type
Enum stating with type of preconditioner to use.
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

◆ 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::EigenSparseLinearSolver< T >::get_converged_reason ( ) const
overridevirtual
Returns
The solver's convergence flag

Implements libMesh::LinearSolver< T >.

Definition at line 418 of file eigen_sparse_linear_solver.C.

References libMesh::CONVERGED_ITS.

419 {
420  auto it = _convergence_reasons.find(_comp_info);
421 
422  // If later versions of Eigen start returning new enumerations,
423  // we'll need to add them to the map...
424  if (it == _convergence_reasons.end())
425  {
426  libmesh_warning("Warning: unknown Eigen::ComputationInfo: " \
427  << _comp_info \
428  << " returning CONVERGED_ITS." \
429  << std::endl);
430  return CONVERGED_ITS;
431  }
432  else
433  return it->second;
434 }
Eigen::ComputationInfo _comp_info
Store the result of the last solve.
static std::map< Eigen::ComputationInfo, LinearConvergenceReason > _convergence_reasons
Static map between Eigen ComputationInfo enumerations and libMesh LinearConvergenceReason enumeration...

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

template<typename T >
void libMesh::EigenSparseLinearSolver< T >::init ( const char *  name = nullptr)
overridevirtual

Initialize data structures if not done so already.

Implements libMesh::LinearSolver< T >.

Definition at line 70 of file eigen_sparse_linear_solver.C.

References libMesh::libMeshPrivateData::_is_initialized, and libMesh::initialized().

71 {
72  // Initialize the data structures if not done so already.
73  if (!this->initialized())
74  {
75  this->_is_initialized = true;
76  }
77 }
bool initialized() const
Definition: linear_solver.h:85
bool _is_initialized
Flag indicating if the data structures have been initialized.

◆ init_names()

template<typename T>
virtual void libMesh::LinearSolver< T >::init_names ( const System )
inlinevirtualinherited

Apply names to the system to be solved.

For most packages this is a no-op; for PETSc 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 in libMesh::PetscLinearSolver< T >, and libMesh::PetscLinearSolver< Number >.

Definition at line 106 of file linear_solver.h.

106 {}

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

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

◆ 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::LinearSolver< T >::restrict_solve_to ( const std::vector< unsigned int > *const  dofs,
const SubsetSolveMode  subset_solve_mode = SUBSET_ZERO 
)
virtualinherited

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 in libMesh::PetscLinearSolver< T >, and libMesh::PetscLinearSolver< Number >.

Definition at line 138 of file linear_solver.C.

140 {
141  if (dofs != nullptr)
142  libmesh_not_implemented();
143 }

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

template<typename T >
void libMesh::EigenSparseLinearSolver< T >::set_eigen_preconditioner_type ( )
private

Tells Eigen to use the user-specified preconditioner stored in _preconditioner_type.

Definition at line 387 of file eigen_sparse_linear_solver.C.

388 {
389  libmesh_not_implemented();
390 
391  // switch (this->_preconditioner_type)
392  // {
393  // case IDENTITY_PRECOND:
394  // _precond_type = nullptr; return;
395 
396  // case ILU_PRECOND:
397  // _precond_type = ILUPrecond; return;
398 
399  // case JACOBI_PRECOND:
400  // _precond_type = JacobiPrecond; return;
401 
402  // case SSOR_PRECOND:
403  // _precond_type = SSORPrecond; return;
404 
405 
406  // default:
407  // libMesh::err << "ERROR: Unsupported LASPACK Preconditioner: "
408  // << this->_preconditioner_type << std::endl
409  // << "Continuing with ILU" << std::endl;
410  // this->_preconditioner_type = ILU_PRECOND;
411  // this->set_laspack_preconditioner_type();
412  // }
413 }

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

◆ solve() [1/6]

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

Call the Eigen solver.

Implements libMesh::LinearSolver< T >.

Definition at line 83 of file eigen_sparse_linear_solver.C.

References libMesh::EigenSparseMatrix< T >::_mat, libMesh::BICGSTAB, libMesh::CG, libMesh::EigenSparseMatrix< T >::close(), libMesh::Utility::enum_to_string(), libMesh::err, libMesh::GMRES, libMesh::ICC_PRECOND, libMesh::IDENTITY_PRECOND, libMesh::ILU_PRECOND, libMesh::TriangleWrapper::init(), libMesh::JACOBI_PRECOND, libMesh::out, and libMesh::SPARSELU.

88 {
89  LOG_SCOPE("solve()", "EigenSparseLinearSolver");
90  this->init ();
91 
92  // Make sure the data passed in are really Eigen types
93  EigenSparseMatrix<T> & matrix = cast_ref<EigenSparseMatrix<T> &>(matrix_in);
94  EigenSparseVector<T> & solution = cast_ref<EigenSparseVector<T> &>(solution_in);
95  EigenSparseVector<T> & rhs = cast_ref<EigenSparseVector<T> &>(rhs_in);
96 
97  // Close the matrix and vectors in case this wasn't already done.
98  matrix.close();
99  solution.close();
100  rhs.close();
101 
102  std::pair<unsigned int, Real> retval(0,0.);
103 
104  // Eigen doesn't give us a solver base class? We'll just use a
105  // generic lambda, then.
106  auto do_solve = [this, &rhs, &solution, tol, m_its]
107  (auto & e_solver, std::string_view msg) {
108  const int max_its = this->get_int_solver_setting("max_its", m_its);
109  const double abs_tol = this->get_real_solver_setting("abs_tol", tol);
110 
111  e_solver.setMaxIterations(max_its);
112  e_solver.setTolerance(abs_tol);
113  libMesh::out << msg << std::endl;
114 
115  solution._vec = e_solver.solveWithGuess(rhs._vec,solution._vec);
116 
117  libMesh::out << "#iterations: " << e_solver.iterations() << " / " << max_its << std::endl;
118  libMesh::out << "estimated error: " << e_solver.error() << " / " << abs_tol << std::endl;
119  _comp_info = e_solver.info();
120  return std::make_pair(e_solver.iterations(), e_solver.error());
121  };
122 
123  using Eigen::DiagonalPreconditioner;
124  using Eigen::IdentityPreconditioner;
125  using Eigen::IncompleteCholesky;
126  using Eigen::IncompleteLUT;
127 
128  // Solve the linear system
129  switch (this->_solver_type)
130  {
131  // Conjugate-Gradient
132  case CG:
133  {
134  const int UPLO = Eigen::Lower|Eigen::Upper;
135 
136  switch (this->_preconditioner_type)
137  {
138  case IDENTITY_PRECOND:
139  {
140  Eigen::ConjugateGradient<EigenSM,UPLO,IdentityPreconditioner> solver (matrix._mat);
141  retval = do_solve(solver, "Eigen CG solver without preconditioning");
142  break;
143  }
144  case ILU_PRECOND:
145  {
146  Eigen::ConjugateGradient<EigenSM,UPLO,IncompleteLUT<Number,eigen_idx_type>>
147  solver (matrix._mat);
148  retval = do_solve(solver, "Eigen CG solver with Incomplete Cholesky preconditioning");
149  break;
150  }
151  case ICC_PRECOND:
152  {
153  Eigen::ConjugateGradient<EigenSM,UPLO,
154  IncompleteCholesky<Number,Eigen::Lower,Eigen::AMDOrdering<eigen_idx_type>>>
155  solver (matrix._mat);
156  retval = do_solve(solver, "Eigen CG solver with Incomplete Cholesky preconditioning");
157  break;
158  }
159  default: // For our default let's use their default
160  libmesh_warning("No EigenSparseLinearSolver support for " <<
161  Utility::enum_to_string<PreconditionerType>(this->_preconditioner_type)
162  << " preconditioning.");
163  libmesh_fallthrough();
164  case JACOBI_PRECOND:
165  {
166  Eigen::ConjugateGradient<EigenSM,UPLO,DiagonalPreconditioner<Number>> solver (matrix._mat);
167  retval = do_solve(solver, "Eigen CG solver with Jacobi preconditioning");
168  break;
169  }
170  }
171  break;
172  }
173 
174  // Bi-Conjugate Gradient Stabilized
175  case BICGSTAB:
176  {
177  switch (this->_preconditioner_type)
178  {
179  case IDENTITY_PRECOND:
180  {
181  Eigen::BiCGSTAB<EigenSM, IdentityPreconditioner> solver (matrix._mat);
182  retval = do_solve(solver, "Eigen BiCGStab solver");
183  break;
184  }
185  case ICC_PRECOND:
186  case ILU_PRECOND:
187  {
188  Eigen::BiCGSTAB<EigenSM,IncompleteLUT<Number, eigen_idx_type>>
189  solver (matrix._mat);
190  retval = do_solve(solver, "Eigen BiCGSTAB solver with ILU preconditioning");
191  break;
192  }
193  default: // For our default let's use their default
194  libmesh_warning("No EigenSparseLinearSolver support for " <<
195  Utility::enum_to_string<PreconditionerType>(this->_preconditioner_type)
196  << " preconditioning.");
197  libmesh_fallthrough();
198  case JACOBI_PRECOND:
199  {
200  Eigen::BiCGSTAB<EigenSM,DiagonalPreconditioner<Number>> solver (matrix._mat);
201  retval = do_solve(solver, "Eigen BiCGSTAB solver with Jacobi preconditioning");
202  break;
203  }
204  }
205  break;
206  }
207 
208  // Generalized Minimum Residual
209  case GMRES:
210  {
211  auto set_restart_and_solve = [this, &do_solve]
212  (auto & gm_solver, std::string_view msg) {
213  // If there is an int parameter called "gmres_restart" in the
214  // SolverConfiguration object, pass it to the Eigen GMRES
215  // solver.
216  if (this->_solver_configuration)
217  {
218  auto it = this->_solver_configuration->int_valued_data.find("gmres_restart");
219 
220  if (it != this->_solver_configuration->int_valued_data.end())
221  gm_solver.set_restart(it->second);
222  }
223 
224  std::ostringstream full_msg;
225  full_msg << msg << ", restart = " << gm_solver.get_restart();
226  return do_solve(gm_solver, full_msg.str());
227  };
228 
229  switch (this->_preconditioner_type)
230  {
231  case IDENTITY_PRECOND:
232  {
233  Eigen::GMRES<EigenSM,IdentityPreconditioner> solver (matrix._mat);
234  retval = set_restart_and_solve(solver, "Eigen GMRES solver without preconditioning");
235  break;
236  }
237  case ICC_PRECOND:
238  case ILU_PRECOND:
239  {
240  Eigen::GMRES<EigenSM,IncompleteLUT<Number, eigen_idx_type>>
241  solver (matrix._mat);
242  retval = set_restart_and_solve(solver, "Eigen GMRES solver with ILU preconditioning");
243  break;
244  }
245  default: // For our default let's use their default
246  libmesh_warning("No EigenSparseLinearSolver support for " <<
247  Utility::enum_to_string<PreconditionerType>(this->_preconditioner_type)
248  << " preconditioning.");
249  libmesh_fallthrough();
250  case JACOBI_PRECOND:
251  {
252  Eigen::GMRES<EigenSM,DiagonalPreconditioner<Number>> solver (matrix._mat);
253  retval = set_restart_and_solve(solver, "Eigen CG solver with Jacobi preconditioning");
254  break;
255  }
256  }
257  break;
258  }
259 
260  case SPARSELU:
261  {
262  // SparseLU solver code adapted from:
263  // http://eigen.tuxfamily.org/dox-devel/classEigen_1_1SparseLU.html
264  //
265  // From Eigen docs:
266  // The input matrix A should be in a compressed and
267  // column-major form. Otherwise an expensive copy will be
268  // made. You can call the inexpensive makeCompressed() to get
269  // a compressed matrix.
270  //
271  // Note: we don't have a column-major storage format here, so
272  // I think a copy must be made in order to use SparseLU. It
273  // appears that we also have to call makeCompressed(),
274  // otherwise you get a segfault.
275  matrix._mat.makeCompressed();
276 
277  // Build the SparseLU solver object. Note, there is one other
278  // sparse direct solver available in Eigen:
279  //
280  // Eigen::SparseQR<EigenSM, Eigen::AMDOrdering<int>> solver;
281  //
282  // I've tested it, and it works, but it is much slower than
283  // SparseLU. The main benefit of SparseQR is that it can
284  // handle non-square matrices, but we don't allow non-square
285  // sparse matrices to be built in libmesh...
286  Eigen::SparseLU<EigenSM> solver;
287 
288  libMesh::out << "Eigen Sparse LU solver" << std::endl;
289 
290  // Compute the ordering permutation vector from the structural pattern of the matrix.
291  solver.analyzePattern(matrix._mat);
292 
293  // Compute the numerical factorization
294  solver.factorize(matrix._mat);
295 
296  // Use the factors to solve the linear system
297  solution._vec = solver.solve(rhs._vec);
298 
299  // Set up the return value. The SparseLU solver doesn't
300  // support asking for the number of iterations or the final
301  // error, so we'll just report back 1 and 0, respectively.
302  retval = std::make_pair(/*n. iterations=*/1, /*error=*/0);
303 
304  // Store the success/failure reason and break out.
305  _comp_info = solver.info();
306  break;
307  }
308 
309  // Unknown solver, use BICGSTAB
310  default:
311  {
312  libMesh::err << "ERROR: Unsupported Eigen Solver: "
313  << Utility::enum_to_string(this->_solver_type) << std::endl
314  << "Continuing with BICGSTAB" << std::endl;
315 
316  this->_solver_type = BICGSTAB;
317 
318  return this->solve (matrix,
319  solution,
320  rhs,
321  tol,
322  m_its);
323  }
324  }
325 
326  return retval;
327 }
OStreamProxy err
SolverType _solver_type
Enum stating which type of iterative solver to use.
Eigen::ComputationInfo _comp_info
Store the result of the last solve.
virtual void init(const char *name=nullptr) override
Initialize data structures if not done so already.
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.
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...
Eigen::SparseMatrix< Number, Eigen::RowMajor, eigen_idx_type > EigenSM
virtual std::pair< unsigned int, Real > solve(SparseMatrix< T > &matrix, NumericVector< T > &solution, NumericVector< T > &rhs, const std::optional< double > tol=std::nullopt, const std::optional< unsigned int > m_its=std::nullopt) override
Call the Eigen solver.
std::string enum_to_string(const T e)
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.
OStreamProxy out
PreconditionerType _preconditioner_type
Enum stating with type of preconditioner to use.

◆ solve() [2/6]

template<typename T >
std::pair< unsigned int, Real > libMesh::EigenSparseLinearSolver< T >::solve ( SparseMatrix< T > &  matrix,
SparseMatrix< T > &  pc,
NumericVector< T > &  solution,
NumericVector< T > &  rhs,
const std::optional< double >  tol = std::nullopt,
const std::optional< unsigned int m_its = std::nullopt 
)
inlineoverridevirtual

Call the Eigen solver.

Implements libMesh::LinearSolver< T >.

Definition at line 186 of file eigen_sparse_linear_solver.h.

192 {
193  libmesh_error_msg("ERROR: Eigen does not support a user-supplied preconditioner!");
194 
195  return std::pair<unsigned int, Real>();
196 }

◆ solve() [3/6]

template<typename T >
std::pair< unsigned int, Real > libMesh::EigenSparseLinearSolver< 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 359 of file eigen_sparse_linear_solver.C.

364 {
365  libmesh_not_implemented();
366  return std::make_pair(0,0.0);
367 }

◆ solve() [4/6]

template<typename T >
std::pair< unsigned int, Real > libMesh::EigenSparseLinearSolver< 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 373 of file eigen_sparse_linear_solver.C.

379 {
380  libmesh_not_implemented();
381  return std::make_pair(0,0.0);
382 }

◆ solve() [5/6]

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

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

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

Definition at line 335 of file linear_solver.h.

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

◆ 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

◆ _comp_info

template<typename T>
Eigen::ComputationInfo libMesh::EigenSparseLinearSolver< T >::_comp_info
private

Store the result of the last solve.

Definition at line 141 of file eigen_sparse_linear_solver.h.

◆ _convergence_reasons

template<typename T>
std::map< Eigen::ComputationInfo, LinearConvergenceReason > libMesh::EigenSparseLinearSolver< T >::_convergence_reasons = EigenSparseLinearSolver<T>::build_map()
staticprivate

Static map between Eigen ComputationInfo enumerations and libMesh LinearConvergenceReason enumerations.

Definition at line 147 of file eigen_sparse_linear_solver.h.

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

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

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

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

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