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

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

#include <laspack_matrix.h>

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

Public Member Functions

 LaspackLinearSolver (const libMesh::Parallel::Communicator &comm LIBMESH_CAN_DEFAULT_TO_COMMWORLD)
 Constructor. More...
 
 ~LaspackLinearSolver ()
 Destructor. More...
 
virtual void clear () libmesh_override
 Release all memory and clear data structures. More...
 
virtual void init (const char *name=libmesh_nullptr) libmesh_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 double tol, const unsigned int m_its) libmesh_override
 Call the Laspack solver. More...
 
virtual std::pair< unsigned int, Realadjoint_solve (SparseMatrix< T > &matrix, NumericVector< T > &solution, NumericVector< T > &rhs, const double tol, const unsigned int m_its) libmesh_override
 Call the Laspack 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 double tol, const unsigned int m_its) libmesh_override
 Call the Laspack solver. More...
 
virtual std::pair< unsigned int, Realsolve (const ShellMatrix< T > &shell_matrix, NumericVector< T > &solution_in, NumericVector< T > &rhs_in, const double tol, const unsigned int m_its) libmesh_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 double tol, const unsigned int m_its) libmesh_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 void print_converged_reason () const libmesh_override
 Prints a useful message about why the latest linear solve con(di)verged. More...
 
virtual LinearConvergenceReason get_converged_reason () const libmesh_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 double, const unsigned int)
 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 double, const unsigned int)
 This function solves a system whose matrix is a shell matrix, but an optional sparse matrix may be used as preconditioning matrix. 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 UniquePtr< 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=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

void increment_constructor_count (const std::string &name)
 Increments the construction counter. More...
 
void increment_destructor_count (const std::string &name)
 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_laspack_preconditioner_type ()
 Tells LASPACK to use the user-specified preconditioner stored in _preconditioner_type. More...
 

Private Attributes

PrecondProcType _precond_type
 Preconditioner type. More...
 

Detailed Description

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

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

Author
Benjamin Kirk
Date
2002-2007

Definition at line 43 of file laspack_matrix.h.

Member Typedef Documentation

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

template<typename T >
libMesh::LaspackLinearSolver< T >::LaspackLinearSolver ( const libMesh::Parallel::Communicator &comm  LIBMESH_CAN_DEFAULT_TO_COMMWORLD)

Constructor.

Initializes Laspack data structures

Definition at line 159 of file laspack_linear_solver.h.

159  :
160  LinearSolver<T>(comm),
161  _precond_type (ILUPrecond)
162 {
163 }
PrecondProcType _precond_type
Preconditioner type.
const Parallel::Communicator & comm() const
template<typename T >
libMesh::LaspackLinearSolver< T >::~LaspackLinearSolver ( )

Destructor.

Definition at line 169 of file laspack_linear_solver.h.

References libMesh::LaspackLinearSolver< T >::clear().

170 {
171  this->clear ();
172 }
virtual void clear() libmesh_override
Release all memory and clear data structures.

Member Function Documentation

template<typename T >
std::pair< unsigned int, Real > libMesh::LaspackLinearSolver< T >::adjoint_solve ( SparseMatrix< T > &  matrix,
NumericVector< T > &  solution,
NumericVector< T > &  rhs,
const double  tol,
const unsigned int  m_its 
)
virtual

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

Reimplemented from libMesh::LinearSolver< T >.

Definition at line 283 of file laspack_linear_solver.C.

References libMesh::BICG, libMesh::BICGSTAB, libMesh::CG, libMesh::CGN, libMesh::CGS, libMesh::Utility::enum_to_string(), libMesh::err, libMesh::GMRES, libMesh::TriangleWrapper::init(), libMesh::JACOBI, libMesh::QMR, and libMesh::SSOR.

288 {
289  LOG_SCOPE("adjoint_solve()", "LaspackLinearSolver");
290  this->init ();
291 
292  // Make sure the data passed in are really in Laspack types
293  LaspackMatrix<T> * matrix = cast_ptr<LaspackMatrix<T> *>(&matrix_in);
294  LaspackVector<T> * solution = cast_ptr<LaspackVector<T> *>(&solution_in);
295  LaspackVector<T> * rhs = cast_ptr<LaspackVector<T> *>(&rhs_in);
296 
297  // Zero-out the solution to prevent the solver from exiting in 0
298  // iterations (?)
299  //TODO:[BSK] Why does Laspack do this? Comment out this and try ex13...
300  solution->zero();
301 
302  // Close the matrix and vectors in case this wasn't already done.
303  matrix->close ();
304  solution->close ();
305  rhs->close ();
306 
307  // Set the preconditioner type
309 
310  // Set the solver tolerance
311  SetRTCAccuracy (tol);
312 
313  // Solve the linear system
314  switch (this->_solver_type)
315  {
316  // Conjugate-Gradient
317  case CG:
318  {
319  CGIter (Transp_Q(&matrix->_QMat),
320  &solution->_vec,
321  &rhs->_vec,
322  m_its,
324  1.);
325  break;
326  }
327 
328  // Conjugate-Gradient Normalized
329  case CGN:
330  {
331  CGNIter (Transp_Q(&matrix->_QMat),
332  &solution->_vec,
333  &rhs->_vec,
334  m_its,
336  1.);
337  break;
338  }
339 
340  // Conjugate-Gradient Squared
341  case CGS:
342  {
343  CGSIter (Transp_Q(&matrix->_QMat),
344  &solution->_vec,
345  &rhs->_vec,
346  m_its,
348  1.);
349  break;
350  }
351 
352  // Bi-Conjugate Gradient
353  case BICG:
354  {
355  BiCGIter (Transp_Q(&matrix->_QMat),
356  &solution->_vec,
357  &rhs->_vec,
358  m_its,
360  1.);
361  break;
362  }
363 
364  // Bi-Conjugate Gradient Stabilized
365  case BICGSTAB:
366  {
367  BiCGSTABIter (Transp_Q(&matrix->_QMat),
368  &solution->_vec,
369  &rhs->_vec,
370  m_its,
372  1.);
373  break;
374  }
375 
376  // Quasi-Minimum Residual
377  case QMR:
378  {
379  QMRIter (Transp_Q(&matrix->_QMat),
380  &solution->_vec,
381  &rhs->_vec,
382  m_its,
384  1.);
385  break;
386  }
387 
388  // Symmetric over-relaxation
389  case SSOR:
390  {
391  SSORIter (Transp_Q(&matrix->_QMat),
392  &solution->_vec,
393  &rhs->_vec,
394  m_its,
396  1.);
397  break;
398  }
399 
400  // Jacobi Relaxation
401  case JACOBI:
402  {
403  JacobiIter (Transp_Q(&matrix->_QMat),
404  &solution->_vec,
405  &rhs->_vec,
406  m_its,
408  1.);
409  break;
410  }
411 
412  // Generalized Minimum Residual
413  case GMRES:
414  {
415  SetGMRESRestart (30);
416  GMRESIter (Transp_Q(&matrix->_QMat),
417  &solution->_vec,
418  &rhs->_vec,
419  m_its,
421  1.);
422  break;
423  }
424 
425  // Unknown solver, use GMRES
426  default:
427  {
428  libMesh::err << "ERROR: Unsupported LASPACK Solver: "
429  << Utility::enum_to_string(this->_solver_type) << std::endl
430  << "Continuing with GMRES" << std::endl;
431 
432  this->_solver_type = GMRES;
433 
434  return this->solve (*matrix,
435  *solution,
436  *rhs,
437  tol,
438  m_its);
439  }
440  }
441 
442  // Check for an error
443  if (LASResult() != LASOK)
444  {
445  WriteLASErrDescr(stdout);
446  libmesh_error_msg("Exiting after LASPACK Error!");
447  }
448 
449  // Get the convergence step # and residual
450  return std::make_pair(GetLastNoIter(), GetLastAccuracy());
451 }
OStreamProxy err
SolverType _solver_type
Enum stating which type of iterative solver to use.
void set_laspack_preconditioner_type()
Tells LASPACK to use the user-specified preconditioner stored in _preconditioner_type.
virtual std::pair< unsigned int, Real > solve(SparseMatrix< T > &matrix, NumericVector< T > &solution, NumericVector< T > &rhs, const double tol, const unsigned int m_its) libmesh_override
Call the Laspack solver.
virtual void init(const char *name=libmesh_nullptr) libmesh_override
Initialize data structures if not done so already.
PrecondProcType _precond_type
Preconditioner type.
std::string enum_to_string(const T e)
template<typename T>
void libMesh::LinearSolver< T >::attach_preconditioner ( Preconditioner< T > *  preconditioner)
inherited

Attaches a Preconditioner object to be used.

Definition at line 103 of file linear_solver.C.

References libMesh::libMeshPrivateData::_is_initialized, and libMesh::SHELL_PRECOND.

Referenced by libMesh::LinearSolver< Number >::set_solver_type().

104 {
105  if (this->_is_initialized)
106  libmesh_error_msg("Preconditioner must be attached before the solver is initialized!");
107 
109  _preconditioner = preconditioner;
110 }
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.
template<typename T >
UniquePtr< 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 42 of file linear_solver.C.

References libMesh::EIGEN_SOLVERS, libMesh::LASPACK_SOLVERS, libMesh::libmesh_ignore(), libMesh::PETSC_SOLVERS, and libMesh::TRILINOS_SOLVERS.

Referenced by libMesh::ImplicitSystem::get_linear_solver(), and libMesh::TimeSolver::init().

44 {
45  // Avoid unused parameter warnings when no solver packages are enabled.
47 
48  // Build the appropriate solver
49  switch (solver_package)
50  {
51 #ifdef LIBMESH_HAVE_LASPACK
52  case LASPACK_SOLVERS:
53  return UniquePtr<LinearSolver<T>>(new LaspackLinearSolver<T>(comm));
54 #endif
55 
56 
57 #ifdef LIBMESH_HAVE_PETSC
58  case PETSC_SOLVERS:
59  return UniquePtr<LinearSolver<T>>(new PetscLinearSolver<T>(comm));
60 #endif
61 
62 
63 #ifdef LIBMESH_TRILINOS_HAVE_AZTECOO
64  case TRILINOS_SOLVERS:
65  return UniquePtr<LinearSolver<T>>(new AztecLinearSolver<T>(comm));
66 #endif
67 
68 
69 #ifdef LIBMESH_HAVE_EIGEN
70  case EIGEN_SOLVERS:
71  return UniquePtr<LinearSolver<T>>(new EigenSparseLinearSolver<T>(comm));
72 #endif
73 
74  default:
75  libmesh_error_msg("ERROR: Unrecognized solver package: " << solver_package);
76  }
77 
78  return UniquePtr<LinearSolver<T>>();
79 }
void libmesh_ignore(const T &)
const Parallel::Communicator & comm() const
template<typename T >
void libMesh::LaspackLinearSolver< T >::clear ( )
virtual

Release all memory and clear data structures.

Reimplemented from libMesh::LinearSolver< T >.

Definition at line 80 of file laspack_linear_solver.C.

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

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

81 {
82  if (this->initialized())
83  {
84  this->_is_initialized = false;
85 
86  this->_solver_type = GMRES;
88  }
89 }
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.
const Parallel::Communicator& libMesh::ParallelObject::comm ( ) const
inherited
Returns
A reference to the Parallel::Communicator object used by this mesh.

Definition at line 87 of file parallel_object.h.

References libMesh::ParallelObject::_communicator.

Referenced by libMesh::__libmesh_petsc_diff_solver_monitor(), libMesh::__libmesh_petsc_diff_solver_residual(), libMesh::__libmesh_petsc_preconditioner_apply(), libMesh::__libmesh_petsc_snes_jacobian(), libMesh::__libmesh_petsc_snes_postcheck(), libMesh::__libmesh_petsc_snes_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::ParmetisPartitioner::_do_repartition(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::SlepcEigenSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult(), libMesh::SlepcEigenSolver< T >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult_add(), libMesh::EquationSystems::_read_impl(), libMesh::MeshRefinement::_refine_elements(), libMesh::MeshRefinement::_smooth_flags(), add_cube_convex_hull_to_mesh(), libMesh::TransientRBConstruction::add_IC_to_RB_space(), libMesh::ImplicitSystem::add_matrix(), libMesh::RBConstruction::add_scaled_matrix_and_vector(), libMesh::System::add_vector(), libMesh::EigenSparseLinearSolver< T >::adjoint_solve(), libMesh::UnstructuredMesh::all_second_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::TransientRBConstruction::allocate_data_structures(), libMesh::RBConstruction::allocate_data_structures(), libMesh::TransientRBConstruction::assemble_affine_expansion(), libMesh::FEMSystem::assemble_qoi(), libMesh::MeshCommunication::assign_global_indices(), libMesh::ParmetisPartitioner::assign_partitioning(), libMesh::DofMap::attach_matrix(), libMesh::Parallel::BinSorter< KeyType, IdxType >::binsort(), libMesh::Parallel::Sort< KeyType, IdxType >::binsort(), libMesh::MeshCommunication::broadcast(), libMesh::SparseMatrix< T >::build(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::Parallel::Histogram< KeyType, IdxType >::build_histogram(), libMesh::PetscNonlinearSolver< T >::build_mat_null_space(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::MeshBase::cache_elem_dims(), libMesh::System::calculate_norm(), libMesh::DofMap::check_dirichlet_bcid_consistency(), libMesh::Parallel::Sort< KeyType, IdxType >::communicate_bins(), 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::RBSCMConstruction::compute_SCM_bounds_on_training_set(), libMesh::Problem_Interface::computeF(), libMesh::Problem_Interface::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::MeshTools::create_bounding_box(), 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::MeshCommunication::delete_remote_elements(), libMesh::DofMap::distribute_dofs(), DMlibMeshFunction(), DMlibMeshJacobian(), DMlibMeshSetSystem_libMesh(), DMVariableBounds_libMesh(), libMesh::MeshRefinement::eliminate_unrefined_patches(), libMesh::RBEIMConstruction::enrich_RB_space(), libMesh::TransientRBConstruction::enrich_RB_space(), libMesh::RBConstruction::enrich_RB_space(), AssembleOptimization::equality_constraints(), libMesh::WeightedPatchRecoveryErrorEstimator::estimate_error(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::PatchRecoveryErrorEstimator::estimate_error(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::RBEIMConstruction::evaluate_mesh_function(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_error_fraction(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::MeshCommunication::gather(), libMesh::MeshCommunication::gather_neighboring_elements(), libMesh::MeshfreeInterpolation::gather_remote_data(), libMesh::CondensedEigenSystem::get_eigenpair(), libMesh::DofMap::get_info(), libMesh::ImplicitSystem::get_linear_solver(), libMesh::EquationSystems::get_solution(), AssembleOptimization::inequality_constraints(), AssembleOptimization::inequality_constraints_jacobian(), libMesh::LocationMap< T >::init(), libMesh::TopologyMap::init(), libMesh::PetscDiffSolver::init(), libMesh::TimeSolver::init(), libMesh::TaoOptimizationSolver< T >::init(), libMesh::PetscNonlinearSolver< T >::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::EigenSystem::init_data(), libMesh::EigenSystem::init_matrices(), libMesh::ParmetisPartitioner::initialize(), libMesh::OptimizationSystem::initialize_equality_constraints_storage(), libMesh::OptimizationSystem::initialize_inequality_constraints_storage(), libMesh::RBEIMConstruction::initialize_rb_construction(), integrate_function(), 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::MeshRefinement::limit_level_mismatch_at_edge(), libMesh::MeshRefinement::limit_level_mismatch_at_node(), libMesh::MeshRefinement::limit_overrefined_boundary(), libMesh::MeshRefinement::limit_underrefined_boundary(), 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_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::MeshSerializer::MeshSerializer(), LinearElasticityWithContact::move_mesh(), libMesh::DistributedMesh::n_active_elem(), libMesh::MeshTools::n_active_levels(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::CondensedEigenSystem::n_global_non_condensed_dofs(), libMesh::MeshTools::n_levels(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::MeshTools::n_p_levels(), libMesh::BoundaryInfo::n_shellface_conds(), new_function_base(), 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::MeshTools::paranoid_n_levels(), libMesh::Partitioner::partition(), libMesh::MetisPartitioner::partition_range(), 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::SparseMatrix< T >::print(), FEMParameters::read(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::XdrIO::read(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::RBEvaluation::read_in_vectors_from_multiple_files(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::RBConstruction::read_riesz_representors_from_files(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::MeshBase::recalculate_n_partitions(), libMesh::MeshCommunication::redistribute(), libMesh::MeshRefinement::refine_and_coarsen_elements(), libMesh::DistributedMesh::renumber_dof_objects(), LinearElasticityWithContact::residual_and_jacobian(), libMesh::MeshCommunication::send_coarse_ghosts(), libMesh::TransientRBConstruction::set_error_temporal_data(), libMesh::RBEIMConstruction::set_explicit_sys_subvector(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::Partitioner::set_parent_processor_ids(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::Parallel::Sort< KeyType, IdxType >::sort(), libMesh::MeshBase::subdomain_ids(), libMesh::BoundaryInfo::sync(), libMesh::Parallel::sync_element_data_by_parent_id(), libMesh::Parallel::sync_node_data_by_element_id(), libMesh::MeshRefinement::test_level_one(), MeshfunctionDFEM::test_mesh_function_dfem(), MeshfunctionDFEM::test_mesh_function_dfem_grad(), libMesh::MeshRefinement::test_unflagged(), PointLocatorTest::testLocator(), BoundaryInfoTest::testMesh(), SystemsTest::testProjectCubeWithMeshFunction(), libMesh::MeshTools::total_weight(), libMesh::MeshFunctionSolutionTransfer::transfer(), libMesh::MeshfreeSolutionTransfer::transfer(), libMesh::TransientRBConstruction::truth_assembly(), libMesh::RBConstruction::truth_assembly(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::TransientRBConstruction::update_RB_initial_condition_all_N(), libMesh::RBEIMConstruction::update_RB_system_matrices(), 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::RBEvaluation::write_out_vectors(), libMesh::TransientRBConstruction::write_riesz_representors_to_files(), libMesh::RBConstruction::write_riesz_representors_to_files(), libMesh::XdrIO::write_serialized_bcs_helper(), 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().

88  { return _communicator; }
const Parallel::Communicator & _communicator
void libMesh::ReferenceCounter::disable_print_counter_info ( )
staticinherited

Definition at line 107 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

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

108 {
109  _enable_print_counter = false;
110  return;
111 }
static bool _enable_print_counter
Flag to control whether reference count information is printed when print_info is called...
void libMesh::ReferenceCounter::enable_print_counter_info ( )
staticinherited

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

Definition at line 101 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

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

102 {
103  _enable_print_counter = true;
104  return;
105 }
static bool _enable_print_counter
Flag to control whether reference count information is printed when print_info is called...
template<typename T >
LinearConvergenceReason libMesh::LaspackLinearSolver< T >::get_converged_reason ( ) const
virtual
Returns
The solver's convergence flag.

Implements libMesh::LinearSolver< T >.

Definition at line 532 of file laspack_linear_solver.C.

References libMesh::CONVERGED_RTOL_NORMAL, and libMesh::DIVERGED_NULL.

533 {
534  switch (LASResult())
535  {
536  case LASOK : return CONVERGED_RTOL_NORMAL;
537  default : return DIVERGED_NULL;
538  }
539 }
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 (Counts::iterator it = _counts.begin();
59  it != _counts.end(); ++it)
60  {
61  const std::string name(it->first);
62  const unsigned int creations = it->second.first;
63  const unsigned int destructions = it->second.second;
64 
65  oss << "| " << name << " reference count information:\n"
66  << "| Creations: " << creations << '\n'
67  << "| Destructions: " << destructions << '\n';
68  }
69 
70  oss << " ---------------------------------------------------------------------------- \n";
71 
72  return oss.str();
73 
74 #else
75 
76  return "";
77 
78 #endif
79 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:39
static Counts _counts
Actually holds the data.
template<typename T >
bool libMesh::LinearSolver< T >::get_same_preconditioner ( )
inherited
Returns
same_preconditioner, which indicates if we reuse the same preconditioner for subsequent solves.

Definition at line 326 of file linear_solver.h.

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

Referenced by libMesh::LinearSolver< Number >::set_solver_type().

327 {
328  return same_preconditioner;
329 }
bool same_preconditioner
Boolean flag to indicate whether we want to use an identical preconditioner to the previous solve...
void libMesh::ReferenceCounter::increment_constructor_count ( const std::string &  name)
protectedinherited

Increments the construction counter.

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

Definition at line 185 of file reference_counter.h.

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

Referenced by libMesh::ReferenceCounter::n_objects(), and libMesh::ReferenceCountedObject< RBParametrized >::ReferenceCountedObject().

186 {
187  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
188  std::pair<unsigned int, unsigned int> & p = _counts[name];
189 
190  p.first++;
191 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:39
spin_mutex spin_mtx
A convenient spin mutex object which can be used for obtaining locks.
Definition: threads.C:29
static Counts _counts
Actually holds the data.
void libMesh::ReferenceCounter::increment_destructor_count ( const std::string &  name)
protectedinherited

Increments the destruction counter.

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

Definition at line 198 of file reference_counter.h.

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

Referenced by libMesh::ReferenceCounter::n_objects(), and libMesh::ReferenceCountedObject< RBParametrized >::~ReferenceCountedObject().

199 {
200  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
201  std::pair<unsigned int, unsigned int> & p = _counts[name];
202 
203  p.second++;
204 }
std::string name(const ElemQuality q)
This function returns a string containing some name for q.
Definition: elem_quality.C:39
spin_mutex spin_mtx
A convenient spin mutex object which can be used for obtaining locks.
Definition: threads.C:29
static Counts _counts
Actually holds the data.
template<typename T >
void libMesh::LaspackLinearSolver< T >::init ( const char *  name = libmesh_nullptr)
virtual

Initialize data structures if not done so already.

Implements libMesh::LinearSolver< T >.

Definition at line 94 of file laspack_linear_solver.C.

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

95 {
96  // Initialize the data structures if not done so already.
97  if (!this->initialized())
98  {
99  this->_is_initialized = true;
100  }
101 
102  // SetRTCAuxProc (print_iter_accuracy);
103 }
bool initialized() const
Definition: linear_solver.h:85
bool _is_initialized
Flag indicating if the data structures have been initialized.
template<typename T>
virtual void libMesh::LinearSolver< T >::init_names ( const System )
virtualinherited

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 {}
template<typename T>
bool libMesh::LinearSolver< T >::initialized ( ) const
inherited
Returns
true if the data structures are initialized, false otherwise.

Definition at line 85 of file linear_solver.h.

Referenced by libMesh::EigenSparseLinearSolver< T >::clear(), and libMesh::EigenSparseLinearSolver< T >::init().

85 { return _is_initialized; }
bool _is_initialized
Flag indicating if the data structures have been initialized.
static unsigned int libMesh::ReferenceCounter::n_objects ( )
staticinherited
processor_id_type libMesh::ParallelObject::n_processors ( ) const
inherited
Returns
The number of processors in the group.

Definition at line 93 of file parallel_object.h.

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

Referenced by libMesh::ParmetisPartitioner::_do_repartition(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::DistributedMesh::add_elem(), libMesh::DistributedMesh::add_node(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::FEMSystem::assembly(), libMesh::ParmetisPartitioner::assign_partitioning(), libMesh::AztecLinearSolver< T >::AztecLinearSolver(), libMesh::MeshCommunication::broadcast(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::DistributedMesh::clear(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::UnstructuredMesh::create_pid_mesh(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DistributedMesh::DistributedMesh(), libMesh::EnsightIO::EnsightIO(), libMesh::MeshCommunication::gather(), libMesh::MeshCommunication::gather_neighboring_elements(), libMesh::MeshBase::get_info(), libMesh::EquationSystems::get_solution(), libMesh::SystemSubsetBySubdomain::init(), libMesh::ParmetisPartitioner::initialize(), libMesh::Nemesis_IO_Helper::initialize(), libMesh::DistributedMesh::insert_elem(), 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::SparsityPattern::Build::parallel_sync(), libMesh::Partitioner::partition(), libMesh::MeshBase::partition(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::PetscLinearSolver< T >::PetscLinearSolver(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::SparseMatrix< T >::print(), libMesh::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::XdrIO::read_header(), libMesh::CheckpointIO::read_nodes(), libMesh::MeshCommunication::redistribute(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::Partitioner::repartition(), libMesh::MeshCommunication::send_coarse_ghosts(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::Parallel::Sort< KeyType, IdxType >::sort(), WriteVecAndScalar::testWrite(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), and libMesh::XdrIO::write_serialized_nodesets().

94  { return cast_int<processor_id_type>(_communicator.size()); }
unsigned int size() const
Definition: parallel.h:726
const Parallel::Communicator & _communicator
template<typename T >
PreconditionerType libMesh::LinearSolver< T >::preconditioner_type ( ) const
inherited
Returns
The type of preconditioner to use.

Definition at line 83 of file linear_solver.C.

Referenced by libMesh::LinearSolver< Number >::set_solver_type().

84 {
85  if (_preconditioner)
86  return _preconditioner->type();
87 
88  return _preconditioner_type;
89 }
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.
template<typename T >
void libMesh::LaspackLinearSolver< T >::print_converged_reason ( ) const
virtual

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

Reimplemented from libMesh::LinearSolver< T >.

Definition at line 515 of file laspack_linear_solver.C.

References libMesh::out.

516 {
517  switch (LASResult())
518  {
519  case LASOK :
520  libMesh::out << "Laspack converged.\n";
521  break;
522  default :
523  libMesh::out << "Laspack diverged.\n";
524  }
525  libMesh::out << "Detailed reporting is currently only supported"
526  << "with Petsc 2.3.1 and later." << std::endl;
527 }
OStreamProxy out
void libMesh::ReferenceCounter::print_info ( std::ostream &  out = libMesh::out)
staticinherited

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

Definition at line 88 of file reference_counter.C.

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

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

89 {
91  out_stream << ReferenceCounter::get_info();
92 }
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_type libMesh::ParallelObject::processor_id ( ) const
inherited
Returns
The rank of this processor in the group.

Definition at line 99 of file parallel_object.h.

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

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::EquationSystems::_read_impl(), libMesh::DistributedMesh::add_elem(), libMesh::BoundaryInfo::add_elements(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::DistributedMesh::add_node(), libMesh::MeshRefinement::add_node(), libMesh::MeshTools::Modification::all_tri(), libMesh::FEMSystem::assembly(), libMesh::ParmetisPartitioner::assign_partitioning(), libMesh::MeshCommunication::broadcast(), libMesh::EquationSystems::build_discontinuous_solution_vector(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::ParmetisPartitioner::build_graph(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::DofMap::build_sparsity(), libMesh::DistributedMesh::clear(), 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::MeshTools::correct_node_proc_ids(), libMesh::ExodusII_IO_Helper::create(), libMesh::DistributedMesh::delete_elem(), libMesh::DistributedMesh::delete_node(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DistributedMesh::DistributedMesh(), libMesh::EnsightIO::EnsightIO(), libMesh::RBEIMConstruction::evaluate_mesh_function(), libMesh::MeshFunction::find_element(), libMesh::MeshFunction::find_elements(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::MeshCommunication::gather(), libMesh::MeshCommunication::gather_neighboring_elements(), 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::Nemesis_IO_Helper::get_node_cmap(), libMesh::Nemesis_IO_Helper::get_node_map(), libMesh::Nemesis_IO_Helper::get_ns_param_global(), libMesh::EquationSystems::get_solution(), libMesh::Nemesis_IO_Helper::get_ss_param_global(), libMesh::SparsityPattern::Build::handle_vi_vj(), libMesh::SystemSubsetBySubdomain::init(), HeatSystem::init_data(), libMesh::ParmetisPartitioner::initialize(), 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::RBEIMEvaluation::legacy_write_offline_data_to_files(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBSCMEvaluation::legacy_write_offline_data_to_files(), libMesh::RBEIMEvaluation::legacy_write_out_interpolation_points_elem(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), 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::MeshBase::n_active_local_elem(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::BoundaryInfo::n_edge_conds(), 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::WeightedPatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::SparsityPattern::Build::operator()(), libMesh::PatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::MetisPartitioner::partition_range(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::SparseMatrix< T >::print(), libMesh::NumericVector< T >::print_global(), 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::CheckpointIO::read(), libMesh::XdrIO::read(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::RBEvaluation::read_in_vectors_from_multiple_files(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::RBConstruction::read_riesz_representors_from_files(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::MeshCommunication::redistribute(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::MeshCommunication::send_coarse_ghosts(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::LaplaceMeshSmoother::smooth(), DefaultCouplingTest::testCoupling(), PointNeighborCouplingTest::testCoupling(), BoundaryInfoTest::testShellFaceConstraints(), WriteVecAndScalar::testWrite(), libMesh::MeshTools::total_weight(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::Parallel::Packing< Node * >::unpack(), libMesh::Parallel::Packing< Elem * >::unpack(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::DTKAdapter::update_variable_values(), libMesh::MeshTools::weight(), libMesh::NameBasedIO::write(), libMesh::CheckpointIO::write(), libMesh::XdrIO::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_elements(), libMesh::ExodusII_IO::write_global_data(), libMesh::ExodusII_IO_Helper::write_global_values(), 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::ExodusII_IO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data_discontinuous(), libMesh::ExodusII_IO_Helper::write_nodal_values(), libMesh::Nemesis_IO_Helper::write_nodesets(), libMesh::ExodusII_IO_Helper::write_nodesets(), libMesh::RBEvaluation::write_out_vectors(), write_output_solvedata(), libMesh::RBConstruction::write_riesz_representors_to_files(), libMesh::XdrIO::write_serialized_bc_names(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::XdrIO::write_serialized_subdomain_names(), libMesh::Nemesis_IO_Helper::write_sidesets(), libMesh::ExodusII_IO_Helper::write_sidesets(), libMesh::ExodusII_IO::write_timestep(), and libMesh::ExodusII_IO_Helper::write_timestep().

100  { return cast_int<processor_id_type>(_communicator.rank()); }
const Parallel::Communicator & _communicator
unsigned int rank() const
Definition: parallel.h:724
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 NULL pointer.

Reimplemented in libMesh::PetscLinearSolver< T >, and libMesh::PetscLinearSolver< Number >.

Definition at line 121 of file linear_solver.C.

References libmesh_nullptr.

Referenced by libMesh::LinearSolver< Number >::set_solver_type().

123 {
124  if (dofs != libmesh_nullptr)
125  libmesh_not_implemented();
126 }
const class libmesh_nullptr_t libmesh_nullptr
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 114 of file linear_solver.C.

Referenced by libMesh::ImplicitSystem::disable_cache(), libMesh::RBConstruction::initialize_rb_construction(), main(), and libMesh::LinearSolver< Number >::set_solver_type().

115 {
116  same_preconditioner = reuse_flag;
117 }
bool same_preconditioner
Boolean flag to indicate whether we want to use an identical preconditioner to the previous solve...
template<typename T >
void libMesh::LaspackLinearSolver< T >::set_laspack_preconditioner_type ( )
private

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

Definition at line 486 of file laspack_linear_solver.C.

References libMesh::err, libMesh::IDENTITY_PRECOND, libMesh::ILU_PRECOND, libMesh::JACOBI_PRECOND, libmesh_nullptr, and libMesh::SSOR_PRECOND.

487 {
488  switch (this->_preconditioner_type)
489  {
490  case IDENTITY_PRECOND:
491  _precond_type = libmesh_nullptr; return;
492 
493  case ILU_PRECOND:
494  _precond_type = ILUPrecond; return;
495 
496  case JACOBI_PRECOND:
497  _precond_type = JacobiPrecond; return;
498 
499  case SSOR_PRECOND:
500  _precond_type = SSORPrecond; return;
501 
502 
503  default:
504  libMesh::err << "ERROR: Unsupported LASPACK Preconditioner: "
505  << this->_preconditioner_type << std::endl
506  << "Continuing with ILU" << std::endl;
509  }
510 }
OStreamProxy err
void set_laspack_preconditioner_type()
Tells LASPACK to use the user-specified preconditioner stored in _preconditioner_type.
const class libmesh_nullptr_t libmesh_nullptr
PrecondProcType _precond_type
Preconditioner type.
PreconditionerType _preconditioner_type
Enum stating with type of preconditioner to use.
template<typename T >
void libMesh::LinearSolver< T >::set_preconditioner_type ( const PreconditionerType  pct)
inherited

Sets the type of preconditioner to use.

Definition at line 93 of file linear_solver.C.

Referenced by libMesh::LinearSolver< Number >::set_solver_type().

94 {
95  if (_preconditioner)
96  _preconditioner->set_type(pct);
97  else
99 }
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.
template<typename T >
void libMesh::LinearSolver< T >::set_solver_configuration ( SolverConfiguration solver_configuration)
inherited

Set the solver configuration object.

Definition at line 162 of file linear_solver.C.

Referenced by libMesh::LinearSolver< Number >::set_solver_type().

163 {
164  _solver_configuration = &solver_configuration;
165 }
SolverConfiguration * _solver_configuration
Optionally store a SolverOptions object that can be used to set parameters like solver type...
template<typename T>
void libMesh::LinearSolver< T >::set_solver_type ( const SolverType  st)
inherited

Sets the type of solver to use.

Definition at line 116 of file linear_solver.h.

Referenced by main().

117  { _solver_type = st; }
SolverType _solver_type
Enum stating which type of iterative solver to use.
template<typename T >
std::pair< unsigned int, Real > libMesh::LaspackLinearSolver< T >::solve ( SparseMatrix< T > &  matrix,
NumericVector< T > &  solution,
NumericVector< T > &  rhs,
const double  tol,
const unsigned int  m_its 
)
virtual

Call the Laspack solver.

Implements libMesh::LinearSolver< T >.

Definition at line 109 of file laspack_linear_solver.C.

References libMesh::BICG, libMesh::BICGSTAB, libMesh::CG, libMesh::CGN, libMesh::CGS, libMesh::Utility::enum_to_string(), libMesh::err, libMesh::GMRES, libMesh::TriangleWrapper::init(), libMesh::JACOBI, libMesh::QMR, and libMesh::SSOR.

114 {
115  LOG_SCOPE("solve()", "LaspackLinearSolver");
116  this->init ();
117 
118  // Make sure the data passed in are really in Laspack types
119  LaspackMatrix<T> * matrix = cast_ptr<LaspackMatrix<T> *>(&matrix_in);
120  LaspackVector<T> * solution = cast_ptr<LaspackVector<T> *>(&solution_in);
121  LaspackVector<T> * rhs = cast_ptr<LaspackVector<T> *>(&rhs_in);
122 
123  // Zero-out the solution to prevent the solver from exiting in 0
124  // iterations (?)
125  //TODO:[BSK] Why does Laspack do this? Comment out this and try ex13...
126  solution->zero();
127 
128  // Close the matrix and vectors in case this wasn't already done.
129  matrix->close ();
130  solution->close ();
131  rhs->close ();
132 
133  // Set the preconditioner type
135 
136  // Set the solver tolerance
137  SetRTCAccuracy (tol);
138 
139  // Solve the linear system
140  switch (this->_solver_type)
141  {
142  // Conjugate-Gradient
143  case CG:
144  {
145  CGIter (&matrix->_QMat,
146  &solution->_vec,
147  &rhs->_vec,
148  m_its,
150  1.);
151  break;
152  }
153 
154  // Conjugate-Gradient Normalized
155  case CGN:
156  {
157  CGNIter (&matrix->_QMat,
158  &solution->_vec,
159  &rhs->_vec,
160  m_its,
162  1.);
163  break;
164  }
165 
166  // Conjugate-Gradient Squared
167  case CGS:
168  {
169  CGSIter (&matrix->_QMat,
170  &solution->_vec,
171  &rhs->_vec,
172  m_its,
174  1.);
175  break;
176  }
177 
178  // Bi-Conjugate Gradient
179  case BICG:
180  {
181  BiCGIter (&matrix->_QMat,
182  &solution->_vec,
183  &rhs->_vec,
184  m_its,
186  1.);
187  break;
188  }
189 
190  // Bi-Conjugate Gradient Stabilized
191  case BICGSTAB:
192  {
193  BiCGSTABIter (&matrix->_QMat,
194  &solution->_vec,
195  &rhs->_vec,
196  m_its,
198  1.);
199  break;
200  }
201 
202  // Quasi-Minimum Residual
203  case QMR:
204  {
205  QMRIter (&matrix->_QMat,
206  &solution->_vec,
207  &rhs->_vec,
208  m_its,
210  1.);
211  break;
212  }
213 
214  // Symmetric over-relaxation
215  case SSOR:
216  {
217  SSORIter (&matrix->_QMat,
218  &solution->_vec,
219  &rhs->_vec,
220  m_its,
222  1.);
223  break;
224  }
225 
226  // Jacobi Relaxation
227  case JACOBI:
228  {
229  JacobiIter (&matrix->_QMat,
230  &solution->_vec,
231  &rhs->_vec,
232  m_its,
234  1.);
235  break;
236  }
237 
238  // Generalized Minimum Residual
239  case GMRES:
240  {
241  SetGMRESRestart (30);
242  GMRESIter (&matrix->_QMat,
243  &solution->_vec,
244  &rhs->_vec,
245  m_its,
247  1.);
248  break;
249  }
250 
251  // Unknown solver, use GMRES
252  default:
253  {
254  libMesh::err << "ERROR: Unsupported LASPACK Solver: "
255  << Utility::enum_to_string(this->_solver_type) << std::endl
256  << "Continuing with GMRES" << std::endl;
257 
258  this->_solver_type = GMRES;
259 
260  return this->solve (*matrix,
261  *solution,
262  *rhs,
263  tol,
264  m_its);
265  }
266  }
267 
268  // Check for an error
269  if (LASResult() != LASOK)
270  {
271  WriteLASErrDescr(stdout);
272  libmesh_error_msg("Exiting after LASPACK Error!");
273  }
274 
275  // Get the convergence step # and residual
276  return std::make_pair(GetLastNoIter(), GetLastAccuracy());
277 }
OStreamProxy err
SolverType _solver_type
Enum stating which type of iterative solver to use.
void set_laspack_preconditioner_type()
Tells LASPACK to use the user-specified preconditioner stored in _preconditioner_type.
virtual std::pair< unsigned int, Real > solve(SparseMatrix< T > &matrix, NumericVector< T > &solution, NumericVector< T > &rhs, const double tol, const unsigned int m_its) libmesh_override
Call the Laspack solver.
virtual void init(const char *name=libmesh_nullptr) libmesh_override
Initialize data structures if not done so already.
PrecondProcType _precond_type
Preconditioner type.
std::string enum_to_string(const T e)
template<typename T >
std::pair< unsigned int, Real > libMesh::LaspackLinearSolver< T >::solve ( SparseMatrix< T > &  matrix,
SparseMatrix< T > &  pc,
NumericVector< T > &  solution,
NumericVector< T > &  rhs,
const double  tol,
const unsigned int  m_its 
)
virtual

Call the Laspack solver.

Implements libMesh::LinearSolver< T >.

Definition at line 179 of file laspack_linear_solver.h.

185 {
186  libmesh_error_msg("ERROR: LASPACK does not support a user-supplied preconditioner!");
187 
188  std::pair<unsigned int, Real> p;
189  return p;
190 }
template<typename T >
std::pair< unsigned int, Real > libMesh::LaspackLinearSolver< T >::solve ( const ShellMatrix< T > &  shell_matrix,
NumericVector< T > &  solution_in,
NumericVector< T > &  rhs_in,
const double  tol,
const unsigned int  m_its 
)
virtual

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

Implements libMesh::LinearSolver< T >.

Definition at line 458 of file laspack_linear_solver.C.

463 {
464  libmesh_not_implemented();
465  return std::make_pair(0,0.0);
466 }
template<typename T >
std::pair< unsigned int, Real > libMesh::LaspackLinearSolver< T >::solve ( const ShellMatrix< T > &  shell_matrix,
const SparseMatrix< T > &  precond_matrix,
NumericVector< T > &  solution_in,
NumericVector< T > &  rhs_in,
const double  tol,
const unsigned int  m_its 
)
virtual

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 472 of file laspack_linear_solver.C.

478 {
479  libmesh_not_implemented();
480  return std::make_pair(0,0.0);
481 }
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 double  tol,
const unsigned int  n_iter 
)
inherited

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

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

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

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

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

357 {
358  if (pc_mat)
359  return this->solve(mat, *pc_mat, sol, rhs, tol, n_iter);
360  else
361  return this->solve(mat, sol, rhs, tol, n_iter);
362 }
virtual std::pair< unsigned int, Real > solve(SparseMatrix< T > &, NumericVector< T > &, NumericVector< T > &, const double, const unsigned int)=0
This function calls the solver _solver_type preconditioned with the _preconditioner_type precondition...
template<typename T>
SolverType libMesh::LinearSolver< T >::solver_type ( ) const
inherited
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

const Parallel::Communicator& libMesh::ParallelObject::_communicator
protectedinherited
ReferenceCounter::Counts libMesh::ReferenceCounter::_counts
staticprotectedinherited
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().

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::EigenSparseLinearSolver< T >::clear(), libMesh::EigenSparseLinearSolver< T >::init(), and libMesh::LinearSolver< Number >::initialized().

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.

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

template<typename T >
PrecondProcType libMesh::LaspackLinearSolver< T >::_precond_type
private

Preconditioner type.

Definition at line 152 of file laspack_linear_solver.h.

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.

template<typename T>
PreconditionerType libMesh::LinearSolver< T >::_preconditioner_type
protectedinherited
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.

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

template<typename T>
SolverType libMesh::LinearSolver< T >::_solver_type
protectedinherited
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.

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


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